[wifi] Defer ESP8266 listener callbacks to main loop to fix stack overflow

esphome/components/esp32/__init__.py

@@ -1329,6 +1329,10 @@ async def to_code(config):
     # Disable dynamic log level control to save memory
     add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
 
+    # Disable per-tag log level filtering since dynamic level control is disabled above
+    # This saves ~250 bytes of RAM (tag cache) and associated code
+    add_idf_sdkconfig_option("CONFIG_LOG_TAG_LEVEL_IMPL_NONE", True)
+
     # Reduce PHY TX power in the event of a brownout
     add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -34,29 +34,14 @@ static const char *const ESP_HOSTED_VERSION_STR = STRINGIFY(ESP_HOSTED_VERSION_M
     ESP_HOSTED_VERSION_MINOR_1) "." STRINGIFY(ESP_HOSTED_VERSION_PATCH_1);
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
-// Parse an integer from str, advancing ptr past the number
-// Returns false if no digits were parsed
-static bool parse_int(const char *&ptr, int &value) {
-  char *end;
-  value = static_cast<int>(strtol(ptr, &end, 10));
-  if (end == ptr)
-    return false;
-  ptr = end;
-  return true;
-}
-
 // Parse version string "major.minor.patch" into components
-// Returns true if at least major.minor was parsed
+// Returns true if parsing succeeded
 static bool parse_version(const std::string &version_str, int &major, int &minor, int &patch) {
   major = minor = patch = 0;
-  const char *ptr = version_str.c_str();
-
-  if (!parse_int(ptr, major) || *ptr++ != '.' || !parse_int(ptr, minor))
-    return false;
-  if (*ptr == '.')
-    parse_int(++ptr, patch);
-
-  return true;
+  if (sscanf(version_str.c_str(), "%d.%d.%d", &major, &minor, &patch) >= 2) {
+    return true;
+  }
+  return false;
 }
 
 // Compare two versions, returns:

esphome/components/i2c/i2c.cpp

@@ -11,12 +11,6 @@ namespace i2c {
 static const char *const TAG = "i2c";
 
 void I2CBus::i2c_scan_() {
-  // suppress logs from the IDF I2C library during the scan
-#if defined(USE_ESP32) && defined(USE_LOGGER)
-  auto previous = esp_log_level_get("*");
-  esp_log_level_set("*", ESP_LOG_NONE);
-#endif
-
   for (uint8_t address = 8; address != 120; address++) {
     auto err = write_readv(address, nullptr, 0, nullptr, 0);
     if (err == ERROR_OK) {
@@ -27,9 +21,6 @@ void I2CBus::i2c_scan_() {
     // it takes 16sec to scan on nrf52. It prevents board reset.
     arch_feed_wdt();
   }
-#if defined(USE_ESP32) && defined(USE_LOGGER)
-  esp_log_level_set("*", previous);
-#endif
 }
 
 ErrorCode I2CDevice::read_register(uint8_t a_register, uint8_t *data, size_t len) {

esphome/components/logger/logger_esp32.cpp

@@ -114,9 +114,6 @@ void Logger::pre_setup() {
 
   global_logger = this;
   esp_log_set_vprintf(esp_idf_log_vprintf_);
-  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
-    esp_log_level_set("*", ESP_LOG_VERBOSE);
-  }
 
   ESP_LOGI(TAG, "Log initialized");
 }

esphome/components/udp/__init__.py

@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID, Lambda
-from esphome.cpp_generator import ExpressionStatement, MockObj
+from esphome.core import ID
+from esphome.cpp_generator import literal
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,6 +24,8 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
+trigger_argname = "data"
+trigger_argtype = [(trigger_args, trigger_argname)]
 
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -111,13 +113,14 @@ async def to_code(config):
     cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
-        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
         trigger = await automation.build_automation(
-            trigger, [(trigger_args, "data")], on_receive
+            trigger_id, trigger_argtype, on_receive
         )
-        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
-        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
-        cg.add(var.add_listener(trigger))
+        trigger_lambda = await cg.process_lambda(
+            trigger.trigger(literal(trigger_argname)), trigger_argtype
+        )
+        cg.add(var.add_listener(trigger_lambda))
         cg.add(var.set_should_listen())
 
 

esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp

@@ -155,8 +155,9 @@ void USBCDCACMInstance::setup() {
     return;
   }
 
-  // Use a larger stack size for (very) verbose logging
-  const size_t stack_size = esp_log_level_get(TAG) > ESP_LOG_DEBUG ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
+  // Use a larger stack size for very verbose logging
+  constexpr size_t stack_size =
+      ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
 
   // Create a simple, unique task name per interface
   char task_name[] = "usb_tx_0";

esphome/components/wifi/wifi_component.cpp

@@ -643,7 +643,7 @@ void WiFiComponent::restart_adapter() {
   // through start_connecting() first. Without this clear, stale errors would
   // trigger spurious "failed (callback)" logs. The canonical clear location
   // is in start_connecting(); this is the only exception to that pattern.
-  this->error_from_callback_ = false;
+  this->error_from_callback_ = 0;
 }
 
 void WiFiComponent::loop() {
@@ -1063,7 +1063,7 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
   // This is the canonical location for clearing the flag since all connection
   // attempts go through start_connecting(). The only other clear is in
   // restart_adapter() which enters COOLDOWN without calling start_connecting().
-  this->error_from_callback_ = false;
+  this->error_from_callback_ = 0;
 
   if (!this->wifi_sta_connect_(ap)) {
     ESP_LOGE(TAG, "wifi_sta_connect_ failed");
@@ -1468,7 +1468,11 @@ void WiFiComponent::check_connecting_finished(uint32_t now) {
   }
 
   if (this->error_from_callback_) {
+    // ESP8266: logging done in callback, listeners deferred via pending_.disconnect
+    // Other platforms: just log generic failure message
+#ifndef USE_ESP8266
     ESP_LOGW(TAG, "Connecting to network failed (callback)");
+#endif
     this->retry_connect();
     return;
   }

esphome/components/wifi/wifi_component.h

@@ -58,6 +58,12 @@ static constexpr int8_t WIFI_RSSI_DISCONNECTED = -127;
 /// Buffer size for SSID (IEEE 802.11 max 32 bytes + null terminator)
 static constexpr size_t SSID_BUFFER_SIZE = 33;
 
+#ifdef USE_ESP8266
+/// Special disconnect reason for authmode downgrade (CVE-2020-12638 mitigation)
+/// Not a real WiFi reason code - used internally for deferred logging
+static constexpr uint8_t WIFI_DISCONNECT_REASON_AUTHMODE_DOWNGRADE = 254;
+#endif
+
 struct SavedWifiSettings {
   char ssid[33];
   char password[65];
@@ -590,6 +596,9 @@ class WiFiComponent : public Component {
   void connect_soon_();
 
   void wifi_loop_();
+#ifdef USE_ESP8266
+  void process_pending_callbacks_();
+#endif
   bool wifi_mode_(optional<bool> sta, optional<bool> ap);
   bool wifi_sta_pre_setup_();
   bool wifi_apply_output_power_(float output_power);
@@ -704,10 +713,26 @@ class WiFiComponent : public Component {
   uint8_t num_ipv6_addresses_{0};
 #endif /* USE_NETWORK_IPV6 */
 
+  // 0 = no error, non-zero = disconnect reason code from callback
+  // This serves as both the error flag and stores the reason for deferred logging
+  uint8_t error_from_callback_{0};
+
+#ifdef USE_ESP8266
+  // Pending listener callbacks from system context (ESP8266 only)
+  // ESP8266 callbacks run in SDK system context with ~2KB stack where
+  // calling arbitrary listener callbacks is unsafe. These flags defer
+  // listener notifications to wifi_loop_() which runs with full stack.
+  struct {
+    bool connect : 1;        // STA connected, notify listeners
+    bool disconnect : 1;     // STA disconnected, notify listeners
+    bool got_ip : 1;         // Got IP, notify listeners
+    bool scan_complete : 1;  // Scan complete, notify listeners
+  } pending_{};
+#endif
+
   // Group all boolean values together
   bool has_ap_{false};
   bool handled_connected_state_{false};
-  bool error_from_callback_{false};
   bool scan_done_{false};
   bool ap_setup_{false};
   bool ap_started_{false};

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -511,21 +511,8 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
                it.channel);
 #endif
       s_sta_connected = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-      for (auto *listener : global_wifi_component->connect_state_listeners_) {
-        listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
-      }
-#endif
-      // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
-#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
-      if (const WiFiAP *config = global_wifi_component->get_selected_sta_();
-          config && config->get_manual_ip().has_value()) {
-        for (auto *listener : global_wifi_component->ip_state_listeners_) {
-          listener->on_ip_state(global_wifi_component->wifi_sta_ip_addresses(),
-                                global_wifi_component->get_dns_address(0), global_wifi_component->get_dns_address(1));
-        }
-      }
-#endif
+      // Defer listener callbacks to main loop - system context has limited stack
+      global_wifi_component->pending_.connect = true;
       break;
     }
     case EVENT_STAMODE_DISCONNECTED: {
@@ -543,17 +530,9 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       }
       s_sta_connected = false;
       s_sta_connecting = false;
-      // IMPORTANT: Set error flag BEFORE notifying listeners.
-      // This ensures is_connected() returns false during listener callbacks,
-      // which is critical for proper reconnection logic (e.g., roaming).
-      global_wifi_component->error_from_callback_ = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-      // Notify listeners AFTER setting error flag so they see correct state
-      static constexpr uint8_t EMPTY_BSSID[6] = {};
-      for (auto *listener : global_wifi_component->connect_state_listeners_) {
-        listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
-      }
-#endif
+      // Store reason as error flag; defer listener callbacks to main loop
+      global_wifi_component->error_from_callback_ = it.reason;
+      global_wifi_component->pending_.disconnect = true;
       break;
     }
     case EVENT_STAMODE_AUTHMODE_CHANGE: {
@@ -564,10 +543,8 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       // https://lbsfilm.at/blog/wpa2-authenticationmode-downgrade-in-espressif-microprocessors
       if (it.old_mode != AUTH_OPEN && it.new_mode == AUTH_OPEN) {
         ESP_LOGW(TAG, "Potential Authmode downgrade detected, disconnecting");
-        // we can't call retry_connect() from this context, so disconnect immediately
-        // and notify main thread with error_from_callback_
         wifi_station_disconnect();
-        global_wifi_component->error_from_callback_ = true;
+        global_wifi_component->error_from_callback_ = WIFI_DISCONNECT_REASON_AUTHMODE_DOWNGRADE;
       }
       break;
     }
@@ -578,12 +555,8 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       ESP_LOGV(TAG, "static_ip=%s gateway=%s netmask=%s", network::IPAddress(&it.ip).str_to(ip_buf),
                network::IPAddress(&it.gw).str_to(gw_buf), network::IPAddress(&it.mask).str_to(mask_buf));
       s_sta_got_ip = true;
-#ifdef USE_WIFI_IP_STATE_LISTENERS
-      for (auto *listener : global_wifi_component->ip_state_listeners_) {
-        listener->on_ip_state(global_wifi_component->wifi_sta_ip_addresses(), global_wifi_component->get_dns_address(0),
-                              global_wifi_component->get_dns_address(1));
-      }
-#endif
+      // Defer listener callbacks to main loop - system context has limited stack
+      global_wifi_component->pending_.got_ip = true;
       break;
     }
     case EVENT_STAMODE_DHCP_TIMEOUT: {
@@ -793,11 +766,7 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
   ESP_LOGV(TAG, "Scan complete: %zu found, %zu stored%s", total, this->scan_result_.size(),
            needs_full ? "" : " (filtered)");
   this->scan_done_ = true;
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
-  for (auto *listener : global_wifi_component->scan_results_listeners_) {
-    listener->on_wifi_scan_results(global_wifi_component->scan_result_);
-  }
-#endif
+  this->pending_.scan_complete = true;  // Defer listener callbacks to main loop
 }
 
 #ifdef USE_WIFI_AP
@@ -983,7 +952,59 @@ network::IPAddress WiFiComponent::wifi_gateway_ip_() {
   return network::IPAddress(&ip.gw);
 }
 network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return network::IPAddress(dns_getserver(num)); }
-void WiFiComponent::wifi_loop_() {}
+void WiFiComponent::wifi_loop_() { this->process_pending_callbacks_(); }
+
+void WiFiComponent::process_pending_callbacks_() {
+  // Notify listeners for connect event (logging already done in callback)
+  if (this->pending_.connect) {
+    this->pending_.connect = false;
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+    bssid_t bssid = this->wifi_bssid();
+    char ssid_buf[SSID_BUFFER_SIZE];
+    for (auto *listener : this->connect_state_listeners_) {
+      listener->on_wifi_connect_state(StringRef(this->wifi_ssid_to(ssid_buf)), bssid);
+    }
+#endif
+#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
+    if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_manual_ip().has_value()) {
+      for (auto *listener : this->ip_state_listeners_) {
+        listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+      }
+    }
+#endif
+  }
+
+  // Notify listeners for disconnect event (logging already done in callback)
+  if (this->pending_.disconnect) {
+    this->pending_.disconnect = false;
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+    static constexpr uint8_t EMPTY_BSSID[6] = {};
+    for (auto *listener : this->connect_state_listeners_) {
+      listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
+    }
+#endif
+  }
+
+  // Notify listeners for got IP event (logging already done in callback)
+  if (this->pending_.got_ip) {
+    this->pending_.got_ip = false;
+#ifdef USE_WIFI_IP_STATE_LISTENERS
+    for (auto *listener : this->ip_state_listeners_) {
+      listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+    }
+#endif
+  }
+
+  // Notify listeners for scan complete (logging already done in callback)
+  if (this->pending_.scan_complete) {
+    this->pending_.scan_complete = false;
+#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
+    for (auto *listener : this->scan_results_listeners_) {
+      listener->on_wifi_scan_results(this->scan_result_);
+    }
+#endif
+  }
+}
 
 }  // namespace esphome::wifi
 #endif

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -774,7 +774,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     }
     s_sta_connected = false;
     s_sta_connecting = false;
-    error_from_callback_ = true;
+    error_from_callback_ = 1;
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
     static constexpr uint8_t EMPTY_BSSID[6] = {};
     for (auto *listener : this->connect_state_listeners_) {

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -494,7 +494,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
                    s_ignored_disconnect_count, get_disconnect_reason_str(it.reason));
           s_sta_state = LTWiFiSTAState::ERROR_FAILED;
           WiFi.disconnect();
-          this->error_from_callback_ = true;
+          this->error_from_callback_ = 1;
           // Don't break - fall through to notify listeners
         } else {
           ESP_LOGV(TAG, "Ignoring disconnect event with empty ssid while connecting (reason=%s, count=%u)",
@@ -520,7 +520,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
           reason == WIFI_REASON_NO_AP_FOUND || reason == WIFI_REASON_ASSOC_FAIL ||
           reason == WIFI_REASON_HANDSHAKE_TIMEOUT) {
         WiFi.disconnect();
-        this->error_from_callback_ = true;
+        this->error_from_callback_ = 1;
       }
 
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
@@ -539,7 +539,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
       if (it.old_mode != WIFI_AUTH_OPEN && it.new_mode == WIFI_AUTH_OPEN) {
         ESP_LOGW(TAG, "Potential Authmode downgrade detected, disconnecting");
         WiFi.disconnect();
-        this->error_from_callback_ = true;
+        this->error_from_callback_ = 1;
         s_sta_state = LTWiFiSTAState::ERROR_FAILED;
       }
       break;

esphome/core/__init__.py

@@ -278,9 +278,13 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")
 
 class Lambda:
     def __init__(self, value):
+        from esphome.cpp_generator import Expression, statement
+
         # pylint: disable=protected-access
         if isinstance(value, Lambda):
             self._value = value._value
+        elif isinstance(value, Expression):
+            self._value = str(statement(value))
         else:
             self._value = value
         self._parts = None

esphome/cpp_generator.py

@@ -462,6 +462,16 @@ def statement(expression: Expression | Statement) -> Statement:
     return ExpressionStatement(expression)
 
 
+def literal(name: str) -> "MockObj":
+    """Create a literal name that will appear in the generated code
+    not surrounded by quotes.
+
+    :param name: The name of the literal.
+    :return: The literal as a MockObj.
+    """
+    return MockObj(name, "")
+
+
 def variable(
     id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -665,7 +675,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 
 async def process_lambda(
-    value: Lambda,
+    value: Lambda | Expression,
     parameters: TemplateArgsType,
     capture: str = "",
     return_type: SafeExpType = None,
@@ -689,6 +699,14 @@ async def process_lambda(
 
     if value is None:
         return None
+    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
+    # "Generating C++ source..." stage, so check here to save the developer's hair.
+    assert isinstance(parameters, list) and all(
+        isinstance(p, tuple) and len(p) == 2 for p in parameters
+    )
+    if isinstance(value, Expression):
+        value = Lambda(value)
+
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
         full_id, var = await get_variable_with_full_id(id)

tests/unit_tests/test_cpp_generator.py

@@ -347,3 +347,280 @@ class TestMockObj:
         assert isinstance(actual, cg.MockObj)
         assert actual.base == "foo.eek"
         assert actual.op == "."
+
+
+class TestStatementFunction:
+    """Tests for the statement() function."""
+
+    def test_statement__expression_converted_to_statement(self):
+        """Test that expressions are converted to ExpressionStatement."""
+        expr = cg.RawExpression("foo()")
+        result = cg.statement(expr)
+
+        assert isinstance(result, cg.ExpressionStatement)
+        assert str(result) == "foo();"
+
+    def test_statement__statement_unchanged(self):
+        """Test that statements are returned unchanged."""
+        stmt = cg.RawStatement("foo()")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "foo()"
+
+    def test_statement__expression_statement_unchanged(self):
+        """Test that ExpressionStatement is returned unchanged."""
+        stmt = cg.ExpressionStatement(42)
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "42;"
+
+    def test_statement__line_comment_unchanged(self):
+        """Test that LineComment is returned unchanged."""
+        stmt = cg.LineComment("This is a comment")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "// This is a comment"
+
+
+class TestLiteralFunction:
+    """Tests for the literal() function."""
+
+    def test_literal__creates_mockobj(self):
+        """Test that literal() creates a MockObj."""
+        result = cg.literal("MY_CONSTANT")
+
+        assert isinstance(result, cg.MockObj)
+        assert result.base == "MY_CONSTANT"
+        assert result.op == ""
+
+    def test_literal__string_representation(self):
+        """Test that literal names appear unquoted in generated code."""
+        result = cg.literal("nullptr")
+
+        assert str(result) == "nullptr"
+
+    def test_literal__can_be_used_in_expressions(self):
+        """Test that literals can be used as part of larger expressions."""
+        null_lit = cg.literal("nullptr")
+        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
+
+        assert str(expr) == "my_func(nullptr)"
+
+    def test_literal__common_cpp_literals(self):
+        """Test common C++ literal values."""
+        test_cases = [
+            ("nullptr", "nullptr"),
+            ("true", "true"),
+            ("false", "false"),
+            ("NULL", "NULL"),
+            ("NAN", "NAN"),
+        ]
+
+        for name, expected in test_cases:
+            result = cg.literal(name)
+            assert str(result) == expected
+
+
+class TestLambdaConstructor:
+    """Tests for the Lambda class constructor in core/__init__.py."""
+
+    def test_lambda__from_string(self):
+        """Test Lambda constructor with string argument."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+
+        assert lambda_obj.value == "return x + 1;"
+        assert str(lambda_obj) == "return x + 1;"
+
+    def test_lambda__from_expression(self):
+        """Test Lambda constructor with Expression argument."""
+        from esphome.core import Lambda
+
+        expr = cg.RawExpression("x + 1")
+        lambda_obj = Lambda(expr)
+
+        # Expression should be converted to statement (with semicolon)
+        assert lambda_obj.value == "x + 1;"
+
+    def test_lambda__from_lambda(self):
+        """Test Lambda constructor with another Lambda argument."""
+        from esphome.core import Lambda
+
+        original = Lambda("return x + 1;")
+        copy = Lambda(original)
+
+        assert copy.value == original.value
+        assert copy.value == "return x + 1;"
+
+    def test_lambda__parts_parsing(self):
+        """Test that Lambda correctly parses parts with id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(my_sensor).state;")
+        parts = lambda_obj.parts
+
+        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
+        assert len(parts) == 4
+        assert parts[0] == "return "
+        assert parts[1] == "my_sensor"
+        assert parts[2] == "."
+        assert parts[3] == "state;"
+
+    def test_lambda__requires_ids(self):
+        """Test that Lambda correctly extracts required IDs."""
+        from esphome.core import ID, Lambda
+
+        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 2
+        assert all(isinstance(id_obj, ID) for id_obj in ids)
+        assert ids[0].id == "sensor1"
+        assert ids[1].id == "sensor2"
+
+    def test_lambda__no_ids(self):
+        """Test Lambda with no id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 0
+
+    def test_lambda__comment_removal(self):
+        """Test that comments are removed when parsing parts."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
+        parts = lambda_obj.parts
+
+        # Comment should be replaced with space, not affect parsing
+        assert "my_sensor" not in str(parts)
+
+    def test_lambda__multiline_string(self):
+        """Test Lambda with multiline string."""
+        from esphome.core import Lambda
+
+        code = """if (id(sensor).state > 0) {
+  return true;
+}
+return false;"""
+        lambda_obj = Lambda(code)
+
+        assert lambda_obj.value == code
+        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
+
+
+@pytest.mark.asyncio
+class TestProcessLambda:
+    """Tests for the process_lambda() async function."""
+
+    async def test_process_lambda__none_value(self):
+        """Test that None returns None."""
+        result = await cg.process_lambda(None, [])
+
+        assert result is None
+
+    async def test_process_lambda__with_expression(self):
+        """Test process_lambda with Expression argument."""
+
+        expr = cg.RawExpression("return x + 1")
+        result = await cg.process_lambda(expr, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        assert "x + 1" in str(result)
+
+    async def test_process_lambda__simple_lambda_no_ids(self):
+        """Test process_lambda with simple Lambda without id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        # Should have parameter
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "return x + 1;" in lambda_str
+
+    async def test_process_lambda__with_return_type(self):
+        """Test process_lambda with return type specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x > 0;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "-> bool" in lambda_str
+
+    async def test_process_lambda__with_capture(self):
+        """Test process_lambda with capture specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return captured + x;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[captured]" in lambda_str
+
+    async def test_process_lambda__empty_capture(self):
+        """Test process_lambda with empty capture (stateless lambda)."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[]" in lambda_str
+
+    async def test_process_lambda__no_parameters(self):
+        """Test process_lambda with no parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        result = await cg.process_lambda(lambda_obj, [])
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        # Should have empty parameter list
+        assert "()" in lambda_str
+
+    async def test_process_lambda__multiple_parameters(self):
+        """Test process_lambda with multiple parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + y + z;")
+        result = await cg.process_lambda(
+            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
+        )
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "float y" in lambda_str
+        assert "bool z" in lambda_str
+
+    async def test_process_lambda__parameter_validation(self):
+        """Test that malformed parameters raise assertion error."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x;")
+
+        # Test invalid parameter format (not list of tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, "invalid")
+
+        # Test invalid tuple format (not 2-element tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
+
+        # Test invalid tuple format (single element)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int,)])