[template][event] Use StringRef for set_action and on_event triggers

esphome/codegen.py

@@ -69,6 +69,7 @@ from esphome.cpp_types import (  # noqa: F401
     JsonObjectConst,
     Parented,
     PollingComponent,
+    StringRef,
     arduino_json_ns,
     bool_,
     const_char_ptr,

esphome/components/event/__init__.py

@@ -90,9 +90,7 @@ async def setup_event_core_(var, config, *, event_types: list[str]):
 
     for conf in config.get(CONF_ON_EVENT, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(
-            trigger, [(cg.std_string, "event_type")], conf
-        )
+        await automation.build_automation(trigger, [(cg.StringRef, "event_type")], conf)
 
     cg.add(var.set_event_types(event_types))
 

esphome/components/event/automation.h

@@ -14,10 +14,10 @@ template<typename... Ts> class TriggerEventAction : public Action<Ts...>, public
   void play(const Ts &...x) override { this->parent_->trigger(this->event_type_.value(x...)); }
 };
 
-class EventTrigger : public Trigger<std::string> {
+class EventTrigger : public Trigger<StringRef> {
  public:
   EventTrigger(Event *event) {
-    event->add_on_event_callback([this](const std::string &event_type) { this->trigger(event_type); });
+    event->add_on_event_callback([this](StringRef event_type) { this->trigger(event_type); });
   }
 };
 

esphome/components/event/event.cpp

@@ -23,7 +23,7 @@ void Event::trigger(const std::string &event_type) {
   }
   this->last_event_type_ = found;
   ESP_LOGD(TAG, "'%s' >> '%s'", this->get_name().c_str(), this->last_event_type_);
-  this->event_callback_.call(event_type);
+  this->event_callback_.call(StringRef(found));
 #if defined(USE_EVENT) && defined(USE_CONTROLLER_REGISTRY)
   ControllerRegistry::notify_event(this);
 #endif
@@ -45,7 +45,7 @@ void Event::set_event_types(const std::vector<const char *> &event_types) {
   this->last_event_type_ = nullptr;  // Reset when types change
 }
 
-void Event::add_on_event_callback(std::function<void(const std::string &event_type)> &&callback) {
+void Event::add_on_event_callback(std::function<void(StringRef event_type)> &&callback) {
   this->event_callback_.add(std::move(callback));
 }
 

esphome/components/event/event.h

@@ -70,10 +70,10 @@ class Event : public EntityBase, public EntityBase_DeviceClass {
   /// Check if an event has been triggered.
   bool has_event() const { return this->last_event_type_ != nullptr; }
 
-  void add_on_event_callback(std::function<void(const std::string &event_type)> &&callback);
+  void add_on_event_callback(std::function<void(StringRef event_type)> &&callback);
 
  protected:
-  LazyCallbackManager<void(const std::string &event_type)> event_callback_;
+  LazyCallbackManager<void(StringRef event_type)> event_callback_;
   FixedVector<const char *> types_;
 
  private:

esphome/components/fan/__init__.py

@@ -77,7 +77,7 @@ FanSpeedSetTrigger = fan_ns.class_(
     "FanSpeedSetTrigger", automation.Trigger.template(cg.int_)
 )
 FanPresetSetTrigger = fan_ns.class_(
-    "FanPresetSetTrigger", automation.Trigger.template(cg.std_string)
+    "FanPresetSetTrigger", automation.Trigger.template(cg.StringRef)
 )
 
 FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
@@ -287,7 +287,7 @@ async def setup_fan_core_(var, config):
         await automation.build_automation(trigger, [(cg.int_, "x")], conf)
     for conf in config.get(CONF_ON_PRESET_SET, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
+        await automation.build_automation(trigger, [(cg.StringRef, "x")], conf)
 
 
 async def register_fan(var, config):

esphome/components/fan/automation.h

@@ -208,7 +208,7 @@ class FanSpeedSetTrigger : public Trigger<int> {
   int last_speed_;
 };
 
-class FanPresetSetTrigger : public Trigger<std::string> {
+class FanPresetSetTrigger : public Trigger<StringRef> {
  public:
   FanPresetSetTrigger(Fan *state) {
     state->add_on_state_callback([this, state]() {
@@ -216,7 +216,7 @@ class FanPresetSetTrigger : public Trigger<std::string> {
       auto should_trigger = preset_mode != this->last_preset_mode_;
       this->last_preset_mode_ = preset_mode;
       if (should_trigger) {
-        this->trigger(std::string(preset_mode));
+        this->trigger(preset_mode);
       }
     });
     this->last_preset_mode_ = state->get_preset_mode();

esphome/components/modbus_controller/modbus_controller.h

@@ -271,31 +271,24 @@ class ServerRegister {
 
   // Formats a raw value into a string representation based on the value type for debugging
   std::string format_value(int64_t value) const {
-    // max 48: float with %.1f can be up to 42 chars (3.4e38 → 38 integer digits + decimal + 1 digit + sign + null)
-    // int64_t max is 20 chars + sign + null = 22, so 48 covers both
-    char buf[48];
     switch (this->value_type) {
       case SensorValueType::U_WORD:
       case SensorValueType::U_DWORD:
       case SensorValueType::U_DWORD_R:
       case SensorValueType::U_QWORD:
       case SensorValueType::U_QWORD_R:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRIu64, static_cast<uint64_t>(value));
-        return buf;
+        return std::to_string(static_cast<uint64_t>(value));
       case SensorValueType::S_WORD:
       case SensorValueType::S_DWORD:
       case SensorValueType::S_DWORD_R:
       case SensorValueType::S_QWORD:
       case SensorValueType::S_QWORD_R:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, value);
-        return buf;
+        return std::to_string(value);
       case SensorValueType::FP32_R:
       case SensorValueType::FP32:
-        buf_append_printf(buf, sizeof(buf), 0, "%.1f", bit_cast<float>(static_cast<uint32_t>(value)));
-        return buf;
+        return str_sprintf("%.1f", bit_cast<float>(static_cast<uint32_t>(value)));
       default:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, value);
-        return buf;
+        return std::to_string(value);
     }
   }
 

esphome/components/modbus_controller/text_sensor/modbus_textsensor.cpp

@@ -16,20 +16,12 @@ void ModbusTextSensor::parse_and_publish(const std::vector<uint8_t> &data) {
   while ((items_left > 0) && index < data.size()) {
     uint8_t b = data[index];
     switch (this->encode_) {
-      case RawEncoding::HEXBYTES: {
-        // max 3: 2 hex digits + null
-        char hex_buf[3];
-        snprintf(hex_buf, sizeof(hex_buf), "%02x", b);
-        output_str += hex_buf;
+      case RawEncoding::HEXBYTES:
+        output_str += str_snprintf("%02x", 2, b);
         break;
-      }
-      case RawEncoding::COMMA: {
-        // max 5: optional ','(1) + uint8(3) + null, for both ",%d" and "%d"
-        char dec_buf[5];
-        snprintf(dec_buf, sizeof(dec_buf), index != this->offset ? ",%d" : "%d", b);
-        output_str += dec_buf;
+      case RawEncoding::COMMA:
+        output_str += str_sprintf(index != this->offset ? ",%d" : "%d", b);
         break;
-      }
       case RawEncoding::ANSI:
         if (b < 0x20)
           break;

esphome/components/opentherm/opentherm.cpp

@@ -561,9 +561,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }
 
 void OpenTherm::debug_data(OpenthermData &data) {
-  char type_buf[9], id_buf[9], hb_buf[9], lb_buf[9];
-  ESP_LOGD(TAG, "%s %s %s %s", format_bin_to(type_buf, data.type), format_bin_to(id_buf, data.id),
-           format_bin_to(hb_buf, data.valueHB), format_bin_to(lb_buf, data.valueLB));
+  ESP_LOGD(TAG, "%s %s %s %s", format_bin(data.type).c_str(), format_bin(data.id).c_str(),
+           format_bin(data.valueHB).c_str(), format_bin(data.valueLB).c_str());
   ESP_LOGD(TAG, "type: %s; id: %u; HB: %u; LB: %u; uint_16: %u; float: %f",
            this->message_type_to_str((MessageType) data.type), data.id, data.valueHB, data.valueLB, data.u16(),
            data.f88());

esphome/components/select/__init__.py

@@ -33,7 +33,7 @@ SelectPtr = Select.operator("ptr")
 # Triggers
 SelectStateTrigger = select_ns.class_(
     "SelectStateTrigger",
-    automation.Trigger.template(cg.std_string, cg.size_t),
+    automation.Trigger.template(cg.StringRef, cg.size_t),
 )
 
 # Actions
@@ -100,7 +100,7 @@ async def setup_select_core_(var, config, *, options: list[str]):
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
-            trigger, [(cg.std_string, "x"), (cg.size_t, "i")], conf
+            trigger, [(cg.StringRef, "x"), (cg.size_t, "i")], conf
         )
 
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:

esphome/components/select/automation.h

@@ -6,11 +6,11 @@
 
 namespace esphome::select {
 
-class SelectStateTrigger : public Trigger<std::string, size_t> {
+class SelectStateTrigger : public Trigger<StringRef, size_t> {
  public:
   explicit SelectStateTrigger(Select *parent) : parent_(parent) {
     parent->add_on_state_callback(
-        [this](size_t index) { this->trigger(std::string(this->parent_->option_at(index)), index); });
+        [this](size_t index) { this->trigger(StringRef(this->parent_->option_at(index)), index); });
   }
 
  protected:

esphome/components/template/select/__init__.py

@@ -88,5 +88,5 @@ async def to_code(config):
 
     if CONF_SET_ACTION in config:
         await automation.build_automation(
-            var.get_set_trigger(), [(cg.std_string, "x")], config[CONF_SET_ACTION]
+            var.get_set_trigger(), [(cg.StringRef, "x")], config[CONF_SET_ACTION]
         )

esphome/components/template/select/template_select.cpp

@@ -41,7 +41,7 @@ void TemplateSelect::update() {
 }
 
 void TemplateSelect::control(size_t index) {
-  this->set_trigger_->trigger(std::string(this->option_at(index)));
+  this->set_trigger_->trigger(StringRef(this->option_at(index)));
 
   if (this->optimistic_)
     this->publish_state(index);

esphome/components/template/select/template_select.h

@@ -4,6 +4,7 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/preferences.h"
+#include "esphome/core/string_ref.h"
 #include "esphome/core/template_lambda.h"
 
 namespace esphome::template_ {
@@ -17,7 +18,7 @@ class TemplateSelect final : public select::Select, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<StringRef> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_initial_option_index(size_t initial_option_index) { this->initial_option_index_ = initial_option_index; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
@@ -27,7 +28,7 @@ class TemplateSelect final : public select::Select, public PollingComponent {
   bool optimistic_ = false;
   size_t initial_option_index_{0};
   bool restore_value_ = false;
-  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+  Trigger<StringRef> *set_trigger_ = new Trigger<StringRef>();
   TemplateLambda<std::string> f_;
 
   ESPPreferenceObject pref_;

esphome/core/helpers.cpp

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

esphome/core/helpers.h

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

esphome/core/string_ref.h

@@ -72,6 +72,7 @@ class StringRef {
 
   constexpr const char *c_str() const { return base_; }
   constexpr size_type size() const { return len_; }
+  constexpr size_type length() const { return len_; }
   constexpr bool empty() const { return len_ == 0; }
   constexpr const_reference operator[](size_type pos) const { return *(base_ + pos); }
 
@@ -80,6 +81,32 @@ class StringRef {
 
   operator std::string() const { return str(); }
 
+  /// Find first occurrence of substring, returns std::string::npos if not found.
+  /// Note: Requires the underlying string to be null-terminated.
+  size_type find(const char *s, size_type pos = 0) const {
+    if (pos >= len_)
+      return std::string::npos;
+    const char *result = std::strstr(base_ + pos, s);
+    // Verify entire match is within bounds (strstr searches to null terminator)
+    if (result && result + std::strlen(s) <= base_ + len_)
+      return static_cast<size_type>(result - base_);
+    return std::string::npos;
+  }
+  size_type find(char c, size_type pos = 0) const {
+    if (pos >= len_)
+      return std::string::npos;
+    const void *result = std::memchr(base_ + pos, static_cast<unsigned char>(c), len_ - pos);
+    return result ? static_cast<size_type>(static_cast<const char *>(result) - base_) : std::string::npos;
+  }
+
+  /// Return substring as std::string
+  std::string substr(size_type pos = 0, size_type count = std::string::npos) const {
+    if (pos >= len_)
+      return std::string();
+    size_type actual_count = (count == std::string::npos || pos + count > len_) ? len_ - pos : count;
+    return std::string(base_ + pos, actual_count);
+  }
+
  private:
   const char *base_;
   size_type len_;
@@ -160,6 +187,43 @@ inline std::string operator+(const std::string &lhs, const StringRef &rhs) {
   str.append(rhs.c_str(), rhs.size());
   return str;
 }
+// String conversion functions for ADL compatibility (allows stoi(x) where x is StringRef)
+// Must be in esphome namespace for ADL to find them. Uses strtol/strtod directly to avoid heap allocation.
+namespace internal {
+// NOLINTBEGIN(google-runtime-int)
+template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, F conv) {
+  char *end;
+  R result = conv(str.c_str(), &end);
+  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
+  if (pos)
+    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
+  return result;
+}
+template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, int base, F conv) {
+  char *end;
+  R result = conv(str.c_str(), &end, base);
+  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
+  if (pos)
+    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
+  return result;
+}
+// NOLINTEND(google-runtime-int)
+}  // namespace internal
+// NOLINTBEGIN(readability-identifier-naming,google-runtime-int)
+inline int stoi(const StringRef &str, size_t *pos = nullptr, int base = 10) {
+  return static_cast<int>(internal::parse_number<long>(str, pos, base, std::strtol));
+}
+inline long stol(const StringRef &str, size_t *pos = nullptr, int base = 10) {
+  return internal::parse_number<long>(str, pos, base, std::strtol);
+}
+inline float stof(const StringRef &str, size_t *pos = nullptr) {
+  return internal::parse_number<float>(str, pos, std::strtof);
+}
+inline double stod(const StringRef &str, size_t *pos = nullptr) {
+  return internal::parse_number<double>(str, pos, std::strtod);
+}
+// NOLINTEND(readability-identifier-naming,google-runtime-int)
+
 #ifdef USE_JSON
 // NOLINTNEXTLINE(readability-identifier-naming)
 inline void convertToJson(const StringRef &src, JsonVariant dst) { dst.set(src.c_str()); }

esphome/cpp_types.py

@@ -44,3 +44,4 @@ gpio_Flags = gpio_ns.enum("Flags", is_class=True)
 EntityCategory = esphome_ns.enum("EntityCategory")
 Parented = esphome_ns.class_("Parented")
 ESPTime = esphome_ns.struct("ESPTime")
+StringRef = esphome_ns.class_("StringRef")

script/ci-custom.py

@@ -682,7 +682,6 @@ def lint_trailing_whitespace(fname, match):
 # Heap-allocating helpers that cause fragmentation on long-running embedded devices.
 # These return std::string and should be replaced with stack-based alternatives.
 HEAP_ALLOCATING_HELPERS = {
-    "format_bin": "format_bin_to() with a stack buffer",
     "format_hex": "format_hex_to() with a stack buffer",
     "format_hex_pretty": "format_hex_pretty_to() with a stack buffer",
     "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
@@ -700,7 +699,6 @@ HEAP_ALLOCATING_HELPERS = {
     # get_mac_address(?!_) ensures we don't match get_mac_address_into_buffer, etc.
     # CPP_RE_EOL captures rest of line so NOLINT comments are detected
     r"[^\w]("
-    r"format_bin(?!_)|"
     r"format_hex(?!_)|"
     r"format_hex_pretty(?!_)|"
     r"format_mac_address_pretty|"

tests/integration/fixtures/select_stringref_trigger.yaml

@@ -0,0 +1,85 @@
+esphome:
+  name: select-stringref-test
+  friendly_name: Select StringRef Test
+
+host:
+
+logger:
+  level: DEBUG
+
+api:
+
+select:
+  - platform: template
+    name: "Test Select"
+    id: test_select
+    optimistic: true
+    options:
+      - "Option A"
+      - "Option B"
+      - "Option C"
+    initial_option: "Option A"
+    on_value:
+      then:
+        # Test 1: Log the value directly (StringRef -> const char* via c_str())
+        - logger.log:
+            format: "Select value: %s"
+            args: ['x.c_str()']
+        # Test 2: String concatenation (StringRef + const char* -> std::string)
+        - lambda: |-
+            std::string with_suffix = x + " selected";
+            ESP_LOGI("test", "Concatenated: %s", with_suffix.c_str());
+        # Test 3: Comparison (StringRef == const char*)
+        - lambda: |-
+            if (x == "Option B") {
+              ESP_LOGI("test", "Option B was selected");
+            }
+        # Test 4: Use index parameter (variable name is 'i')
+        - lambda: |-
+            ESP_LOGI("test", "Select index: %d", (int)i);
+        # Test 5: StringRef.length() method
+        - lambda: |-
+            ESP_LOGI("test", "Length: %d", (int)x.length());
+        # Test 6: StringRef.find() method with substring
+        - lambda: |-
+            if (x.find("Option") != std::string::npos) {
+              ESP_LOGI("test", "Found 'Option' in value");
+            }
+        # Test 7: StringRef.find() method with character
+        - lambda: |-
+            size_t space_pos = x.find(' ');
+            if (space_pos != std::string::npos) {
+              ESP_LOGI("test", "Space at position: %d", (int)space_pos);
+            }
+        # Test 8: StringRef.substr() method
+        - lambda: |-
+            std::string prefix = x.substr(0, 6);
+            ESP_LOGI("test", "Substr prefix: %s", prefix.c_str());
+
+  # Second select with numeric options to test ADL functions
+  - platform: template
+    name: "Baud Rate"
+    id: baud_select
+    optimistic: true
+    options:
+      - "9600"
+      - "115200"
+    initial_option: "9600"
+    on_value:
+      then:
+        # Test 9: stoi via ADL
+        - lambda: |-
+            int baud = stoi(x);
+            ESP_LOGI("test", "stoi result: %d", baud);
+        # Test 10: stol via ADL
+        - lambda: |-
+            long baud_long = stol(x);
+            ESP_LOGI("test", "stol result: %ld", baud_long);
+        # Test 11: stof via ADL
+        - lambda: |-
+            float baud_float = stof(x);
+            ESP_LOGI("test", "stof result: %.0f", baud_float);
+        # Test 12: stod via ADL
+        - lambda: |-
+            double baud_double = stod(x);
+            ESP_LOGI("test", "stod result: %.0f", baud_double);

tests/integration/test_select_stringref_trigger.py

@@ -0,0 +1,143 @@
+"""Integration test for select on_value trigger with StringRef parameter."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_select_stringref_trigger(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test select on_value trigger passes StringRef that works with string operations."""
+    loop = asyncio.get_running_loop()
+
+    # Track log messages to verify StringRef operations work
+    value_logged_future = loop.create_future()
+    concatenated_future = loop.create_future()
+    comparison_future = loop.create_future()
+    index_logged_future = loop.create_future()
+    length_future = loop.create_future()
+    find_substr_future = loop.create_future()
+    find_char_future = loop.create_future()
+    substr_future = loop.create_future()
+    # ADL functions
+    stoi_future = loop.create_future()
+    stol_future = loop.create_future()
+    stof_future = loop.create_future()
+    stod_future = loop.create_future()
+
+    # Patterns to match in logs
+    value_pattern = re.compile(r"Select value: Option B")
+    concatenated_pattern = re.compile(r"Concatenated: Option B selected")
+    comparison_pattern = re.compile(r"Option B was selected")
+    index_pattern = re.compile(r"Select index: 1")
+    length_pattern = re.compile(r"Length: 8")  # "Option B" is 8 chars
+    find_substr_pattern = re.compile(r"Found 'Option' in value")
+    find_char_pattern = re.compile(r"Space at position: 6")  # space at index 6
+    substr_pattern = re.compile(r"Substr prefix: Option")
+    # ADL function patterns (115200 from baud rate select)
+    stoi_pattern = re.compile(r"stoi result: 115200")
+    stol_pattern = re.compile(r"stol result: 115200")
+    stof_pattern = re.compile(r"stof result: 115200")
+    stod_pattern = re.compile(r"stod result: 115200")
+
+    def check_output(line: str) -> None:
+        """Check log output for expected messages."""
+        if not value_logged_future.done() and value_pattern.search(line):
+            value_logged_future.set_result(True)
+        if not concatenated_future.done() and concatenated_pattern.search(line):
+            concatenated_future.set_result(True)
+        if not comparison_future.done() and comparison_pattern.search(line):
+            comparison_future.set_result(True)
+        if not index_logged_future.done() and index_pattern.search(line):
+            index_logged_future.set_result(True)
+        if not length_future.done() and length_pattern.search(line):
+            length_future.set_result(True)
+        if not find_substr_future.done() and find_substr_pattern.search(line):
+            find_substr_future.set_result(True)
+        if not find_char_future.done() and find_char_pattern.search(line):
+            find_char_future.set_result(True)
+        if not substr_future.done() and substr_pattern.search(line):
+            substr_future.set_result(True)
+        # ADL functions
+        if not stoi_future.done() and stoi_pattern.search(line):
+            stoi_future.set_result(True)
+        if not stol_future.done() and stol_pattern.search(line):
+            stol_future.set_result(True)
+        if not stof_future.done() and stof_pattern.search(line):
+            stof_future.set_result(True)
+        if not stod_future.done() and stod_pattern.search(line):
+            stod_future.set_result(True)
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "select-stringref-test"
+
+        # List entities to find our select
+        entities, _ = await client.list_entities_services()
+
+        select_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Test Select"),
+            None,
+        )
+        assert select_entity is not None, "Test Select entity not found"
+
+        baud_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Baud Rate"),
+            None,
+        )
+        assert baud_entity is not None, "Baud Rate entity not found"
+
+        # Change select to Option B - this should trigger on_value with StringRef
+        client.select_command(select_entity.key, "Option B")
+        # Change baud to 115200 - this tests ADL functions (stoi, stol, stof, stod)
+        client.select_command(baud_entity.key, "115200")
+
+        # Wait for all log messages confirming StringRef operations work
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(
+                    value_logged_future,
+                    concatenated_future,
+                    comparison_future,
+                    index_logged_future,
+                    length_future,
+                    find_substr_future,
+                    find_char_future,
+                    substr_future,
+                    stoi_future,
+                    stol_future,
+                    stof_future,
+                    stod_future,
+                ),
+                timeout=5.0,
+            )
+        except TimeoutError:
+            results = {
+                "value_logged": value_logged_future.done(),
+                "concatenated": concatenated_future.done(),
+                "comparison": comparison_future.done(),
+                "index_logged": index_logged_future.done(),
+                "length": length_future.done(),
+                "find_substr": find_substr_future.done(),
+                "find_char": find_char_future.done(),
+                "substr": substr_future.done(),
+                "stoi": stoi_future.done(),
+                "stol": stol_future.done(),
+                "stof": stof_future.done(),
+                "stod": stod_future.done(),
+            }
+            pytest.fail(f"StringRef operations failed - received: {results}")