[template.alarm_control_panel] Use FixedVector for iteration-only sensor storage

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

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

esphome/analyze_memory/cli.py

@@ -15,11 +15,6 @@ from . import (
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
-    # Symbol size threshold for detailed analysis
-    SYMBOL_SIZE_THRESHOLD: int = (
-        100  # Show symbols larger than this in detailed analysis
-    )
-
     # Column width constants
     COL_COMPONENT: int = 29
     COL_FLASH_TEXT: int = 14
@@ -196,21 +191,14 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # All core symbols above threshold
+            # Top 15 largest core symbols
             lines.append("")
+            lines.append(f"Top 15 Largest {_COMPONENT_CORE} Symbols:")
             sorted_core_symbols = sorted(
                 self._esphome_core_symbols, key=lambda x: x[2], reverse=True
             )
-            large_core_symbols = [
-                (symbol, demangled, size)
-                for symbol, demangled, size in sorted_core_symbols
-                if size > self.SYMBOL_SIZE_THRESHOLD
-            ]
 
-            lines.append(
-                f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
-            )
-            for i, (symbol, demangled, size) in enumerate(large_core_symbols):
+            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -280,15 +268,13 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols above threshold for better visibility
+                # Show all symbols > 100 bytes for better visibility
                 large_symbols = [
-                    (sym, dem, size)
-                    for sym, dem, size in sorted_symbols
-                    if size > self.SYMBOL_SIZE_THRESHOLD
+                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size) in enumerate(large_symbols):
                     lines.append(f"{i + 1}. {demangled} ({size:,} B)")

esphome/components/binary_sensor/automation.cpp

@@ -1,11 +1,12 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void MultiClickTrigger::on_state_(bool state) {
+void binary_sensor::MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -66,7 +67,7 @@ void MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void MultiClickTrigger::schedule_cooldown_() {
+void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
   this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
@@ -78,7 +79,7 @@ void MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -89,19 +90,19 @@ void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
   });
 }
-void MultiClickTrigger::cancel() {
+void binary_sensor::MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void MultiClickTrigger::trigger_() {
+void binary_sensor::MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -117,4 +118,5 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/automation.h

@@ -9,7 +9,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -171,4 +172,5 @@ template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts..
   BinarySensor *sensor_;
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.cpp

@@ -3,7 +3,9 @@
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
@@ -61,4 +63,6 @@ void BinarySensor::add_filters(std::initializer_list<Filter *> filters) {
 }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.h

@@ -6,7 +6,9 @@
 
 #include <initializer_list>
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
@@ -68,4 +70,5 @@ class BinarySensorInitiallyOff : public BinarySensor {
   bool has_state() const override { return true; }
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/filter.cpp

@@ -2,7 +2,9 @@
 
 #include "binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
@@ -130,4 +132,6 @@ optional<bool> SettleFilter::new_value(bool value) {
 
 float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/filter.h

@@ -4,7 +4,9 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 
@@ -137,4 +139,6 @@ class SettleFilter : public Filter, public Component {
   bool steady_{true};
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/font/__init__.py

@@ -36,6 +36,7 @@ from esphome.const import (
     CONF_WEIGHT,
 )
 from esphome.core import CORE, HexInt
+from esphome.helpers import cpp_string_escape
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,6 +50,7 @@ font_ns = cg.esphome_ns.namespace("font")
 
 Font = font_ns.class_("Font")
 Glyph = font_ns.class_("Glyph")
+GlyphData = font_ns.struct("GlyphData")
 
 CONF_BPP = "bpp"
 CONF_EXTRAS = "extras"
@@ -461,7 +463,7 @@ FONT_SCHEMA = cv.Schema(
             )
         ),
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(GlyphData),
     },
 )
 
@@ -581,15 +583,22 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        [
-            x.glyph,
-            prog_arr + (y - len(x.bitmap_data)),
-            x.advance,
-            x.offset_x,
-            x.offset_y,
-            x.width,
-            x.height,
-        ]
+        cg.StructInitializer(
+            GlyphData,
+            (
+                "a_char",
+                cg.RawExpression(f"(const uint8_t *){cpp_string_escape(x.glyph)}"),
+            ),
+            (
+                "data",
+                cg.RawExpression(f"{str(prog_arr)} + {str(y - len(x.bitmap_data))}"),
+            ),
+            ("advance", x.advance),
+            ("offset_x", x.offset_x),
+            ("offset_y", x.offset_y),
+            ("width", x.width),
+            ("height", x.height),
+        )
         for (x, y) in zip(
             glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )

esphome/components/font/font.cpp

@@ -9,19 +9,20 @@ namespace font {
 
 static const char *const TAG = "font";
 
+const uint8_t *Glyph::get_char() const { return this->glyph_data_->a_char; }
 // Compare the char at the string position with this char.
 // Return true if this char is less than or equal the other.
 bool Glyph::compare_to(const uint8_t *str) const {
   // 1 -> this->char_
   // 2 -> str
   for (uint32_t i = 0;; i++) {
-    if (this->a_char[i] == '\0')
+    if (this->glyph_data_->a_char[i] == '\0')
       return true;
     if (str[i] == '\0')
       return false;
-    if (this->a_char[i] > str[i])
+    if (this->glyph_data_->a_char[i] > str[i])
       return false;
-    if (this->a_char[i] < str[i])
+    if (this->glyph_data_->a_char[i] < str[i])
       return true;
   }
   // this should not happen
@@ -29,32 +30,35 @@ bool Glyph::compare_to(const uint8_t *str) const {
 }
 int Glyph::match_length(const uint8_t *str) const {
   for (uint32_t i = 0;; i++) {
-    if (this->a_char[i] == '\0')
+    if (this->glyph_data_->a_char[i] == '\0')
       return i;
-    if (str[i] != this->a_char[i])
+    if (str[i] != this->glyph_data_->a_char[i])
       return 0;
   }
   // this should not happen
   return 0;
 }
 void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
-  *x1 = this->offset_x;
-  *y1 = this->offset_y;
-  *width = this->width;
-  *height = this->height;
+  *x1 = this->glyph_data_->offset_x;
+  *y1 = this->glyph_data_->offset_y;
+  *width = this->glyph_data_->width;
+  *height = this->glyph_data_->height;
 }
 
-Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : glyphs_(ConstVector(data, data_nr)),
-      baseline_(baseline),
+    : baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
-      bpp_(bpp) {}
-int Font::match_next_glyph(const uint8_t *str, int *match_length) const {
+      bpp_(bpp) {
+  glyphs_.reserve(data_nr);
+  for (int i = 0; i < data_nr; ++i)
+    glyphs_.emplace_back(&data[i]);
+}
+int Font::match_next_glyph(const uint8_t *str, int *match_length) {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
@@ -84,18 +88,18 @@ void Font::measure(const char *str, int *width, int *x_offset, int *baseline, in
     if (glyph_n < 0) {
       // Unknown char, skip
       if (!this->get_glyphs().empty())
-        x += this->get_glyphs()[0].advance;
+        x += this->get_glyphs()[0].glyph_data_->advance;
       i++;
       continue;
     }
 
     const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph.offset_x;
+      min_x = glyph.glyph_data_->offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph.offset_x);
+      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
     }
-    x += glyph.advance;
+    x += glyph.glyph_data_->advance;
 
     i += match_length;
     has_char = true;
@@ -114,7 +118,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
       // Unknown char, skip
       ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
       if (!this->get_glyphs().empty()) {
-        uint8_t glyph_width = this->get_glyphs()[0].advance;
+        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->advance;
         display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
@@ -126,7 +130,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
     const Glyph &glyph = this->get_glyphs()[glyph_n];
     glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
 
-    const uint8_t *data = glyph.data;
+    const uint8_t *data = glyph.glyph_data_->data;
     const int max_x = x_at + scan_x1 + scan_width;
     const int max_y = y_start + scan_y1 + scan_height;
 
@@ -164,7 +168,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph.advance;
+    x_at += glyph.glyph_data_->advance;
 
     i += match_length;
   }

esphome/components/font/font.h

@@ -12,19 +12,21 @@ namespace font {
 
 class Font;
 
+struct GlyphData {
+  const uint8_t *a_char;
+  const uint8_t *data;
+  int advance;
+  int offset_x;
+  int offset_y;
+  int width;
+  int height;
+};
+
 class Glyph {
  public:
-  constexpr Glyph(const char *a_char, const uint8_t *data, int advance, int offset_x, int offset_y, int width,
-                  int height)
-      : a_char(a_char),
-        data(data),
-        advance(advance),
-        offset_x(offset_x),
-        offset_y(offset_y),
-        width(width),
-        height(height) {}
+  Glyph(const GlyphData *data) : glyph_data_(data) {}
 
-  const uint8_t *get_char() const { return reinterpret_cast<const uint8_t *>(this->a_char); }
+  const uint8_t *get_char() const;
 
   bool compare_to(const uint8_t *str) const;
 
@@ -32,16 +34,12 @@ class Glyph {
 
   void scan_area(int *x1, int *y1, int *width, int *height) const;
 
-  const char *a_char;
-  const uint8_t *data;
-  int advance;
-  int offset_x;
-  int offset_y;
-  int width;
-  int height;
+  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
 
  protected:
   friend Font;
+
+  const GlyphData *glyph_data_;
 };
 
 class Font
@@ -52,8 +50,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A list of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs
+   * @param data A vector of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs in data.
    * @param baseline The y-offset from the top of the text to the baseline.
    * @param height The y-offset from the top of the text to the bottom.
    * @param descender The y-offset from the baseline to the lowest stroke in the font (e.g. from letters like g or p).
@@ -61,10 +59,10 @@ class Font
    * @param capheight The height of capital letters, usually measured at the "X" glyph.
    * @param bpp The bits per pixel used for this font. Used to read data out of the glyph bitmaps.
    */
-  Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
        uint8_t bpp = 1);
 
-  int match_next_glyph(const uint8_t *str, int *match_length) const;
+  int match_next_glyph(const uint8_t *str, int *match_length);
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -80,10 +78,10 @@ class Font
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
 
-  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
+  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
 
  protected:
-  ConstVector<Glyph> glyphs_;
+  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
   int baseline_;
   int height_;
   int descender_;

esphome/components/ld2410/sensor.py

@@ -31,83 +31,35 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -121,13 +73,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -135,13 +81,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,84 +31,36 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
             unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
         ),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -122,13 +74,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -136,13 +82,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/light/light_call.cpp

@@ -52,10 +52,8 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   }
 
 static const LogString *color_mode_to_human(ColorMode color_mode) {
-  if (color_mode == ColorMode::ON_OFF)
-    return LOG_STR("On/Off");
-  if (color_mode == ColorMode::BRIGHTNESS)
-    return LOG_STR("Brightness");
+  if (color_mode == ColorMode::UNKNOWN)
+    return LOG_STR("Unknown");
   if (color_mode == ColorMode::WHITE)
     return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
@@ -70,7 +68,7 @@ static const LogString *color_mode_to_human(ColorMode color_mode) {
     return LOG_STR("RGB + cold/warm white");
   if (color_mode == ColorMode::RGB_COLOR_TEMPERATURE)
     return LOG_STR("RGB + color temperature");
-  return LOG_STR("Unknown");
+  return LOG_STR("");
 }
 
 // Helper to log percentage values

esphome/components/lvgl/font.cpp

@@ -43,7 +43,7 @@ FontEngine::FontEngine(font::Font *esp_font) : font_(esp_font) {
 
 const lv_font_t *FontEngine::get_lv_font() { return &this->lv_font_; }
 
-const font::Glyph *FontEngine::get_glyph_data(uint32_t unicode_letter) {
+const font::GlyphData *FontEngine::get_glyph_data(uint32_t unicode_letter) {
   if (unicode_letter == last_letter_)
     return this->last_data_;
   uint8_t unicode[5];
@@ -67,7 +67,7 @@ const font::Glyph *FontEngine::get_glyph_data(uint32_t unicode_letter) {
   int glyph_n = this->font_->match_next_glyph(unicode, &match_length);
   if (glyph_n < 0)
     return nullptr;
-  this->last_data_ = &this->font_->get_glyphs()[glyph_n];
+  this->last_data_ = this->font_->get_glyphs()[glyph_n].get_glyph_data();
   this->last_letter_ = unicode_letter;
   return this->last_data_;
 }

esphome/components/lvgl/lvgl_esphome.h

@@ -140,7 +140,7 @@ class FontEngine {
   FontEngine(font::Font *esp_font);
   const lv_font_t *get_lv_font();
 
-  const font::Glyph *get_glyph_data(uint32_t unicode_letter);
+  const font::GlyphData *get_glyph_data(uint32_t unicode_letter);
   uint16_t baseline{};
   uint16_t height{};
   uint8_t bpp{};
@@ -148,7 +148,7 @@ class FontEngine {
  protected:
   font::Font *font_{};
   uint32_t last_letter_{};
-  const font::Glyph *last_data_{};
+  const font::GlyphData *last_data_{};
   lv_font_t lv_font_{};
 };
 #endif  // USE_LVGL_FONT

esphome/components/template/alarm_control_panel/__init__.py

@@ -137,7 +137,11 @@ async def to_code(config):
         cg.add(var.set_arming_night_time(config[CONF_ARMING_NIGHT_TIME]))
         supports_arm_night = True
 
-    for sensor in config.get(CONF_BINARY_SENSORS, []):
+    if sensors := config.get(CONF_BINARY_SENSORS, []):
+        # Initialize FixedVector with the exact number of sensors
+        cg.add(var.init_sensors(len(sensors)))
+
+    for sensor in sensors:
         bs = await cg.get_variable(sensor[CONF_INPUT])
 
         flags = BinarySensorFlags[FLAG_NORMAL]

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -20,10 +20,13 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
   // Save the flags and type. Assign a store index for the per sensor data type.
   SensorDataStore sd;
   sd.last_chime_state = false;
-  this->sensor_map_[sensor].flags = flags;
-  this->sensor_map_[sensor].type = type;
+  AlarmSensor alarm_sensor;
+  alarm_sensor.sensor = sensor;
+  alarm_sensor.info.flags = flags;
+  alarm_sensor.info.type = type;
+  alarm_sensor.info.store_index = this->next_store_index_++;
+  this->sensors_.push_back(alarm_sensor);
   this->sensor_data_.push_back(sd);
-  this->sensor_map_[sensor].store_index = this->next_store_index_++;
 };
 
 static const LogString *sensor_type_to_string(AlarmSensorType type) {
@@ -45,7 +48,7 @@ void TemplateAlarmControlPanel::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "TemplateAlarmControlPanel:\n"
                 "  Current State: %s\n"
-                "  Number of Codes: %u\n"
+                "  Number of Codes: %zu\n"
                 "  Requires Code To Arm: %s\n"
                 "  Arming Away Time: %" PRIu32 "s\n"
                 "  Arming Home Time: %" PRIu32 "s\n"
@@ -58,7 +61,8 @@ void TemplateAlarmControlPanel::dump_config() {
                 (this->arming_home_time_ / 1000), (this->arming_night_time_ / 1000), (this->pending_time_ / 1000),
                 (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
+    const uint16_t flags = alarm_sensor.info.flags;
     ESP_LOGCONFIG(TAG,
                   "  Binary Sensor:\n"
                   "    Name: %s\n"
@@ -67,11 +71,10 @@ void TemplateAlarmControlPanel::dump_config() {
                   "    Armed night bypass: %s\n"
                   "    Auto bypass: %s\n"
                   "    Chime mode: %s",
-                  sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(info.type)),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_CHIME));
+                  alarm_sensor.sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(alarm_sensor.info.type)),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_AUTO), TRUEFALSE(flags & BINARY_SENSOR_MODE_CHIME));
   }
 #endif
 }
@@ -121,7 +124,9 @@ void TemplateAlarmControlPanel::loop() {
 
 #ifdef USE_BINARY_SENSOR
   // Test all of the sensors regardless of the alarm panel state
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
+    const auto &info = alarm_sensor.info;
+    auto *sensor = alarm_sensor.sensor;
     // Check for chime zones
     if (info.flags & BINARY_SENSOR_MODE_CHIME) {
       // Look for the transition from closed to open
@@ -242,11 +247,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
     // Check for faulted bypass_auto sensors and remove them from monitoring
-    if ((info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor->state)) {
-      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", sensor->get_name().c_str());
-      this->bypassed_sensor_indicies_.push_back(info.store_index);
+    if ((alarm_sensor.info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (alarm_sensor.sensor->state)) {
+      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", alarm_sensor.sensor->get_name().c_str());
+      this->bypassed_sensor_indicies_.push_back(alarm_sensor.info.store_index);
     }
   }
 #endif

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -1,11 +1,12 @@
 #pragma once
 
 #include <cinttypes>
-#include <map>
+#include <vector>
 
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
 
 #include "esphome/components/alarm_control_panel/alarm_control_panel.h"
 
@@ -49,6 +50,13 @@ struct SensorInfo {
   uint8_t store_index;
 };
 
+#ifdef USE_BINARY_SENSOR
+struct AlarmSensor {
+  binary_sensor::BinarySensor *sensor;
+  SensorInfo info;
+};
+#endif
+
 class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControlPanel, public Component {
  public:
   TemplateAlarmControlPanel();
@@ -63,6 +71,12 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
   void bypass_before_arming();
 
 #ifdef USE_BINARY_SENSOR
+  /** Initialize the sensors vector with the specified capacity.
+   *
+   * @param capacity The number of sensors to allocate space for.
+   */
+  void init_sensors(size_t capacity) { this->sensors_.init(capacity); }
+
   /** Add a binary_sensor to the alarm_panel.
    *
    * @param sensor The BinarySensor instance.
@@ -122,8 +136,8 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
  protected:
   void control(const alarm_control_panel::AlarmControlPanelCall &call) override;
 #ifdef USE_BINARY_SENSOR
-  // This maps a binary sensor to its alarm specific info
-  std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
+  // List of binary sensors with their alarm-specific info
+  FixedVector<AlarmSensor> sensors_;
   // a list of automatically bypassed sensors
   std::vector<uint8_t> bypassed_sensor_indicies_;
 #endif

esphome/components/uart/__init__.py

@@ -1,4 +1,3 @@
-from logging import getLogger
 import math
 import re
 
@@ -36,8 +35,6 @@ from esphome.core import CORE, ID
 import esphome.final_validate as fv
 from esphome.yaml_util import make_data_base
 
-_LOGGER = getLogger(__name__)
-
 CODEOWNERS = ["@esphome/core"]
 uart_ns = cg.esphome_ns.namespace("uart")
 UARTComponent = uart_ns.class_("UARTComponent")
@@ -133,21 +130,6 @@ def validate_host_config(config):
     return config
 
 
-def validate_rx_buffer_size(config):
-    if CORE.is_esp32:
-        # ESP32 UART hardware FIFO is 128 bytes (LP UART is 16 bytes, but we use 128 as safe minimum)
-        # rx_buffer_size must be greater than the hardware FIFO length
-        min_buffer_size = 128
-        if config[CONF_RX_BUFFER_SIZE] <= min_buffer_size:
-            _LOGGER.warning(
-                "UART rx_buffer_size (%d bytes) is too small and must be greater than the hardware "
-                "FIFO size (%d bytes). The buffer size will be automatically adjusted at runtime.",
-                config[CONF_RX_BUFFER_SIZE],
-                min_buffer_size,
-            )
-    return config
-
-
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -265,7 +247,6 @@ CONFIG_SCHEMA = cv.All(
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
     validate_host_config,
-    validate_rx_buffer_size,
 )
 
 

esphome/components/uart/uart_component_esp_idf.cpp

@@ -91,16 +91,6 @@ void IDFUARTComponent::setup() {
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
   this->lock_ = xSemaphoreCreateMutex();
 
-#if (SOC_UART_LP_NUM >= 1)
-  size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
-#else
-  size_t fifo_len = SOC_UART_FIFO_LEN;
-#endif
-  if (this->rx_buffer_size_ <= fifo_len) {
-    ESP_LOGW(TAG, "rx_buffer_size is too small, must be greater than %zu", fifo_len);
-    this->rx_buffer_size_ = fifo_len * 2;
-  }
-
   xSemaphoreTake(this->lock_, portMAX_DELAY);
 
   this->load_settings(false);
@@ -247,12 +237,8 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  uart_write_bytes(this->uart_num_, data, len);
   xSemaphoreGive(this->lock_);
-  if (write_len != (int32_t) len) {
-    ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
-    this->mark_failed();
-  }
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_TX, data[i]);
@@ -281,7 +267,6 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
 
 bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   size_t length_to_read = len;
-  int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
   xSemaphoreTake(this->lock_, portMAX_DELAY);
@@ -292,31 +277,25 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
   xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
   }
 #endif
-  return read_len == (int32_t) length_to_read;
+  return true;
 }
 
 int IDFUARTComponent::available() {
-  size_t available = 0;
-  esp_err_t err;
+  size_t available;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  err = uart_get_buffered_data_len(this->uart_num_, &available);
+  uart_get_buffered_data_len(this->uart_num_, &available);
+  if (this->has_peek_)
+    available++;
   xSemaphoreGive(this->lock_);
 
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-  }
-  if (this->has_peek_) {
-    available++;
-  }
   return available;
 }
 

esphome/components/web_server_idf/web_server_idf.cpp

@@ -489,18 +489,10 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 
 void AsyncEventSourceResponse::destroy(void *ptr) {
   auto *rsp = static_cast<AsyncEventSourceResponse *>(ptr);
-  int fd = rsp->fd_.exchange(0);  // Atomically get and clear fd
-
-  if (fd > 0) {
-    ESP_LOGD(TAG, "Event source connection closed (fd: %d)", fd);
-    // Immediately shut down the socket to prevent lwIP from delivering more data
-    // This prevents "recv_tcp: recv for wrong pcb!" assertions when the TCP stack
-    // tries to deliver queued data after the session is marked as dead
-    // See: https://github.com/esphome/esphome/issues/11936
-    shutdown(fd, SHUT_RDWR);
-    // Note: We don't close() the socket - httpd owns it and will close it
-  }
-  // Session will be cleaned up in the main loop to avoid race conditions
+  ESP_LOGD(TAG, "Event source connection closed (fd: %d)", rsp->fd_.load());
+  // Mark as dead by setting fd to 0 - will be cleaned up in the main loop
+  rsp->fd_.store(0);
+  // Note: We don't delete or remove from set here to avoid race conditions
 }
 
 // helper for allowing only unique entries in the queue

esphome/components/wifi/__init__.py

@@ -12,6 +12,7 @@ from esphome.components.network import (
 from esphome.components.psram import is_guaranteed as psram_is_guaranteed
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
+from esphome.config_validation import only_with_esp_idf
 from esphome.const import (
     CONF_AP,
     CONF_BSSID,
@@ -351,7 +352,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_USE_PSRAM): cv.All(
-                cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
+                only_with_esp_idf, cv.requires_component("psram"), cv.boolean
             ),
         }
     ),

esphome/core/helpers.h

@@ -111,23 +111,6 @@ template<> constexpr int64_t byteswap(int64_t n) { return __builtin_bswap64(n);
 /// @name Container utilities
 ///@{
 
-/// Lightweight read-only view over a const array stored in RODATA (will typically be in flash memory)
-/// Avoids copying data from flash to RAM by keeping a pointer to the flash data.
-/// Similar to std::span but with minimal overhead for embedded systems.
-
-template<typename T> class ConstVector {
- public:
-  constexpr ConstVector(const T *data, size_t size) : data_(data), size_(size) {}
-
-  const constexpr T &operator[](size_t i) const { return data_[i]; }
-  constexpr size_t size() const { return size_; }
-  constexpr bool empty() const { return size_ == 0; }
-
- protected:
-  const T *data_;
-  size_t size_;
-};
-
 /// Minimal static vector - saves memory by avoiding std::vector overhead
 template<typename T, size_t N> class StaticVector {
  public:

esphome/core/scheduler.cpp

@@ -609,12 +609,13 @@ uint64_t Scheduler::millis_64_(uint32_t now) {
   if (now < last && (last - now) > HALF_MAX_UINT32) {
     this->millis_major_++;
     major++;
-    this->last_millis_ = now;
 #ifdef ESPHOME_DEBUG_SCHEDULER
     ESP_LOGD(TAG, "Detected true 32-bit rollover at %" PRIu32 "ms (was %" PRIu32 ")", now, last);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
-  } else if (now > last) {
-    // Only update if time moved forward
+  }
+
+  // Only update if time moved forward
+  if (now > last) {
     this->last_millis_ = now;
   }
 

requirements_test.txt

@@ -1,6 +1,6 @@
-pylint==4.0.3
+pylint==4.0.2
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.5  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.4  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.1  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

tests/integration/fixtures/sensor_timeout_filter.yaml

@@ -1,150 +0,0 @@
-esphome:
-  name: test-timeout-filters
-
-host:
-api:
-  batch_delay: 0ms  # Disable batching to receive all state updates
-logger:
-  level: DEBUG
-
-# Template sensors that we'll use to publish values
-sensor:
-  - platform: template
-    name: "Source Timeout Last"
-    id: source_timeout_last
-    accuracy_decimals: 1
-
-  - platform: template
-    name: "Source Timeout Reset"
-    id: source_timeout_reset
-    accuracy_decimals: 1
-
-  - platform: template
-    name: "Source Timeout Static"
-    id: source_timeout_static
-    accuracy_decimals: 1
-
-  - platform: template
-    name: "Source Timeout Lambda"
-    id: source_timeout_lambda
-    accuracy_decimals: 1
-
-  # Test 1: TimeoutFilter - "last" mode (outputs last received value)
-  - platform: copy
-    source_id: source_timeout_last
-    name: "Timeout Last Sensor"
-    id: timeout_last_sensor
-    filters:
-      - timeout:
-          timeout: 100ms
-          value: last  # Explicitly specify "last" mode to use TimeoutFilter class
-
-  # Test 2: TimeoutFilter - reset behavior (same filter, different source)
-  - platform: copy
-    source_id: source_timeout_reset
-    name: "Timeout Reset Sensor"
-    id: timeout_reset_sensor
-    filters:
-      - timeout:
-          timeout: 100ms
-          value: last  # Explicitly specify "last" mode
-
-  # Test 3: TimeoutFilterConfigured - static value mode
-  - platform: copy
-    source_id: source_timeout_static
-    name: "Timeout Static Sensor"
-    id: timeout_static_sensor
-    filters:
-      - timeout:
-          timeout: 100ms
-          value: 99.9
-
-  # Test 4: TimeoutFilterConfigured - lambda mode
-  - platform: copy
-    source_id: source_timeout_lambda
-    name: "Timeout Lambda Sensor"
-    id: timeout_lambda_sensor
-    filters:
-      - timeout:
-          timeout: 100ms
-          value: !lambda "return -1.0;"
-
-# Scripts to publish values with controlled timing
-script:
-  # Test 1: Single value followed by timeout
-  - id: test_timeout_last_script
-    then:
-      # Publish initial value
-      - sensor.template.publish:
-          id: source_timeout_last
-          state: 42.0
-      # Wait for timeout to fire (100ms + margin)
-      - delay: 150ms
-
-  # Test 2: Multiple values before timeout (should reset timer)
-  - id: test_timeout_reset_script
-    then:
-      # Publish first value
-      - sensor.template.publish:
-          id: source_timeout_reset
-          state: 10.0
-      # Wait 50ms (halfway to timeout)
-      - delay: 50ms
-      # Publish second value (resets timeout)
-      - sensor.template.publish:
-          id: source_timeout_reset
-          state: 20.0
-      # Wait 50ms (halfway to timeout again)
-      - delay: 50ms
-      # Publish third value (resets timeout)
-      - sensor.template.publish:
-          id: source_timeout_reset
-          state: 30.0
-      # Wait for timeout to fire (100ms + margin)
-      - delay: 150ms
-
-  # Test 3: Static value timeout
-  - id: test_timeout_static_script
-    then:
-      # Publish initial value
-      - sensor.template.publish:
-          id: source_timeout_static
-          state: 55.5
-      # Wait for timeout to fire
-      - delay: 150ms
-
-  # Test 4: Lambda value timeout
-  - id: test_timeout_lambda_script
-    then:
-      # Publish initial value
-      - sensor.template.publish:
-          id: source_timeout_lambda
-          state: 77.7
-      # Wait for timeout to fire
-      - delay: 150ms
-
-# Buttons to trigger each test scenario
-button:
-  - platform: template
-    name: "Test Timeout Last Button"
-    id: test_timeout_last_button
-    on_press:
-      - script.execute: test_timeout_last_script
-
-  - platform: template
-    name: "Test Timeout Reset Button"
-    id: test_timeout_reset_button
-    on_press:
-      - script.execute: test_timeout_reset_script
-
-  - platform: template
-    name: "Test Timeout Static Button"
-    id: test_timeout_static_button
-    on_press:
-      - script.execute: test_timeout_static_script
-
-  - platform: template
-    name: "Test Timeout Lambda Button"
-    id: test_timeout_lambda_button
-    on_press:
-      - script.execute: test_timeout_lambda_script

tests/integration/fixtures/template_alarm_control_panel_many_sensors.yaml

@@ -0,0 +1,136 @@
+esphome:
+  name: template-alarm-many-sensors
+  friendly_name: "Template Alarm Control Panel with Many Sensors"
+
+logger:
+
+host:
+
+api:
+
+binary_sensor:
+  - platform: template
+    id: sensor1
+    name: "Door 1"
+  - platform: template
+    id: sensor2
+    name: "Door 2"
+  - platform: template
+    id: sensor3
+    name: "Window 1"
+  - platform: template
+    id: sensor4
+    name: "Window 2"
+  - platform: template
+    id: sensor5
+    name: "Motion 1"
+  - platform: template
+    id: sensor6
+    name: "Motion 2"
+  - platform: template
+    id: sensor7
+    name: "Glass Break 1"
+  - platform: template
+    id: sensor8
+    name: "Glass Break 2"
+  - platform: template
+    id: sensor9
+    name: "Smoke Detector"
+  - platform: template
+    id: sensor10
+    name: "CO Detector"
+
+alarm_control_panel:
+  - platform: template
+    id: test_alarm
+    name: "Test Alarm"
+    codes:
+      - "1234"
+    requires_code_to_arm: true
+    arming_away_time: 5s
+    arming_home_time: 3s
+    arming_night_time: 3s
+    pending_time: 10s
+    trigger_time: 300s
+    restore_mode: ALWAYS_DISARMED
+    binary_sensors:
+      - input: sensor1
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: true
+        chime: true
+        trigger_mode: DELAYED
+      - input: sensor2
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: true
+        chime: true
+        trigger_mode: DELAYED
+      - input: sensor3
+        bypass_armed_home: true
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: DELAYED
+      - input: sensor4
+        bypass_armed_home: true
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: DELAYED
+      - input: sensor5
+        bypass_armed_home: false
+        bypass_armed_night: true
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor6
+        bypass_armed_home: false
+        bypass_armed_night: true
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor7
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor8
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor9
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT_ALWAYS
+      - input: sensor10
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT_ALWAYS
+    on_disarmed:
+      - logger.log: "Alarm disarmed"
+    on_arming:
+      - logger.log: "Alarm arming"
+    on_armed_away:
+      - logger.log: "Alarm armed away"
+    on_armed_home:
+      - logger.log: "Alarm armed home"
+    on_armed_night:
+      - logger.log: "Alarm armed night"
+    on_pending:
+      - logger.log: "Alarm pending"
+    on_triggered:
+      - logger.log: "Alarm triggered"
+    on_cleared:
+      - logger.log: "Alarm cleared"
+    on_chime:
+      - logger.log: "Chime activated"
+    on_ready:
+      - logger.log: "Sensors ready state changed"

tests/integration/test_sensor_timeout_filter.py

@@ -1,185 +0,0 @@
-"""Test sensor timeout filter functionality."""
-
-from __future__ import annotations
-
-import asyncio
-
-from aioesphomeapi import EntityState, SensorState
-import pytest
-
-from .state_utils import InitialStateHelper, build_key_to_entity_mapping
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_sensor_timeout_filter(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test TimeoutFilter and TimeoutFilterConfigured with all modes."""
-    loop = asyncio.get_running_loop()
-
-    # Track state changes for all sensors
-    timeout_last_states: list[float] = []
-    timeout_reset_states: list[float] = []
-    timeout_static_states: list[float] = []
-    timeout_lambda_states: list[float] = []
-
-    # Futures for each test scenario
-    test1_complete = loop.create_future()  # TimeoutFilter - last mode
-    test2_complete = loop.create_future()  # TimeoutFilter - reset behavior
-    test3_complete = loop.create_future()  # TimeoutFilterConfigured - static value
-    test4_complete = loop.create_future()  # TimeoutFilterConfigured - lambda
-
-    def on_state(state: EntityState) -> None:
-        """Track sensor state updates."""
-        if not isinstance(state, SensorState):
-            return
-
-        if state.missing_state:
-            return
-
-        sensor_name = key_to_sensor.get(state.key)
-
-        # Test 1: TimeoutFilter - last mode
-        if sensor_name == "timeout_last_sensor":
-            timeout_last_states.append(state.state)
-            # Expect 2 values: initial 42.0 + timeout fires with 42.0
-            if len(timeout_last_states) >= 2 and not test1_complete.done():
-                test1_complete.set_result(True)
-
-        # Test 2: TimeoutFilter - reset behavior
-        elif sensor_name == "timeout_reset_sensor":
-            timeout_reset_states.append(state.state)
-            # Expect 4 values: 10.0, 20.0, 30.0, then timeout fires with 30.0
-            if len(timeout_reset_states) >= 4 and not test2_complete.done():
-                test2_complete.set_result(True)
-
-        # Test 3: TimeoutFilterConfigured - static value
-        elif sensor_name == "timeout_static_sensor":
-            timeout_static_states.append(state.state)
-            # Expect 2 values: initial 55.5 + timeout fires with 99.9
-            if len(timeout_static_states) >= 2 and not test3_complete.done():
-                test3_complete.set_result(True)
-
-        # Test 4: TimeoutFilterConfigured - lambda
-        elif sensor_name == "timeout_lambda_sensor":
-            timeout_lambda_states.append(state.state)
-            # Expect 2 values: initial 77.7 + timeout fires with -1.0
-            if len(timeout_lambda_states) >= 2 and not test4_complete.done():
-                test4_complete.set_result(True)
-
-    async with (
-        run_compiled(yaml_config),
-        api_client_connected() as client,
-    ):
-        entities, services = await client.list_entities_services()
-
-        key_to_sensor = build_key_to_entity_mapping(
-            entities,
-            [
-                "timeout_last_sensor",
-                "timeout_reset_sensor",
-                "timeout_static_sensor",
-                "timeout_lambda_sensor",
-            ],
-        )
-
-        initial_state_helper = InitialStateHelper(entities)
-        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
-
-        try:
-            await initial_state_helper.wait_for_initial_states()
-        except TimeoutError:
-            pytest.fail("Timeout waiting for initial states")
-
-        # Helper to find buttons by object_id substring
-        def find_button(object_id_substring: str) -> int:
-            """Find a button by object_id substring and return its key."""
-            button = next(
-                (e for e in entities if object_id_substring in e.object_id.lower()),
-                None,
-            )
-            assert button is not None, f"Button '{object_id_substring}' not found"
-            return button.key
-
-        # Find all test buttons
-        test1_button_key = find_button("test_timeout_last_button")
-        test2_button_key = find_button("test_timeout_reset_button")
-        test3_button_key = find_button("test_timeout_static_button")
-        test4_button_key = find_button("test_timeout_lambda_button")
-
-        # === Test 1: TimeoutFilter - last mode ===
-        client.button_command(test1_button_key)
-        try:
-            await asyncio.wait_for(test1_complete, timeout=2.0)
-        except TimeoutError:
-            pytest.fail(f"Test 1 timeout. Received states: {timeout_last_states}")
-
-        assert len(timeout_last_states) == 2, (
-            f"Test 1: Should have 2 states, got {len(timeout_last_states)}: {timeout_last_states}"
-        )
-        assert timeout_last_states[0] == pytest.approx(42.0), (
-            f"Test 1: First state should be 42.0, got {timeout_last_states[0]}"
-        )
-        assert timeout_last_states[1] == pytest.approx(42.0), (
-            f"Test 1: Timeout should output last value (42.0), got {timeout_last_states[1]}"
-        )
-
-        # === Test 2: TimeoutFilter - reset behavior ===
-        client.button_command(test2_button_key)
-        try:
-            await asyncio.wait_for(test2_complete, timeout=2.0)
-        except TimeoutError:
-            pytest.fail(f"Test 2 timeout. Received states: {timeout_reset_states}")
-
-        assert len(timeout_reset_states) == 4, (
-            f"Test 2: Should have 4 states, got {len(timeout_reset_states)}: {timeout_reset_states}"
-        )
-        assert timeout_reset_states[0] == pytest.approx(10.0), (
-            f"Test 2: First state should be 10.0, got {timeout_reset_states[0]}"
-        )
-        assert timeout_reset_states[1] == pytest.approx(20.0), (
-            f"Test 2: Second state should be 20.0, got {timeout_reset_states[1]}"
-        )
-        assert timeout_reset_states[2] == pytest.approx(30.0), (
-            f"Test 2: Third state should be 30.0, got {timeout_reset_states[2]}"
-        )
-        assert timeout_reset_states[3] == pytest.approx(30.0), (
-            f"Test 2: Timeout should output last value (30.0), got {timeout_reset_states[3]}"
-        )
-
-        # === Test 3: TimeoutFilterConfigured - static value ===
-        client.button_command(test3_button_key)
-        try:
-            await asyncio.wait_for(test3_complete, timeout=2.0)
-        except TimeoutError:
-            pytest.fail(f"Test 3 timeout. Received states: {timeout_static_states}")
-
-        assert len(timeout_static_states) == 2, (
-            f"Test 3: Should have 2 states, got {len(timeout_static_states)}: {timeout_static_states}"
-        )
-        assert timeout_static_states[0] == pytest.approx(55.5), (
-            f"Test 3: First state should be 55.5, got {timeout_static_states[0]}"
-        )
-        assert timeout_static_states[1] == pytest.approx(99.9), (
-            f"Test 3: Timeout should output configured value (99.9), got {timeout_static_states[1]}"
-        )
-
-        # === Test 4: TimeoutFilterConfigured - lambda ===
-        client.button_command(test4_button_key)
-        try:
-            await asyncio.wait_for(test4_complete, timeout=2.0)
-        except TimeoutError:
-            pytest.fail(f"Test 4 timeout. Received states: {timeout_lambda_states}")
-
-        assert len(timeout_lambda_states) == 2, (
-            f"Test 4: Should have 2 states, got {len(timeout_lambda_states)}: {timeout_lambda_states}"
-        )
-        assert timeout_lambda_states[0] == pytest.approx(77.7), (
-            f"Test 4: First state should be 77.7, got {timeout_lambda_states[0]}"
-        )
-        assert timeout_lambda_states[1] == pytest.approx(-1.0), (
-            f"Test 4: Timeout should evaluate lambda (-1.0), got {timeout_lambda_states[1]}"
-        )

tests/integration/test_template_alarm_control_panel_many_sensors.py

@@ -0,0 +1,118 @@
+"""Integration test for template alarm control panel with many sensors."""
+
+from __future__ import annotations
+
+import aioesphomeapi
+from aioesphomeapi.model import APIIntEnum
+import pytest
+
+from .state_utils import InitialStateHelper
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+class EspHomeACPFeatures(APIIntEnum):
+    """ESPHome AlarmControlPanel feature numbers."""
+
+    ARM_HOME = 1
+    ARM_AWAY = 2
+    ARM_NIGHT = 4
+    TRIGGER = 8
+    ARM_CUSTOM_BYPASS = 16
+    ARM_VACATION = 32
+
+
+@pytest.mark.asyncio
+async def test_template_alarm_control_panel_many_sensors(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test template alarm control panel with 10 binary sensors using FixedVector."""
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        # Get entity info first
+        entities, _ = await client.list_entities_services()
+
+        # Find the alarm control panel and binary sensors
+        alarm_info: aioesphomeapi.AlarmControlPanelInfo | None = None
+        binary_sensors: list[aioesphomeapi.BinarySensorInfo] = []
+
+        for entity in entities:
+            if isinstance(entity, aioesphomeapi.AlarmControlPanelInfo):
+                alarm_info = entity
+            elif isinstance(entity, aioesphomeapi.BinarySensorInfo):
+                binary_sensors.append(entity)
+
+        assert alarm_info is not None, "Alarm control panel entity info not found"
+        assert alarm_info.name == "Test Alarm"
+        assert alarm_info.requires_code is True
+        assert alarm_info.requires_code_to_arm is True
+
+        # Verify we have 10 binary sensors
+        assert len(binary_sensors) == 10, (
+            f"Expected 10 binary sensors, got {len(binary_sensors)}"
+        )
+
+        # Verify sensor names
+        expected_sensor_names = {
+            "Door 1",
+            "Door 2",
+            "Window 1",
+            "Window 2",
+            "Motion 1",
+            "Motion 2",
+            "Glass Break 1",
+            "Glass Break 2",
+            "Smoke Detector",
+            "CO Detector",
+        }
+        actual_sensor_names = {sensor.name for sensor in binary_sensors}
+        assert actual_sensor_names == expected_sensor_names, (
+            f"Sensor names mismatch. Expected: {expected_sensor_names}, "
+            f"Got: {actual_sensor_names}"
+        )
+
+        # Use InitialStateHelper to wait for all initial states
+        state_helper = InitialStateHelper(entities)
+
+        def on_state(state: aioesphomeapi.EntityState) -> None:
+            # We'll receive subsequent states here after initial states
+            pass
+
+        client.subscribe_states(state_helper.on_state_wrapper(on_state))
+
+        # Wait for all initial states
+        await state_helper.wait_for_initial_states(timeout=5.0)
+
+        # Verify the alarm state is disarmed initially
+        alarm_state = state_helper.initial_states.get(alarm_info.key)
+        assert alarm_state is not None, "Alarm control panel initial state not received"
+        assert isinstance(alarm_state, aioesphomeapi.AlarmControlPanelEntityState)
+        assert alarm_state.state == aioesphomeapi.AlarmControlPanelState.DISARMED, (
+            f"Expected initial state DISARMED, got {alarm_state.state}"
+        )
+
+        # Verify all 10 binary sensors have initial states
+        binary_sensor_states = [
+            state_helper.initial_states.get(sensor.key) for sensor in binary_sensors
+        ]
+        assert all(state is not None for state in binary_sensor_states), (
+            "Not all binary sensors have initial states"
+        )
+
+        # Verify all binary sensor states are BinarySensorState type
+        for i, state in enumerate(binary_sensor_states):
+            assert isinstance(state, aioesphomeapi.BinarySensorState), (
+                f"Binary sensor {i} state is not BinarySensorState: {type(state)}"
+            )
+
+        # Verify supported features
+        expected_features = (
+            EspHomeACPFeatures.ARM_HOME
+            | EspHomeACPFeatures.ARM_AWAY
+            | EspHomeACPFeatures.ARM_NIGHT
+            | EspHomeACPFeatures.TRIGGER
+        )
+        assert alarm_info.supported_features == expected_features, (
+            f"Expected supported_features={expected_features} (ARM_HOME|ARM_AWAY|ARM_NIGHT|TRIGGER), "
+            f"got {alarm_info.supported_features}"
+        )