Merge upstream/dev into mid_loop branch

Resolved conflict in base_automation.h by combining:
- Upstream's const ref parameters (const Ts &...x)
- Our timestamp passing to check_internal_(now)

esphome/__main__.py

@@ -741,13 +741,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1209,17 +1202,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -1,7 +1,6 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
-import json
 import sys
 
 from . import (
@@ -284,28 +283,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/esp32_ble/ble.cpp

@@ -96,10 +96,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -37,7 +37,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -107,7 +107,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/ld2420/ld2420.cpp

@@ -174,7 +174,7 @@ static uint8_t calc_checksum(void *data, size_t size) {
 static int get_firmware_int(const char *version_string) {
   std::string version_str = version_string;
   if (version_str[0] == 'v') {
-    version_str.erase(0, 1);
+    version_str = version_str.substr(1);
   }
   version_str.erase(remove(version_str.begin(), version_str.end(), '.'), version_str.end());
   int version_integer = stoi(version_str);

esphome/components/lvgl/select/lvgl_select.h

@@ -59,8 +59,8 @@ class LVGLSelect : public select::Select, public Component {
     const auto &opts = this->widget_->get_options();
     FixedVector<const char *> opt_ptrs;
     opt_ptrs.init(opts.size());
-    for (const auto &opt : opts) {
-      opt_ptrs.push_back(opt.c_str());
+    for (size_t i = 0; i < opts.size(); i++) {
+      opt_ptrs[i] = opts[i].c_str();
     }
     this->traits.set_options(opt_ptrs);
   }

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/remote_base/pronto_protocol.cpp

@@ -71,7 +71,6 @@ static const uint16_t FALLBACK_FREQUENCY = 64767U;  // To use with frequency = 0
 static const uint32_t MICROSECONDS_IN_SECONDS = 1000000UL;
 static const uint16_t PRONTO_DEFAULT_GAP = 45000;
 static const uint16_t MARK_EXCESS_MICROS = 20;
-static constexpr size_t PRONTO_LOG_CHUNK_SIZE = 230;
 
 static uint16_t to_frequency_k_hz(uint16_t code) {
   if (code == 0)
@@ -226,17 +225,18 @@ optional<ProntoData> ProntoProtocol::decode(RemoteReceiveData src) {
 }
 
 void ProntoProtocol::dump(const ProntoData &data) {
-  std::string rest = data.data;
+  std::string rest;
+
+  rest = data.data;
   ESP_LOGI(TAG, "Received Pronto: data=");
-  do {
-    size_t chunk_size = rest.size() > PRONTO_LOG_CHUNK_SIZE ? PRONTO_LOG_CHUNK_SIZE : rest.size();
-    ESP_LOGI(TAG, "%.*s", (int) chunk_size, rest.c_str());
-    if (rest.size() > PRONTO_LOG_CHUNK_SIZE) {
-      rest.erase(0, PRONTO_LOG_CHUNK_SIZE);
+  while (true) {
+    ESP_LOGI(TAG, "%s", rest.substr(0, 230).c_str());
+    if (rest.size() > 230) {
+      rest = rest.substr(230);
     } else {
       break;
     }
-  } while (true);
+  }
 }
 
 }  // namespace remote_base

esphome/components/rtttl/rtttl.cpp

@@ -35,7 +35,9 @@ void Rtttl::dump_config() {
 
 void Rtttl::play(std::string rtttl) {
   if (this->state_ != State::STATE_STOPPED && this->state_ != State::STATE_STOPPING) {
-    ESP_LOGW(TAG, "Already playing: %.*s", (int) this->rtttl_.find(':'), this->rtttl_.c_str());
+    int pos = this->rtttl_.find(':');
+    auto name = this->rtttl_.substr(0, pos);
+    ESP_LOGW(TAG, "Already playing: %s", name.c_str());
     return;
   }
 
@@ -57,7 +59,8 @@ void Rtttl::play(std::string rtttl) {
     return;
   }
 
-  ESP_LOGD(TAG, "Playing song %.*s", (int) this->position_, this->rtttl_.c_str());
+  auto name = this->rtttl_.substr(0, this->position_);
+  ESP_LOGD(TAG, "Playing song %s", name.c_str());
 
   // get default duration
   this->position_ = this->rtttl_.find("d=", this->position_);

esphome/components/select/select.h

@@ -77,21 +77,23 @@ class Select : public EntityBase {
 
   void add_on_state_callback(std::function<void(std::string, size_t)> &&callback);
 
-  /** Set the value of the select by index, this is an optional virtual method.
-   *
-   * This method is called by the SelectCall when the index is already known.
-   * Default implementation converts to string and calls control().
-   * Override this to work directly with indices and avoid string conversions.
-   *
-   * @param index The index as validated by the SelectCall.
-   */
-  virtual void control(size_t index) { this->control(this->option_at(index)); }
-
  protected:
   friend class SelectCall;
 
   size_t active_index_{0};
 
+  /** Set the value of the select by index, this is an optional virtual method.
+   *
+   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
+   * Overriding this index-based version is PREFERRED as it avoids string conversions.
+   *
+   * This method is called by the SelectCall when the index is already known.
+   * Default implementation converts to string and calls control(const std::string&).
+   *
+   * @param index The index as validated by the SelectCall.
+   */
+  virtual void control(size_t index) { this->control(this->option_at(index)); }
+
   /** Set the value of the select, this is a virtual method that each select integration can implement.
    *
    * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.

esphome/components/select/select_traits.cpp

@@ -7,8 +7,8 @@ void SelectTraits::set_options(const std::initializer_list<const char *> &option
 
 void SelectTraits::set_options(const FixedVector<const char *> &options) {
   this->options_.init(options.size());
-  for (const auto &opt : options) {
-    this->options_.push_back(opt);
+  for (size_t i = 0; i < options.size(); i++) {
+    this->options_[i] = options[i];
   }
 }
 

esphome/components/voice_assistant/voice_assistant.cpp

@@ -657,8 +657,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         ESP_LOGW(TAG, "No text in STT_END event");
         return;
       } else if (text.length() > 500) {
-        text.resize(497);
-        text += "...";
+        text = text.substr(0, 497) + "...";
       }
       ESP_LOGD(TAG, "Speech recognised as: \"%s\"", text.c_str());
       this->defer([this, text]() { this->stt_end_trigger_->trigger(text); });
@@ -715,8 +714,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         return;
       }
       if (text.length() > 500) {
-        text.resize(497);
-        text += "...";
+        text = text.substr(0, 497) + "...";
       }
       ESP_LOGD(TAG, "Response: \"%s\"", text.c_str());
       this->defer([this, text]() {

esphome/components/web_server_idf/web_server_idf.cpp

@@ -353,9 +353,8 @@ void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
 void AsyncResponseStream::print(float value) {
   // Use stack buffer to avoid temporary string allocation
   // Size: sign (1) + digits (10) + decimal (1) + precision (6) + exponent (5) + null (1) = 24, use 32 for safety
-  constexpr size_t float_buf_size = 32;
-  char buf[float_buf_size];
-  int len = snprintf(buf, float_buf_size, "%f", value);
+  char buf[32];
+  int len = snprintf(buf, sizeof(buf), "%f", value);
   this->content_.append(buf, len);
 }
 

esphome/components/wifi_info/wifi_info_text_sensor.h

@@ -10,8 +10,6 @@
 namespace esphome {
 namespace wifi_info {
 
-static constexpr size_t MAX_STATE_LENGTH = 255;
-
 class IPAddressWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
  public:
   void update() override {
@@ -73,14 +71,11 @@ class ScanResultsWiFiInfo : public PollingComponent, public text_sensor::TextSen
       scan_results += "dB\n";
     }
 
-    // There's a limit of 255 characters per state.
-    // Longer states just don't get sent so we truncate it.
-    if (scan_results.length() > MAX_STATE_LENGTH) {
-      scan_results.resize(MAX_STATE_LENGTH);
-    }
     if (this->last_scan_results_ != scan_results) {
       this->last_scan_results_ = scan_results;
-      this->publish_state(scan_results);
+      // There's a limit of 255 characters per state.
+      // Longer states just don't get sent so we truncate it.
+      this->publish_state(scan_results.substr(0, 255));
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }

esphome/core/__init__.py

@@ -707,15 +707,6 @@ class EsphomeCore:
     def relative_piolibdeps_path(self, *path: str | Path) -> Path:
         return self.relative_build_path(".piolibdeps", *path)
 
-    @property
-    def platformio_cache_dir(self) -> str:
-        """Get the PlatformIO cache directory path."""
-        # Check if running in Docker/HA addon with custom cache dir
-        if (cache_dir := os.environ.get("PLATFORMIO_CACHE_DIR")) and cache_dir.strip():
-            return cache_dir
-        # Default PlatformIO cache location
-        return os.path.expanduser("~/.platformio/.cache")
-
     @property
     def firmware_bin(self) -> Path:
         if self.is_libretiny:

esphome/core/base_automation.h

@@ -98,22 +98,28 @@ template<typename... Ts> class ForCondition : public Condition<Ts...>, public Co
 
   TEMPLATABLE_VALUE(uint32_t, time);
 
-  void loop() override { this->check_internal(); }
-  float get_setup_priority() const override { return setup_priority::DATA; }
-  bool check_internal() {
-    bool cond = this->condition_->check();
-    if (!cond)
-      this->last_inactive_ = App.get_loop_component_start_time();
-    return cond;
+  void loop() override {
+    // Safe to use cached time - only called from Application::loop()
+    this->check_internal_(App.get_loop_component_start_time());
   }
 
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
   bool check(const Ts &...x) override {
-    if (!this->check_internal())
+    auto now = millis();
+    if (!this->check_internal_(now))
       return false;
-    return millis() - this->last_inactive_ >= this->time_.value(x...);
+    return now - this->last_inactive_ >= this->time_.value(x...);
   }
 
  protected:
+  bool check_internal_(uint32_t now) {
+    bool cond = this->condition_->check();
+    if (!cond)
+      this->last_inactive_ = now;
+    return cond;
+  }
+
   Condition<> *condition_;
   uint32_t last_inactive_{0};
 };
@@ -424,34 +430,17 @@ template<typename... Ts> class WaitUntilAction : public Action<Ts...>, public Co
     auto timeout = this->timeout_value_.optional_value(x...);
     this->var_queue_.emplace_front(now, timeout, std::make_tuple(x...));
 
-    // Enable loop now that we have work to do
-    this->enable_loop();
-    this->loop();
+    // Do immediate check with fresh timestamp
+    if (this->process_queue_(now)) {
+      // Only enable loop if we still have pending items
+      this->enable_loop();
+    }
   }
 
   void loop() override {
-    if (this->num_running_ == 0)
-      return;
-
-    auto now = App.get_loop_component_start_time();
-
-    this->var_queue_.remove_if([&](auto &queued) {
-      auto start = std::get<uint32_t>(queued);
-      auto timeout = std::get<optional<uint32_t>>(queued);
-      auto &var = std::get<std::tuple<Ts...>>(queued);
-
-      auto expired = timeout && (now - start) >= *timeout;
-
-      if (!expired && !this->condition_->check_tuple(var)) {
-        return false;
-      }
-
-      this->play_next_tuple_(var);
-      return true;
-    });
-
-    // If queue is now empty, disable loop until next play_complex
-    if (this->var_queue_.empty()) {
+    // Safe to use cached time - only called from Application::loop()
+    if (this->num_running_ > 0 && !this->process_queue_(App.get_loop_component_start_time())) {
+      // If queue is now empty, disable loop until next play_complex
       this->disable_loop();
     }
   }
@@ -467,6 +456,31 @@ template<typename... Ts> class WaitUntilAction : public Action<Ts...>, public Co
   }
 
  protected:
+  // Helper: Process queue, triggering completed items and removing them
+  // Returns true if queue still has pending items
+  bool process_queue_(uint32_t now) {
+    // Process each queued wait_until and remove completed ones
+    this->var_queue_.remove_if([&](auto &queued) {
+      auto start = std::get<uint32_t>(queued);
+      auto timeout = std::get<optional<uint32_t>>(queued);
+      auto &var = std::get<std::tuple<Ts...>>(queued);
+
+      // Check if timeout has expired
+      auto expired = timeout && (now - start) >= *timeout;
+
+      // Keep waiting if not expired and condition not met
+      if (!expired && !this->condition_->check_tuple(var)) {
+        return false;
+      }
+
+      // Condition met or timed out - trigger next action
+      this->play_next_tuple_(var);
+      return true;
+    });
+
+    return !this->var_queue_.empty();
+  }
+
   Condition<Ts...> *condition_;
   std::forward_list<std::tuple<uint32_t, optional<uint32_t>, std::tuple<Ts...>>> var_queue_{};
 };

esphome/core/helpers.cpp

@@ -414,8 +414,10 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
-static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
+static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                            "abcdefghijklmnopqrstuvwxyz"
+                                            "0123456789+/";
 
 // Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
@@ -425,8 +427,8 @@ static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqr
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  const void *ptr = memchr(BASE64_CHARS, c, sizeof(BASE64_CHARS));
-  return ptr ? (static_cast<const char *>(ptr) - BASE64_CHARS) : 0;
+  const char *pos = strchr(BASE64_CHARS, c);
+  return pos ? (pos - BASE64_CHARS) : 0;
 }
 
 static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

esphome/core/helpers.h

@@ -144,9 +144,6 @@ template<typename T, size_t N> class StaticVector {
   size_t size() const { return count_; }
   bool empty() const { return count_ == 0; }
 
-  // Direct access to size counter for efficient in-place construction
-  size_t &count() { return count_; }
-
   T &operator[](size_t i) { return data_[i]; }
   const T &operator[](size_t i) const { return data_[i]; }
 
@@ -251,8 +248,6 @@ template<typename T> class FixedVector {
   }
 
   // Allocate capacity - can be called multiple times to reinit
-  // IMPORTANT: After calling init(), you MUST use push_back() to add elements.
-  // Direct assignment via operator[] does NOT update the size counter.
   void init(size_t n) {
     cleanup_();
     reset_();

esphome/core/scheduler.h

@@ -94,9 +94,10 @@ class Scheduler {
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
-    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
-    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
+    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
+    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
+    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)

esphome/platformio_api.py

@@ -145,16 +145,7 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    result = run_platformio_cli_run(config, verbose, *args)
-
-    # Run memory analysis if enabled
-    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
-        try:
-            analyze_memory_usage(config)
-        except Exception as e:
-            _LOGGER.warning("Failed to analyze memory usage: %s", e)
-
-    return result
+    return run_platformio_cli_run(config, verbose, *args)
 
 
 def _run_idedata(config):
@@ -403,74 +394,3 @@ class IDEData:
             if path.endswith(".exe")
             else f"{path[:-3]}readelf"
         )
-
-
-def analyze_memory_usage(config: dict[str, Any]) -> None:
-    """Analyze memory usage by component after compilation."""
-    # Lazy import to avoid overhead when not needed
-    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
-    from esphome.analyze_memory.helpers import get_esphome_components
-
-    idedata = get_idedata(config)
-
-    # Get paths to tools
-    elf_path = idedata.firmware_elf_path
-    objdump_path = idedata.objdump_path
-    readelf_path = idedata.readelf_path
-
-    # Debug logging
-    _LOGGER.debug("ELF path from idedata: %s", elf_path)
-
-    # Check if file exists
-    if not Path(elf_path).exists():
-        # Try alternate path
-        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
-        if alt_path.exists():
-            elf_path = str(alt_path)
-            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
-        else:
-            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
-            return
-
-    # Extract external components from config
-    external_components = set()
-
-    # Get the list of built-in ESPHome components
-    builtin_components = get_esphome_components()
-
-    # Special non-component keys that appear in configs
-    NON_COMPONENT_KEYS = {
-        CONF_ESPHOME,
-        "substitutions",
-        "packages",
-        "globals",
-        "<<",
-    }
-
-    # Check all top-level keys in config
-    for key in config:
-        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
-            # This is an external component
-            external_components.add(key)
-
-    _LOGGER.debug("Detected external components: %s", external_components)
-
-    # Create analyzer and run analysis
-    analyzer = MemoryAnalyzerCLI(
-        elf_path, objdump_path, readelf_path, external_components
-    )
-    analyzer.analyze()
-
-    # Generate and print report
-    report = analyzer.generate_report()
-    _LOGGER.info("\n%s", report)
-
-    # Optionally save to file
-    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
-        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
-        if report_file.suffix == ".json":
-            report_file.write_text(analyzer.to_json())
-            _LOGGER.info("Memory report saved to %s", report_file)
-        else:
-            report_file.write_text(report)
-            _LOGGER.info("Memory report saved to %s", report_file)

tests/component_tests/text/test_text.py

@@ -66,6 +66,5 @@ def test_text_config_lamda_is_set(generate_main):
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
     # Then
-    # Stateless lambda optimization: empty capture list allows function pointer conversion
     assert "it_4->set_template([]() -> esphome::optional<std::string> {" in main_cpp
     assert 'return std::string{"Hello"};' in main_cpp

tests/integration/fixtures/wait_until_mid_loop_timing.yaml

@@ -0,0 +1,109 @@
+# Test for PR #11676 bug: wait_until timeout when triggered mid-component-loop
+# This demonstrates that App.get_loop_component_start_time() is stale when
+# wait_until is triggered partway through a component's loop execution
+
+esphome:
+  name: wait-mid-loop
+
+host:
+
+api:
+  actions:
+    - action: test_mid_loop_timeout
+      then:
+        - logger.log: "=== Test: wait_until triggered mid-loop should timeout correctly ==="
+
+        # Reset test state
+        - globals.set:
+            id: test_complete
+            value: 'false'
+
+        # Trigger the slow script that will call wait_until mid-execution
+        - script.execute: slow_script
+
+        # Wait for test to complete (should take ~300ms: 100ms delay + 200ms timeout)
+        - wait_until:
+            condition:
+              lambda: return id(test_complete);
+            timeout: 2s
+
+        - if:
+            condition:
+              lambda: return id(test_complete);
+            then:
+              - logger.log: "✓ Test PASSED: wait_until timed out correctly"
+            else:
+              - logger.log: "✗ Test FAILED: wait_until did not complete properly"
+
+logger:
+  level: DEBUG
+
+globals:
+  - id: test_complete
+    type: bool
+    restore_value: false
+    initial_value: 'false'
+
+  - id: test_condition
+    type: bool
+    restore_value: false
+    initial_value: 'false'
+
+  - id: timeout_start_time
+    type: uint32_t
+    restore_value: false
+    initial_value: '0'
+
+  - id: timeout_end_time
+    type: uint32_t
+    restore_value: false
+    initial_value: '0'
+
+script:
+  # This script simulates a component that takes time during its execution
+  # When wait_until is triggered mid-script, the loop_component_start_time
+  # will be stale (from when the script's component loop started)
+  - id: slow_script
+    then:
+      - logger.log: "Script: Starting, about to do some work..."
+
+      # Simulate component doing work for 100ms
+      # This represents time spent in a component's loop() before triggering wait_until
+      - delay: 100ms
+
+      - logger.log: "Script: 100ms elapsed, now starting wait_until with 200ms timeout"
+      - lambda: |-
+          // Record when timeout starts
+          id(timeout_start_time) = millis();
+          id(test_condition) = false;
+
+      # At this point:
+      # - Script component's loop started 100ms ago
+      # - App.loop_component_start_time_ = time from 100ms ago (stale!)
+      # - wait_until will capture millis() NOW (fresh)
+      # - BUG: loop() will use stale loop_component_start_time, causing immediate timeout
+
+      - wait_until:
+          condition:
+            lambda: return id(test_condition);
+          timeout: 200ms
+
+      - lambda: |-
+          // Record when timeout completes
+          id(timeout_end_time) = millis();
+          uint32_t elapsed = id(timeout_end_time) - id(timeout_start_time);
+
+          ESP_LOGD("TEST", "wait_until completed after %u ms (expected ~200ms)", elapsed);
+
+          // Check if timeout took approximately correct time
+          // Should be ~200ms, not <50ms (immediate timeout)
+          if (elapsed >= 150 && elapsed <= 250) {
+            ESP_LOGD("TEST", "✓ Timeout duration correct: %u ms", elapsed);
+            id(test_complete) = true;
+          } else {
+            ESP_LOGE("TEST", "✗ Timeout duration WRONG: %u ms (expected 150-250ms)", elapsed);
+            if (elapsed < 50) {
+              ESP_LOGE("TEST", "  → Likely BUG: Immediate timeout due to stale loop_component_start_time");
+            }
+            id(test_complete) = false;
+          }

tests/integration/test_wait_until_mid_loop_timing.py

@@ -0,0 +1,112 @@
+"""Integration test for PR #11676 mid-loop timing bug.
+
+This test validates that wait_until timeouts work correctly when triggered
+mid-component-loop, where App.get_loop_component_start_time() is stale.
+
+The bug: When wait_until is triggered partway through a component's loop execution
+(e.g., from a script or automation), the cached loop_component_start_time_ is stale
+relative to when the action was actually triggered. This causes timeout calculations
+to underflow and timeout immediately instead of waiting the specified duration.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_wait_until_mid_loop_timing(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that wait_until timeout works when triggered mid-component-loop.
+
+    This test:
+    1. Executes a script that delays 100ms (simulating component work)
+    2. Then starts wait_until with 200ms timeout
+    3. Verifies timeout takes ~200ms, not <50ms (immediate timeout bug)
+    """
+    loop = asyncio.get_running_loop()
+
+    # Track test results
+    test_results = {
+        "timeout_duration": None,
+        "passed": False,
+        "failed": False,
+        "bug_detected": False,
+    }
+
+    # Patterns for log messages
+    timeout_duration = re.compile(r"wait_until completed after (\d+) ms")
+    test_pass = re.compile(r"✓ Timeout duration correct")
+    test_fail = re.compile(r"✗ Timeout duration WRONG")
+    bug_pattern = re.compile(r"Likely BUG: Immediate timeout")
+    test_passed = re.compile(r"✓ Test PASSED")
+    test_failed = re.compile(r"✗ Test FAILED")
+
+    test_complete = loop.create_future()
+
+    def check_output(line: str) -> None:
+        """Check log output for test results."""
+        # Extract timeout duration
+        match = timeout_duration.search(line)
+        if match:
+            test_results["timeout_duration"] = int(match.group(1))
+
+        if test_pass.search(line):
+            test_results["passed"] = True
+        if test_fail.search(line):
+            test_results["failed"] = True
+        if bug_pattern.search(line):
+            test_results["bug_detected"] = True
+
+        # Final test result
+        if (
+            test_passed.search(line)
+            or test_failed.search(line)
+            and not test_complete.done()
+        ):
+            test_complete.set_result(True)
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Get the test service
+        _, services = await client.list_entities_services()
+        test_service = next(
+            (s for s in services if s.name == "test_mid_loop_timeout"), None
+        )
+        assert test_service is not None, "test_mid_loop_timeout service not found"
+
+        # Execute the test
+        client.execute_service(test_service, {})
+
+        # Wait for test to complete (100ms delay + 200ms timeout + margins = ~500ms)
+        await asyncio.wait_for(test_complete, timeout=5.0)
+
+        # Verify results
+        assert test_results["timeout_duration"] is not None, (
+            "Timeout duration not reported"
+        )
+        assert test_results["passed"], (
+            f"Test failed: wait_until took {test_results['timeout_duration']}ms, expected ~200ms. "
+            f"Bug detected: {test_results['bug_detected']}"
+        )
+        assert not test_results["bug_detected"], (
+            f"BUG DETECTED: wait_until timed out immediately ({test_results['timeout_duration']}ms) "
+            "instead of waiting 200ms. This indicates stale loop_component_start_time."
+        )
+
+        # Additional validation: timeout should be ~200ms (150-250ms range)
+        duration = test_results["timeout_duration"]
+        assert 150 <= duration <= 250, (
+            f"Timeout duration {duration}ms outside expected range (150-250ms). "
+            f"This suggests timing regression from PR #11676."
+        )

tests/unit_tests/test_core.py

@@ -670,45 +670,3 @@ class TestEsphomeCore:
             os.environ.pop("ESPHOME_IS_HA_ADDON", None)
             os.environ.pop("ESPHOME_DATA_DIR", None)
             assert target.data_dir == Path(expected_default)
-
-    def test_platformio_cache_dir_with_env_var(self):
-        """Test platformio_cache_dir when PLATFORMIO_CACHE_DIR env var is set."""
-        target = core.EsphomeCore()
-        test_cache_dir = "/custom/cache/dir"
-
-        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": test_cache_dir}):
-            assert target.platformio_cache_dir == test_cache_dir
-
-    def test_platformio_cache_dir_without_env_var(self):
-        """Test platformio_cache_dir defaults to ~/.platformio/.cache."""
-        target = core.EsphomeCore()
-
-        with patch.dict(os.environ, {}, clear=True):
-            # Ensure env var is not set
-            os.environ.pop("PLATFORMIO_CACHE_DIR", None)
-            expected = os.path.expanduser("~/.platformio/.cache")
-            assert target.platformio_cache_dir == expected
-
-    def test_platformio_cache_dir_empty_env_var(self):
-        """Test platformio_cache_dir with empty env var falls back to default."""
-        target = core.EsphomeCore()
-
-        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": ""}):
-            expected = os.path.expanduser("~/.platformio/.cache")
-            assert target.platformio_cache_dir == expected
-
-    def test_platformio_cache_dir_whitespace_env_var(self):
-        """Test platformio_cache_dir with whitespace-only env var falls back to default."""
-        target = core.EsphomeCore()
-
-        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": "   "}):
-            expected = os.path.expanduser("~/.platformio/.cache")
-            assert target.platformio_cache_dir == expected
-
-    def test_platformio_cache_dir_docker_addon_path(self):
-        """Test platformio_cache_dir in Docker/HA addon environment."""
-        target = core.EsphomeCore()
-        addon_cache = "/data/cache/platformio"
-
-        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": addon_cache}):
-            assert target.platformio_cache_dir == addon_cache

tests/unit_tests/test_writer.py

@@ -355,7 +355,6 @@ def test_clean_build(
     mock_core.relative_pioenvs_path.return_value = pioenvs_dir
     mock_core.relative_piolibdeps_path.return_value = piolibdeps_dir
     mock_core.relative_build_path.return_value = dependencies_lock
-    mock_core.platformio_cache_dir = str(platformio_cache_dir)
 
     # Verify all exist before
     assert pioenvs_dir.exists()