[analyze-memory] Show all core symbols > 100 B instead of top 15 (#11909)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         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@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         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.4
+    rev: v0.14.5
     hooks:
       # Run the linter.
       - id: ruff

esphome/analyze_memory/cli.py

@@ -15,6 +15,11 @@ 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
@@ -191,14 +196,21 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # Top 15 largest core symbols
+            # All core symbols above threshold
             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
+            ]
 
-            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
+            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):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -268,13 +280,15 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols > 100 bytes for better visibility
+                # Show all symbols above threshold for better visibility
                 large_symbols = [
-                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
+                    (sym, dem, size)
+                    for sym, dem, size in sorted_symbols
+                    if size > self.SYMBOL_SIZE_THRESHOLD
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} 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,12 +1,11 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void binary_sensor::MultiClickTrigger::on_state_(bool state) {
+void MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -67,7 +66,7 @@ void binary_sensor::MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
+void 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]() {
@@ -79,7 +78,7 @@ void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -90,19 +89,19 @@ void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void 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 binary_sensor::MultiClickTrigger::cancel() {
+void MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void binary_sensor::MultiClickTrigger::trigger_() {
+void MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -118,5 +117,4 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/automation.h

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

esphome/components/binary_sensor/binary_sensor.cpp

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

esphome/components/binary_sensor/binary_sensor.h

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

esphome/components/binary_sensor/filter.cpp

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

esphome/components/binary_sensor/filter.h

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

esphome/components/font/__init__.py

@@ -36,7 +36,6 @@ 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__)
@@ -50,7 +49,6 @@ 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"
@@ -463,7 +461,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(GlyphData),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
     },
 )
 
@@ -583,22 +581,15 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        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),
-        )
+        [
+            x.glyph,
+            prog_arr + (y - len(x.bitmap_data)),
+            x.advance,
+            x.offset_x,
+            x.offset_y,
+            x.width,
+            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,20 +9,19 @@ 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->glyph_data_->a_char[i] == '\0')
+    if (this->a_char[i] == '\0')
       return true;
     if (str[i] == '\0')
       return false;
-    if (this->glyph_data_->a_char[i] > str[i])
+    if (this->a_char[i] > str[i])
       return false;
-    if (this->glyph_data_->a_char[i] < str[i])
+    if (this->a_char[i] < str[i])
       return true;
   }
   // this should not happen
@@ -30,35 +29,32 @@ 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->glyph_data_->a_char[i] == '\0')
+    if (this->a_char[i] == '\0')
       return i;
-    if (str[i] != this->glyph_data_->a_char[i])
+    if (str[i] != this->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->glyph_data_->offset_x;
-  *y1 = this->glyph_data_->offset_y;
-  *width = this->glyph_data_->width;
-  *height = this->glyph_data_->height;
+  *x1 = this->offset_x;
+  *y1 = this->offset_y;
+  *width = this->width;
+  *height = this->height;
 }
 
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : baseline_(baseline),
+    : glyphs_(ConstVector(data, data_nr)),
+      baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
-      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) {
+      bpp_(bpp) {}
+int Font::match_next_glyph(const uint8_t *str, int *match_length) const {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
@@ -88,18 +84,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].glyph_data_->advance;
+        x += this->get_glyphs()[0].advance;
       i++;
       continue;
     }
 
     const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph.glyph_data_->offset_x;
+      min_x = glyph.offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
+      min_x = std::min(min_x, x + glyph.offset_x);
     }
-    x += glyph.glyph_data_->advance;
+    x += glyph.advance;
 
     i += match_length;
     has_char = true;
@@ -118,7 +114,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].glyph_data_->advance;
+        uint8_t glyph_width = this->get_glyphs()[0].advance;
         display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
@@ -130,7 +126,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.glyph_data_->data;
+    const uint8_t *data = glyph.data;
     const int max_x = x_at + scan_x1 + scan_width;
     const int max_y = y_start + scan_y1 + scan_height;
 
@@ -168,7 +164,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph.glyph_data_->advance;
+    x_at += glyph.advance;
 
     i += match_length;
   }

esphome/components/font/font.h

@@ -12,21 +12,19 @@ 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:
-  Glyph(const GlyphData *data) : glyph_data_(data) {}
+  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) {}
 
-  const uint8_t *get_char() const;
+  const uint8_t *get_char() const { return reinterpret_cast<const uint8_t *>(this->a_char); }
 
   bool compare_to(const uint8_t *str) const;
 
@@ -34,12 +32,16 @@ class Glyph {
 
   void scan_area(int *x1, int *y1, int *width, int *height) const;
 
-  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
+  const char *a_char;
+  const uint8_t *data;
+  int advance;
+  int offset_x;
+  int offset_y;
+  int width;
+  int height;
 
  protected:
   friend Font;
-
-  const GlyphData *glyph_data_;
 };
 
 class Font
@@ -50,8 +52,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A vector of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs in data.
+   * @param data A list of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs
    * @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).
@@ -59,10 +61,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 GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const Glyph *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);
+  int match_next_glyph(const uint8_t *str, int *match_length) const;
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -78,10 +80,10 @@ class Font
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
 
-  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
+  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
 
  protected:
-  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
+  ConstVector<Glyph> glyphs_;
   int baseline_;
   int height_;
   int descender_;

esphome/components/ld2410/sensor.py

@@ -31,35 +31,83 @@ 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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -73,7 +121,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -81,7 +135,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,36 +31,84 @@ 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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"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=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -74,7 +122,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -82,7 +136,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

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::GlyphData *FontEngine::get_glyph_data(uint32_t unicode_letter) {
+const font::Glyph *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::GlyphData *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].get_glyph_data();
+  this->last_data_ = &this->font_->get_glyphs()[glyph_n];
   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::GlyphData *get_glyph_data(uint32_t unicode_letter);
+  const font::Glyph *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::GlyphData *last_data_{};
+  const font::Glyph *last_data_{};
   lv_font_t lv_font_{};
 };
 #endif  // USE_LVGL_FONT

esphome/components/uart/__init__.py

@@ -1,3 +1,4 @@
+from logging import getLogger
 import math
 import re
 
@@ -35,6 +36,8 @@ 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")
@@ -130,6 +133,21 @@ 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)
@@ -247,6 +265,7 @@ 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,6 +91,16 @@ 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);
@@ -237,8 +247,12 @@ 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);
-  uart_write_bytes(this->uart_num_, data, len);
+  int32_t write_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]);
@@ -267,6 +281,7 @@ 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);
@@ -277,25 +292,31 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    read_len = 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 true;
+  return read_len == (int32_t) length_to_read;
 }
 
 int IDFUARTComponent::available() {
-  size_t available;
+  size_t available = 0;
+  esp_err_t err;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  uart_get_buffered_data_len(this->uart_num_, &available);
-  if (this->has_peek_)
-    available++;
+  err = uart_get_buffered_data_len(this->uart_num_, &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/wifi/__init__.py

@@ -12,7 +12,6 @@ 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,
@@ -352,7 +351,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_USE_PSRAM): cv.All(
-                only_with_esp_idf, cv.requires_component("psram"), cv.boolean
+                cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
             ),
         }
     ),

esphome/core/helpers.h

@@ -111,6 +111,23 @@ 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,13 +609,12 @@ 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 */
-  }
-
-  // Only update if time moved forward
-  if (now > last) {
+  } else if (now > last) {
+    // Only update if time moved forward
     this->last_millis_ = now;
   }
 

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==4.0.3
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.4  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.5  # 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

@@ -0,0 +1,150 @@
+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/test_sensor_timeout_filter.py

@@ -0,0 +1,185 @@
+"""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]}"
+        )