Address Copilot review feedback

- Fix regex to actually match std::to_string() by using alternation (the : in the lookbehind was preventing matches) - Update error message to mention both std::to_string() and unqualified to_string() forms - Correct buffer sizes for signed integer types: - int8_t: 5 chars (not 4) for "-128\0" - int16_t: 7 chars (not 6) for "-32768\0" - int32_t: 12 chars (not 11) for "-2147483648\0"
Merge branch 'dev' into no_new_to_string
2026-01-30 08:22:14 -07:00 · 2026-01-28 18:14:16 -10:00 · 2026-01-28 17:42:57 -10:00 · 2026-01-21 19:50:39 -10:00 · 2026-01-19 17:44:25 -10:00 · 2026-01-19 17:43:46 -10:00
59 changed files with 111 additions and 1537 deletions
--- 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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+      uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
      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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        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@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
+        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
--- a/1
+++ b/1
@@ -104,7 +104,6 @@ esphome/components/cc1101/* @gabest11 @lygris
 esphome/components/ccs811/* @habbie
 esphome/components/cd74hc4067/* @asoehlke
 esphome/components/ch422g/* @clydebarrow @jesterret
-esphome/components/ch423/* @dwmw2
 esphome/components/chsc6x/* @kkosik20
 esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
--- a/esphome/components/adc/sensor.py
+++ b/esphome/components/adc/sensor.py
@@ -2,7 +2,7 @@ import logging

 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
-from esphome.components.esp32 import get_esp32_variant, include_builtin_idf_component
+from esphome.components.esp32 import get_esp32_variant
 from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
 from esphome.components.zephyr import (
    zephyr_add_overlay,
@@ -118,9 +118,6 @@ async def to_code(config):
    cg.add(var.set_sampling_mode(config[CONF_SAMPLING_MODE]))

    if CORE.is_esp32:
-        # Re-enable ESP-IDF's ADC driver (excluded by default to save compile time)
-        include_builtin_idf_component("esp_adc")
-
        if attenuation := config.get(CONF_ATTENUATION):
            if attenuation == "auto":
                cg.add(var.set_autorange(cg.global_ns.true))
--- a/esphome/components/api/homeassistant_service.h
+++ b/esphome/components/api/homeassistant_service.h
@@ -25,7 +25,9 @@ template<typename... X> class TemplatableStringValue : public TemplatableValue<s

 private:
  // Helper to convert value to string - handles the case where value is already a string
-  template<typename T> static std::string value_to_string(T &&val) { return to_string(std::forward<T>(val)); }
+  template<typename T> static std::string value_to_string(T &&val) {
+    return to_string(std::forward<T>(val));  // NOLINT
+  }

  // Overloads for string types - needed because std::to_string doesn't support them
  static std::string value_to_string(char *val) {
--- a/esphome/components/audio/init.py
+++ b/esphome/components/audio/init.py
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components.esp32 import add_idf_component, include_builtin_idf_component
+from esphome.components.esp32 import add_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_NUM_CHANNELS, CONF_SAMPLE_RATE
 import esphome.final_validate as fv
@@ -166,9 +166,6 @@ def final_validate_audio_schema(


 async def to_code(config):
-    # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time)
-    include_builtin_idf_component("esp_http_client")
-
    add_idf_component(
        name="esphome/esp-audio-libs",
        ref="2.0.3",
--- a/esphome/components/bme680_bsec/init.py
+++ b/esphome/components/bme680_bsec/init.py
@@ -89,9 +89,8 @@ async def to_code(config):
        var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL].total_milliseconds)
    )

-    # Although this component does not use SPI/Wire directly, the BSEC library requires them
+    # Although this component does not use SPI, the BSEC library requires the SPI library
    cg.add_library("SPI", None)
-    cg.add_library("Wire", None)

    cg.add_define("USE_BSEC")
    cg.add_library("boschsensortec/BSEC Software Library", "1.6.1480")
--- a/esphome/components/ch423/init.py
+++ b/esphome/components/ch423/init.py
@@ -1,103 +0,0 @@
-from esphome import pins
-import esphome.codegen as cg
-from esphome.components import i2c
-from esphome.components.i2c import I2CBus
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_I2C_ID,
-    CONF_ID,
-    CONF_INPUT,
-    CONF_INVERTED,
-    CONF_MODE,
-    CONF_NUMBER,
-    CONF_OPEN_DRAIN,
-    CONF_OUTPUT,
-)
-from esphome.core import CORE
-
-CODEOWNERS = ["@dwmw2"]
-DEPENDENCIES = ["i2c"]
-MULTI_CONF = True
-ch423_ns = cg.esphome_ns.namespace("ch423")
-
-CH423Component = ch423_ns.class_("CH423Component", cg.Component, i2c.I2CDevice)
-CH423GPIOPin = ch423_ns.class_(
-    "CH423GPIOPin", cg.GPIOPin, cg.Parented.template(CH423Component)
-)
-
-CONF_CH423 = "ch423"
-
-# Note that no address is configurable - each register in the CH423 has a dedicated i2c address
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.declare_id(CH423Component),
-        cv.GenerateID(CONF_I2C_ID): cv.use_id(I2CBus),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    # Can't use register_i2c_device because there is no CONF_ADDRESS
-    parent = await cg.get_variable(config[CONF_I2C_ID])
-    cg.add(var.set_i2c_bus(parent))
-
-
-# This is used as a final validation step so that modes have been fully transformed.
-def pin_mode_check(pin_config, _):
-    if pin_config[CONF_MODE][CONF_INPUT] and pin_config[CONF_NUMBER] >= 8:
-        raise cv.Invalid("CH423 only supports input on pins 0-7")
-    if pin_config[CONF_MODE][CONF_OPEN_DRAIN] and pin_config[CONF_NUMBER] < 8:
-        raise cv.Invalid("CH423 only supports open drain output on pins 8-23")
-
-    ch423_id = pin_config[CONF_CH423]
-    pin_num = pin_config[CONF_NUMBER]
-    is_output = pin_config[CONF_MODE][CONF_OUTPUT]
-    is_open_drain = pin_config[CONF_MODE][CONF_OPEN_DRAIN]
-
-    # Track pin modes per CH423 instance in CORE.data
-    ch423_modes = CORE.data.setdefault(CONF_CH423, {})
-    if ch423_id not in ch423_modes:
-        ch423_modes[ch423_id] = {"gpio_output": None, "gpo_open_drain": None}
-
-    if pin_num < 8:
-        # GPIO pins (0-7): all must have same direction
-        if ch423_modes[ch423_id]["gpio_output"] is None:
-            ch423_modes[ch423_id]["gpio_output"] = is_output
-        elif ch423_modes[ch423_id]["gpio_output"] != is_output:
-            raise cv.Invalid(
-                "CH423 GPIO pins (0-7) must all be configured as input or all as output"
-            )
-    # GPO pins (8-23): all must have same open-drain setting
-    elif ch423_modes[ch423_id]["gpo_open_drain"] is None:
-        ch423_modes[ch423_id]["gpo_open_drain"] = is_open_drain
-    elif ch423_modes[ch423_id]["gpo_open_drain"] != is_open_drain:
-        raise cv.Invalid(
-            "CH423 GPO pins (8-23) must all be configured as push-pull or all as open-drain"
-        )
-
-
-CH423_PIN_SCHEMA = pins.gpio_base_schema(
-    CH423GPIOPin,
-    cv.int_range(min=0, max=23),
-    modes=[CONF_INPUT, CONF_OUTPUT, CONF_OPEN_DRAIN],
-).extend(
-    {
-        cv.Required(CONF_CH423): cv.use_id(CH423Component),
-    }
-)
-
-
-@pins.PIN_SCHEMA_REGISTRY.register(CONF_CH423, CH423_PIN_SCHEMA, pin_mode_check)
-async def ch423_pin_to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    parent = await cg.get_variable(config[CONF_CH423])
-
-    cg.add(var.set_parent(parent))
-
-    num = config[CONF_NUMBER]
-    cg.add(var.set_pin(num))
-    cg.add(var.set_inverted(config[CONF_INVERTED]))
-    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
-    return var
--- a/esphome/components/ch423/ch423.cpp
+++ b/esphome/components/ch423/ch423.cpp
@@ -1,148 +0,0 @@
-#include "ch423.h"
-#include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
-
-namespace esphome::ch423 {
-
-static constexpr uint8_t CH423_REG_SYS = 0x24;    // Set system parameters (0x48 >> 1)
-static constexpr uint8_t CH423_SYS_IO_OE = 0x01;  // IO output enable
-static constexpr uint8_t CH423_SYS_OD_EN = 0x04;  // Open drain enable for OC pins
-static constexpr uint8_t CH423_REG_IO = 0x30;     // Write/read IO7-IO0 (0x60 >> 1)
-static constexpr uint8_t CH423_REG_IO_RD = 0x26;  // Read IO7-IO0 (0x4D >> 1, rounded down)
-static constexpr uint8_t CH423_REG_OCL = 0x22;    // Write OC7-OC0 (0x44 >> 1)
-static constexpr uint8_t CH423_REG_OCH = 0x23;    // Write OC15-OC8 (0x46 >> 1)
-
-static const char *const TAG = "ch423";
-
-void CH423Component::setup() {
-  // set outputs before mode
-  this->write_outputs_();
-  // Set system parameters and check for errors
-  bool success = this->write_reg_(CH423_REG_SYS, this->sys_params_);
-  // Only read inputs if pins are configured for input (IO_OE not set)
-  if (success && !(this->sys_params_ & CH423_SYS_IO_OE)) {
-    success = this->read_inputs_();
-  }
-  if (!success) {
-    ESP_LOGE(TAG, "CH423 not detected");
-    this->mark_failed();
-    return;
-  }
-
-  ESP_LOGCONFIG(TAG, "Initialization complete. Warning: %d, Error: %d", this->status_has_warning(),
-                this->status_has_error());
-}
-
-void CH423Component::loop() {
-  // Clear all the previously read flags.
-  this->pin_read_flags_ = 0x00;
-}
-
-void CH423Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "CH423:");
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-  }
-}
-
-void CH423Component::pin_mode(uint8_t pin, gpio::Flags flags) {
-  if (pin < 8) {
-    if (flags & gpio::FLAG_OUTPUT) {
-      this->sys_params_ |= CH423_SYS_IO_OE;
-    }
-  } else if (pin >= 8 && pin < 24) {
-    if (flags & gpio::FLAG_OPEN_DRAIN) {
-      this->sys_params_ |= CH423_SYS_OD_EN;
-    }
-  }
-}
-
-bool CH423Component::digital_read(uint8_t pin) {
-  if (this->pin_read_flags_ == 0 || this->pin_read_flags_ & (1 << pin)) {
-    // Read values on first access or in case it's being read again in the same loop
-    this->read_inputs_();
-  }
-
-  this->pin_read_flags_ |= (1 << pin);
-  return (this->input_bits_ & (1 << pin)) != 0;
-}
-
-void CH423Component::digital_write(uint8_t pin, bool value) {
-  if (value) {
-    this->output_bits_ |= (1 << pin);
-  } else {
-    this->output_bits_ &= ~(1 << pin);
-  }
-  this->write_outputs_();
-}
-
-bool CH423Component::read_inputs_() {
-  if (this->is_failed()) {
-    return false;
-  }
-  // reading inputs requires IO_OE to be 0
-  if (this->sys_params_ & CH423_SYS_IO_OE) {
-    return false;
-  }
-  uint8_t result = this->read_reg_(CH423_REG_IO_RD);
-  this->input_bits_ = result;
-  this->status_clear_warning();
-  return true;
-}
-
-// Write a register. Can't use the standard write_byte() method because there is no single pre-configured i2c address.
-bool CH423Component::write_reg_(uint8_t reg, uint8_t value) {
-  auto err = this->bus_->write_readv(reg, &value, 1, nullptr, 0);
-  if (err != i2c::ERROR_OK) {
-    char buf[64];
-    ESPHOME_snprintf_P(buf, sizeof(buf), ESPHOME_PSTR("write failed for register 0x%X, error %d"), reg, err);
-    this->status_set_warning(buf);
-    return false;
-  }
-  this->status_clear_warning();
-  return true;
-}
-
-uint8_t CH423Component::read_reg_(uint8_t reg) {
-  uint8_t value;
-  auto err = this->bus_->write_readv(reg, nullptr, 0, &value, 1);
-  if (err != i2c::ERROR_OK) {
-    char buf[64];
-    ESPHOME_snprintf_P(buf, sizeof(buf), ESPHOME_PSTR("read failed for register 0x%X, error %d"), reg, err);
-    this->status_set_warning(buf);
-    return 0;
-  }
-  this->status_clear_warning();
-  return value;
-}
-
-bool CH423Component::write_outputs_() {
-  bool success = true;
-  // Write IO7-IO0
-  success &= this->write_reg_(CH423_REG_IO, static_cast<uint8_t>(this->output_bits_));
-  // Write OC7-OC0
-  success &= this->write_reg_(CH423_REG_OCL, static_cast<uint8_t>(this->output_bits_ >> 8));
-  // Write OC15-OC8
-  success &= this->write_reg_(CH423_REG_OCH, static_cast<uint8_t>(this->output_bits_ >> 16));
-  return success;
-}
-
-float CH423Component::get_setup_priority() const { return setup_priority::IO; }
-
-// Run our loop() method very early in the loop, so that we cache read values
-// before other components call our digital_read() method.
-float CH423Component::get_loop_priority() const { return 9.0f; }  // Just after WIFI
-
-void CH423GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
-bool CH423GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) ^ this->inverted_; }
-
-void CH423GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value ^ this->inverted_); }
-size_t CH423GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "EXIO%u via CH423", this->pin_);
-}
-void CH423GPIOPin::set_flags(gpio::Flags flags) {
-  flags_ = flags;
-  this->parent_->pin_mode(this->pin_, flags);
-}
-
-}  // namespace esphome::ch423
--- a/esphome/components/ch423/ch423.h
+++ b/esphome/components/ch423/ch423.h
@@ -1,67 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/hal.h"
-#include "esphome/components/i2c/i2c.h"
-
-namespace esphome::ch423 {
-
-class CH423Component : public Component, public i2c::I2CDevice {
- public:
-  CH423Component() = default;
-
-  /// Check i2c availability and setup masks
-  void setup() override;
-  /// Poll for input changes periodically
-  void loop() override;
-  /// Helper function to read the value of a pin.
-  bool digital_read(uint8_t pin);
-  /// Helper function to write the value of a pin.
-  void digital_write(uint8_t pin, bool value);
-  /// Helper function to set the pin mode of a pin.
-  void pin_mode(uint8_t pin, gpio::Flags flags);
-
-  float get_setup_priority() const override;
-  float get_loop_priority() const override;
-  void dump_config() override;
-
- protected:
-  bool write_reg_(uint8_t reg, uint8_t value);
-  uint8_t read_reg_(uint8_t reg);
-  bool read_inputs_();
-  bool write_outputs_();
-
-  /// The mask to write as output state - 1 means HIGH, 0 means LOW
-  uint32_t output_bits_{0x00};
-  /// Flags to check if read previously during this loop
-  uint8_t pin_read_flags_{0x00};
-  /// Copy of last read values
-  uint8_t input_bits_{0x00};
-  /// System parameters
-  uint8_t sys_params_{0x00};
-};
-
-/// Helper class to expose a CH423 pin as a GPIO pin.
-class CH423GPIOPin : public GPIOPin {
- public:
-  void setup() override{};
-  void pin_mode(gpio::Flags flags) override;
-  bool digital_read() override;
-  void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
-
-  void set_parent(CH423Component *parent) { parent_ = parent; }
-  void set_pin(uint8_t pin) { pin_ = pin; }
-  void set_inverted(bool inverted) { inverted_ = inverted; }
-  void set_flags(gpio::Flags flags);
-
-  gpio::Flags get_flags() const override { return this->flags_; }
-
- protected:
-  CH423Component *parent_{};
-  uint8_t pin_{};
-  bool inverted_{};
-  gpio::Flags flags_{};
-};
-
-}  // namespace esphome::ch423
--- a/esphome/components/display/init.py
+++ b/esphome/components/display/init.py
@@ -15,7 +15,7 @@ from esphome.const import (
    CONF_UPDATE_INTERVAL,
    SCHEDULER_DONT_RUN,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority

 IS_PLATFORM_COMPONENT = True

@@ -222,8 +222,3 @@ async def display_is_displaying_page_to_code(config, condition_id, template_arg,
 async def to_code(config):
    cg.add_global(display_ns.using)
    cg.add_define("USE_DISPLAY")
-    if CORE.is_esp32:
-        # Re-enable ESP-IDF's LCD driver (excluded by default to save compile time)
-        from esphome.components.esp32 import include_builtin_idf_component
-
-        include_builtin_idf_component("esp_lcd")
--- a/esphome/components/es8156/audio_dac.py
+++ b/esphome/components/es8156/audio_dac.py
@@ -2,8 +2,7 @@ import esphome.codegen as cg
 from esphome.components import i2c
 from esphome.components.audio_dac import AudioDac
 import esphome.config_validation as cv
-from esphome.const import CONF_AUDIO_DAC, CONF_BITS_PER_SAMPLE, CONF_ID
-import esphome.final_validate as fv
+from esphome.const import CONF_ID

 CODEOWNERS = ["@kbx81"]
 DEPENDENCIES = ["i2c"]
@@ -22,29 +21,6 @@ CONFIG_SCHEMA = (
 )


-def _final_validate(config):
-    full_config = fv.full_config.get()
-
-    # Check all speaker configurations for ones that reference this es8156
-    speaker_configs = full_config.get("speaker", [])
-    for speaker_config in speaker_configs:
-        audio_dac_id = speaker_config.get(CONF_AUDIO_DAC)
-        if (
-            audio_dac_id is not None
-            and audio_dac_id == config[CONF_ID]
-            and (bits_per_sample := speaker_config.get(CONF_BITS_PER_SAMPLE))
-            is not None
-            and bits_per_sample > 24
-        ):
-            raise cv.Invalid(
-                f"ES8156 does not support more than 24 bits per sample. "
-                f"The speaker referencing this audio_dac has bits_per_sample set to {bits_per_sample}."
-            )
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
--- a/esphome/components/es8156/es8156.cpp
+++ b/esphome/components/es8156/es8156.cpp
@@ -17,61 +17,24 @@ static const char *const TAG = "es8156";
  }

 void ES8156::setup() {
-  // REG02 MODE CONFIG 1: Enable software mode for I2C control of volume/mute
-  // Bit 2: SOFT_MODE_SEL=1 (software mode enabled)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG02_SCLK_MODE, 0x04));
-
-  // Analog system configuration (active-low power down bits, active-high enables)
-  // REG20 ANALOG SYSTEM: Configure analog signal path
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG20_ANALOG_SYS1, 0x2A));
-
-  // REG21 ANALOG SYSTEM: VSEL=0x1C (bias level ~120%), normal VREF ramp speed
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG21_ANALOG_SYS2, 0x3C));
-
-  // REG22 ANALOG SYSTEM: Line out mode (HPSW=0), OUT_MUTE=0 (not muted)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG22_ANALOG_SYS3, 0x00));
-
-  // REG24 ANALOG SYSTEM: Low power mode for VREFBUF, HPCOM, DACVRP; DAC normal power
-  // Bits 2:0 = 0x07: LPVREFBUF=1, LPHPCOM=1, LPDACVRP=1, LPDAC=0
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG24_ANALOG_LP, 0x07));
-
-  // REG23 ANALOG SYSTEM: Lowest bias (IBIAS_SW=0), VMIDLVL=VDDA/2, normal impedance
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG23_ANALOG_SYS4, 0x00));

-  // Timing and interface configuration
-  // REG0A/0B TIME CONTROL: Fast state machine transitions
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0A_TIME_CONTROL1, 0x01));
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0B_TIME_CONTROL2, 0x01));
-
-  // REG11 SDP INTERFACE CONFIG: Default I2S format (24-bit, I2S mode)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG11_DAC_SDP, 0x00));
-
-  // REG19 EQ CONTROL 1: EQ disabled (EQ_ON=0), EQ_BAND_NUM=2
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG19_EQ_CONTROL1, 0x20));

-  // REG0D P2S CONTROL: Parallel-to-serial converter settings
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0D_P2S_CONTROL, 0x14));
-
-  // REG09 MISC CONTROL 2: Default settings
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG09_MISC_CONTROL2, 0x00));
-
-  // REG18 MISC CONTROL 3: Stereo channel routing, no inversion
-  // Bits 5:4 CHN_CROSS: 0=L→L/R→R, 1=L to both, 2=R to both, 3=swap L/R
-  // Bits 3:2: LCH_INV/RCH_INV channel inversion
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG18_MISC_CONTROL3, 0x00));
-
-  // REG08 CLOCK OFF: Enable all internal clocks (0x3F = all clock gates open)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG08_CLOCK_ON_OFF, 0x3F));
-
-  // REG00 RESET CONTROL: Reset sequence
-  // First: RST_DIG=1 (assert digital reset)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x02));
-  // Then: CSM_ON=1 (enable chip state machine), RST_DIG=1
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x03));
-
-  // REG25 ANALOG SYSTEM: Power up analog blocks
-  // VMIDSEL=2 (normal VMID operation), PDN_ANA=0, ENREFR=0, ENHPCOM=0
-  // PDN_DACVREFGEN=0, PDN_VREFBUF=0, PDN_DAC=0 (all enabled)
  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG25_ANALOG_SYS5, 0x20));
 }

--- a/esphome/components/esp32/init.py
+++ b/esphome/components/esp32/init.py
@@ -5,7 +5,6 @@ import logging
 import os
 from pathlib import Path
 import re
-import shutil

 from esphome import yaml_util
 import esphome.codegen as cg
@@ -51,11 +50,9 @@ from esphome.writer import clean_cmake_cache

 from .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
-    KEY_ARDUINO_LIBRARIES,
    KEY_BOARD,
    KEY_COMPONENTS,
    KEY_ESP32,
-    KEY_EXCLUDE_COMPONENTS,
    KEY_EXTRA_BUILD_FILES,
    KEY_FLASH_SIZE,
    KEY_FULL_CERT_BUNDLE,
@@ -89,7 +86,6 @@ IS_TARGET_PLATFORM = True
 CONF_ASSERTION_LEVEL = "assertion_level"
 CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
 CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
-CONF_INCLUDE_BUILTIN_IDF_COMPONENTS = "include_builtin_idf_components"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_ENABLE_OTA_ROLLBACK = "enable_ota_rollback"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
@@ -118,198 +114,6 @@ COMPILER_OPTIMIZATIONS = {
    "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
 }

-# ESP-IDF components excluded by default to reduce compile time.
-# Components can be re-enabled by calling include_builtin_idf_component() in to_code().
-#
-# Cannot be excluded (dependencies of required components):
-# - "console": espressif/mdns unconditionally depends on it
-# - "sdmmc": driver -> esp_driver_sdmmc -> sdmmc dependency chain
-DEFAULT_EXCLUDED_IDF_COMPONENTS = (
-    "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
-    "esp_adc",  # ADC driver - only needed by adc component
-    "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
-    "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
-    "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
-    "esp_eth",  # Ethernet driver - only needed by ethernet component
-    "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
-    "esp_http_client",  # HTTP client - only needed by http_request component
-    "esp_https_ota",  # ESP-IDF HTTPS OTA - ESPHome has its own OTA implementation
-    "esp_https_server",  # HTTPS server - ESPHome has its own web server
-    "esp_lcd",  # LCD controller drivers - only needed by display component
-    "esp_local_ctrl",  # Local control over HTTPS/BLE - ESPHome has native API
-    "espcoredump",  # Core dump support - ESPHome has its own debug component
-    "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
-    "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
-    "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
-    "protocomm",  # Protocol communication for provisioning - unused by ESPHome
-    "spiffs",  # SPIFFS filesystem - ESPHome doesn't use filesystem storage (IDF only)
-    "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
-    "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
-    "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation
-)
-
-# Additional IDF managed components to exclude for Arduino framework builds
-# These are pulled in by the Arduino framework's idf_component.yml but not used by ESPHome
-# Note: Component names include the namespace prefix (e.g., "espressif__cbor") because
-# that's how managed components are registered in the IDF build system
-# List includes direct dependencies from arduino-esp32/idf_component.yml
-# plus transitive dependencies from RainMaker/Insights (except espressif/mdns which we need)
-ARDUINO_EXCLUDED_IDF_COMPONENTS = (
-    "chmorgan__esp-libhelix-mp3",  # MP3 decoder - not used
-    "espressif__cbor",  # CBOR library - only used by RainMaker/Insights
-    "espressif__esp-dsp",  # DSP library - not used
-    "espressif__esp-modbus",  # Modbus - ESPHome has its own
-    "espressif__esp-sr",  # Speech recognition - not used
-    "espressif__esp-zboss-lib",  # Zigbee ZBOSS library - not used
-    "espressif__esp-zigbee-lib",  # Zigbee library - not used
-    "espressif__esp_diag_data_store",  # Diagnostics - not used
-    "espressif__esp_diagnostics",  # Diagnostics - not used
-    "espressif__esp_hosted",  # ESP hosted - only for ESP32-P4
-    "espressif__esp_insights",  # ESP Insights - not used
-    "espressif__esp_modem",  # Modem library - not used
-    "espressif__esp_rainmaker",  # RainMaker - not used
-    "espressif__esp_rcp_update",  # RCP update - RainMaker transitive dep
-    "espressif__esp_schedule",  # Schedule - RainMaker transitive dep
-    "espressif__esp_secure_cert_mgr",  # Secure cert - RainMaker transitive dep
-    "espressif__esp_wifi_remote",  # WiFi remote - only for ESP32-P4
-    "espressif__json_generator",  # JSON generator - RainMaker transitive dep
-    "espressif__json_parser",  # JSON parser - RainMaker transitive dep
-    "espressif__lan867x",  # Ethernet PHY - ESPHome uses ESP-IDF ethernet directly
-    "espressif__libsodium",  # Crypto - ESPHome uses its own noise-c library
-    "espressif__network_provisioning",  # Network provisioning - not used
-    "espressif__qrcode",  # QR code - not used
-    "espressif__rmaker_common",  # RainMaker common - not used
-    "joltwallet__littlefs",  # LittleFS - ESPHome doesn't use filesystem
-)
-
-# Mapping of Arduino libraries to IDF managed components they require
-# When an Arduino library is enabled via cg.add_library(), these components
-# are automatically un-stubbed from ARDUINO_EXCLUDED_IDF_COMPONENTS.
-#
-# Note: Some libraries (Matter, LittleFS, ESP_SR, WiFiProv, ArduinoOTA) already have
-# conditional maybe_add_component() calls in arduino-esp32/CMakeLists.txt that handle
-# their managed component dependencies. Our mapping is primarily needed for libraries
-# that don't have such conditionals (Ethernet, PPP, Zigbee, RainMaker, Insights, etc.)
-# and to ensure the stubs are removed from our idf_component.yml overrides.
-ARDUINO_LIBRARY_IDF_COMPONENTS: dict[str, tuple[str, ...]] = {
-    "BLE": ("esp_driver_gptimer",),
-    "BluetoothSerial": ("esp_driver_gptimer",),
-    "ESP_HostedOTA": ("espressif__esp_hosted", "espressif__esp_wifi_remote"),
-    "ESP_SR": ("espressif__esp-sr",),
-    "Ethernet": ("espressif__lan867x",),
-    "FFat": ("fatfs",),
-    "Insights": (
-        "espressif__cbor",
-        "espressif__esp_insights",
-        "espressif__esp_diagnostics",
-        "espressif__esp_diag_data_store",
-        "espressif__rmaker_common",  # Transitive dep from esp_insights
-    ),
-    "LittleFS": ("joltwallet__littlefs",),
-    "Matter": ("espressif__esp_matter",),
-    "PPP": ("espressif__esp_modem",),
-    "RainMaker": (
-        # Direct deps from idf_component.yml
-        "espressif__cbor",
-        "espressif__esp_rainmaker",
-        "espressif__esp_insights",
-        "espressif__esp_diagnostics",
-        "espressif__esp_diag_data_store",
-        "espressif__rmaker_common",
-        "espressif__qrcode",
-        # Transitive deps from esp_rainmaker
-        "espressif__esp_rcp_update",
-        "espressif__esp_schedule",
-        "espressif__esp_secure_cert_mgr",
-        "espressif__json_generator",
-        "espressif__json_parser",
-        "espressif__network_provisioning",
-    ),
-    "SD": ("fatfs",),
-    "SD_MMC": ("fatfs",),
-    "SPIFFS": ("spiffs",),
-    "WiFiProv": ("espressif__network_provisioning", "espressif__qrcode"),
-    "Zigbee": ("espressif__esp-zigbee-lib", "espressif__esp-zboss-lib"),
-}
-
-# Arduino library to Arduino library dependencies
-# When enabling one library, also enable its dependencies
-# Kconfig "select" statements don't work with CONFIG_ARDUINO_SELECTIVE_COMPILATION
-ARDUINO_LIBRARY_DEPENDENCIES: dict[str, tuple[str, ...]] = {
-    "Ethernet": ("Network",),
-    "WiFi": ("Network",),
-}
-
-
-def _idf_component_stub_name(component: str) -> str:
-    """Get stub directory name from IDF component name.
-
-    Component names are typically namespace__name (e.g., espressif__cbor).
-    Returns just the name part (e.g., cbor). If no namespace is present,
-    returns the original component name.
-    """
-    _prefix, sep, suffix = component.partition("__")
-    return suffix if sep else component
-
-
-def _idf_component_dep_name(component: str) -> str:
-    """Convert IDF component name to dependency format.
-
-    Converts espressif__cbor to espressif/cbor.
-    """
-    return component.replace("__", "/")
-
-
-# Arduino libraries to disable by default when using Arduino framework
-# ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
-# (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
-# Components use cg.add_library() which auto-enables any they need
-# This list must match ARDUINO_ALL_LIBRARIES from arduino-esp32/CMakeLists.txt
-ARDUINO_DISABLED_LIBRARIES: frozenset[str] = frozenset(
-    {
-        "ArduinoOTA",
-        "AsyncUDP",
-        "BLE",
-        "BluetoothSerial",
-        "DNSServer",
-        "EEPROM",
-        "ESP_HostedOTA",
-        "ESP_I2S",
-        "ESP_NOW",
-        "ESP_SR",
-        "ESPmDNS",
-        "Ethernet",
-        "FFat",
-        "FS",
-        "Hash",
-        "HTTPClient",
-        "HTTPUpdate",
-        "Insights",
-        "LittleFS",
-        "Matter",
-        "NetBIOS",
-        "Network",
-        "NetworkClientSecure",
-        "OpenThread",
-        "PPP",
-        "Preferences",
-        "RainMaker",
-        "SD",
-        "SD_MMC",
-        "SimpleBLE",
-        "SPI",
-        "SPIFFS",
-        "Ticker",
-        "Update",
-        "USB",
-        "WebServer",
-        "WiFi",
-        "WiFiProv",
-        "Wire",
-        "Zigbee",
-    }
-)
-
 # ESP32 (original) chip revision options
 # Setting minimum revision to 3.0 or higher:
 # - Reduces flash size by excluding workaround code for older chip bugs
@@ -399,15 +203,6 @@ def set_core_data(config):
            )
    CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] = {}
    CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
-    # Initialize with default exclusions - components can call include_builtin_idf_component()
-    # to re-enable any they need
-    excluded = set(DEFAULT_EXCLUDED_IDF_COMPONENTS)
-    # Add Arduino-specific managed component exclusions when using Arduino framework
-    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
-        excluded.update(ARDUINO_EXCLUDED_IDF_COMPONENTS)
-    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] = excluded
-    # Initialize Arduino library tracking - cg.add_library() auto-enables libraries
-    CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES] = set()
    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
        config[CONF_FRAMEWORK][CONF_VERSION]
    )
@@ -533,48 +328,6 @@ def add_idf_component(
        }


-def exclude_builtin_idf_component(name: str) -> None:
-    """Exclude an ESP-IDF component from the build.
-
-    This reduces compile time by skipping components that are not needed.
-    The component will be passed to ESP-IDF's EXCLUDE_COMPONENTS cmake variable.
-
-    Note: Components that are dependencies of other required components
-    cannot be excluded - ESP-IDF will still build them.
-    """
-    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS].add(name)
-
-
-def include_builtin_idf_component(name: str) -> None:
-    """Remove an ESP-IDF component from the exclusion list.
-
-    Call this from components that need an ESP-IDF component that is
-    excluded by default in DEFAULT_EXCLUDED_IDF_COMPONENTS. This ensures the
-    component will be built when needed.
-    """
-    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS].discard(name)
-
-
-def _enable_arduino_library(name: str) -> None:
-    """Enable an Arduino library that is disabled by default.
-
-    This is called automatically by CORE.add_library() when a component adds
-    an Arduino library via cg.add_library(). Components should not call this
-    directly - just use cg.add_library("LibName", None).
-
-    Args:
-        name: The library name (e.g., "Wire", "SPI", "WiFi")
-    """
-    enabled_libs: set[str] = CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES]
-    enabled_libs.add(name)
-    # Also enable any required Arduino library dependencies
-    for dep_lib in ARDUINO_LIBRARY_DEPENDENCIES.get(name, ()):
-        enabled_libs.add(dep_lib)
-    # Also enable any required IDF components
-    for idf_component in ARDUINO_LIBRARY_IDF_COMPONENTS.get(name, ()):
-        include_builtin_idf_component(idf_component)
-
-
 def add_extra_script(stage: str, filename: str, path: Path):
    """Add an extra script to the project."""
    key = f"{stage}:{filename}"
@@ -919,26 +672,11 @@ CONF_RINGBUF_IN_IRAM = "ringbuf_in_iram"
 CONF_HEAP_IN_IRAM = "heap_in_iram"
 CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
 CONF_USE_FULL_CERTIFICATE_BUNDLE = "use_full_certificate_bundle"
-CONF_DISABLE_DEBUG_STUBS = "disable_debug_stubs"
-CONF_DISABLE_OCD_AWARE = "disable_ocd_aware"
-CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY = "disable_usb_serial_jtag_secondary"
-CONF_DISABLE_DEV_NULL_VFS = "disable_dev_null_vfs"
-CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
-CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
-CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
-CONF_DISABLE_FATFS = "disable_fatfs"

 # VFS requirement tracking
-# Components that need VFS features can call require_vfs_*() functions
+# Components that need VFS features can call require_vfs_select() or require_vfs_dir()
 KEY_VFS_SELECT_REQUIRED = "vfs_select_required"
 KEY_VFS_DIR_REQUIRED = "vfs_dir_required"
-KEY_VFS_TERMIOS_REQUIRED = "vfs_termios_required"
-# Feature requirement tracking - components can call require_* functions to re-enable
-# These are stored in CORE.data[KEY_ESP32] dict
-KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED = "usb_serial_jtag_secondary_required"
-KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
-KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
-KEY_FATFS_REQUIRED = "fatfs_required"


 def require_vfs_select() -> None:
@@ -959,15 +697,6 @@ def require_vfs_dir() -> None:
    CORE.data[KEY_VFS_DIR_REQUIRED] = True


-def require_vfs_termios() -> None:
-    """Mark that VFS termios support is required by a component.
-
-    Call this from components that use terminal I/O functions (usb_serial_jtag_vfs_*, etc.).
-    This prevents CONFIG_VFS_SUPPORT_TERMIOS from being disabled.
-    """
-    CORE.data[KEY_VFS_TERMIOS_REQUIRED] = True
-
-
 def require_full_certificate_bundle() -> None:
    """Request the full certificate bundle instead of the common-CAs-only bundle.

@@ -980,43 +709,6 @@ def require_full_certificate_bundle() -> None:
    CORE.data[KEY_ESP32][KEY_FULL_CERT_BUNDLE] = True


-def require_usb_serial_jtag_secondary() -> None:
-    """Mark that USB Serial/JTAG secondary console is required by a component.
-
-    Call this from components (e.g., logger) that need USB Serial/JTAG console output.
-    This prevents CONFIG_ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG from being disabled.
-    """
-    CORE.data[KEY_ESP32][KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED] = True
-
-
-def require_mbedtls_peer_cert() -> None:
-    """Mark that mbedTLS peer certificate retention is required by a component.
-
-    Call this from components that need access to the peer certificate after
-    the TLS handshake is complete. This prevents CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
-    from being disabled.
-    """
-    CORE.data[KEY_ESP32][KEY_MBEDTLS_PEER_CERT_REQUIRED] = True
-
-
-def require_mbedtls_pkcs7() -> None:
-    """Mark that mbedTLS PKCS#7 support is required by a component.
-
-    Call this from components that need PKCS#7 certificate validation.
-    This prevents CONFIG_MBEDTLS_PKCS7_C from being disabled.
-    """
-    CORE.data[KEY_ESP32][KEY_MBEDTLS_PKCS7_REQUIRED] = True
-
-
-def require_fatfs() -> None:
-    """Mark that FATFS support is required by a component.
-
-    Call this from components that use FATFS (e.g., SD card, storage components).
-    This prevents FATFS from being disabled when disable_fatfs is set.
-    """
-    CORE.data[KEY_ESP32][KEY_FATFS_REQUIRED] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
    """Parse IDF component shorthand syntax like 'owner/component^version'"""
    # Match operator followed by version-like string (digit or *)
@@ -1101,19 +793,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                cv.Optional(
                    CONF_USE_FULL_CERTIFICATE_BUNDLE, default=False
                ): cv.boolean,
-                cv.Optional(
-                    CONF_INCLUDE_BUILTIN_IDF_COMPONENTS, default=[]
-                ): cv.ensure_list(cv.string_strict),
-                cv.Optional(CONF_DISABLE_DEBUG_STUBS, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_OCD_AWARE, default=True): cv.boolean,
-                cv.Optional(
-                    CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY, default=True
-                ): cv.boolean,
-                cv.Optional(CONF_DISABLE_DEV_NULL_VFS, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
            }
        ),
        cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -1303,40 +982,6 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
    add_idf_sdkconfig_option("CONFIG_LWIP_MAX_SOCKETS", max_sockets)


-@coroutine_with_priority(CoroPriority.FINAL)
-async def _write_exclude_components() -> None:
-    """Write EXCLUDE_COMPONENTS cmake arg after all components have registered exclusions."""
-    if KEY_ESP32 not in CORE.data:
-        return
-    excluded = CORE.data[KEY_ESP32].get(KEY_EXCLUDE_COMPONENTS)
-    if excluded:
-        exclude_list = ";".join(sorted(excluded))
-        cg.add_platformio_option(
-            "board_build.cmake_extra_args", f"-DEXCLUDE_COMPONENTS={exclude_list}"
-        )
-
-
-@coroutine_with_priority(CoroPriority.FINAL)
-async def _write_arduino_libraries_sdkconfig() -> None:
-    """Write Arduino selective compilation sdkconfig after all components have added libraries.
-
-    This must run at FINAL priority so that all components have had a chance to call
-    cg.add_library() which auto-enables Arduino libraries via _enable_arduino_library().
-    """
-    if KEY_ESP32 not in CORE.data:
-        return
-    # Enable Arduino selective compilation to disable unused Arduino libraries
-    # ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
-    # (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
-    # cg.add_library() auto-enables needed libraries; users can also add
-    # libraries via esphome: libraries: config which calls cg.add_library()
-    add_idf_sdkconfig_option("CONFIG_ARDUINO_SELECTIVE_COMPILATION", True)
-    enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
-    for lib in ARDUINO_DISABLED_LIBRARIES:
-        # Enable if explicitly requested, disable otherwise
-        add_idf_sdkconfig_option(f"CONFIG_ARDUINO_SELECTIVE_{lib}", lib in enabled_libs)
-
-
@coroutine_with_priority(CoroPriority.FINAL)
 async def _add_yaml_idf_components(components: list[ConfigType]):
    """Add IDF components from YAML config with final priority to override code-added components."""
@@ -1550,11 +1195,6 @@ async def to_code(config):

    # Apply LWIP optimization settings
    advanced = conf[CONF_ADVANCED]
-
-    # Re-include any IDF components the user explicitly requested
-    for component_name in advanced.get(CONF_INCLUDE_BUILTIN_IDF_COMPONENTS, []):
-        include_builtin_idf_component(component_name)
-
    # DHCP server: only disable if explicitly set to false
    # WiFi component handles its own optimization when AP mode is not used
    # When using Arduino with Ethernet, DHCP server functions must be available
@@ -1593,18 +1233,11 @@ async def to_code(config):
        add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)

    # Disable VFS support for termios (terminal I/O functions)
-    # USB Serial JTAG VFS functions require termios support.
-    # Components that need it (e.g., logger when USB_SERIAL_JTAG is supported but not selected
-    # as the logger output) call require_vfs_termios().
+    # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
    # Saves approximately 1.8KB of flash when disabled (default).
-    if CORE.data.get(KEY_VFS_TERMIOS_REQUIRED, False):
-        # Component requires VFS termios - force enable regardless of user setting
-        add_idf_sdkconfig_option("CONFIG_VFS_SUPPORT_TERMIOS", True)
-    else:
-        # No component needs it - allow user to control (default: disabled)
-        add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
-        )
+    add_idf_sdkconfig_option(
+        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
+    )

    # Disable VFS support for select() with file descriptors
    # ESPHome only uses select() with sockets via lwip_select(), which still works.
@@ -1683,61 +1316,6 @@ async def to_code(config):

    add_idf_sdkconfig_option(f"CONFIG_LOG_DEFAULT_LEVEL_{conf[CONF_LOG_LEVEL]}", True)

-    # Disable OpenOCD debug stubs to save code size
-    # These are used for on-chip debugging with OpenOCD/JTAG, rarely needed for ESPHome
-    if advanced[CONF_DISABLE_DEBUG_STUBS]:
-        add_idf_sdkconfig_option("CONFIG_ESP_DEBUG_STUBS_ENABLE", False)
-
-    # Disable OCD-aware exception handlers
-    # When enabled, the panic handler detects JTAG debugger and halts instead of resetting
-    # Most ESPHome users don't use JTAG debugging
-    if advanced[CONF_DISABLE_OCD_AWARE]:
-        add_idf_sdkconfig_option("CONFIG_ESP_DEBUG_OCDAWARE", False)
-
-    # Disable USB Serial/JTAG secondary console
-    # Components like logger can call require_usb_serial_jtag_secondary() to re-enable
-    if CORE.data[KEY_ESP32].get(KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED, False):
-        add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG", True)
-    elif advanced[CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY]:
-        add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_SECONDARY_NONE", True)
-
-    # Disable /dev/null VFS initialization
-    # ESPHome doesn't typically need /dev/null
-    if advanced[CONF_DISABLE_DEV_NULL_VFS]:
-        add_idf_sdkconfig_option("CONFIG_VFS_INITIALIZE_DEV_NULL", False)
-
-    # Disable keeping peer certificate after TLS handshake
-    # Saves ~4KB heap per connection, but prevents certificate inspection after handshake
-    # Components that need it can call require_mbedtls_peer_cert()
-    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PEER_CERT_REQUIRED, False):
-        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", True)
-    elif advanced[CONF_DISABLE_MBEDTLS_PEER_CERT]:
-        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", False)
-
-    # Disable PKCS#7 support in mbedTLS
-    # Only needed for specific certificate validation scenarios
-    # Components that need it can call require_mbedtls_pkcs7()
-    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PKCS7_REQUIRED, False):
-        # Component called require_mbedtls_pkcs7() - enable regardless of user setting
-        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", True)
-    elif advanced[CONF_DISABLE_MBEDTLS_PKCS7]:
-        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", False)
-
-    # Disable regi2c control functions in IRAM
-    # Only needed if using analog peripherals (ADC, DAC, etc.) from ISRs while cache is disabled
-    if advanced[CONF_DISABLE_REGI2C_IN_IRAM]:
-        add_idf_sdkconfig_option("CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM", False)
-
-    # Disable FATFS support
-    # Components that need FATFS (SD card, etc.) can call require_fatfs()
-    if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):
-        # Component called require_fatfs() - enable regardless of user setting
-        add_idf_sdkconfig_option("CONFIG_FATFS_LFN_NONE", False)
-        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 2)
-    elif advanced[CONF_DISABLE_FATFS]:
-        add_idf_sdkconfig_option("CONFIG_FATFS_LFN_NONE", True)
-        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 0)
-
    for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
        add_idf_sdkconfig_option(name, RawSdkconfigValue(value))

@@ -1746,16 +1324,6 @@ async def to_code(config):
    if conf[CONF_COMPONENTS]:
        CORE.add_job(_add_yaml_idf_components, conf[CONF_COMPONENTS])

-    # Write EXCLUDE_COMPONENTS at FINAL priority after all components have had
-    # a chance to call include_builtin_idf_component() to re-enable components they need.
-    # Default exclusions are added in set_core_data() during config validation.
-    CORE.add_job(_write_exclude_components)
-
-    # Write Arduino selective compilation sdkconfig at FINAL priority after all
-    # components have had a chance to call cg.add_library() to enable libraries they need.
-    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
-        CORE.add_job(_write_arduino_libraries_sdkconfig)
-

 APP_PARTITION_SIZES = {
    "2MB": 0x0C0000,  # 768 KB
@@ -1836,49 +1404,11 @@ def _write_sdkconfig():

 def _write_idf_component_yml():
    yml_path = CORE.relative_build_path("src/idf_component.yml")
-    dependencies: dict[str, dict] = {}
-
-    # For Arduino builds, override unused managed components from the Arduino framework
-    # by pointing them to empty stub directories using override_path
-    # This prevents the IDF component manager from downloading the real components
-    if CORE.using_arduino:
-        # Determine which IDF components are needed by enabled Arduino libraries
-        enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
-        required_idf_components = {
-            comp
-            for lib in enabled_libs
-            for comp in ARDUINO_LIBRARY_IDF_COMPONENTS.get(lib, ())
-        }
-
-        # Only stub components that are not required by any enabled Arduino library
-        components_to_stub = (
-            set(ARDUINO_EXCLUDED_IDF_COMPONENTS) - required_idf_components
-        )
-
-        stubs_dir = CORE.relative_build_path("component_stubs")
-        stubs_dir.mkdir(exist_ok=True)
-        for component_name in components_to_stub:
-            # Create stub directory with minimal CMakeLists.txt
-            stub_path = stubs_dir / _idf_component_stub_name(component_name)
-            stub_path.mkdir(exist_ok=True)
-            stub_cmake = stub_path / "CMakeLists.txt"
-            if not stub_cmake.exists():
-                stub_cmake.write_text("idf_component_register()\n")
-            dependencies[_idf_component_dep_name(component_name)] = {
-                "version": "*",
-                "override_path": str(stub_path),
-            }
-
-        # Remove stubs for components that are now required by enabled libraries
-        for component_name in required_idf_components:
-            stub_path = stubs_dir / _idf_component_stub_name(component_name)
-            if stub_path.exists():
-                shutil.rmtree(stub_path)
-
    if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
        components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
+        dependencies = {}
        for name, component in components.items():
-            dependency: dict[str, str] = {}
+            dependency = {}
            if component[KEY_REF]:
                dependency["version"] = component[KEY_REF]
            if component[KEY_REPO]:
@@ -1886,8 +1416,9 @@ def _write_idf_component_yml():
            if component[KEY_PATH]:
                dependency["path"] = component[KEY_PATH]
            dependencies[name] = dependency
-
-    contents = yaml_util.dump({"dependencies": dependencies}) if dependencies else ""
+        contents = yaml_util.dump({"dependencies": dependencies})
+    else:
+        contents = ""
    if write_file_if_changed(yml_path, contents):
        dependencies_lock = CORE.relative_build_path("dependencies.lock")
        if dependencies_lock.is_file():
--- a/esphome/components/esp32/const.py
+++ b/esphome/components/esp32/const.py
@@ -6,8 +6,6 @@ KEY_FLASH_SIZE = "flash_size"
 KEY_VARIANT = "variant"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"
 KEY_COMPONENTS = "components"
-KEY_EXCLUDE_COMPONENTS = "exclude_components"
-KEY_ARDUINO_LIBRARIES = "arduino_libraries"
 KEY_REPO = "repo"
 KEY_REF = "ref"
 KEY_REFRESH = "refresh"
--- a/esphome/components/esp32_ble/ble_uuid.h
+++ b/esphome/components/esp32_ble/ble_uuid.h
@@ -48,7 +48,7 @@ class ESPBTUUID {

  // Remove before 2026.8.0
  ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const;
+  std::string to_string() const;  // NOLINT
  const char *to_str(std::span<char, UUID_STR_LEN> output) const;

 protected:
--- a/esphome/components/esp32_rmt_led_strip/light.py
+++ b/esphome/components/esp32_rmt_led_strip/light.py
@@ -5,7 +5,6 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import esp32, light
 from esphome.components.const import CONF_USE_PSRAM
-from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CHIPSET,
@@ -130,9 +129,6 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config):
-    # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
-    include_builtin_idf_component("esp_driver_rmt")
-
    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
    await light.register_light(var, config)
    await cg.register_component(var, config)
--- a/esphome/components/esp32_touch/init.py
+++ b/esphome/components/esp32_touch/init.py
@@ -6,7 +6,6 @@ from esphome.components.esp32 import (
    VARIANT_ESP32S3,
    get_esp32_variant,
    gpio,
-    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -267,9 +266,6 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config):
-    # Re-enable ESP-IDF's touch sensor driver (excluded by default to save compile time)
-    include_builtin_idf_component("esp_driver_touch_sens")
-
    touch = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(touch, config)

--- a/esphome/components/espnow/init.py
+++ b/esphome/components/espnow/init.py
@@ -13,7 +13,7 @@ from esphome.const import (
    CONF_TRIGGER_ID,
    CONF_WIFI,
 )
-from esphome.core import HexInt
+from esphome.core import CORE, HexInt
 from esphome.types import ConfigType

 CODEOWNERS = ["@jesserockz"]
@@ -124,6 +124,9 @@ async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

+    if CORE.using_arduino:
+        cg.add_library("WiFi", None)
+
    # ESP-NOW uses wake_loop_threadsafe() to wake the main loop from ESP-NOW callbacks
    # This enables low-latency event processing instead of waiting for select() timeout
    socket.require_wake_loop_threadsafe()
--- a/esphome/components/ethernet/init.py
+++ b/esphome/components/ethernet/init.py
@@ -14,7 +14,6 @@ from esphome.components.esp32 import (
    add_idf_component,
    add_idf_sdkconfig_option,
    get_esp32_variant,
-    include_builtin_idf_component,
 )
 from esphome.components.network import ip_address_literal
 from esphome.components.spi import CONF_INTERFACE_INDEX, get_spi_interface
@@ -420,13 +419,13 @@ async def to_code(config):
    # Also disable WiFi/BT coexistence since WiFi is disabled
    add_idf_sdkconfig_option("CONFIG_SW_COEXIST_ENABLE", False)

-    # Re-enable ESP-IDF's Ethernet driver (excluded by default to save compile time)
-    include_builtin_idf_component("esp_eth")
-
    if config[CONF_TYPE] == "LAN8670":
        # Add LAN867x 10BASE-T1S PHY support component
        add_idf_component(name="espressif/lan867x", ref="2.0.0")

+    if CORE.using_arduino:
+        cg.add_library("WiFi", None)
+
    CORE.add_job(final_step)


--- a/esphome/components/http_request/init.py
+++ b/esphome/components/http_request/init.py
@@ -155,9 +155,6 @@ async def to_code(config):
        cg.add(var.set_watchdog_timeout(timeout_ms))

    if CORE.is_esp32:
-        # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time)
-        esp32.include_builtin_idf_component("esp_http_client")
-
        cg.add(var.set_buffer_size_rx(config[CONF_BUFFER_SIZE_RX]))
        cg.add(var.set_buffer_size_tx(config[CONF_BUFFER_SIZE_TX]))
        cg.add(var.set_verify_ssl(config[CONF_VERIFY_SSL]))
--- a/esphome/components/i2s_audio/init.py
+++ b/esphome/components/i2s_audio/init.py
@@ -1,11 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
-    add_idf_sdkconfig_option,
-    get_esp32_variant,
-    include_builtin_idf_component,
-)
-from esphome.components.esp32.const import (
    VARIANT_ESP32,
    VARIANT_ESP32C3,
    VARIANT_ESP32C5,
@@ -15,6 +10,8 @@ from esphome.components.esp32.const import (
    VARIANT_ESP32P4,
    VARIANT_ESP32S2,
    VARIANT_ESP32S3,
+    add_idf_sdkconfig_option,
+    get_esp32_variant,
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
@@ -275,10 +272,6 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
-
-    # Re-enable ESP-IDF's I2S driver (excluded by default to save compile time)
-    include_builtin_idf_component("esp_driver_i2s")
-
    if use_legacy():
        cg.add_define("USE_I2S_LEGACY")

--- a/esphome/components/i2s_audio/media_player/init.py
+++ b/esphome/components/i2s_audio/media_player/init.py
@@ -114,7 +114,6 @@ async def to_code(config):
        cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
        cg.add(var.set_i2s_comm_fmt_lsb(config[CONF_I2S_COMM_FMT] == "lsb"))

-    cg.add_library("WiFi", None)
    cg.add_library("NetworkClientSecure", None)
    cg.add_library("HTTPClient", None)
    cg.add_library("esphome/ESP32-audioI2S", "2.3.0")
--- a/esphome/components/logger/init.py
+++ b/esphome/components/logger/init.py
@@ -16,8 +16,6 @@ from esphome.components.esp32 import (
    VARIANT_ESP32S3,
    add_idf_sdkconfig_option,
    get_esp32_variant,
-    require_usb_serial_jtag_secondary,
-    require_vfs_termios,
 )
 from esphome.components.libretiny import get_libretiny_component, get_libretiny_family
 from esphome.components.libretiny.const import (
@@ -399,15 +397,9 @@ async def to_code(config):
        elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
            add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG", True)
            cg.add_define("USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG")
-    # Define platform support flags for components that need auto-detection
    try:
        uart_selection(USB_SERIAL_JTAG)
        cg.add_define("USE_LOGGER_USB_SERIAL_JTAG")
-        # USB Serial JTAG code is compiled when platform supports it.
-        # Enable secondary USB serial JTAG console so the VFS functions are available.
-        if CORE.is_esp32 and config[CONF_HARDWARE_UART] != USB_SERIAL_JTAG:
-            require_usb_serial_jtag_secondary()
-            require_vfs_termios()
    except cv.Invalid:
        pass
    try:
--- a/esphome/components/mdns/mdns_esp32.cpp
+++ b/esphome/components/mdns/mdns_esp32.cpp
@@ -12,10 +12,6 @@ namespace esphome::mdns {
 static const char *const TAG = "mdns";

 static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services) {
-#ifdef USE_OPENTHREAD
-  // OpenThread handles service registration via SRP client
-  // Services are compiled by MDNSComponent::compile_records_() and consumed by OpenThreadSrpComponent
-#else
  esp_err_t err = mdns_init();
  if (err != ESP_OK) {
    ESP_LOGW(TAG, "Init failed: %s", esp_err_to_name(err));
@@ -45,16 +41,13 @@ static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_S
      ESP_LOGW(TAG, "Failed to register service %s: %s", MDNS_STR_ARG(service.service_type), esp_err_to_name(err));
    }
  }
-#endif
 }

 void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }

 void MDNSComponent::on_shutdown() {
-#ifndef USE_OPENTHREAD
  mdns_free();
  delay(40);  // Allow the mdns packets announcing service removal to be sent
-#endif
 }

 }  // namespace esphome::mdns
--- a/esphome/components/midea/climate.py
+++ b/esphome/components/midea/climate.py
@@ -30,7 +30,7 @@ from esphome.const import (
    UNIT_PERCENT,
    UNIT_WATT,
 )
-from esphome.core import CORE, coroutine
+from esphome.core import coroutine

 CODEOWNERS = ["@dudanov"]
 DEPENDENCIES = ["climate", "uart"]
@@ -290,7 +290,4 @@ async def to_code(config):
    if CONF_HUMIDITY_SETPOINT in config:
        sens = await sensor.new_sensor(config[CONF_HUMIDITY_SETPOINT])
        cg.add(var.set_humidity_setpoint_sensor(sens))
-    # MideaUART library requires WiFi (WiFi auto-enables Network via dependency mapping)
-    if CORE.is_esp32:
-        cg.add_library("WiFi", None)
    cg.add_library("dudanov/MideaUART", "1.1.9")
--- a/esphome/components/mqtt/init.py
+++ b/esphome/components/mqtt/init.py
@@ -4,10 +4,7 @@ from esphome import automation
 from esphome.automation import Condition
 import esphome.codegen as cg
 from esphome.components import logger, socket
-from esphome.components.esp32 import (
-    add_idf_sdkconfig_option,
-    include_builtin_idf_component,
-)
+from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -363,8 +360,6 @@ async def to_code(config):
    # This enables low-latency MQTT event processing instead of waiting for select() timeout
    if CORE.is_esp32:
        socket.require_wake_loop_threadsafe()
-        # Re-enable ESP-IDF's mqtt component (excluded by default to save compile time)
-        include_builtin_idf_component("mqtt")

    cg.add_define("USE_MQTT")
    cg.add_global(mqtt_ns.using)
--- a/esphome/components/neopixelbus/light.py
+++ b/esphome/components/neopixelbus/light.py
@@ -1,12 +1,7 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import light
-from esphome.components.esp32 import (
-    VARIANT_ESP32C3,
-    VARIANT_ESP32S3,
-    get_esp32_variant,
-    include_builtin_idf_component,
-)
+from esphome.components.esp32 import VARIANT_ESP32C3, VARIANT_ESP32S3, get_esp32_variant
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CHANNEL,
@@ -210,10 +205,6 @@ async def to_code(config):
    has_white = "W" in config[CONF_TYPE]
    method = config[CONF_METHOD]

-    # Re-enable ESP-IDF's RMT driver if using RMT method (excluded by default)
-    if CORE.is_esp32 and method[CONF_TYPE] == METHOD_ESP32_RMT:
-        include_builtin_idf_component("esp_driver_rmt")
-
    method_template = METHODS[method[CONF_TYPE]].to_code(
        method, config[CONF_VARIANT], config[CONF_INVERT]
    )
--- a/esphome/components/network/init.py
+++ b/esphome/components/network/init.py
@@ -137,7 +137,8 @@ CONFIG_SCHEMA = cv.Schema(
@coroutine_with_priority(CoroPriority.NETWORK)
 async def to_code(config):
    cg.add_define("USE_NETWORK")
-    # ESP32 with Arduino uses ESP-IDF network APIs directly, no Arduino Network library needed
+    if CORE.using_arduino and CORE.is_esp32:
+        cg.add_library("Networking", None)

    # Apply high performance networking settings
    # Config can explicitly enable/disable, or default to component-driven behavior
--- a/esphome/components/nextion/display.py
+++ b/esphome/components/nextion/display.py
@@ -177,8 +177,6 @@ async def to_code(config):
        cg.add_define("USE_NEXTION_TFT_UPLOAD")
        cg.add(var.set_tft_url(config[CONF_TFT_URL]))
        if CORE.is_esp32:
-            # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time)
-            esp32.include_builtin_idf_component("esp_http_client")
            esp32.add_idf_sdkconfig_option("CONFIG_ESP_TLS_INSECURE", True)
            esp32.add_idf_sdkconfig_option(
                "CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY", True
--- a/esphome/components/number/init.py
+++ b/esphome/components/number/init.py
@@ -1,6 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import mqtt, web_server, zigbee
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ABOVE,
@@ -189,7 +189,6 @@ validate_unit_of_measurement = cv.string_strict
 _NUMBER_SCHEMA = (
    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
-    .extend(zigbee.NUMBER_SCHEMA)
    .extend(
        {
            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTNumberComponent),
@@ -215,7 +214,6 @@ _NUMBER_SCHEMA = (


 _NUMBER_SCHEMA.add_extra(entity_duplicate_validator("number"))
-_NUMBER_SCHEMA.add_extra(zigbee.validate_number)


 def number_schema(
@@ -279,8 +277,6 @@ async def setup_number_core_(
    if web_server_config := config.get(CONF_WEB_SERVER):
        await web_server.add_entity_config(var, web_server_config)

-    await zigbee.setup_number(var, config, min_value, max_value, step)
-

 async def register_number(
    var, config, *, min_value: float, max_value: float, step: float
--- a/esphome/components/remote_receiver/init.py
+++ b/esphome/components/remote_receiver/init.py
@@ -170,9 +170,6 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
 async def to_code(config):
    pin = await cg.gpio_pin_expression(config[CONF_PIN])
    if CORE.is_esp32:
-        # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
-        esp32.include_builtin_idf_component("esp_driver_rmt")
-
        var = cg.new_Pvariable(config[CONF_ID], pin)
        cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
        cg.add(var.set_receive_symbols(config[CONF_RECEIVE_SYMBOLS]))
--- a/esphome/components/remote_transmitter/init.py
+++ b/esphome/components/remote_transmitter/init.py
@@ -112,9 +112,6 @@ async def digital_write_action_to_code(config, action_id, template_arg, args):
 async def to_code(config):
    pin = await cg.gpio_pin_expression(config[CONF_PIN])
    if CORE.is_esp32:
-        # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
-        esp32.include_builtin_idf_component("esp_driver_rmt")
-
        var = cg.new_Pvariable(config[CONF_ID], pin)
        cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
        cg.add(var.set_non_blocking(config[CONF_NON_BLOCKING]))
--- a/esphome/components/speaker/init.py
+++ b/esphome/components/speaker/init.py
@@ -2,7 +2,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import audio, audio_dac
 import esphome.config_validation as cv
-from esphome.const import CONF_AUDIO_DAC, CONF_DATA, CONF_ID, CONF_VOLUME
+from esphome.const import CONF_DATA, CONF_ID, CONF_VOLUME
 from esphome.core import CORE, ID
 from esphome.coroutine import CoroPriority, coroutine_with_priority

@@ -11,6 +11,8 @@ CODEOWNERS = ["@jesserockz", "@kahrendt"]

 IS_PLATFORM_COMPONENT = True

+CONF_AUDIO_DAC = "audio_dac"
+
 speaker_ns = cg.esphome_ns.namespace("speaker")

 Speaker = speaker_ns.class_("Speaker")
--- a/esphome/components/voice_assistant/voice_assistant.h
+++ b/esphome/components/voice_assistant/voice_assistant.h
@@ -83,7 +83,7 @@ struct Timer {
  }
  // Remove before 2026.8.0
  ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const {
+  std::string to_string() const {  // NOLINT
    char buffer[TO_STR_BUFFER_SIZE];
    return this->to_str(buffer);
  }
--- a/esphome/components/web_server_base/init.py
+++ b/esphome/components/web_server_base/init.py
@@ -38,8 +38,11 @@ async def to_code(config):
        cg.add_define("WEB_SERVER_DEFAULT_HEADERS_COUNT", 1)
        return

-    # ESP32 uses IDF web server (early return above), so this is for other Arduino platforms
    if CORE.using_arduino:
+        if CORE.is_esp32:
+            cg.add_library("WiFi", None)
+            cg.add_library("FS", None)
+            cg.add_library("Update", None)
        if CORE.is_esp8266:
            cg.add_library("ESP8266WiFi", None)
        if CORE.is_libretiny:
--- a/esphome/components/wled/init.py
+++ b/esphome/components/wled/init.py
@@ -3,7 +3,6 @@ from esphome.components.light.effects import register_addressable_effect
 from esphome.components.light.types import AddressableLightEffect
 import esphome.config_validation as cv
 from esphome.const import CONF_NAME, CONF_PORT
-from esphome.core import CORE

 wled_ns = cg.esphome_ns.namespace("wled")
 WLEDLightEffect = wled_ns.class_("WLEDLightEffect", AddressableLightEffect)
@@ -28,6 +27,4 @@ async def wled_light_effect_to_code(config, effect_id):
    cg.add(effect.set_port(config[CONF_PORT]))
    cg.add(effect.set_sync_group_mask(config[CONF_SYNC_GROUP_MASK]))
    cg.add(effect.set_blank_on_start(config[CONF_BLANK_ON_START]))
-    if CORE.is_esp32:
-        cg.add_library("WiFi", None)
    return effect
--- a/esphome/components/zigbee/init.py
+++ b/esphome/components/zigbee/init.py
@@ -24,12 +24,7 @@ from .const_zephyr import (
    ZigbeeComponent,
    zigbee_ns,
 )
-from .zigbee_zephyr import (
-    zephyr_binary_sensor,
-    zephyr_number,
-    zephyr_sensor,
-    zephyr_switch,
-)
+from .zigbee_zephyr import zephyr_binary_sensor, zephyr_sensor, zephyr_switch

 _LOGGER = logging.getLogger(__name__)

@@ -48,7 +43,6 @@ def zigbee_set_core_data(config: ConfigType) -> ConfigType:
 BINARY_SENSOR_SCHEMA = cv.Schema({}).extend(zephyr_binary_sensor)
 SENSOR_SCHEMA = cv.Schema({}).extend(zephyr_sensor)
 SWITCH_SCHEMA = cv.Schema({}).extend(zephyr_switch)
-NUMBER_SCHEMA = cv.Schema({}).extend(zephyr_number)

 CONFIG_SCHEMA = cv.All(
    cv.Schema(
@@ -131,21 +125,6 @@ async def setup_switch(entity: cg.MockObj, config: ConfigType) -> None:
        await zephyr_setup_switch(entity, config)


-async def setup_number(
-    entity: cg.MockObj,
-    config: ConfigType,
-    min_value: float,
-    max_value: float,
-    step: float,
-) -> None:
-    if not config.get(CONF_ZIGBEE_ID) or config.get(CONF_INTERNAL):
-        return
-    if CORE.using_zephyr:
-        from .zigbee_zephyr import zephyr_setup_number
-
-        await zephyr_setup_number(entity, config, min_value, max_value, step)
-
-
 def consume_endpoint(config: ConfigType) -> ConfigType:
    if not config.get(CONF_ZIGBEE_ID) or config.get(CONF_INTERNAL):
        return config
@@ -173,10 +152,6 @@ def validate_switch(config: ConfigType) -> ConfigType:
    return consume_endpoint(config)


-def validate_number(config: ConfigType) -> ConfigType:
-    return consume_endpoint(config)
-
-
 ZIGBEE_ACTION_SCHEMA = automation.maybe_simple_id(
    cv.Schema(
        {
--- a/esphome/components/zigbee/const_zephyr.py
+++ b/esphome/components/zigbee/const_zephyr.py
@@ -4,7 +4,6 @@ zigbee_ns = cg.esphome_ns.namespace("zigbee")
 ZigbeeComponent = zigbee_ns.class_("ZigbeeComponent", cg.Component)
 BinaryAttrs = zigbee_ns.struct("BinaryAttrs")
 AnalogAttrs = zigbee_ns.struct("AnalogAttrs")
-AnalogAttrsOutput = zigbee_ns.struct("AnalogAttrsOutput")

 CONF_MAX_EP_NUMBER = 8
 CONF_ZIGBEE_ID = "zigbee_id"
@@ -13,7 +12,6 @@ CONF_WIPE_ON_BOOT = "wipe_on_boot"
 CONF_ZIGBEE_BINARY_SENSOR = "zigbee_binary_sensor"
 CONF_ZIGBEE_SENSOR = "zigbee_sensor"
 CONF_ZIGBEE_SWITCH = "zigbee_switch"
-CONF_ZIGBEE_NUMBER = "zigbee_number"
 CONF_POWER_SOURCE = "power_source"
 POWER_SOURCE = {
    "UNKNOWN": "ZB_ZCL_BASIC_POWER_SOURCE_UNKNOWN",
@@ -40,4 +38,3 @@ ZB_ZCL_CLUSTER_ID_IDENTIFY = "ZB_ZCL_CLUSTER_ID_IDENTIFY"
 ZB_ZCL_CLUSTER_ID_BINARY_INPUT = "ZB_ZCL_CLUSTER_ID_BINARY_INPUT"
 ZB_ZCL_CLUSTER_ID_ANALOG_INPUT = "ZB_ZCL_CLUSTER_ID_ANALOG_INPUT"
 ZB_ZCL_CLUSTER_ID_BINARY_OUTPUT = "ZB_ZCL_CLUSTER_ID_BINARY_OUTPUT"
-ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT = "ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT"
--- a/esphome/components/zigbee/zigbee_number_zephyr.cpp
+++ b/esphome/components/zigbee/zigbee_number_zephyr.cpp
@@ -1,111 +0,0 @@
-#include "zigbee_number_zephyr.h"
-#if defined(USE_ZIGBEE) && defined(USE_NRF52) && defined(USE_NUMBER)
-#include "esphome/core/log.h"
-extern "C" {
-#include <zboss_api.h>
-#include <zboss_api_addons.h>
-#include <zb_nrf_platform.h>
-#include <zigbee/zigbee_app_utils.h>
-#include <zb_error_to_string.h>
-}
-namespace esphome::zigbee {
-
-static const char *const TAG = "zigbee.number";
-
-void ZigbeeNumber::setup() {
-  this->parent_->add_callback(this->endpoint_, [this](zb_bufid_t bufid) { this->zcl_device_cb_(bufid); });
-  this->number_->add_on_state_callback([this](float state) {
-    this->cluster_attributes_->present_value = state;
-    ESP_LOGD(TAG, "Set attribute endpoint: %d, present_value %f", this->endpoint_,
-             this->cluster_attributes_->present_value);
-    ZB_ZCL_SET_ATTRIBUTE(this->endpoint_, ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT, ZB_ZCL_CLUSTER_SERVER_ROLE,
-                         ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID, (zb_uint8_t *) &cluster_attributes_->present_value,
-                         ZB_FALSE);
-    this->parent_->force_report();
-  });
-}
-
-void ZigbeeNumber::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Zigbee Number\n"
-                "  Endpoint: %d, present_value %f",
-                this->endpoint_, this->cluster_attributes_->present_value);
-}
-
-void ZigbeeNumber::zcl_device_cb_(zb_bufid_t bufid) {
-  zb_zcl_device_callback_param_t *p_device_cb_param = ZB_BUF_GET_PARAM(bufid, zb_zcl_device_callback_param_t);
-  zb_zcl_device_callback_id_t device_cb_id = p_device_cb_param->device_cb_id;
-  zb_uint16_t cluster_id = p_device_cb_param->cb_param.set_attr_value_param.cluster_id;
-  zb_uint16_t attr_id = p_device_cb_param->cb_param.set_attr_value_param.attr_id;
-
-  switch (device_cb_id) {
-    /* ZCL set attribute value */
-    case ZB_ZCL_SET_ATTR_VALUE_CB_ID:
-      if (cluster_id == ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT) {
-        ESP_LOGI(TAG, "Analog output attribute setting");
-        if (attr_id == ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID) {
-          float value =
-              *reinterpret_cast<const float *>(&p_device_cb_param->cb_param.set_attr_value_param.values.data32);
-          this->defer([this, value]() {
-            this->cluster_attributes_->present_value = value;
-            auto call = this->number_->make_call();
-            call.set_value(value);
-            call.perform();
-          });
-        }
-      } else {
-        /* other clusters attribute handled here */
-        ESP_LOGI(TAG, "Unhandled cluster attribute id: %d", cluster_id);
-        p_device_cb_param->status = RET_NOT_IMPLEMENTED;
-      }
-      break;
-    default:
-      p_device_cb_param->status = RET_NOT_IMPLEMENTED;
-      break;
-  }
-
-  ESP_LOGD(TAG, "%s status: %hd", __func__, p_device_cb_param->status);
-}
-
-const zb_uint8_t ZB_ZCL_ANALOG_OUTPUT_STATUS_FLAG_MAX_VALUE = 0x0F;
-
-static zb_ret_t check_value_analog_server(zb_uint16_t attr_id, zb_uint8_t endpoint,
-                                          zb_uint8_t *value) {  // NOLINT(readability-non-const-parameter)
-  zb_ret_t ret = RET_OK;
-  ZVUNUSED(endpoint);
-
-  switch (attr_id) {
-    case ZB_ZCL_ATTR_ANALOG_OUTPUT_OUT_OF_SERVICE_ID:
-      ret = ZB_ZCL_CHECK_BOOL_VALUE(*value) ? RET_OK : RET_ERROR;
-      break;
-    case ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID:
-      break;
-
-    case ZB_ZCL_ATTR_ANALOG_OUTPUT_STATUS_FLAG_ID:
-      if (*value > ZB_ZCL_ANALOG_OUTPUT_STATUS_FLAG_MAX_VALUE) {
-        ret = RET_ERROR;
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  return ret;
-}
-
-}  // namespace esphome::zigbee
-
-void zb_zcl_analog_output_init_server() {
-  zb_zcl_add_cluster_handlers(ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT, ZB_ZCL_CLUSTER_SERVER_ROLE,
-                              esphome::zigbee::check_value_analog_server, (zb_zcl_cluster_write_attr_hook_t) NULL,
-                              (zb_zcl_cluster_handler_t) NULL);
-}
-
-void zb_zcl_analog_output_init_client() {
-  zb_zcl_add_cluster_handlers(ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT, ZB_ZCL_CLUSTER_CLIENT_ROLE,
-                              (zb_zcl_cluster_check_value_t) NULL, (zb_zcl_cluster_write_attr_hook_t) NULL,
-                              (zb_zcl_cluster_handler_t) NULL);
-}
-
-#endif
--- a/esphome/components/zigbee/zigbee_number_zephyr.h
+++ b/esphome/components/zigbee/zigbee_number_zephyr.h
@@ -1,118 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#if defined(USE_ZIGBEE) && defined(USE_NRF52) && defined(USE_NUMBER)
-#include "esphome/components/zigbee/zigbee_zephyr.h"
-#include "esphome/core/component.h"
-#include "esphome/components/number/number.h"
-extern "C" {
-#include <zboss_api.h>
-#include <zboss_api_addons.h>
-}
-
-enum {
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_DESCRIPTION_ID = 0x001C,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_MAX_PRESENT_VALUE_ID = 0x0041,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_MIN_PRESENT_VALUE_ID = 0x0045,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_OUT_OF_SERVICE_ID = 0x0051,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID = 0x0055,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_RESOLUTION_ID = 0x006A,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_STATUS_FLAG_ID = 0x006F,
-  ZB_ZCL_ATTR_ANALOG_OUTPUT_ENGINEERING_UNITS_ID = 0x0075,
-};
-
-#define ZB_ZCL_ANALOG_OUTPUT_CLUSTER_REVISION_DEFAULT ((zb_uint16_t) 0x0001u)
-
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_DESCRIPTION_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_DESCRIPTION_ID, ZB_ZCL_ATTR_TYPE_CHAR_STRING, ZB_ZCL_ATTR_ACCESS_READ_ONLY, \
-        (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), (void *) (data_ptr) \
-  }
-
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_OUT_OF_SERVICE_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_OUT_OF_SERVICE_ID, ZB_ZCL_ATTR_TYPE_BOOL, \
-        ZB_ZCL_ATTR_ACCESS_READ_ONLY | ZB_ZCL_ATTR_ACCESS_WRITE_OPTIONAL, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-// PresentValue
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID, ZB_ZCL_ATTR_TYPE_SINGLE, \
-        ZB_ZCL_ATTR_ACCESS_READ_WRITE | ZB_ZCL_ATTR_ACCESS_REPORTING, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-// MaxPresentValue
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_MAX_PRESENT_VALUE_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_MAX_PRESENT_VALUE_ID, ZB_ZCL_ATTR_TYPE_SINGLE, \
-        ZB_ZCL_ATTR_ACCESS_READ_ONLY | ZB_ZCL_ATTR_ACCESS_WRITE_OPTIONAL, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-// MinPresentValue
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_MIN_PRESENT_VALUE_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_MIN_PRESENT_VALUE_ID, ZB_ZCL_ATTR_TYPE_SINGLE, \
-        ZB_ZCL_ATTR_ACCESS_READ_ONLY | ZB_ZCL_ATTR_ACCESS_WRITE_OPTIONAL, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-// Resolution
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_RESOLUTION_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_RESOLUTION_ID, ZB_ZCL_ATTR_TYPE_SINGLE, \
-        ZB_ZCL_ATTR_ACCESS_READ_ONLY | ZB_ZCL_ATTR_ACCESS_WRITE_OPTIONAL, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_STATUS_FLAG_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_STATUS_FLAG_ID, ZB_ZCL_ATTR_TYPE_8BITMAP, \
-        ZB_ZCL_ATTR_ACCESS_READ_ONLY | ZB_ZCL_ATTR_ACCESS_REPORTING, (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), \
-        (void *) (data_ptr) \
-  }
-
-#define ZB_SET_ATTR_DESCR_WITH_ZB_ZCL_ATTR_ANALOG_OUTPUT_ENGINEERING_UNITS_ID(data_ptr) \
-  { \
-    ZB_ZCL_ATTR_ANALOG_OUTPUT_ENGINEERING_UNITS_ID, ZB_ZCL_ATTR_TYPE_16BIT_ENUM, ZB_ZCL_ATTR_ACCESS_READ_ONLY, \
-        (ZB_ZCL_NON_MANUFACTURER_SPECIFIC), (void *) (data_ptr) \
-  }
-
-#define ESPHOME_ZB_ZCL_DECLARE_ANALOG_OUTPUT_ATTRIB_LIST(attr_list, out_of_service, present_value, status_flag, \
-                                                         max_present_value, min_present_value, resolution, \
-                                                         engineering_units, description) \
-  ZB_ZCL_START_DECLARE_ATTRIB_LIST_CLUSTER_REVISION(attr_list, ZB_ZCL_ANALOG_OUTPUT) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_OUT_OF_SERVICE_ID, (out_of_service)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_PRESENT_VALUE_ID, (present_value)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_STATUS_FLAG_ID, (status_flag)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_MAX_PRESENT_VALUE_ID, (max_present_value)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_MIN_PRESENT_VALUE_ID, (min_present_value)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_RESOLUTION_ID, (resolution)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_ENGINEERING_UNITS_ID, (engineering_units)) \
-  ZB_ZCL_SET_ATTR_DESC(ZB_ZCL_ATTR_ANALOG_OUTPUT_DESCRIPTION_ID, (description)) \
-  ZB_ZCL_FINISH_DECLARE_ATTRIB_LIST
-
-void zb_zcl_analog_output_init_server();
-void zb_zcl_analog_output_init_client();
-#define ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT_SERVER_ROLE_INIT zb_zcl_analog_output_init_server
-#define ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT_CLIENT_ROLE_INIT zb_zcl_analog_output_init_client
-
-namespace esphome::zigbee {
-
-class ZigbeeNumber : public ZigbeeEntity, public Component {
- public:
-  ZigbeeNumber(number::Number *n) : number_(n) {}
-  void set_cluster_attributes(AnalogAttrsOutput &cluster_attributes) {
-    this->cluster_attributes_ = &cluster_attributes;
-  }
-
-  void setup() override;
-  void dump_config() override;
-
- protected:
-  number::Number *number_;
-  AnalogAttrsOutput *cluster_attributes_{nullptr};
-  void zcl_device_cb_(zb_bufid_t bufid);
-};
-
-}  // namespace esphome::zigbee
-#endif
--- a/esphome/components/zigbee/zigbee_switch_zephyr.cpp
+++ b/esphome/components/zigbee/zigbee_switch_zephyr.cpp
@@ -50,7 +50,7 @@ void ZigbeeSwitch::zcl_device_cb_(zb_bufid_t bufid) {
        if (attr_id == ZB_ZCL_ATTR_BINARY_OUTPUT_PRESENT_VALUE_ID) {
          this->defer([this, value]() {
            this->cluster_attributes_->present_value = value ? ZB_TRUE : ZB_FALSE;
-            this->switch_->control(value);
+            this->switch_->publish_state(value);
          });
        }
      } else {
--- a/esphome/components/zigbee/zigbee_zephyr.cpp
+++ b/esphome/components/zigbee/zigbee_zephyr.cpp
@@ -101,8 +101,8 @@ void ZigbeeComponent::zcl_device_cb(zb_bufid_t bufid) {
  zb_uint16_t attr_id = p_device_cb_param->cb_param.set_attr_value_param.attr_id;
  auto endpoint = p_device_cb_param->endpoint;

-  ESP_LOGI(TAG, "%s id %hd, cluster_id %d, attr_id %d, endpoint: %d", __func__, device_cb_id, cluster_id, attr_id,
-           endpoint);
+  ESP_LOGI(TAG, "Zcl_device_cb %s id %hd, cluster_id %d, attr_id %d, endpoint: %d", __func__, device_cb_id, cluster_id,
+           attr_id, endpoint);

  /* Set default response value. */
  p_device_cb_param->status = RET_OK;
--- a/esphome/components/zigbee/zigbee_zephyr.h
+++ b/esphome/components/zigbee/zigbee_zephyr.h
@@ -60,12 +60,6 @@ struct AnalogAttrs {
  zb_uchar_t description[ZB_ZCL_MAX_STRING_SIZE];
 };

-struct AnalogAttrsOutput : AnalogAttrs {
-  float max_present_value;
-  float min_present_value;
-  float resolution;
-};
-
 class ZigbeeComponent : public Component {
 public:
  void setup() override;
--- a/esphome/components/zigbee/zigbee_zephyr.py
+++ b/esphome/components/zigbee/zigbee_zephyr.py
@@ -55,7 +55,6 @@ from .const_zephyr import (
    CONF_WIPE_ON_BOOT,
    CONF_ZIGBEE_BINARY_SENSOR,
    CONF_ZIGBEE_ID,
-    CONF_ZIGBEE_NUMBER,
    CONF_ZIGBEE_SENSOR,
    CONF_ZIGBEE_SWITCH,
    KEY_EP_NUMBER,
@@ -63,14 +62,12 @@ from .const_zephyr import (
    POWER_SOURCE,
    ZB_ZCL_BASIC_ATTRS_EXT_T,
    ZB_ZCL_CLUSTER_ID_ANALOG_INPUT,
-    ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT,
    ZB_ZCL_CLUSTER_ID_BASIC,
    ZB_ZCL_CLUSTER_ID_BINARY_INPUT,
    ZB_ZCL_CLUSTER_ID_BINARY_OUTPUT,
    ZB_ZCL_CLUSTER_ID_IDENTIFY,
    ZB_ZCL_IDENTIFY_ATTRS_T,
    AnalogAttrs,
-    AnalogAttrsOutput,
    BinaryAttrs,
    ZigbeeComponent,
    zigbee_ns,
@@ -79,7 +76,6 @@ from .const_zephyr import (
 ZigbeeBinarySensor = zigbee_ns.class_("ZigbeeBinarySensor", cg.Component)
 ZigbeeSensor = zigbee_ns.class_("ZigbeeSensor", cg.Component)
 ZigbeeSwitch = zigbee_ns.class_("ZigbeeSwitch", cg.Component)
-ZigbeeNumber = zigbee_ns.class_("ZigbeeNumber", cg.Component)

 # BACnet engineering units mapping (ZCL uses BACnet unit codes)
 # See: https://github.com/zigpy/zha/blob/dev/zha/application/platforms/number/bacnet.py
@@ -143,15 +139,6 @@ zephyr_switch = cv.Schema(
    }
 )

-zephyr_number = cv.Schema(
-    {
-        cv.OnlyWith(CONF_ZIGBEE_ID, ["nrf52", "zigbee"]): cv.use_id(ZigbeeComponent),
-        cv.OnlyWith(CONF_ZIGBEE_NUMBER, ["nrf52", "zigbee"]): cv.declare_id(
-            ZigbeeNumber
-        ),
-    }
-)
-

 async def zephyr_to_code(config: ConfigType) -> None:
    zephyr_add_prj_conf("ZIGBEE", True)
@@ -357,16 +344,6 @@ async def zephyr_setup_switch(entity: cg.MockObj, config: ConfigType) -> None:
    CORE.add_job(_add_switch, entity, config)


-async def zephyr_setup_number(
-    entity: cg.MockObj,
-    config: ConfigType,
-    min_value: float,
-    max_value: float,
-    step: float,
-) -> None:
-    CORE.add_job(_add_number, entity, config, min_value, max_value, step)
-
-
 def get_slot_index() -> int:
    """Find the next available endpoint slot."""
    slot = next(
@@ -474,31 +451,3 @@ async def _add_switch(entity: cg.MockObj, config: ConfigType) -> None:
        ZB_ZCL_CLUSTER_ID_BINARY_OUTPUT,
        "ZB_HA_CUSTOM_ATTR_DEVICE_ID",
    )
-
-
-async def _add_number(
-    entity: cg.MockObj,
-    config: ConfigType,
-    min_value: float,
-    max_value: float,
-    step: float,
-) -> None:
-    # Get BACnet engineering unit from unit_of_measurement
-    unit = config.get(CONF_UNIT_OF_MEASUREMENT, "")
-    bacnet_unit = BACNET_UNITS.get(unit, BACNET_UNIT_NO_UNITS)
-
-    await _add_zigbee_ep(
-        entity,
-        config,
-        CONF_ZIGBEE_NUMBER,
-        AnalogAttrsOutput,
-        "ESPHOME_ZB_ZCL_DECLARE_ANALOG_OUTPUT_ATTRIB_LIST",
-        ZB_ZCL_CLUSTER_ID_ANALOG_OUTPUT,
-        "ZB_HA_CUSTOM_ATTR_DEVICE_ID",
-        extra_field_values={
-            "max_present_value": max_value,
-            "min_present_value": min_value,
-            "resolution": step,
-            "engineering_units": bacnet_unit,
-        },
-    )
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -149,7 +149,6 @@ CONF_ASSUMED_STATE = "assumed_state"
 CONF_AT = "at"
 CONF_ATTENUATION = "attenuation"
 CONF_ATTRIBUTE = "attribute"
-CONF_AUDIO_DAC = "audio_dac"
 CONF_AUTH = "auth"
 CONF_AUTO_CLEAR_ENABLED = "auto_clear_enabled"
 CONF_AUTO_MODE = "auto_mode"
--- a/esphome/core/init.py
+++ b/esphome/core/init.py
@@ -888,16 +888,6 @@ class EsphomeCore:
            library.name if "/" not in library.name else library.name.split("/")[-1]
        )

-        # Auto-enable Arduino libraries on ESP32 Arduino builds
-        if self.is_esp32 and self.using_arduino:
-            from esphome.components.esp32 import (
-                ARDUINO_DISABLED_LIBRARIES,
-                _enable_arduino_library,
-            )
-
-            if short_name in ARDUINO_DISABLED_LIBRARIES:
-                _enable_arduino_library(short_name)
-
        if short_name not in self.platformio_libraries:
            _LOGGER.debug("Adding library: %s", library)
            self.platformio_libraries[short_name] = library
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -756,6 +756,53 @@ def lint_no_sprintf(fname, match):
    )


+@lint_re_check(
+    # Match std::to_string() or unqualified to_string() calls
+    # The esphome namespace has "using std::to_string;" so unqualified calls resolve to std::to_string
+    # Use negative lookbehind for unqualified calls to avoid matching:
+    #   - Function definitions: "const char *to_string(" or "std::string to_string("
+    #   - Method definitions: "Class::to_string("
+    #   - Method calls: ".to_string(" or "->to_string("
+    #   - Other identifiers: "_to_string("
+    # Also explicitly match std::to_string since : is in the lookbehind
+    r"(?:(?<![*&.\w>:])to_string|std\s*::\s*to_string)\s*\(" + CPP_RE_EOL,
+    include=cpp_include,
+    exclude=[
+        # Vendored library
+        "esphome/components/http_request/httplib.h",
+        # Deprecated helpers that return std::string
+        "esphome/core/helpers.cpp",
+        # The using declaration itself
+        "esphome/core/helpers.h",
+        # Test fixtures - not production embedded code
+        "tests/integration/fixtures/*",
+    ],
+)
+def lint_no_std_to_string(fname, match):
+    return (
+        f"{highlight('std::to_string()')} (including unqualified {highlight('to_string()')}) "
+        f"allocates heap memory. On long-running embedded devices, repeated heap allocations "
+        f"fragment memory over time.\n"
+        f"Please use {highlight('snprintf()')} with a stack buffer instead.\n"
+        f"\n"
+        f"Buffer sizes and format specifiers (sizes include sign and null terminator):\n"
+        f"  uint8_t:          4 chars   - %u (or PRIu8)\n"
+        f"  int8_t:           5 chars   - %d (or PRId8)\n"
+        f"  uint16_t:         6 chars   - %u (or PRIu16)\n"
+        f"  int16_t:          7 chars   - %d (or PRId16)\n"
+        f"  uint32_t:         11 chars  - %" + "PRIu32\n"
+        "  int32_t:          12 chars  - %" + "PRId32\n"
+        "  uint64_t:         21 chars  - %" + "PRIu64\n"
+        "  int64_t:          21 chars  - %" + "PRId64\n"
+        f"  float/double:     24 chars  - %.8g (15 digits + sign + decimal + e+XXX)\n"
+        f"                    317 chars - %f (for DBL_MAX: 309 int digits + decimal + 6 frac + sign)\n"
+        f"\n"
+        f"For sensor values, use value_accuracy_to_buf() from helpers.h.\n"
+        f'Example: char buf[11]; snprintf(buf, sizeof(buf), "%" PRIu32, value);\n'
+        f"(If strictly necessary, add `{highlight('// NOLINT')}` to the end of the line)"
+    )
+
+
@lint_content_find_check(
    "ESP_LOG",
    include=["*.h", "*.tcc"],
--- a/tests/components/ch423/common.yaml
+++ b/tests/components/ch423/common.yaml
@@ -1,36 +0,0 @@
-ch423:
-  - id: ch423_hub
-    i2c_id: i2c_bus
-
-binary_sensor:
-  - platform: gpio
-    id: ch423_input
-    name: CH423 Binary Sensor
-    pin:
-      ch423: ch423_hub
-      number: 1
-      mode: INPUT
-      inverted: true
-  - platform: gpio
-    id: ch423_input_2
-    name: CH423 Binary Sensor 2
-    pin:
-      ch423: ch423_hub
-      number: 0
-      mode: INPUT
-      inverted: false
-output:
-  - platform: gpio
-    id: ch423_out_11
-    pin:
-      ch423: ch423_hub
-      number: 11
-      mode: OUTPUT_OPEN_DRAIN
-      inverted: true
-  - platform: gpio
-    id: ch423_out_23
-    pin:
-      ch423: ch423_hub
-      number: 23
-      mode: OUTPUT_OPEN_DRAIN
-      inverted: false
--- a/tests/components/ch423/test.esp32-idf.yaml
+++ b/tests/components/ch423/test.esp32-idf.yaml
@@ -1,4 +0,0 @@
-packages:
-  i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
-
-<<: !include common.yaml
--- a/tests/components/ch423/test.esp8266-ard.yaml
+++ b/tests/components/ch423/test.esp8266-ard.yaml
@@ -1,4 +0,0 @@
-packages:
-  i2c: !include ../../test_build_components/common/i2c/esp8266-ard.yaml
-
-<<: !include common.yaml
--- a/tests/components/ch423/test.rp2040-ard.yaml
+++ b/tests/components/ch423/test.rp2040-ard.yaml
@@ -1,4 +0,0 @@
-packages:
-  i2c: !include ../../test_build_components/common/i2c/rp2040-ard.yaml
-
-<<: !include common.yaml
--- a/tests/components/esp32/test.esp32-idf.yaml
+++ b/tests/components/esp32/test.esp32-idf.yaml
@@ -8,16 +8,6 @@ esp32:
      enable_lwip_bridge_interface: true
      disable_libc_locks_in_iram: false  # Test explicit opt-out of RAM optimization
      use_full_certificate_bundle: false  # Test CMN bundle (default)
-      include_builtin_idf_components:
-        - freertos  # Test escape hatch (freertos is always included anyway)
-      disable_debug_stubs: true
-      disable_ocd_aware: true
-      disable_usb_serial_jtag_secondary: true
-      disable_dev_null_vfs: true
-      disable_mbedtls_peer_cert: true
-      disable_mbedtls_pkcs7: true
-      disable_regi2c_in_iram: true
-      disable_fatfs: true

 wifi:
  ssid: MySSID
--- a/tests/components/esp32/test.esp32-p4-idf.yaml
+++ b/tests/components/esp32/test.esp32-p4-idf.yaml
@@ -10,14 +10,6 @@ esp32:
        ref: 2.7.0
    advanced:
      enable_idf_experimental_features: yes
-      disable_debug_stubs: true
-      disable_ocd_aware: true
-      disable_usb_serial_jtag_secondary: true
-      disable_dev_null_vfs: true
-      disable_mbedtls_peer_cert: true
-      disable_mbedtls_pkcs7: true
-      disable_regi2c_in_iram: true
-      disable_fatfs: true

 ota:
  platform: esphome
--- a/tests/components/esp32/test.esp32-s3-idf.yaml
+++ b/tests/components/esp32/test.esp32-s3-idf.yaml
@@ -5,14 +5,6 @@ esp32:
    advanced:
      execute_from_psram: true
      disable_libc_locks_in_iram: true  # Test default RAM optimization enabled
-      disable_debug_stubs: true
-      disable_ocd_aware: true
-      disable_usb_serial_jtag_secondary: true
-      disable_dev_null_vfs: true
-      disable_mbedtls_peer_cert: true
-      disable_mbedtls_pkcs7: true
-      disable_regi2c_in_iram: true
-      disable_fatfs: true

 psram:
  mode: octal
--- a/tests/components/i2s_audio/test.esp32-ard.yaml
+++ b/tests/components/i2s_audio/test.esp32-ard.yaml
@@ -1,16 +0,0 @@
-substitutions:
-  i2s_bclk_pin: GPIO15
-  i2s_lrclk_pin: GPIO4
-  i2s_mclk_pin: GPIO5
-
-<<: !include common.yaml
-
-wifi:
-  ssid: test
-  password: test1234
-
-media_player:
-  - platform: i2s_audio
-    name: Test Media Player
-    dac_type: internal
-    mode: stereo
--- a/tests/components/zigbee/common.yaml
+++ b/tests/components/zigbee/common.yaml
@@ -6,6 +6,8 @@ binary_sensor:
    name: "Garage Door Open 2"
  - platform: template
    name: "Garage Door Open 3"
+  - platform: template
+    name: "Garage Door Open 4"
  - platform: template
    name: "Garage Door Internal"
    internal: True
@@ -42,11 +44,3 @@ switch:
  - platform: template
    name: "Template Switch"
    optimistic: true
-
-number:
-  - platform: template
-    name: "Template number"
-    optimistic: true
-    min_value: 2
-    max_value: 100
-    step: 1
--- a/tests/unit_tests/components/test_ch423.py
+++ b/tests/unit_tests/components/test_ch423.py
@@ -1,58 +0,0 @@
-"""Tests for ch423 component validation."""
-
-from unittest.mock import patch
-
-from esphome import config, yaml_util
-from esphome.core import CORE
-
-
-def test_ch423_mixed_gpio_modes_fails(tmp_path, capsys):
-    """Test that mixing input/output on GPIO pins 0-7 fails validation."""
-    test_file = tmp_path / "test.yaml"
-    test_file.write_text("""
-esphome:
-  name: test
-
-esp8266:
-  board: esp01_1m
-
-i2c:
-  sda: GPIO4
-  scl: GPIO5
-
-ch423:
-  - id: ch423_hub
-
-binary_sensor:
-  - platform: gpio
-    name: "CH423 Input 0"
-    pin:
-      ch423: ch423_hub
-      number: 0
-      mode: input
-
-switch:
-  - platform: gpio
-    name: "CH423 Output 1"
-    pin:
-      ch423: ch423_hub
-      number: 1
-      mode: output
-""")
-
-    parsed_yaml = yaml_util.load_yaml(test_file)
-
-    with (
-        patch.object(yaml_util, "load_yaml", return_value=parsed_yaml),
-        patch.object(CORE, "config_path", test_file),
-    ):
-        result = config.read_config({})
-
-    assert result is None, "Expected validation to fail with mixed GPIO modes"
-
-    # Check that the error message mentions the GPIO pin restriction
-    captured = capsys.readouterr()
-    assert (
-        "GPIO pins (0-7) must all be configured as input or all as output"
-        in captured.out
-    )
--- a/tests/unit_tests/test_core.py
+++ b/tests/unit_tests/test_core.py
@@ -780,78 +780,3 @@ class TestEsphomeCore:
        target.config = {const.CONF_ESPHOME: {"name": "test"}, "logger": {}}

        assert target.has_networking is False
-
-    def test_add_library__esp32_arduino_enables_disabled_library(self, target):
-        """Test add_library auto-enables Arduino libraries on ESP32 Arduino builds."""
-        target.data[const.KEY_CORE] = {
-            const.KEY_TARGET_PLATFORM: "esp32",
-            const.KEY_TARGET_FRAMEWORK: "arduino",
-        }
-
-        library = core.Library("WiFi", None)
-
-        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
-            target.add_library(library)
-            mock_enable.assert_called_once_with("WiFi")
-
-        assert "WiFi" in target.platformio_libraries
-
-    def test_add_library__esp32_arduino_ignores_non_arduino_library(self, target):
-        """Test add_library doesn't enable libraries not in ARDUINO_DISABLED_LIBRARIES."""
-        target.data[const.KEY_CORE] = {
-            const.KEY_TARGET_PLATFORM: "esp32",
-            const.KEY_TARGET_FRAMEWORK: "arduino",
-        }
-
-        library = core.Library("SomeOtherLib", "1.0.0")
-
-        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
-            target.add_library(library)
-            mock_enable.assert_not_called()
-
-        assert "SomeOtherLib" in target.platformio_libraries
-
-    def test_add_library__esp32_idf_does_not_enable_arduino_library(self, target):
-        """Test add_library doesn't auto-enable Arduino libraries on ESP32 IDF builds."""
-        target.data[const.KEY_CORE] = {
-            const.KEY_TARGET_PLATFORM: "esp32",
-            const.KEY_TARGET_FRAMEWORK: "esp-idf",
-        }
-
-        library = core.Library("WiFi", None)
-
-        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
-            target.add_library(library)
-            mock_enable.assert_not_called()
-
-        assert "WiFi" in target.platformio_libraries
-
-    def test_add_library__esp8266_does_not_enable_arduino_library(self, target):
-        """Test add_library doesn't auto-enable Arduino libraries on ESP8266."""
-        target.data[const.KEY_CORE] = {
-            const.KEY_TARGET_PLATFORM: "esp8266",
-            const.KEY_TARGET_FRAMEWORK: "arduino",
-        }
-
-        library = core.Library("WiFi", None)
-
-        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
-            target.add_library(library)
-            mock_enable.assert_not_called()
-
-        assert "WiFi" in target.platformio_libraries
-
-    def test_add_library__extracts_short_name_from_path(self, target):
-        """Test add_library extracts short name from library paths like owner/lib."""
-        target.data[const.KEY_CORE] = {
-            const.KEY_TARGET_PLATFORM: "esp32",
-            const.KEY_TARGET_FRAMEWORK: "arduino",
-        }
-
-        library = core.Library("arduino/Wire", None)
-
-        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
-            target.add_library(library)
-            mock_enable.assert_called_once_with("Wire")
-
-        assert "Wire" in target.platformio_libraries
Author	SHA1	Message	Date
J. Nick Koston	6ca1b90752	Address Copilot review feedback - Fix regex to actually match std::to_string() by using alternation (the : in the lookbehind was preventing matches) - Update error message to mention both std::to_string() and unqualified to_string() forms - Correct buffer sizes for signed integer types: - int8_t: 5 chars (not 4) for "-128\0" - int16_t: 7 chars (not 6) for "-32768\0" - int32_t: 12 chars (not 11) for "-2147483648\0"	2026-01-28 18:14:16 -10:00
J. Nick Koston	fe1aa7e9ba	Merge branch 'dev' into no_new_to_string	2026-01-28 17:42:57 -10:00
J. Nick Koston	8d51e2f580	Merge remote-tracking branch 'upstream/dev' into no_new_to_string # Conflicts: # script/ci-custom.py	2026-01-21 19:50:39 -10:00
J. Nick Koston	11fb46ad11	Apply suggestions from code review	2026-01-19 17:44:25 -10:00
J. Nick Koston	9245c691d0	Merge branch 'dev' into no_new_to_string	2026-01-19 17:43:46 -10:00
J. Nick Koston	971a1a3e00	[ci] Block new std::to_string() usage, suggest snprintf alternatives	2026-01-19 08:49:31 -10:00