esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/http_request/__init__.py

@@ -5,10 +5,12 @@ from esphome.components.const import CONF_REQUEST_HEADERS
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_CAPTURE_RESPONSE,
     CONF_ESP8266_DISABLE_SSL_SUPPORT,
     CONF_ID,
     CONF_METHOD,
     CONF_ON_ERROR,
+    CONF_ON_RESPONSE,
     CONF_TIMEOUT,
     CONF_TRIGGER_ID,
     CONF_URL,
@@ -52,12 +54,10 @@ CONF_BUFFER_SIZE_TX = "buffer_size_tx"
 CONF_CA_CERTIFICATE_PATH = "ca_certificate_path"
 
 CONF_MAX_RESPONSE_BUFFER_SIZE = "max_response_buffer_size"
-CONF_ON_RESPONSE = "on_response"
 CONF_HEADERS = "headers"
 CONF_COLLECT_HEADERS = "collect_headers"
 CONF_BODY = "body"
 CONF_JSON = "json"
-CONF_CAPTURE_RESPONSE = "capture_response"
 
 
 def validate_url(value):
@@ -194,7 +194,7 @@ async def to_code(config):
             cg.add_define("CPPHTTPLIB_OPENSSL_SUPPORT")
         elif path := config.get(CONF_CA_CERTIFICATE_PATH):
             cg.add_define("CPPHTTPLIB_OPENSSL_SUPPORT")
-            cg.add(var.set_ca_path(path))
+            cg.add(var.set_ca_path(str(path)))
             cg.add_build_flag("-lssl")
             cg.add_build_flag("-lcrypto")
 

esphome/components/htu21d/htu21d.cpp

@@ -9,8 +9,8 @@ static const char *const TAG = "htu21d";
 
 static const uint8_t HTU21D_ADDRESS = 0x40;
 static const uint8_t HTU21D_REGISTER_RESET = 0xFE;
-static const uint8_t HTU21D_REGISTER_TEMPERATURE = 0xF3;
-static const uint8_t HTU21D_REGISTER_HUMIDITY = 0xF5;
+static const uint8_t HTU21D_REGISTER_TEMPERATURE = 0xE3;
+static const uint8_t HTU21D_REGISTER_HUMIDITY = 0xE5;
 static const uint8_t HTU21D_WRITERHT_REG_CMD = 0xE6; /**< Write RH/T User Register 1 */
 static const uint8_t HTU21D_REGISTER_STATUS = 0xE7;
 static const uint8_t HTU21D_WRITEHEATER_REG_CMD = 0x51; /**< Write Heater Control Register */
@@ -57,7 +57,6 @@ void HTU21DComponent::update() {
 
     if (this->temperature_ != nullptr)
       this->temperature_->publish_state(temperature);
-    this->status_clear_warning();
 
     if (this->write(&HTU21D_REGISTER_HUMIDITY, 1) != i2c::ERROR_OK) {
       this->status_set_warning();
@@ -79,10 +78,11 @@ void HTU21DComponent::update() {
       if (this->humidity_ != nullptr)
         this->humidity_->publish_state(humidity);
 
-      int8_t heater_level;
+      this->status_clear_warning();
 
       // HTU21D does have a heater module but does not have heater level
       // Setting heater level to 1 in case the heater is ON
+      uint8_t heater_level = 0;
       if (this->sensor_model_ == HTU21D_SENSOR_MODEL_HTU21D) {
         if (this->is_heater_enabled()) {
           heater_level = 1;
@@ -97,34 +97,30 @@ void HTU21DComponent::update() {
 
       if (this->heater_ != nullptr)
         this->heater_->publish_state(heater_level);
-      this->status_clear_warning();
     });
   });
 }
 
 bool HTU21DComponent::is_heater_enabled() {
   uint8_t raw_heater;
-  if (this->read_register(HTU21D_REGISTER_STATUS, reinterpret_cast<uint8_t *>(&raw_heater), 2) != i2c::ERROR_OK) {
+  if (this->read_register(HTU21D_REGISTER_STATUS, &raw_heater, 1) != i2c::ERROR_OK) {
     this->status_set_warning();
     return false;
   }
-  raw_heater = i2c::i2ctohs(raw_heater);
-  return (bool) (((raw_heater) >> (HTU21D_REG_HTRE_BIT)) & 0x01);
+  return (bool) ((raw_heater >> HTU21D_REG_HTRE_BIT) & 0x01);
 }
 
 void HTU21DComponent::set_heater(bool status) {
   uint8_t raw_heater;
-  if (this->read_register(HTU21D_REGISTER_STATUS, reinterpret_cast<uint8_t *>(&raw_heater), 2) != i2c::ERROR_OK) {
+  if (this->read_register(HTU21D_REGISTER_STATUS, &raw_heater, 1) != i2c::ERROR_OK) {
     this->status_set_warning();
     return;
   }
-  raw_heater = i2c::i2ctohs(raw_heater);
   if (status) {
-    raw_heater |= (1 << (HTU21D_REG_HTRE_BIT));
+    raw_heater |= (1 << HTU21D_REG_HTRE_BIT);
   } else {
-    raw_heater &= ~(1 << (HTU21D_REG_HTRE_BIT));
+    raw_heater &= ~(1 << HTU21D_REG_HTRE_BIT);
   }
-
   if (this->write_register(HTU21D_WRITERHT_REG_CMD, &raw_heater, 1) != i2c::ERROR_OK) {
     this->status_set_warning();
     return;
@@ -138,14 +134,13 @@ void HTU21DComponent::set_heater_level(uint8_t level) {
   }
 }
 
-int8_t HTU21DComponent::get_heater_level() {
-  int8_t raw_heater;
-  if (this->read_register(HTU21D_READHEATER_REG_CMD, reinterpret_cast<uint8_t *>(&raw_heater), 2) != i2c::ERROR_OK) {
+uint8_t HTU21DComponent::get_heater_level() {
+  uint8_t raw_heater;
+  if (this->read_register(HTU21D_READHEATER_REG_CMD, &raw_heater, 1) != i2c::ERROR_OK) {
     this->status_set_warning();
     return 0;
   }
-  raw_heater = i2c::i2ctohs(raw_heater);
-  return raw_heater;
+  return raw_heater & 0xF;
 }
 
 float HTU21DComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/htu21d/htu21d.h

@@ -26,7 +26,7 @@ class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
   bool is_heater_enabled();
   void set_heater(bool status);
   void set_heater_level(uint8_t level);
-  int8_t get_heater_level();
+  uint8_t get_heater_level();
 
   float get_setup_priority() const override;
 

esphome/components/i2s_audio/__init__.py

@@ -262,8 +262,7 @@ async def to_code(config):
         cg.add_define("USE_I2S_LEGACY")
 
     # Helps avoid callbacks being skipped due to processor load
-    if CORE.using_esp_idf:
-        add_idf_sdkconfig_option("CONFIG_I2S_ISR_IRAM_SAFE", True)
+    add_idf_sdkconfig_option("CONFIG_I2S_ISR_IRAM_SAFE", True)
 
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -377,7 +377,7 @@ void I2SAudioSpeaker::speaker_task(void *params) {
             this_speaker->current_stream_info_.get_bits_per_sample() <= 16) {
           size_t len = bytes_read / sizeof(int16_t);
           int16_t *tmp_buf = (int16_t *) new_data;
-          for (int i = 0; i < len; i += 2) {
+          for (size_t i = 0; i < len; i += 2) {
             int16_t tmp = tmp_buf[i];
             tmp_buf[i] = tmp_buf[i + 1];
             tmp_buf[i + 1] = tmp;

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -325,7 +325,7 @@ void ILI9XXXDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, cons
       // we could deal here with a non-zero y_offset, but if x_offset is zero, y_offset probably will be so don't bother
       this->write_array(ptr, w * h * 2);
     } else {
-      for (size_t y = 0; y != h; y++) {
+      for (size_t y = 0; y != static_cast<size_t>(h); y++) {
         this->write_array(ptr + (y + y_offset) * stride + x_offset, w * 2);
       }
     }
@@ -349,7 +349,7 @@ void ILI9XXXDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, cons
         App.feed_wdt();
       }
       // end of line? Skip to the next.
-      if (++pixel == w) {
+      if (++pixel == static_cast<size_t>(w)) {
         pixel = 0;
         ptr += (x_pad + x_offset) * 2;
       }

esphome/components/improv_serial/improv_serial_component.cpp

@@ -15,11 +15,10 @@ static const char *const TAG = "improv_serial";
 
 void ImprovSerialComponent::setup() {
   global_improv_serial_component = this;
-#ifdef USE_ARDUINO
-  this->hw_serial_ = logger::global_logger->get_hw_serial();
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   this->uart_num_ = logger::global_logger->get_uart_num();
+#elif defined(USE_ARDUINO)
+  this->hw_serial_ = logger::global_logger->get_hw_serial();
 #endif
 
   if (wifi::global_wifi_component->has_sta()) {
@@ -34,13 +33,7 @@ void ImprovSerialComponent::dump_config() { ESP_LOGCONFIG(TAG, "Improv Serial:")
 optional<uint8_t> ImprovSerialComponent::read_byte_() {
   optional<uint8_t> byte;
   uint8_t data = 0;
-#ifdef USE_ARDUINO
-  if (this->hw_serial_->available()) {
-    this->hw_serial_->readBytes(&data, 1);
-    byte = data;
-  }
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   switch (logger::global_logger->get_uart()) {
     case logger::UART_SELECTION_UART0:
     case logger::UART_SELECTION_UART1:
@@ -76,16 +69,18 @@ optional<uint8_t> ImprovSerialComponent::read_byte_() {
     default:
       break;
   }
+#elif defined(USE_ARDUINO)
+  if (this->hw_serial_->available()) {
+    this->hw_serial_->readBytes(&data, 1);
+    byte = data;
+  }
 #endif
   return byte;
 }
 
 void ImprovSerialComponent::write_data_(std::vector<uint8_t> &data) {
   data.push_back('\n');
-#ifdef USE_ARDUINO
-  this->hw_serial_->write(data.data(), data.size());
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   switch (logger::global_logger->get_uart()) {
     case logger::UART_SELECTION_UART0:
     case logger::UART_SELECTION_UART1:
@@ -112,6 +107,8 @@ void ImprovSerialComponent::write_data_(std::vector<uint8_t> &data) {
     default:
       break;
   }
+#elif defined(USE_ARDUINO)
+  this->hw_serial_->write(data.data(), data.size());
 #endif
 }
 

esphome/components/improv_serial/improv_serial_component.h

@@ -9,10 +9,7 @@
 #include <improv.h>
 #include <vector>
 
-#ifdef USE_ARDUINO
-#include <HardwareSerial.h>
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 #include <driver/uart.h>
 #if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32S3) || \
     defined(USE_ESP32_VARIANT_ESP32H2)
@@ -22,6 +19,8 @@
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
 #include <esp_private/usb_console.h>
 #endif
+#elif defined(USE_ARDUINO)
+#include <HardwareSerial.h>
 #endif
 
 namespace esphome {
@@ -60,11 +59,10 @@ class ImprovSerialComponent : public Component, public improv_base::ImprovBase {
   optional<uint8_t> read_byte_();
   void write_data_(std::vector<uint8_t> &data);
 
-#ifdef USE_ARDUINO
-  Stream *hw_serial_{nullptr};
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   uart_port_t uart_num_;
+#elif defined(USE_ARDUINO)
+  Stream *hw_serial_{nullptr};
 #endif
 
   std::vector<uint8_t> rx_buffer_;

esphome/components/json/json_util.cpp

@@ -8,70 +8,62 @@ namespace json {
 
 static const char *const TAG = "json";
 
-// Build an allocator for the JSON Library using the RAMAllocator class
-struct SpiRamAllocator : ArduinoJson::Allocator {
-  void *allocate(size_t size) override { return this->allocator_.allocate(size); }
-
-  void deallocate(void *pointer) override {
-    // ArduinoJson's Allocator interface doesn't provide the size parameter in deallocate.
-    // RAMAllocator::deallocate() requires the size, which we don't have access to here.
-    // RAMAllocator::deallocate implementation just calls free() regardless of whether
-    // the memory was allocated with heap_caps_malloc or malloc.
-    // This is safe because ESP-IDF's heap implementation internally tracks the memory region
-    // and routes free() to the appropriate heap.
-    free(pointer);  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
-  }
-
-  void *reallocate(void *ptr, size_t new_size) override {
-    return this->allocator_.reallocate(static_cast<uint8_t *>(ptr), new_size);
-  }
-
- protected:
-  RAMAllocator<uint8_t> allocator_{RAMAllocator<uint8_t>(RAMAllocator<uint8_t>::NONE)};
-};
-
 std::string build_json(const json_build_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  auto doc_allocator = SpiRamAllocator();
-  JsonDocument json_document(&doc_allocator);
-  if (json_document.overflowed()) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
-    return "{}";
-  }
-  JsonObject root = json_document.to<JsonObject>();
+  JsonBuilder builder;
+  JsonObject root = builder.root();
   f(root);
-  if (json_document.overflowed()) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
-    return "{}";
-  }
-  std::string output;
-  serializeJson(json_document, output);
-  return output;
+  return builder.serialize();
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
 bool parse_json(const std::string &data, const json_parse_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
+  JsonDocument doc = parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
+  if (doc.overflowed() || doc.isNull())
+    return false;
+  return f(doc.as<JsonObject>());
+  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
+}
+
+JsonDocument parse_json(const uint8_t *data, size_t len) {
+  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
+  if (data == nullptr || len == 0) {
+    ESP_LOGE(TAG, "No data to parse");
+    return JsonObject();  // return unbound object
+  }
+#ifdef USE_PSRAM
   auto doc_allocator = SpiRamAllocator();
   JsonDocument json_document(&doc_allocator);
+#else
+  JsonDocument json_document;
+#endif
   if (json_document.overflowed()) {
     ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
-    return false;
+    return JsonObject();  // return unbound object
   }
-  DeserializationError err = deserializeJson(json_document, data);
-
-  JsonObject root = json_document.as<JsonObject>();
+  DeserializationError err = deserializeJson(json_document, data, len);
 
   if (err == DeserializationError::Ok) {
-    return f(root);
+    return json_document;
   } else if (err == DeserializationError::NoMemory) {
     ESP_LOGE(TAG, "Can not allocate more memory for deserialization. Consider making source string smaller");
-    return false;
+    return JsonObject();  // return unbound object
   }
   ESP_LOGE(TAG, "Parse error: %s", err.c_str());
-  return false;
+  return JsonObject();  // return unbound object
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
+std::string JsonBuilder::serialize() {
+  if (doc_.overflowed()) {
+    ESP_LOGE(TAG, "JSON document overflow");
+    return "{}";
+  }
+  std::string output;
+  serializeJson(doc_, output);
+  return output;
+}
+
 }  // namespace json
 }  // namespace esphome

esphome/components/json/json_util.h

@@ -2,6 +2,7 @@
 
 #include <vector>
 
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 
 #define ARDUINOJSON_ENABLE_STD_STRING 1  // NOLINT
@@ -13,6 +14,31 @@
 namespace esphome {
 namespace json {
 
+#ifdef USE_PSRAM
+// Build an allocator for the JSON Library using the RAMAllocator class
+// This is only compiled when PSRAM is enabled
+struct SpiRamAllocator : ArduinoJson::Allocator {
+  void *allocate(size_t size) override { return allocator_.allocate(size); }
+
+  void deallocate(void *ptr) override {
+    // ArduinoJson's Allocator interface doesn't provide the size parameter in deallocate.
+    // RAMAllocator::deallocate() requires the size, which we don't have access to here.
+    // RAMAllocator::deallocate implementation just calls free() regardless of whether
+    // the memory was allocated with heap_caps_malloc or malloc.
+    // This is safe because ESP-IDF's heap implementation internally tracks the memory region
+    // and routes free() to the appropriate heap.
+    free(ptr);  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
+  }
+
+  void *reallocate(void *ptr, size_t new_size) override {
+    return allocator_.reallocate(static_cast<uint8_t *>(ptr), new_size);
+  }
+
+ protected:
+  RAMAllocator<uint8_t> allocator_{RAMAllocator<uint8_t>::NONE};
+};
+#endif
+
 /// Callback function typedef for parsing JsonObjects.
 using json_parse_t = std::function<bool(JsonObject)>;
 
@@ -25,5 +51,36 @@ std::string build_json(const json_build_t &f);
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
 
+/// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
+JsonDocument parse_json(const uint8_t *data, size_t len);
+/// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
+inline JsonDocument parse_json(const std::string &data) {
+  return parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
+}
+
+/// Builder class for creating JSON documents without lambdas
+class JsonBuilder {
+ public:
+  JsonObject root() {
+    if (!root_created_) {
+      root_ = doc_.to<JsonObject>();
+      root_created_ = true;
+    }
+    return root_;
+  }
+
+  std::string serialize();
+
+ private:
+#ifdef USE_PSRAM
+  SpiRamAllocator allocator_;
+  JsonDocument doc_{&allocator_};
+#else
+  JsonDocument doc_;
+#endif
+  JsonObject root_;
+  bool root_created_{false};
+};
+
 }  // namespace json
 }  // namespace esphome

esphome/components/kamstrup_kmp/kamstrup_kmp.cpp

@@ -22,7 +22,7 @@ void KamstrupKMPComponent::dump_config() {
   LOG_SENSOR("  ", "Flow", this->flow_sensor_);
   LOG_SENSOR("  ", "Volume", this->volume_sensor_);
 
-  for (int i = 0; i < this->custom_sensors_.size(); i++) {
+  for (size_t i = 0; i < this->custom_sensors_.size(); i++) {
     LOG_SENSOR("  ", "Custom Sensor", this->custom_sensors_[i]);
     ESP_LOGCONFIG(TAG, "    Command: 0x%04X", this->custom_commands_[i]);
   }
@@ -268,7 +268,7 @@ void KamstrupKMPComponent::set_sensor_value_(uint16_t command, float value, uint
   }
 
   // Custom sensors
-  for (int i = 0; i < this->custom_commands_.size(); i++) {
+  for (size_t i = 0; i < this->custom_commands_.size(); i++) {
     if (command == this->custom_commands_[i]) {
       this->custom_sensors_[i]->publish_state(value);
     }

esphome/components/key_collector/key_collector.h

@@ -13,8 +13,8 @@ class KeyCollector : public Component {
   void loop() override;
   void dump_config() override;
   void set_provider(key_provider::KeyProvider *provider);
-  void set_min_length(int min_length) { this->min_length_ = min_length; };
-  void set_max_length(int max_length) { this->max_length_ = max_length; };
+  void set_min_length(uint32_t min_length) { this->min_length_ = min_length; };
+  void set_max_length(uint32_t max_length) { this->max_length_ = max_length; };
   void set_start_keys(std::string start_keys) { this->start_keys_ = std::move(start_keys); };
   void set_end_keys(std::string end_keys) { this->end_keys_ = std::move(end_keys); };
   void set_end_key_required(bool end_key_required) { this->end_key_required_ = end_key_required; };
@@ -33,8 +33,8 @@ class KeyCollector : public Component {
  protected:
   void key_pressed_(uint8_t key);
 
-  int min_length_{0};
-  int max_length_{0};
+  uint32_t min_length_{0};
+  uint32_t max_length_{0};
   std::string start_keys_;
   std::string end_keys_;
   bool end_key_required_{false};

esphome/components/libretiny/__init__.py

@@ -1,6 +1,5 @@
 import json
 import logging
-from os.path import dirname, isfile, join
 
 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -24,6 +23,7 @@ from esphome.const import (
     __version__,
 )
 from esphome.core import CORE
+from esphome.storage_json import StorageJSON
 
 from . import gpio  # noqa
 from .const import (
@@ -129,7 +129,7 @@ def only_on_family(*, supported=None, unsupported=None):
     return validator_
 
 
-def get_download_types(storage_json=None):
+def get_download_types(storage_json: StorageJSON = None):
     types = [
         {
             "title": "UF2 package (recommended)",
@@ -139,11 +139,11 @@ def get_download_types(storage_json=None):
         },
     ]
 
-    build_dir = dirname(storage_json.firmware_bin_path)
-    outputs = join(build_dir, "firmware.json")
-    if not isfile(outputs):
+    build_dir = storage_json.firmware_bin_path.parent
+    outputs = build_dir / "firmware.json"
+    if not outputs.is_file():
         return types
-    with open(outputs, encoding="utf-8") as f:
+    with outputs.open(encoding="utf-8") as f:
         outputs = json.load(f)
     for output in outputs:
         if not output["public"]:

esphome/components/libretiny/preferences.cpp

@@ -15,7 +15,14 @@ static const char *const TAG = "lt.preferences";
 
 struct NVSData {
   std::string key;
-  std::vector<uint8_t> data;
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    data = std::make_unique<uint8_t[]>(size);
+    memcpy(data.get(), src, size);
+    len = size;
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -30,15 +37,15 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == key) {
-        obj.data.assign(data, data + len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = key;
-    save.data.assign(data, data + len);
-    s_pending_save.emplace_back(save);
-    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %d", key.c_str(), len);
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
+    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %zu", key.c_str(), len);
     return true;
   }
 
@@ -46,11 +53,11 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -58,10 +65,10 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     fdb_blob_make(blob, data, len);
     size_t actual_len = fdb_kv_get_blob(db, key.c_str(), blob);
     if (actual_len != len) {
-      ESP_LOGVV(TAG, "NVS length does not match (%u!=%u)", actual_len, len);
+      ESP_LOGVV(TAG, "NVS length does not match (%zu!=%zu)", actual_len, len);
       return false;
     } else {
-      ESP_LOGVV(TAG, "fdb_kv_get_blob: key: %s, len: %d", key.c_str(), len);
+      ESP_LOGVV(TAG, "fdb_kv_get_blob: key: %s, len: %zu", key.c_str(), len);
     }
     return true;
   }
@@ -101,7 +108,7 @@ class LibreTinyPreferences : public ESPPreferences {
     if (s_pending_save.empty())
       return true;
 
-    ESP_LOGV(TAG, "Saving %d items...", s_pending_save.size());
+    ESP_LOGV(TAG, "Saving %zu items...", s_pending_save.size());
     // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     fdb_err_t last_err = FDB_NO_ERR;
@@ -112,11 +119,11 @@ class LibreTinyPreferences : public ESPPreferences {
       const auto &save = s_pending_save[i];
       ESP_LOGVV(TAG, "Checking if FDB data %s has changed", save.key.c_str());
       if (is_changed(&db, save)) {
-        ESP_LOGV(TAG, "sync: key: %s, len: %d", save.key.c_str(), save.data.size());
-        fdb_blob_make(&blob, save.data.data(), save.data.size());
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", save.key.c_str(), save.len);
+        fdb_blob_make(&blob, save.data.get(), save.len);
         fdb_err_t err = fdb_kv_set_blob(&db, save.key.c_str(), &blob);
         if (err != FDB_NO_ERR) {
-          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%u) failed: %d", save.key.c_str(), save.data.size(), err);
+          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%zu) failed: %d", save.key.c_str(), save.len, err);
           failed++;
           last_err = err;
           last_key = save.key;
@@ -124,7 +131,7 @@ class LibreTinyPreferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGD(TAG, "FDB data not changed; skipping %s  len=%u", save.key.c_str(), save.data.size());
+        ESP_LOGD(TAG, "FDB data not changed; skipping %s  len=%zu", save.key.c_str(), save.len);
         cached++;
       }
       s_pending_save.erase(s_pending_save.begin() + i);
@@ -147,7 +154,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Check size first - if different, data has changed
-    if (kv.value_len != to_save.data.size()) {
+    if (kv.value_len != to_save.len) {
       return true;
     }
 
@@ -161,7 +168,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Compare the actual data
-    return memcmp(to_save.data.data(), stored_data.get(), kv.value_len) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), kv.value_len) != 0;
   }
 
   bool reset() override {