Fix remaining components using Python int instead of cg.int32

.github/scripts/auto-label-pr/constants.js

@@ -4,7 +4,6 @@ module.exports = {
   CODEOWNERS_MARKER: '<!-- codeowners-request -->',
   TOO_BIG_MARKER: '<!-- too-big-request -->',
   DEPRECATED_COMPONENT_MARKER: '<!-- deprecated-component-request -->',
-  ORG_FORK_MARKER: '<!-- maintainer-access-warning -->',
 
   MANAGED_LABELS: [
     'new-component',

.github/scripts/auto-label-pr/detectors.js

@@ -281,24 +281,6 @@ async function detectDeprecatedComponents(github, context, changedFiles) {
   return { labels, deprecatedInfo };
 }
 
-// Strategy: Detect when maintainers cannot modify the PR branch
-function detectMaintainerAccess(context) {
-  const pr = context.payload.pull_request;
-
-  // Only relevant for cross-repo PRs (forks)
-  if (!pr.head.repo || pr.head.repo.full_name === pr.base.repo.full_name) {
-    return null;
-  }
-
-  if (pr.maintainer_can_modify) {
-    return null;
-  }
-
-  const isOrgFork = pr.head.repo.owner.type === 'Organization';
-  console.log(`Maintainer cannot modify PR branch (${isOrgFork ? 'org fork: ' + pr.head.repo.owner.login : 'user disabled'})`);
-  return { isOrgFork, orgName: pr.head.repo.owner.login };
-}
-
 // Strategy: Requirements detection
 async function detectRequirements(allLabels, prFiles, context) {
   const labels = new Set();
@@ -347,6 +329,5 @@ module.exports = {
   detectTests,
   detectPRTemplateCheckboxes,
   detectDeprecatedComponents,
-  detectMaintainerAccess,
   detectRequirements
 };

.github/scripts/auto-label-pr/index.js

@@ -12,10 +12,9 @@ const {
   detectTests,
   detectPRTemplateCheckboxes,
   detectDeprecatedComponents,
-  detectMaintainerAccess,
   detectRequirements
 } = require('./detectors');
-const { handleReviews, handleMaintainerAccessComment } = require('./reviews');
+const { handleReviews } = require('./reviews');
 const { applyLabels, removeOldLabels } = require('./labels');
 
 // Fetch API data
@@ -115,8 +114,7 @@ module.exports = async ({ github, context }) => {
     codeOwnerLabels,
     testLabels,
     checkboxLabels,
-    deprecatedResult,
-    maintainerAccess
+    deprecatedResult
   ] = await Promise.all([
     detectMergeBranch(context),
     detectComponentPlatforms(changedFiles, apiData),
@@ -129,8 +127,7 @@ module.exports = async ({ github, context }) => {
     detectCodeOwner(github, context, changedFiles),
     detectTests(changedFiles),
     detectPRTemplateCheckboxes(context),
-    detectDeprecatedComponents(github, context, changedFiles),
-    detectMaintainerAccess(context)
+    detectDeprecatedComponents(github, context, changedFiles)
   ]);
 
   // Extract deprecated component info
@@ -180,11 +177,8 @@ module.exports = async ({ github, context }) => {
 
   console.log('Computed labels:', finalLabels.join(', '));
 
-  // Handle reviews and org fork comment
-  await Promise.all([
-    handleReviews(github, context, finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, MAX_LABELS, TOO_BIG_THRESHOLD),
-    handleMaintainerAccessComment(github, context, maintainerAccess)
-  ]);
+  // Handle reviews
+  await handleReviews(github, context, finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, MAX_LABELS, TOO_BIG_THRESHOLD);
 
   // Apply labels
   await applyLabels(github, context, finalLabels);

.github/scripts/auto-label-pr/reviews.js

@@ -2,8 +2,7 @@ const {
   BOT_COMMENT_MARKER,
   CODEOWNERS_MARKER,
   TOO_BIG_MARKER,
-  DEPRECATED_COMPONENT_MARKER,
-  ORG_FORK_MARKER
+  DEPRECATED_COMPONENT_MARKER
 } = require('./constants');
 
 // Generate review messages
@@ -137,63 +136,6 @@ async function handleReviews(github, context, finalLabels, originalLabelCount, d
   }
 }
 
-// Handle maintainer access warning comment
-async function handleMaintainerAccessComment(github, context, maintainerAccess) {
-  if (!maintainerAccess) {
-    return;
-  }
-
-  const { owner, repo } = context.repo;
-  const pr_number = context.issue.number;
-  const prAuthor = context.payload.pull_request.user.login;
-
-  // Check if we already posted the warning (iterate pages to exit early)
-  let existingComment;
-  for await (const { data: comments } of github.paginate.iterator(
-    github.rest.issues.listComments,
-    { owner, repo, issue_number: pr_number }
-  )) {
-    existingComment = comments.find(comment =>
-      comment.user.type === 'Bot' &&
-      comment.body && comment.body.includes(ORG_FORK_MARKER)
-    );
-    if (existingComment) {
-      break;
-    }
-  }
-
-  if (existingComment) {
-    console.log('Maintainer access warning comment already exists, skipping');
-    return;
-  }
-
-  let body;
-  if (maintainerAccess.isOrgFork) {
-    body = `${ORG_FORK_MARKER}\n### ⚠️ Organization Fork Detected\n\n` +
-      `Hey there @${prAuthor},\n` +
-      `It looks like this PR was submitted from a fork owned by the **${maintainerAccess.orgName}** organization. ` +
-      `GitHub does not allow maintainers to push changes to pull request branches when the fork is owned by an organization. ` +
-      `This means we won't be able to make small adjustments or fixups to your PR directly.\n\n` +
-      `To allow maintainer collaboration, please re-submit this PR from a personal fork instead.\n\n` +
-      `See: [Setting up the local repository](https://developers.esphome.io/contributing/development-environment/?h=org#set-up-the-local-repository) for more details.`;
-  } else {
-    body = `${ORG_FORK_MARKER}\n### ⚠️ Maintainer Access Disabled\n\n` +
-      `Hey there @${prAuthor},\n` +
-      `It looks like this PR does not have the "Allow edits from maintainers" option enabled. ` +
-      `This means we won't be able to make small adjustments or fixups to your PR directly.\n\n` +
-      `Please enable this option in the PR sidebar to allow maintainer collaboration.`;
-  }
-
-  await github.rest.issues.createComment({
-    owner,
-    repo,
-    issue_number: pr_number,
-    body
-  });
-  console.log('Created maintainer access warning comment');
-}
-
 module.exports = {
-  handleReviews,
-  handleMaintainerAccessComment
+  handleReviews
 };

.github/workflows/ci.yml

@@ -339,7 +339,7 @@ jobs:
           echo "binary=$BINARY" >> $GITHUB_OUTPUT
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@db35df748deb45fdef0960669f57d627c1956c30 # v4
+        uses: CodSpeedHQ/action@d872884a306dd4853acf0f584f4b706cf0cc72a2 # v4
         with:
           run: ${{ steps.build.outputs.binary }}
           mode: simulation
@@ -868,8 +868,7 @@ jobs:
           python script/test_build_components.py \
             -e compile \
             -c "$component_list" \
-            -t "$platform" \
-            --base-only 2>&1 | \
+            -t "$platform" 2>&1 | \
             tee /dev/stderr | \
             python script/ci_memory_impact_extract.py \
               --output-env \
@@ -955,8 +954,7 @@ jobs:
           python script/test_build_components.py \
             -e compile \
             -c "$component_list" \
-            -t "$platform" \
-            --base-only 2>&1 | \
+            -t "$platform" 2>&1 | \
             tee /dev/stderr | \
             python script/ci_memory_impact_extract.py \
               --output-env \

.github/workflows/status-check-labels.yml

@@ -2,29 +2,30 @@ name: Status check labels
 
 on:
   pull_request:
-    types: [opened, reopened, labeled, unlabeled, synchronize]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
+    types: [labeled, unlabeled]
 
 jobs:
   check:
-    name: Check blocking labels
+    name: Check ${{ matrix.label }}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        label:
+          - needs-docs
+          - merge-after-release
+          - chained-pr
     steps:
-      - name: Check for blocking labels
+      - name: Check for ${{ matrix.label }} label
         uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
-            const blockingLabels = ['needs-docs', 'merge-after-release', 'chained-pr'];
             const { data: labels } = await github.rest.issues.listLabelsOnIssue({
               owner: context.repo.owner,
               repo: context.repo.repo,
               issue_number: context.issue.number
             });
-            const labelNames = labels.map(l => l.name);
-            const found = blockingLabels.filter(bl => labelNames.includes(bl));
-            if (found.length > 0) {
-              core.setFailed(`Pull request cannot be merged, it has blocking label(s): ${found.join(', ')}`);
+            const hasLabel = labels.find(label => label.name === '${{ matrix.label }}');
+            if (hasLabel) {
+              core.setFailed('Pull request cannot be merged, it is labeled as ${{ matrix.label }}');
             }

.pre-commit-config.yaml

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

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.5.0-dev
+PROJECT_NUMBER         = 2026.4.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/codegen.py

@@ -79,7 +79,6 @@ from esphome.cpp_types import (  # noqa: F401
     float_,
     global_ns,
     gpio_Flags,
-    int8,
     int16,
     int32,
     int64,

esphome/components/ade7953_base/ade7953_base.cpp

@@ -8,9 +8,6 @@ namespace ade7953_base {
 
 static const char *const TAG = "ade7953";
 
-constexpr uint16_t CONFIG_DEFAULT = 0x8004u;
-constexpr uint16_t CONFIG_LOCK_BIT = 0x8000u;
-
 static const float ADE_POWER_FACTOR = 154.0f;
 static const float ADE_WATTSEC_POWER_FACTOR = ADE_POWER_FACTOR * ADE_POWER_FACTOR / 3600;
 
@@ -21,12 +18,7 @@ void ADE7953::setup() {
 
   // The chip might take up to 100ms to initialise
   this->set_timeout(100, [this]() {
-    // Lock communication interface (SPI or I2C)
-    uint16_t config_v = CONFIG_DEFAULT;
-    this->ade_read_16(CONFIG_16, &config_v);
-    config_v &= static_cast<uint16_t>(~CONFIG_LOCK_BIT);  // Clear the lock bit
-    this->ade_write_16(CONFIG_16, config_v);
-    // Configure optimum settings according to datasheet
+    // this->ade_write_8(0x0010, 0x04);
     this->ade_write_8(0x00FE, 0xAD);
     this->ade_write_16(0x0120, 0x0030);
     // Set gains

esphome/components/ade7953_base/ade7953_base.h

@@ -9,35 +9,31 @@
 namespace esphome {
 namespace ade7953_base {
 
-static constexpr uint8_t PGA_V_8 =
+static const uint8_t PGA_V_8 =
     0x007;  // PGA_V,  (R/W) Default: 0x00, Unsigned, Voltage channel gain configuration (Bits[2:0])
-static constexpr uint8_t PGA_IA_8 =
+static const uint8_t PGA_IA_8 =
     0x008;  // PGA_IA, (R/W) Default: 0x00, Unsigned, Current Channel A gain configuration (Bits[2:0])
-static constexpr uint8_t PGA_IB_8 =
+static const uint8_t PGA_IB_8 =
     0x009;  // PGA_IB, (R/W) Default: 0x00, Unsigned, Current Channel B gain configuration (Bits[2:0])
 
-static constexpr uint16_t CONFIG_16 = 0x102;  // CONFIG, (R/W) Default: 0x8004, Unsigned, Configuration register
-
-static constexpr uint16_t AIGAIN_32 =
+static const uint32_t AIGAIN_32 =
     0x380;  // AIGAIN, (R/W)   Default: 0x400000, Unsigned,Current channel gain (Current Channel A)(32 bit)
-static constexpr uint16_t AVGAIN_32 =
-    0x381;  // AVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
-static constexpr uint16_t AWGAIN_32 =
+static const uint32_t AVGAIN_32 = 0x381;  // AVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
+static const uint32_t AWGAIN_32 =
     0x382;  // AWGAIN, (R/W)   Default: 0x400000, Unsigned,Active power gain (Current Channel A)(32 bit)
-static constexpr uint16_t AVARGAIN_32 =
+static const uint32_t AVARGAIN_32 =
     0x383;  // AVARGAIN, (R/W) Default: 0x400000, Unsigned, Reactive power gain (Current Channel A)(32 bit)
-static constexpr uint16_t AVAGAIN_32 =
+static const uint32_t AVAGAIN_32 =
     0x384;  // AVAGAIN, (R/W)  Default: 0x400000, Unsigned,Apparent power gain (Current Channel A)(32 bit)
 
-static constexpr uint16_t BIGAIN_32 =
+static const uint32_t BIGAIN_32 =
     0x38C;  // BIGAIN, (R/W)   Default: 0x400000, Unsigned,Current channel gain (Current Channel B)(32 bit)
-static constexpr uint16_t BVGAIN_32 =
-    0x38D;  // BVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
-static constexpr uint16_t BWGAIN_32 =
+static const uint32_t BVGAIN_32 = 0x38D;  // BVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
+static const uint32_t BWGAIN_32 =
     0x38E;  // BWGAIN, (R/W)   Default: 0x400000, Unsigned,Active power gain (Current Channel B)(32 bit)
-static constexpr uint16_t BVARGAIN_32 =
+static const uint32_t BVARGAIN_32 =
     0x38F;  // BVARGAIN, (R/W) Default: 0x400000, Unsigned, Reactive power gain (Current Channel B)(32 bit)
-static constexpr uint16_t BVAGAIN_32 =
+static const uint32_t BVAGAIN_32 =
     0x390;  // BVAGAIN, (R/W)  Default: 0x400000, Unsigned,Apparent power gain (Current Channel B)(32 bit)
 
 class ADE7953 : public PollingComponent, public sensor::Sensor {

esphome/components/ade7953_spi/ade7953_spi.cpp

@@ -7,9 +7,6 @@ namespace ade7953_spi {
 
 static const char *const TAG = "ade7953";
 
-// Datasheet requires at least 1.2µs after clearing CONFIG LOCK_BIT before raising CS
-constexpr uint8_t CONFIG_LOCK_SETTLE_US = 2;
-
 void AdE7953Spi::setup() {
   this->spi_setup();
   ade7953_base::ADE7953::setup();
@@ -35,9 +32,6 @@ bool AdE7953Spi::ade_write_16(uint16_t reg, uint16_t value) {
   this->write_byte16(reg);
   this->transfer_byte(0);
   this->write_byte16(value);
-  if (reg == ade7953_base::CONFIG_16) {
-    delayMicroseconds(CONFIG_LOCK_SETTLE_US);
-  }
   this->disable();
   return false;
 }

esphome/components/ade7953_spi/ade7953_spi.h

@@ -12,7 +12,7 @@ namespace esphome {
 namespace ade7953_spi {
 
 class AdE7953Spi : public ade7953_base::ADE7953,
-                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH, spi::CLOCK_PHASE_TRAILING,
+                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH, spi::CLOCK_PHASE_LEADING,
                                          spi::DATA_RATE_1MHZ> {
  public:
   void setup() override;

esphome/components/ags10/sensor.py

@@ -97,7 +97,7 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
 async def ags10newi2caddress_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    address = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
+    address = await cg.templatable(config[CONF_ADDRESS], args, cg.int32)
     cg.add(var.set_new_address(address))
     return var
 

esphome/components/aic3204/audio_dac.py

@@ -43,7 +43,7 @@ async def aic3204_set_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config.get(CONF_MODE), args, cg.uint8)
+    template_ = await cg.templatable(config.get(CONF_MODE), args, cg.int32)
     cg.add(var.set_auto_mute_mode(template_))
 
     return var

esphome/components/analog_threshold/binary_sensor.py

@@ -40,10 +40,10 @@ async def to_code(config):
     cg.add(var.set_sensor(sens))
 
     if isinstance(config[CONF_THRESHOLD], dict):
-        lower = await cg.templatable(config[CONF_THRESHOLD][CONF_LOWER], [], cg.float_)
-        upper = await cg.templatable(config[CONF_THRESHOLD][CONF_UPPER], [], cg.float_)
+        lower = await cg.templatable(config[CONF_THRESHOLD][CONF_LOWER], [], float)
+        upper = await cg.templatable(config[CONF_THRESHOLD][CONF_UPPER], [], float)
     else:
-        lower = await cg.templatable(config[CONF_THRESHOLD], [], cg.float_)
+        lower = await cg.templatable(config[CONF_THRESHOLD], [], float)
         upper = lower
     cg.add(var.set_upper_threshold(upper))
     cg.add(var.set_lower_threshold(lower))

esphome/components/api/api.proto

@@ -1625,7 +1625,6 @@ message BluetoothLEAdvertisementResponse {
 }
 
 message BluetoothLERawAdvertisement {
-  option (inline_encode) = true;
   uint64 address = 1 [(force) = true];
   sint32 rssi = 2 [(force) = true];
   uint32 address_type = 3 [(max_value) = 4];

esphome/components/api/api_connection.cpp

@@ -52,11 +52,11 @@
 
 namespace esphome::api {
 
-// Maximum messages to read per loop iteration to prevent starving other components.
+// Read a maximum of 5 messages per loop iteration to prevent starving other components.
 // This is a balance between API responsiveness and allowing other components to run.
 // Since each message could contain multiple protobuf messages when using packet batching,
 // this limits the number of messages processed, not the number of TCP packets.
-static constexpr uint8_t MAX_MESSAGES_PER_LOOP = 10;
+static constexpr uint8_t MAX_MESSAGES_PER_LOOP = 5;
 static constexpr uint8_t MAX_PING_RETRIES = 60;
 static constexpr uint16_t PING_RETRY_INTERVAL = 1000;
 static constexpr uint32_t KEEPALIVE_DISCONNECT_TIMEOUT = (KEEPALIVE_TIMEOUT_MS * 5) / 2;
@@ -220,17 +220,10 @@ void APIConnection::loop() {
   }
 
   const uint32_t now = App.get_loop_component_start_time();
-  // Check if socket has data ready before attempting to read.
-  // Also try reading if we hit the message limit last time — LWIP's rcvevent
-  // (used by is_socket_ready) tracks pbuf dequeues, not bytes. When multiple
-  // messages share a TCP segment, the last message's data stays in LWIP's
-  // lastdata cache after rcvevent hits 0, making is_socket_ready() return false
-  // even though data remains.
-  if (this->helper_->is_socket_ready() || this->flags_.may_have_remaining_data) {
-    this->flags_.may_have_remaining_data = false;
+  // Check if socket has data ready before attempting to read
+  if (this->helper_->is_socket_ready()) {
     // Read up to MAX_MESSAGES_PER_LOOP messages per loop to improve throughput
-    uint8_t message_count = 0;
-    for (; message_count < MAX_MESSAGES_PER_LOOP; message_count++) {
+    for (uint8_t message_count = 0; message_count < MAX_MESSAGES_PER_LOOP; message_count++) {
       ReadPacketBuffer buffer;
       err = this->helper_->read_packet(&buffer);
       if (err == APIError::WOULD_BLOCK) {
@@ -252,11 +245,6 @@ void APIConnection::loop() {
           return;
       }
     }
-    // If we hit the limit, there may be more data remaining in LWIP's
-    // lastdata cache that rcvevent doesn't account for.
-    if (message_count == MAX_MESSAGES_PER_LOOP) {
-      this->flags_.may_have_remaining_data = true;
-    }
   }
 
   // Process deferred batch if scheduled and timer has expired
@@ -327,8 +315,6 @@ void APIConnection::process_active_iterator_() {
       this->destroy_active_iterator_();
       if (this->flags_.state_subscription) {
         this->begin_iterator_(ActiveIterator::INITIAL_STATE);
-      } else {
-        this->finalize_iterator_sync_();
       }
     } else {
       this->process_iterator_batch_(this->iterator_storage_.list_entities);
@@ -336,27 +322,21 @@ void APIConnection::process_active_iterator_() {
   } else {  // INITIAL_STATE
     if (this->iterator_storage_.initial_state.completed()) {
       this->destroy_active_iterator_();
-      this->finalize_iterator_sync_();
+      // Process any remaining batched messages immediately
+      if (!this->deferred_batch_.empty()) {
+        this->process_batch_();
+      }
+      // Now that everything is sent, enable immediate sending for future state changes
+      this->flags_.should_try_send_immediately = true;
+      // Release excess memory from buffers that grew during initial sync
+      this->deferred_batch_.release_buffer();
+      this->helper_->release_buffers();
     } else {
       this->process_iterator_batch_(this->iterator_storage_.initial_state);
     }
   }
 }
 
-void APIConnection::finalize_iterator_sync_() {
-  // Flush any remaining batched messages immediately so clients
-  // receive completion responses (e.g. ListEntitiesDoneResponse)
-  // without waiting for the batch timer.
-  if (!this->deferred_batch_.empty()) {
-    this->process_batch_();
-  }
-  // Enable immediate sending for future state changes
-  this->flags_.should_try_send_immediately = true;
-  // Release excess memory from buffers that grew during initial sync
-  this->deferred_batch_.release_buffer();
-  this->helper_->release_buffers();
-}
-
 void APIConnection::process_iterator_batch_(ComponentIterator &iterator) {
   size_t initial_size = this->deferred_batch_.size();
   size_t max_batch = this->get_max_batch_size_();
@@ -426,7 +406,7 @@ uint16_t APIConnection::fill_and_encode_entity_info(EntityBase *entity, InfoResp
 #ifdef USE_DEVICES
   msg.device_id = entity->get_device_id();
 #endif
-  return encode_to_buffer_slow(size_fn(&msg), encode_fn, &msg, conn, remaining_size);
+  return encode_to_buffer(size_fn(&msg), encode_fn, &msg, conn, remaining_size);
 }
 
 uint16_t APIConnection::fill_and_encode_entity_info_with_device_class(EntityBase *entity, InfoResponseProtoMessage &msg,
@@ -2025,12 +2005,48 @@ bool APIConnection::send_message_(uint32_t payload_size, uint8_t message_type, M
   encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
   return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
 }
-// encode_to_buffer is defined inline in api_connection.h (ESPHOME_ALWAYS_INLINE)
+// Encodes a message to the buffer and returns the total number of bytes used,
+// including header and footer overhead. Returns 0 if the message doesn't fit.
+uint16_t APIConnection::encode_to_buffer(uint32_t calculated_size, MessageEncodeFn encode_fn, const void *msg,
+                                         APIConnection *conn, uint32_t remaining_size) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  if (conn->flags_.log_only_mode) {
+    auto *proto_msg = static_cast<const ProtoMessage *>(msg);
+    DumpBuffer dump_buf;
+    conn->log_send_message_(proto_msg->message_name(), proto_msg->dump_to(dump_buf));
+    return 1;
+  }
+#endif
+  // Cache frame sizes to avoid repeated virtual calls
+  const uint8_t header_padding = conn->helper_->frame_header_padding();
+  const uint8_t footer_size = conn->helper_->frame_footer_size();
 
-// Noinline version for cold paths — single shared copy
-uint16_t APIConnection::encode_to_buffer_slow(uint32_t calculated_size, MessageEncodeFn encode_fn, const void *msg,
-                                              APIConnection *conn, uint32_t remaining_size) {
-  return encode_to_buffer(calculated_size, encode_fn, msg, conn, remaining_size);
+  // Calculate total size with padding for buffer allocation
+  size_t total_calculated_size = calculated_size + header_padding + footer_size;
+
+  // Check if it fits
+  if (total_calculated_size > remaining_size)
+    return 0;  // Doesn't fit
+
+  auto &shared_buf = conn->parent_->get_shared_buffer_ref();
+
+  size_t to_add;
+  if (conn->flags_.batch_first_message) {
+    // First message - buffer already prepared by caller, just clear flag
+    conn->flags_.batch_first_message = false;
+    to_add = calculated_size;
+  } else {
+    // Batch message second or later
+    // Reserve for full message, resize to include footer gap + header padding + payload
+    to_add = total_calculated_size;
+  }
+
+  shared_buf.resize(shared_buf.size() + to_add);
+  ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
+  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+
+  // Return total size (header + payload + footer)
+  return static_cast<uint16_t>(total_calculated_size);
 }
 bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
   const bool is_log_message = (message_type == SubscribeLogsResponse::MESSAGE_TYPE);
@@ -2098,13 +2114,6 @@ void APIConnection::process_batch_() {
     return;
   }
 
-  // Ensure TCP_NODELAY is on before draining overflow and writing batch data.
-  // Log messages enable Nagle (NODELAY off) to coalesce small packets.
-  // If Nagle is still on when we try to drain, LWIP holds data in the
-  // Nagle buffer, the TCP send buffer stays full, and the overflow
-  // buffer can never drain — blocking the batch write indefinitely.
-  this->helper_->set_nodelay_for_message(false);
-
   // Try to clear buffer first
   if (!this->try_to_clear_buffer(true)) {
     // Can't write now, we'll try again later
@@ -2164,15 +2173,17 @@ void APIConnection::process_batch_multi_(APIBuffer &shared_buf, size_t num_items
                 "MessageInfo must remain trivially destructible with this placement-new approach");
 
   const size_t messages_to_process = std::min(num_items, MAX_MESSAGES_PER_BATCH);
+  const uint8_t frame_overhead = header_padding + footer_size;
 
   // Stack-allocated array for message info
   alignas(MessageInfo) char message_info_storage[MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo)];
   MessageInfo *message_info = reinterpret_cast<MessageInfo *>(message_info_storage);
   size_t items_processed = 0;
   uint16_t remaining_size = std::numeric_limits<uint16_t>::max();
-  // Track where each message's header begins in the buffer
-  // First message: offset 0 (max padding, may have unused leading bytes)
-  // Subsequent messages: offset points to exact header start (no gaps)
+  // Track where each message's header padding begins in the buffer
+  // For plaintext: this is where the 6-byte header padding starts
+  // For noise: this is where the 7-byte header padding starts
+  // The actual message data follows after the header padding
   uint32_t current_offset = 0;
 
   // Process items and encode directly to buffer (up to our limit)
@@ -2188,14 +2199,13 @@ void APIConnection::process_batch_multi_(APIBuffer &shared_buf, size_t num_items
     }
 
     // Message was encoded successfully
-    // payload_size = header_size + proto_payload_size + footer_size
-    uint16_t proto_payload_size = payload_size - this->batch_header_size_ - footer_size;
+    // payload_size is header_padding + actual payload size + footer_size
+    uint16_t proto_payload_size = payload_size - frame_overhead;
     // Use placement new to construct MessageInfo in pre-allocated stack array
     // This avoids default-constructing all MAX_MESSAGES_PER_BATCH elements
     // Explicit destruction is not needed because MessageInfo is trivially destructible,
     // as ensured by the static_assert in its definition.
-    new (&message_info[items_processed++])
-        MessageInfo(item.message_type, current_offset, proto_payload_size, this->batch_header_size_);
+    new (&message_info[items_processed++]) MessageInfo(item.message_type, current_offset, proto_payload_size);
     // After first message, set remaining size to MAX_BATCH_PACKET_SIZE to avoid fragmentation
     if (items_processed == 1) {
       remaining_size = MAX_BATCH_PACKET_SIZE;
@@ -2245,7 +2255,6 @@ void APIConnection::process_batch_multi_(APIBuffer &shared_buf, size_t num_items
 uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size,
                                           bool batch_first) {
   this->flags_.batch_first_message = batch_first;
-  this->batch_message_type_ = item.message_type;
 #ifdef USE_EVENT
   // Events need aux_data_index to look up event type from entity
   if (item.message_type == EventResponse::MESSAGE_TYPE) {

esphome/components/api/api_connection.h

@@ -276,7 +276,6 @@ class APIConnection final : public APIServerConnectionBase {
       App.schedule_dump_config();
 #ifdef USE_ESP32_CRASH_HANDLER
     esp32::crash_handler_log();
-    esp32::crash_handler_clear();
 #endif
 #ifdef USE_RP2040_CRASH_HANDLER
     rp2040::crash_handler_log();
@@ -411,59 +410,16 @@ class APIConnection final : public APIServerConnectionBase {
   // Non-template buffer management for send_message
   bool send_message_(uint32_t payload_size, uint8_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
-  // Core batch encoding logic. Computes header size, checks fit, resizes buffer, encodes.
-  // ALWAYS_INLINE so the compiler can devirtualize encode_fn at hot call sites.
-  static inline uint16_t ESPHOME_ALWAYS_INLINE encode_to_buffer(uint32_t calculated_size, MessageEncodeFn encode_fn,
-                                                                const void *msg, APIConnection *conn,
-                                                                uint32_t remaining_size) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-    if (conn->flags_.log_only_mode) {
-      auto *proto_msg = static_cast<const ProtoMessage *>(msg);
-      DumpBuffer dump_buf;
-      conn->log_send_message_(proto_msg->message_name(), proto_msg->dump_to(dump_buf));
-      return 1;
-    }
-#endif
-    const uint8_t footer_size = conn->helper_->frame_footer_size();
+  // Non-template buffer management for batch encoding
+  static uint16_t encode_to_buffer(uint32_t calculated_size, MessageEncodeFn encode_fn, const void *msg,
+                                   APIConnection *conn, uint32_t remaining_size);
 
-    // First message uses max padding (already in buffer), subsequent use exact header size
-    size_t to_add;
-    if (conn->flags_.batch_first_message) {
-      conn->flags_.batch_first_message = false;
-      conn->batch_header_size_ = conn->helper_->frame_header_padding();
-      to_add = calculated_size;
-    } else {
-      conn->batch_header_size_ = conn->helper_->frame_header_size(calculated_size, conn->batch_message_type_);
-      to_add = calculated_size + conn->batch_header_size_ + footer_size;
-    }
-
-    // Check if it fits (using actual header size, not max padding)
-    uint16_t total_calculated_size = calculated_size + conn->batch_header_size_ + footer_size;
-    if (total_calculated_size > remaining_size)
-      return 0;
-
-    auto &shared_buf = conn->parent_->get_shared_buffer_ref();
-    shared_buf.resize(shared_buf.size() + to_add);
-    ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
-    encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
-
-    return total_calculated_size;
-  }
-
-  // Noinline version of encode_to_buffer for cold paths (entity info, zero-payload messages).
-  // All cold callers share this single copy instead of each getting an ALWAYS_INLINE expansion.
-  static uint16_t encode_to_buffer_slow(uint32_t calculated_size, MessageEncodeFn encode_fn, const void *msg,
-                                        APIConnection *conn, uint32_t remaining_size);
-
-  // Thin template wrapper — uses noinline encode_to_buffer_slow since
-  // encode_message_to_buffer callers are cold paths (zero-payload control messages).
-  // Hot paths (state/info) go through fill_and_encode_entity_state/info instead.
-  // batch_message_type_ is already set by dispatch_message_ before reaching here.
+  // Thin template wrapper — computes size, delegates buffer work to non-template helper
   template<typename T> static uint16_t encode_message_to_buffer(T &msg, APIConnection *conn, uint32_t remaining_size) {
     if constexpr (T::ESTIMATED_SIZE == 0) {
-      return encode_to_buffer_slow(0, &encode_msg_noop, &msg, conn, remaining_size);
+      return encode_to_buffer(0, &encode_msg_noop, &msg, conn, remaining_size);
     } else {
-      return encode_to_buffer_slow(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
+      return encode_to_buffer(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
     }
   }
 
@@ -662,7 +618,6 @@ class APIConnection final : public APIServerConnectionBase {
   // Helper methods for iterator lifecycle management
   void destroy_active_iterator_();
   void begin_iterator_(ActiveIterator type);
-  void finalize_iterator_sync_();
 #ifdef USE_CAMERA
   std::unique_ptr<camera::CameraImageReader> image_reader_;
 #endif
@@ -771,7 +726,6 @@ class APIConnection final : public APIServerConnectionBase {
     uint8_t batch_scheduled : 1;
     uint8_t batch_first_message : 1;          // For batch buffer allocation
     uint8_t should_try_send_immediately : 1;  // True after initial states are sent
-    uint8_t may_have_remaining_data : 1;      // Read loop hit limit, retry without ready check
 #ifdef HAS_PROTO_MESSAGE_DUMP
     uint8_t log_only_mode : 1;
 #endif
@@ -780,14 +734,9 @@ class APIConnection final : public APIServerConnectionBase {
   // 2-byte types immediately after flags_ (no padding between them)
   uint16_t client_api_version_major_{0};
   uint16_t client_api_version_minor_{0};
-  // 1-byte types to fill remaining space before next 4-byte boundary
+  // 1-byte type to fill padding
   ActiveIterator active_iterator_{ActiveIterator::NONE};
-  uint8_t batch_message_type_{0};  // Current message type during batch encoding
-  // Total: 2 (flags) + 2 + 2 + 1 + 1 = 8 bytes, aligned to 4-byte boundary
-
-  // Actual header size used by encode_to_buffer for the current message.
-  // Read by process_batch_multi_ to pass into MessageInfo.
-  uint8_t batch_header_size_{0};
+  // Total: 2 (flags) + 2 + 2 + 1 = 7 bytes, then 1 byte padding to next 4-byte boundary
 
   uint32_t get_batch_delay_ms_() const { return this->parent_->get_batch_delay(); }
   // Message will use 8 more bytes than the minimum size, and typical

esphome/components/api/api_frame_helper.cpp

@@ -100,17 +100,10 @@ const LogString *api_error_to_logstr(APIError err) {
   return LOG_STR("UNKNOWN");
 }
 
-#ifdef HELPER_LOG_PACKETS
-void APIFrameHelper::log_packet_sending_(const void *data, uint16_t len) {
-  LOG_PACKET_SENDING(reinterpret_cast<const uint8_t *>(data), len);
-}
-#endif
-
 APIError APIFrameHelper::drain_overflow_and_handle_errors_() {
   if (this->overflow_buf_.try_drain(this->socket_.get()) == -1) {
     int err = errno;
-    if (err != EWOULDBLOCK && err != EAGAIN) {
-      this->state_ = State::FAILED;
+    if (this->check_socket_write_err_(err) != APIError::WOULD_BLOCK) {
       HELPER_LOG("Socket write failed with errno %d", err);
       return APIError::SOCKET_WRITE_FAILED;
     }
@@ -118,58 +111,45 @@ APIError APIFrameHelper::drain_overflow_and_handle_errors_() {
   return APIError::OK;
 }
 
-// Single-buffer write path: wraps in iovec and delegates.
-APIError APIFrameHelper::write_raw_buf_(const void *data, uint16_t len, ssize_t sent) {
-  struct iovec iov = {const_cast<void *>(data), len};
-  APIError err = this->write_raw_iov_(&iov, 1, len, sent);
+// Write data to socket, overflow to backlog buffer if LWIP TCP send buffer is full.
+// Returns OK if all data was sent or successfully queued.
+// Returns SOCKET_WRITE_FAILED on hard error (sets state to FAILED).
+APIError APIFrameHelper::write_raw_(const struct iovec *iov, int iovcnt, uint16_t total_write_len) {
 #ifdef HELPER_LOG_PACKETS
-  // Log after write/enqueue so re-entrant log sends can't corrupt data before it's sent
-  if (err == APIError::OK)
-    LOG_PACKET_SENDING(reinterpret_cast<const uint8_t *>(data), len);
+  for (int i = 0; i < iovcnt; i++) {
+    LOG_PACKET_SENDING(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len);
+  }
 #endif
-  return err;
-}
 
-// Handles partial writes, errors, and overflow buffering.
-// Called when the inline fast path couldn't complete the write,
-// or directly from cold paths (handshake, error handling).
-APIError APIFrameHelper::write_raw_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len, ssize_t sent) {
-  if (sent <= 0) {
-    if (sent == WRITE_NOT_ATTEMPTED) {
-      // Cold path: no write attempted yet, drain overflow and try
-      if (!this->overflow_buf_.empty()) {
-        APIError err = this->drain_overflow_and_handle_errors_();
-        if (err != APIError::OK)
-          return err;
-      }
-      if (this->overflow_buf_.empty()) {
-        sent = this->write_iov_to_socket_(iov, iovcnt);
-        if (sent == static_cast<ssize_t>(total_write_len))
-          return APIError::OK;
-        // Partial write or -1: fall through to error check / enqueue below
-      } else {
-        // Overflow backlog remains after drain; skip socket write, enqueue everything
-        sent = 0;
-      }
-    }
-    // WRITE_FAILED (-1): fast path or retry write returned -1, check errno
-    if (sent == WRITE_FAILED) {
+  uint16_t skip = 0;
+
+  // Drain any existing backlog first
+  if (!this->overflow_buf_.empty()) [[unlikely]] {
+    APIError err = this->drain_overflow_and_handle_errors_();
+    if (err != APIError::OK)
+      return err;
+  }
+
+  // If backlog is clear, try direct send
+  if (this->overflow_buf_.empty()) [[likely]] {
+    ssize_t sent =
+        (iovcnt == 1) ? this->socket_->write(iov[0].iov_base, iov[0].iov_len) : this->socket_->writev(iov, iovcnt);
+
+    if (sent == -1) [[unlikely]] {
       int err = errno;
-      if (err != EWOULDBLOCK && err != EAGAIN) {
-        this->state_ = State::FAILED;
+      if (this->check_socket_write_err_(err) != APIError::WOULD_BLOCK) {
         HELPER_LOG("Socket write failed with errno %d", err);
         return APIError::SOCKET_WRITE_FAILED;
       }
-      sent = 0;  // Treat WOULD_BLOCK as zero bytes sent
+    } else if (static_cast<uint16_t>(sent) >= total_write_len) [[likely]] {
+      return APIError::OK;
+    } else {
+      skip = static_cast<uint16_t>(sent);
     }
   }
 
-  // Full write completed (possible when called directly, not via write_raw_fast_buf_)
-  if (sent == static_cast<ssize_t>(total_write_len))
-    return APIError::OK;
-
   // Queue unsent data into overflow buffer
-  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, static_cast<uint16_t>(sent))) {
+  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, skip)) {
     HELPER_LOG("Overflow buffer full, dropping connection");
     this->state_ = State::FAILED;
     return APIError::SOCKET_WRITE_FAILED;

esphome/components/api/api_frame_helper.h

@@ -49,17 +49,12 @@ struct ReadPacketBuffer {
 };
 
 // Packed message info structure to minimize memory usage
-// Note: message_type is uint8_t — all current protobuf message types fit in 8 bits.
-// The noise wire format encodes types as 16-bit, but the high byte is always 0.
-// If message types ever exceed 255, this and encrypt_noise_message_ must be updated.
 struct MessageInfo {
   uint16_t offset;        // Offset in buffer where message starts
   uint16_t payload_size;  // Size of the message payload
   uint8_t message_type;   // Message type (0-255)
-  uint8_t header_size;    // Actual header size used (avoids recomputation in write path)
 
-  MessageInfo(uint8_t type, uint16_t off, uint16_t size, uint8_t hdr)
-      : offset(off), payload_size(size), message_type(type), header_size(hdr) {}
+  MessageInfo(uint8_t type, uint16_t off, uint16_t size) : offset(off), payload_size(size), message_type(type) {}
 };
 
 enum class APIError : uint16_t {
@@ -166,39 +161,23 @@ class APIFrameHelper {
       this->nodelay_counter_ = 0;
     }
   }
-  // Write a single protobuf message - the hot path (87-100% of all writes).
-  // Caller must ensure state is DATA before calling.
-  virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
-  // Write multiple protobuf messages in a single batched operation.
-  // Caller must ensure state is DATA and messages is not empty.
-  // messages contains (message_type, offset, length) for each message in the buffer.
-  // The buffer contains all messages with appropriate padding before each.
-  virtual APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) = 0;
-  // Get the maximum frame header padding required by this protocol (worst case)
-  uint8_t frame_header_padding() const { return frame_header_padding_; }
-  // Get the actual frame header size for a specific message.
-  // For noise: always returns frame_header_padding_ (fixed 7-byte header).
-  // For plaintext: computes actual size from varint lengths (3-6 bytes).
-  // Distinguishes protocols via frame_footer_size_ (noise always has a non-zero MAC
-  // footer, plaintext has footer=0). If a protocol with a plaintext footer is ever
-  // added, this should become a virtual method.
-  uint8_t frame_header_size(uint16_t payload_size, uint8_t message_type) const {
-#if defined(USE_API_NOISE) && defined(USE_API_PLAINTEXT)
-    return this->frame_footer_size_
-               ? this->frame_header_padding_
-               : static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
-#elif defined(USE_API_NOISE)
-    return this->frame_header_padding_;
-#else  // USE_API_PLAINTEXT only
-    return static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
-#endif
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
+    // Resize buffer to include footer space if needed (e.g. Noise MAC)
+    if (frame_footer_size_)
+      buffer.get_buffer()->resize(buffer.get_buffer()->size() + frame_footer_size_);
+    MessageInfo msg{type, 0,
+                    static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_ - frame_footer_size_)};
+    return write_protobuf_messages(buffer, std::span<const MessageInfo>(&msg, 1));
   }
+  // Write multiple protobuf messages in a single operation
+  // messages contains (message_type, offset, length) for each message in the buffer
+  // The buffer contains all messages with appropriate padding before each
+  virtual APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) = 0;
+  // Get the frame header padding required by this protocol
+  uint8_t frame_header_padding() const { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
   uint8_t frame_footer_size() const { return frame_footer_size_; }
-  // Check if socket has buffered data ready to read.
-  // Contract: callers must read until it would block (EAGAIN/EWOULDBLOCK)
-  // or track that they stopped early and retry without this check.
-  // See Socket::ready() for details.
+  // Check if socket has data ready to read
   bool is_socket_ready() const { return socket_ != nullptr && socket_->ready(); }
   // Release excess memory from internal buffers after initial sync
   void release_buffers() {
@@ -217,41 +196,18 @@ class APIFrameHelper {
   // Returns OK for transient errors (WOULD_BLOCK), SOCKET_WRITE_FAILED for hard errors.
   APIError drain_overflow_and_handle_errors_();
 
-  // Sentinel values for the sent parameter in write_raw_ methods
-  static constexpr ssize_t WRITE_FAILED = -1;         // Fast path: write()/writev() returned -1
-  static constexpr ssize_t WRITE_NOT_ATTEMPTED = -2;  // Cold path: no write attempted yet
+  // Common implementation for writing raw data to socket
+  APIError write_raw_(const struct iovec *iov, int iovcnt, uint16_t total_write_len);
 
-  // Dispatch to write() or writev() based on iovec count
-  inline ssize_t ESPHOME_ALWAYS_INLINE write_iov_to_socket_(const struct iovec *iov, int iovcnt) {
-    return (iovcnt == 1) ? this->socket_->write(iov[0].iov_base, iov[0].iov_len) : this->socket_->writev(iov, iovcnt);
+  // Check if a socket write errno is a hard error (not WOULD_BLOCK/EAGAIN).
+  // Returns WOULD_BLOCK for transient errors, SOCKET_WRITE_FAILED for hard errors.
+  APIError check_socket_write_err_(int err) {
+    if (err == EWOULDBLOCK || err == EAGAIN)
+      return APIError::WOULD_BLOCK;
+    this->state_ = State::FAILED;
+    return APIError::SOCKET_WRITE_FAILED;
   }
 
-  // Inlined write methods — used by hot paths (write_protobuf_packet, write_protobuf_messages)
-  // These inline the fast path (overflow empty + full write) and tail-call the out-of-line
-  // slow path only on failure/partial write.
-  inline APIError ESPHOME_ALWAYS_INLINE write_raw_fast_buf_(const void *data, uint16_t len) {
-    if (this->overflow_buf_.empty()) [[likely]] {
-      ssize_t sent = this->socket_->write(data, len);
-      if (sent == static_cast<ssize_t>(len)) [[likely]] {
-#ifdef HELPER_LOG_PACKETS
-        this->log_packet_sending_(data, len);
-#endif
-        return APIError::OK;
-      }
-      // sent is -1 (WRITE_FAILED) or partial write count
-      return this->write_raw_buf_(data, len, sent);
-    }
-    return this->write_raw_buf_(data, len, WRITE_NOT_ATTEMPTED);
-  }
-  // Out-of-line write paths: handle partial writes, errors, overflow buffering
-  // sent: WRITE_NOT_ATTEMPTED (cold path), WRITE_FAILED (fast path write returned -1), or bytes sent (partial write)
-  APIError write_raw_buf_(const void *data, uint16_t len, ssize_t sent = WRITE_NOT_ATTEMPTED);
-  APIError write_raw_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len,
-                          ssize_t sent = WRITE_NOT_ATTEMPTED);
-#ifdef HELPER_LOG_PACKETS
-  void log_packet_sending_(const void *data, uint16_t len);
-#endif
-
   // Socket ownership (4 bytes on 32-bit, 8 bytes on 64-bit)
   std::unique_ptr<socket::Socket> socket_;
 

esphome/components/api/api_frame_helper_noise.cpp

@@ -47,8 +47,15 @@ static constexpr size_t API_MAX_LOG_BYTES = 168;
               format_hex_pretty_to(hex_buf_, (buffer).data(), \
                                    (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
   } while (0)
+#define LOG_PACKET_SENDING(data, len) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Sending raw: %s", \
+              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
+  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
+#define LOG_PACKET_SENDING(data, len) ((void) 0)
 #endif
 
 /// Convert a noise error code to a readable error
@@ -457,83 +464,65 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   buffer->type = type;
   return APIError::OK;
 }
-// Encrypt a single noise message in place and return the encrypted frame length.
-// Returns APIError::OK on success.
-APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
-                                                     uint16_t &encrypted_len_out) {
-  // Write noise header
-  buf_start[0] = 0x01;  // indicator
-  // buf_start[1], buf_start[2] to be set after encryption
-
-  // Write message header (to be encrypted)
-  constexpr uint8_t msg_offset = 3;
-  buf_start[msg_offset] = static_cast<uint8_t>(message_type >> 8);      // type high byte
-  buf_start[msg_offset + 1] = static_cast<uint8_t>(message_type);       // type low byte
-  buf_start[msg_offset + 2] = static_cast<uint8_t>(payload_size >> 8);  // data_len high byte
-  buf_start[msg_offset + 3] = static_cast<uint8_t>(payload_size);       // data_len low byte
-  // payload data is already in the buffer starting at offset + 7
-
-  // Encrypt the message in place
-  NoiseBuffer mbuf;
-  noise_buffer_init(mbuf);
-  noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + payload_size, 4 + payload_size + this->frame_footer_size_);
-
-  int err = noise_cipherstate_encrypt(this->send_cipher_, &mbuf);
-  APIError aerr =
-      this->handle_noise_error_(err, LOG_STR("noise_cipherstate_encrypt"), APIError::CIPHERSTATE_ENCRYPT_FAILED);
-  if (aerr != APIError::OK)
-    return aerr;
-
-  // Fill in the encrypted size
-  buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
-  buf_start[2] = static_cast<uint8_t>(mbuf.size);
-
-  encrypted_len_out = static_cast<uint16_t>(3 + mbuf.size);  // indicator + size + encrypted data
-  return APIError::OK;
-}
-
-APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
-#ifdef ESPHOME_DEBUG_API
-  assert(this->state_ == State::DATA);
-#endif
-
-  // Resize buffer to include footer space for Noise MAC
-  if (this->frame_footer_size_)
-    buffer.get_buffer()->resize(buffer.get_buffer()->size() + this->frame_footer_size_);
-
-  uint16_t payload_size =
-      static_cast<uint16_t>(buffer.get_buffer()->size() - HEADER_PADDING - this->frame_footer_size_);
-  uint8_t *buf_start = buffer.get_buffer()->data();
-  uint16_t encrypted_len;
-  APIError aerr = this->encrypt_noise_message_(buf_start, payload_size, type, encrypted_len);
-  if (aerr != APIError::OK)
-    return aerr;
-  return this->write_raw_fast_buf_(buf_start, encrypted_len);
-}
-
 APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) {
-#ifdef ESPHOME_DEBUG_API
-  assert(this->state_ == State::DATA);
-  assert(!messages.empty());
-#endif
+  APIError aerr = this->check_data_state_();
+  if (aerr != APIError::OK)
+    return aerr;
 
-  // Noise messages are already contiguous in the buffer:
-  // HEADER_PADDING (7) exactly matches the fixed header size, and
-  // footer space (16) is consumed by the encryption MAC.
-  uint8_t *buffer_data = buffer.get_buffer()->data();
-  uint8_t *write_start = buffer_data + messages[0].offset;
-  uint16_t total_write_len = 0;
-
-  for (const auto &msg : messages) {
-    uint8_t *buf_start = buffer_data + msg.offset;
-    uint16_t encrypted_len;
-    APIError aerr = this->encrypt_noise_message_(buf_start, msg.payload_size, msg.message_type, encrypted_len);
-    if (aerr != APIError::OK)
-      return aerr;
-    total_write_len += encrypted_len;
+  if (messages.empty()) {
+    return APIError::OK;
   }
 
-  return this->write_raw_fast_buf_(write_start, total_write_len);
+  uint8_t *buffer_data = buffer.get_buffer()->data();
+
+  // Stack-allocated iovec array - no heap allocation
+  StaticVector<struct iovec, MAX_MESSAGES_PER_BATCH> iovs;
+  uint16_t total_write_len = 0;
+
+  // We need to encrypt each message in place
+  for (const auto &msg : messages) {
+    // The buffer already has padding at offset
+    uint8_t *buf_start = buffer_data + msg.offset;
+
+    // Write noise header
+    buf_start[0] = 0x01;  // indicator
+    // buf_start[1], buf_start[2] to be set after encryption
+
+    // Write message header (to be encrypted)
+    constexpr uint8_t msg_offset = 3;
+    buf_start[msg_offset] = static_cast<uint8_t>(msg.message_type >> 8);      // type high byte
+    buf_start[msg_offset + 1] = static_cast<uint8_t>(msg.message_type);       // type low byte
+    buf_start[msg_offset + 2] = static_cast<uint8_t>(msg.payload_size >> 8);  // data_len high byte
+    buf_start[msg_offset + 3] = static_cast<uint8_t>(msg.payload_size);       // data_len low byte
+    // payload data is already in the buffer starting at offset + 7
+
+    // Make sure we have space for MAC
+    // The buffer should already have been sized appropriately
+
+    // Encrypt the message in place
+    NoiseBuffer mbuf;
+    noise_buffer_init(mbuf);
+    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + msg.payload_size,
+                           4 + msg.payload_size + frame_footer_size_);
+
+    int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
+    APIError aerr =
+        handle_noise_error_(err, LOG_STR("noise_cipherstate_encrypt"), APIError::CIPHERSTATE_ENCRYPT_FAILED);
+    if (aerr != APIError::OK)
+      return aerr;
+
+    // Fill in the encrypted size
+    buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
+    buf_start[2] = static_cast<uint8_t>(mbuf.size);
+
+    // Add iovec for this encrypted message
+    size_t msg_len = static_cast<size_t>(3 + mbuf.size);  // indicator + size + encrypted data
+    iovs.push_back({buf_start, msg_len});
+    total_write_len += msg_len;
+  }
+
+  // Send all encrypted messages in one writev call
+  return this->write_raw_(iovs.data(), iovs.size(), total_write_len);
 }
 
 APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
@@ -542,16 +531,16 @@ APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
   header[1] = (uint8_t) (len >> 8);
   header[2] = (uint8_t) len;
 
-  if (len == 0) {
-    return this->write_raw_buf_(header, 3);
-  }
   struct iovec iov[2];
   iov[0].iov_base = header;
   iov[0].iov_len = 3;
+  if (len == 0) {
+    return this->write_raw_(iov, 1, 3);  // Just header
+  }
   iov[1].iov_base = const_cast<uint8_t *>(data);
   iov[1].iov_len = len;
 
-  return this->write_raw_iov_(iov, 2, 3 + len);
+  return this->write_raw_(iov, 2, 3 + len);  // Header + data
 }
 
 /** Initiate the data structures for the handshake.
@@ -617,7 +606,7 @@ APIError APINoiseFrameHelper::check_handshake_finished_() {
   if (aerr != APIError::OK)
     return aerr;
 
-  this->frame_footer_size_ = noise_cipherstate_get_mac_length(send_cipher_);
+  frame_footer_size_ = noise_cipherstate_get_mac_length(send_cipher_);
 
   HELPER_LOG("Handshake complete!");
   noise_handshakestate_free(handshake_);

esphome/components/api/api_frame_helper_noise.h

@@ -9,22 +9,19 @@ namespace esphome::api {
 
 class APINoiseFrameHelper final : public APIFrameHelper {
  public:
-  // Noise header structure:
-  // Pos 0: indicator (0x01)
-  // Pos 1-2: encrypted payload size (16-bit big-endian)
-  // Pos 3-6: encrypted type (16-bit) + data_len (16-bit)
-  // Pos 7+: actual payload data
-  static constexpr uint8_t HEADER_PADDING = 1 + 2 + 2 + 2;  // indicator + size + type + data_len
-
   APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx)
       : APIFrameHelper(std::move(socket)), ctx_(ctx) {
-    frame_header_padding_ = HEADER_PADDING;
+    // Noise header structure:
+    // Pos 0: indicator (0x01)
+    // Pos 1-2: encrypted payload size (16-bit big-endian)
+    // Pos 3-6: encrypted type (16-bit) + data_len (16-bit)
+    // Pos 7+: actual payload data
+    frame_header_padding_ = 7;
   }
   ~APINoiseFrameHelper() override;
   APIError init() override;
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
   APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 
  protected:
@@ -36,8 +33,6 @@ class APINoiseFrameHelper final : public APIFrameHelper {
   APIError state_action_handshake_write_();
   APIError try_read_frame_();
   APIError write_frame_(const uint8_t *data, uint16_t len);
-  APIError encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
-                                  uint16_t &encrypted_len_out);
   APIError init_handshake_();
   APIError check_handshake_finished_();
   void send_explicit_handshake_reject_(const LogString *reason);

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -39,8 +39,15 @@ static constexpr size_t API_MAX_LOG_BYTES = 168;
               format_hex_pretty_to(hex_buf_, (buffer).data(), \
                                    (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
   } while (0)
+#define LOG_PACKET_SENDING(data, len) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Sending raw: %s", \
+              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
+  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
+#define LOG_PACKET_SENDING(data, len) ((void) 0)
 #endif
 
 /// Initialize the frame helper, returns OK if successful.
@@ -198,6 +205,7 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
       // Make sure to tell the remote that we don't
       // understand the indicator byte so it knows
       // we do not support it.
+      struct iovec iov[1];
       // The \x00 first byte is the marker for plaintext.
       //
       // The remote will know how to handle the indicator byte,
@@ -212,12 +220,14 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
                                                 "Bad indicator byte";
       char msg[INDICATOR_MSG_SIZE];
       memcpy_P(msg, MSG_PROGMEM, INDICATOR_MSG_SIZE);
-      this->write_raw_buf_(msg, INDICATOR_MSG_SIZE);
+      iov[0].iov_base = (void *) msg;
 #else
       static const char MSG[] = "\x00"
                                 "Bad indicator byte";
-      this->write_raw_buf_(MSG, INDICATOR_MSG_SIZE);
+      iov[0].iov_base = (void *) MSG;
 #endif
+      iov[0].iov_len = INDICATOR_MSG_SIZE;
+      this->write_raw_(iov, 1, INDICATOR_MSG_SIZE);
     }
     return aerr;
   }
@@ -227,101 +237,73 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   buffer->type = this->rx_header_parsed_type_;
   return APIError::OK;
 }
-
-// Encode a 16-bit varint (1-3 bytes) using pre-computed length.
-ESPHOME_ALWAYS_INLINE static inline void encode_varint_16(uint16_t value, uint8_t varint_len, uint8_t *p) {
-  if (varint_len >= 2) {
-    *p++ = static_cast<uint8_t>(value | 0x80);
-    value >>= 7;
-    if (varint_len == 3) {
-      *p++ = static_cast<uint8_t>(value | 0x80);
-      value >>= 7;
-    }
-  }
-  *p = static_cast<uint8_t>(value);
-}
-
-// Encode an 8-bit varint (1-2 bytes) using pre-computed length.
-ESPHOME_ALWAYS_INLINE static inline void encode_varint_8(uint8_t value, uint8_t varint_len, uint8_t *p) {
-  if (varint_len == 2) {
-    *p++ = static_cast<uint8_t>(value | 0x80);
-    *p = static_cast<uint8_t>(value >> 7);
-  } else {
-    *p = value;
-  }
-}
-
-// Write plaintext header into pre-allocated padding before payload.
-// padding_size: bytes reserved before payload (HEADER_PADDING for first/single msg,
-//               actual header size for contiguous batch messages).
-// Returns the total header length (indicator + varints).
-ESPHOME_ALWAYS_INLINE static inline uint8_t write_plaintext_header(uint8_t *buf_start, uint16_t payload_size,
-                                                                   uint8_t message_type, uint8_t padding_size) {
-  uint8_t size_varint_len = ProtoSize::varint16(payload_size);
-  uint8_t type_varint_len = ProtoSize::varint8(message_type);
-  uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
-
-  // The header is right-justified within the padding so it sits immediately before payload.
-  //
-  // Single/first message (padding_size = HEADER_PADDING = 6):
-  //   Example (small, header=3): [0-2] unused | [3] 0x00 | [4] size | [5] type | [6...] payload
-  //   Example (medium, header=4): [0-1] unused | [2] 0x00 | [3-4] size | [5] type | [6...] payload
-  //   Example (large, header=6):  [0] 0x00 | [1-3] size | [4-5] type | [6...] payload
-  //
-  // Batch messages 2+ (padding_size = actual header size, no unused bytes):
-  //   Example (small, header=3): [0] 0x00 | [1] size | [2] type | [3...] payload
-  //   Example (medium, header=4): [0] 0x00 | [1-2] size | [3] type | [4...] payload
-#ifdef ESPHOME_DEBUG_API
-  assert(padding_size >= total_header_len);
-#endif
-  uint32_t header_offset = padding_size - total_header_len;
-
-  // Write the plaintext header
-  buf_start[header_offset] = 0x00;  // indicator
-
-  // Encode varints directly into buffer using pre-computed lengths
-  encode_varint_16(payload_size, size_varint_len, buf_start + header_offset + 1);
-  encode_varint_8(message_type, type_varint_len, buf_start + header_offset + 1 + size_varint_len);
-
-  return total_header_len;
-}
-
-APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
-#ifdef ESPHOME_DEBUG_API
-  assert(this->state_ == State::DATA);
-#endif
-
-  uint16_t payload_size = static_cast<uint16_t>(buffer.get_buffer()->size() - HEADER_PADDING);
-  uint8_t *buffer_data = buffer.get_buffer()->data();
-  uint8_t header_len = write_plaintext_header(buffer_data, payload_size, type, HEADER_PADDING);
-  return this->write_raw_fast_buf_(buffer_data + HEADER_PADDING - header_len,
-                                   static_cast<uint16_t>(header_len + payload_size));
-}
-
 APIError APIPlaintextFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer,
                                                           std::span<const MessageInfo> messages) {
-#ifdef ESPHOME_DEBUG_API
-  assert(this->state_ == State::DATA);
-  assert(!messages.empty());
-#endif
-  uint8_t *buffer_data = buffer.get_buffer()->data();
+  APIError aerr = this->check_data_state_();
+  if (aerr != APIError::OK)
+    return aerr;
 
-  // First message has max padding (header_size = HEADER_PADDING), may have unused leading bytes.
-  // Subsequent messages were encoded with exact header sizes (header_size = actual header len).
-  // write_plaintext_header right-justifies the header within header_size bytes of padding.
-  const auto &first = messages[0];
-  uint8_t *first_start = buffer_data + first.offset;
-  uint8_t header_len = write_plaintext_header(first_start, first.payload_size, first.message_type, HEADER_PADDING);
-  uint8_t *write_start = first_start + HEADER_PADDING - header_len;
-  uint16_t total_len = header_len + first.payload_size;
-
-  for (size_t i = 1; i < messages.size(); i++) {
-    const auto &msg = messages[i];
-    header_len = write_plaintext_header(buffer_data + msg.offset, msg.payload_size, msg.message_type, msg.header_size);
-    total_len += header_len + msg.payload_size;
+  if (messages.empty()) {
+    return APIError::OK;
   }
 
-  return this->write_raw_fast_buf_(write_start, total_len);
+  uint8_t *buffer_data = buffer.get_buffer()->data();
+
+  // Stack-allocated iovec array - no heap allocation
+  StaticVector<struct iovec, MAX_MESSAGES_PER_BATCH> iovs;
+  uint16_t total_write_len = 0;
+
+  for (const auto &msg : messages) {
+    // Calculate varint sizes for header layout using inline ternary to avoid varint_slow call overhead
+    uint8_t size_varint_len = msg.payload_size < ProtoSize::VARINT_THRESHOLD_1_BYTE
+                                  ? 1
+                                  : (msg.payload_size < ProtoSize::VARINT_THRESHOLD_2_BYTE ? 2 : 3);
+    uint8_t type_varint_len = msg.message_type < ProtoSize::VARINT_THRESHOLD_1_BYTE ? 1 : 2;
+    uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
+
+    // Calculate where to start writing the header
+    // The header starts at the latest possible position to minimize unused padding
+    //
+    // Example 1 (small values): total_header_len = 3, header_offset = 6 - 3 = 3
+    // [0-2]  - Unused padding
+    // [3]    - 0x00 indicator byte
+    // [4]    - Payload size varint (1 byte, for sizes 0-127)
+    // [5]    - Message type varint (1 byte, for types 0-127)
+    // [6...] - Actual payload data
+    //
+    // Example 2 (medium values): total_header_len = 4, header_offset = 6 - 4 = 2
+    // [0-1]  - Unused padding
+    // [2]    - 0x00 indicator byte
+    // [3-4]  - Payload size varint (2 bytes, for sizes 128-16383)
+    // [5]    - Message type varint (1 byte, for types 0-127)
+    // [6...] - Actual payload data
+    //
+    // Example 3 (large values): total_header_len = 6, header_offset = 6 - 6 = 0
+    // [0]    - 0x00 indicator byte
+    // [1-3]  - Payload size varint (3 bytes, for sizes 16384-65535)
+    // [4-5]  - Message type varint (2 bytes, for types 128-16383)
+    // [6...] - Actual payload data
+    //
+    // The message starts at offset + frame_header_padding_
+    // So we write the header starting at offset + frame_header_padding_ - total_header_len
+    uint8_t *buf_start = buffer_data + msg.offset;
+    uint32_t header_offset = frame_header_padding_ - total_header_len;
+
+    // Write the plaintext header
+    buf_start[header_offset] = 0x00;  // indicator
+
+    // Encode varints directly into buffer
+    encode_varint_to_buffer(msg.payload_size, buf_start + header_offset + 1);
+    encode_varint_to_buffer(msg.message_type, buf_start + header_offset + 1 + size_varint_len);
+
+    // Add iovec for this message (header + payload)
+    size_t msg_len = static_cast<size_t>(total_header_len + msg.payload_size);
+    iovs.push_back({buf_start + header_offset, msg_len});
+    total_write_len += msg_len;
+  }
+
+  // Send all messages in one writev call
+  return write_raw_(iovs.data(), iovs.size(), total_write_len);
 }
 
 }  // namespace esphome::api

esphome/components/api/api_frame_helper_plaintext.h

@@ -7,21 +7,18 @@ namespace esphome::api {
 
 class APIPlaintextFrameHelper final : public APIFrameHelper {
  public:
-  // Plaintext header structure (worst case):
-  // Pos 0: indicator (0x00)
-  // Pos 1-3: payload size varint (up to 3 bytes)
-  // Pos 4-5: message type varint (up to 2 bytes)
-  // Pos 6+: actual payload data
-  static constexpr uint8_t HEADER_PADDING = 1 + 3 + 2;  // indicator + size varint + type varint
-
   explicit APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : APIFrameHelper(std::move(socket)) {
-    frame_header_padding_ = HEADER_PADDING;
+    // Plaintext header structure (worst case):
+    // Pos 0: indicator (0x00)
+    // Pos 1-3: payload size varint (up to 3 bytes)
+    // Pos 4-5: message type varint (up to 2 bytes)
+    // Pos 6+: actual payload data
+    frame_header_padding_ = 6;
   }
   ~APIPlaintextFrameHelper() override = default;
   APIError init() override;
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
   APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 
  protected:

esphome/components/api/api_options.proto

@@ -22,7 +22,6 @@ extend google.protobuf.MessageOptions {
     optional bool log = 1039 [default=true];
     optional bool no_delay = 1040 [default=false];
     optional string base_class = 1041;
-    optional bool inline_encode = 1042 [default=false];
 }
 
 extend google.protobuf.FieldOptions {

esphome/components/api/api_pb2.cpp

@@ -2328,37 +2328,40 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
   }
   return true;
 }
+uint8_t *BluetoothLERawAdvertisement::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+  uint8_t *__restrict__ pos = buffer.get_pos();
+  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
+  ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, this->address);
+  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
+  ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(this->rssi));
+  if (this->address_type) {
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 24);
+    ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, this->address_type);
+  }
+  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 34);
+  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, static_cast<uint8_t>(this->data_len));
+  ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, this->data, this->data_len);
+  return pos;
+}
+uint32_t BluetoothLERawAdvertisement::calculate_size() const {
+  uint32_t size = 0;
+  size += ProtoSize::calc_uint64_force(1, this->address);
+  size += ProtoSize::calc_sint32_force(1, this->rssi);
+  size += this->address_type ? 2 : 0;
+  size += 2 + this->data_len;
+  return size;
+}
 uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    auto &sub_msg = this->advertisements[i];
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 10);
-    uint8_t *len_pos = pos;
-    ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
-    ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
-    ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(sub_msg.rssi));
-    if (sub_msg.address_type) {
-      ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 24);
-      ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address_type);
-    }
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 34);
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, static_cast<uint8_t>(sub_msg.data_len));
-    ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.data, sub_msg.data_len);
-    *len_pos = static_cast<uint8_t>(pos - len_pos - 1);
+    ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 1, this->advertisements[i]);
   }
   return pos;
 }
 uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
   uint32_t size = 0;
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    auto &sub_msg = this->advertisements[i];
-    size += 2;
-    size += ProtoSize::calc_uint64_force(1, sub_msg.address);
-    size += ProtoSize::calc_sint32_force(1, sub_msg.rssi);
-    size += sub_msg.address_type ? 2 : 0;
-    size += 2 + sub_msg.data_len;
+    size += ProtoSize::calc_message_force(1, this->advertisements[i].calculate_size());
   }
   return size;
 }

esphome/components/api/api_pb2.h

@@ -1888,6 +1888,8 @@ class BluetoothLERawAdvertisement final : public ProtoMessage {
   uint32_t address_type{0};
   uint8_t data[62]{};
   uint8_t data_len{0};
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
+  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif

esphome/components/api/proto.h

@@ -298,33 +298,15 @@ constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
 class ProtoEncode {
  public:
   /// Write a multi-byte varint directly through a pos pointer.
-  /// Unrolled based on the compile-time max varint length for T
-  /// (5 bytes for uint32_t, 10 bytes for uint64_t). The explicit unroll gives
-  /// the compiler straight-line code with early exits instead of a
-  /// data-dependent back-edge branch, which measurably speeds up BLE raw
-  /// advertisement MAC encoding (always 7-byte varints) among other hot paths.
-  ///
-  /// Takes/returns pos by value so this function can remain out-of-line without
-  /// forcing the caller to spill pos to memory on every byte write. Callers
-  /// (which are ALWAYS_INLINE) should assign the returned pos back to their
-  /// local. Code size win vs. inlining the whole unroll at every call site.
   template<typename T>
-  static uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, T value) {
-    constexpr int MAX_VARINT_BYTES = (sizeof(T) * 8 + 6) / 7;  // 5 for u32, 10 for u64
-#pragma GCC unroll 10
-    for (int i = 0; i < MAX_VARINT_BYTES - 1; i++) {
+  static inline void encode_varint_raw_loop(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, T value) {
+    do {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-      *pos++ = static_cast<uint8_t>(value) | 0x80;
+      *pos++ = static_cast<uint8_t>(value | 0x80);
       value >>= 7;
-      if (value <= 0x7F) {
-        PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-        *pos++ = static_cast<uint8_t>(value);
-        return pos;
-      }
-    }
+    } while (value > 0x7F);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = static_cast<uint8_t>(value);
-    return pos;
   }
   static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
                                                              uint32_t value) {
@@ -333,7 +315,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value);
       return;
     }
-    pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a varint that is expected to be 1-2 bytes (e.g. zigzag RSSI, small lengths).
   static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_short(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
@@ -349,7 +331,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value >> 7);
       return;
     }
-    pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
                                                                 uint64_t value) {
@@ -358,7 +340,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value);
       return;
     }
-    pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   static inline void ESPHOME_ALWAYS_INLINE encode_field_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
                                                             uint32_t field_id, uint32_t type) {
@@ -370,12 +352,6 @@ class ProtoEncode {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = b;
   }
-  /// Reserve one byte for later backpatch (e.g., sub-message length).
-  /// Advances pos past the reserved byte without writing a value.
-  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
-    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-    pos++;
-  }
   /// Write raw bytes to the buffer (no tag, no length prefix).
   static inline void ESPHOME_ALWAYS_INLINE encode_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
                                                       const void *data, size_t len) {
@@ -420,7 +396,7 @@ class ProtoEncode {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
       *pos++ = static_cast<uint8_t>(len);
     } else {
-      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
       PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     }
     std::memcpy(pos, string, len);
@@ -669,17 +645,6 @@ class ProtoSize {
   static constexpr uint32_t VARINT_THRESHOLD_3_BYTE = 1 << 21;  // 2097152
   static constexpr uint32_t VARINT_THRESHOLD_4_BYTE = 1 << 28;  // 268435456
 
-  // Varint encoded length for a 16-bit value (1, 2, or 3 bytes).
-  // Fully inline — no slow path call for values >= 128.
-  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint16(uint16_t value) {
-    return value < VARINT_THRESHOLD_1_BYTE ? 1 : (value < VARINT_THRESHOLD_2_BYTE ? 2 : 3);
-  }
-
-  // Varint encoded length for an 8-bit value (1 or 2 bytes).
-  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint8(uint8_t value) {
-    return value < VARINT_THRESHOLD_1_BYTE ? 1 : 2;
-  }
-
   /**
    * @brief Calculates the size in bytes needed to encode a uint32_t value as a varint
    *

esphome/components/at581x/__init__.py

@@ -169,17 +169,18 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
 
     # Radar configuration
     if frontend_reset := config.get(CONF_HW_FRONTEND_RESET):
-        template_ = await cg.templatable(frontend_reset, args, cg.int8)
+        template_ = await cg.templatable(frontend_reset, args, cg.int32)
         cg.add(var.set_hw_frontend_reset(template_))
 
     if freq := config.get(CONF_FREQUENCY):
-        if not cg.is_template(freq):
-            freq = int(freq / 1000000)
-        template_ = await cg.templatable(freq, args, cg.int_)
+        if cg.is_template(freq):
+            template_ = await cg.templatable(freq, args, cg.int32)
+        else:
+            template_ = int(freq / 1000000)
         cg.add(var.set_frequency(template_))
 
     if (sens_dist := config.get(CONF_SENSING_DISTANCE)) is not None:
-        template_ = await cg.templatable(sens_dist, args, cg.int_)
+        template_ = await cg.templatable(sens_dist, args, cg.int32)
         cg.add(var.set_sensing_distance(template_))
 
     if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
@@ -199,13 +200,14 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
         cg.add(var.set_trigger_keep(template_))
 
     if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
-        template_ = await cg.templatable(stage_gain, args, cg.int_)
+        template_ = await cg.templatable(stage_gain, args, cg.int32)
         cg.add(var.set_stage_gain(template_))
 
     if power := config.get(CONF_POWER_CONSUMPTION):
-        if not cg.is_template(power):
-            power = int(power * 1000000)
-        template_ = await cg.templatable(power, args, cg.int_)
+        if cg.is_template(power):
+            template_ = await cg.templatable(power, args, cg.int32)
+        else:
+            template_ = int(power * 1000000)
         cg.add(var.set_power_consumption(template_))
 
     return var

esphome/components/audio_adc/__init__.py

@@ -32,7 +32,7 @@ async def audio_adc_set_mic_gain_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config.get(CONF_MIC_GAIN), args, cg.float_)
+    template_ = await cg.templatable(config.get(CONF_MIC_GAIN), args, float)
     cg.add(var.set_mic_gain(template_))
 
     return var

esphome/components/audio_dac/__init__.py

@@ -52,7 +52,7 @@ async def audio_dac_set_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config.get(CONF_VOLUME), args, cg.float_)
+    template_ = await cg.templatable(config.get(CONF_VOLUME), args, float)
     cg.add(var.set_volume(template_))
 
     return var

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -61,15 +61,6 @@ void BedJetClimate::dump_config() {
 }
 
 void BedJetClimate::setup() {
-  // Set custom modes once during setup — stored on Climate base class, wired via get_traits()
-  this->set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES);
-  this->set_supported_custom_presets({
-      this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
-      "M1",
-      "M2",
-      "M3",
-  });
-
   // restore set points
   auto restore = this->restore_state_();
   if (restore.has_value()) {

esphome/components/bedjet/climate/bedjet_climate.h

@@ -42,14 +42,21 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
         climate::CLIMATE_MODE_DRY,
     });
 
+    // It would be better if we had a slider for the fan modes.
+    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES);
     traits.set_supported_presets({
         // If we support NONE, then have to decide what happens if the user switches to it (turn off?)
         // climate::CLIMATE_PRESET_NONE,
         // Climate doesn't have a "TURBO" mode, but we can use the BOOST preset instead.
         climate::CLIMATE_PRESET_BOOST,
     });
-    // Custom fan modes and presets are set once in setup(), stored on Climate base class,
-    // and wired automatically via get_traits()
+    // String literals are stored in rodata and valid for program lifetime
+    traits.set_supported_custom_presets({
+        this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
+        "M1",
+        "M2",
+        "M3",
+    });
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);

esphome/components/cc1101/cc1101.cpp

@@ -150,10 +150,6 @@ void CC1101Component::setup() {
   if (this->gdo0_pin_ != nullptr) {
     this->defer([this]() { this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT); });
   }
-
-  if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
-    this->disable_loop();
-  }
 }
 
 void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi) {
@@ -673,11 +669,6 @@ void CC1101Component::set_packet_mode(bool value) {
     this->state_.GDO0_CFG = 0x0D;
   }
   if (this->initialized_) {
-    if (value) {
-      this->enable_loop();
-    } else {
-      this->disable_loop();
-    }
     this->write_(Register::PKTCTRL0);
     this->write_(Register::PKTCTRL1);
     this->write_(Register::IOCFG0);

esphome/components/climate/__init__.py

@@ -488,16 +488,16 @@ async def climate_control_to_code(config, action_id, template_arg, args):
         template_ = await cg.templatable(mode, args, ClimateMode)
         cg.add(var.set_mode(template_))
     if (target_temp := config.get(CONF_TARGET_TEMPERATURE)) is not None:
-        template_ = await cg.templatable(target_temp, args, cg.float_)
+        template_ = await cg.templatable(target_temp, args, float)
         cg.add(var.set_target_temperature(template_))
     if (target_temp_low := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
-        template_ = await cg.templatable(target_temp_low, args, cg.float_)
+        template_ = await cg.templatable(target_temp_low, args, float)
         cg.add(var.set_target_temperature_low(template_))
     if (target_temp_high := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
-        template_ = await cg.templatable(target_temp_high, args, cg.float_)
+        template_ = await cg.templatable(target_temp_high, args, float)
         cg.add(var.set_target_temperature_high(template_))
     if (target_humidity := config.get(CONF_TARGET_HUMIDITY)) is not None:
-        template_ = await cg.templatable(target_humidity, args, cg.float_)
+        template_ = await cg.templatable(target_humidity, args, float)
         cg.add(var.set_target_humidity(template_))
     if (fan_mode := config.get(CONF_FAN_MODE)) is not None:
         template_ = await cg.templatable(fan_mode, args, ClimateFanMode)

esphome/components/climate/climate.cpp

@@ -484,11 +484,6 @@ void Climate::publish_state() {
 
 ClimateTraits Climate::get_traits() {
   auto traits = this->traits();
-  // Wire custom mode pointers from Climate-owned storage
-  if (this->supported_custom_fan_modes_)
-    traits.set_supported_custom_fan_modes_(this->supported_custom_fan_modes_);
-  if (this->supported_custom_presets_)
-    traits.set_supported_custom_presets_(this->supported_custom_presets_);
 #ifdef USE_CLIMATE_VISUAL_OVERRIDES
   if (!std::isnan(this->visual_min_temperature_override_)) {
     traits.set_visual_min_temperature(this->visual_min_temperature_override_);
@@ -686,8 +681,9 @@ bool Climate::set_fan_mode_(ClimateFanMode mode) {
 }
 
 bool Climate::set_custom_fan_mode_(const char *mode, size_t len) {
-  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode, this->find_custom_fan_mode_(mode, len),
-                                         this->has_custom_fan_mode());
+  auto traits = this->get_traits();
+  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode,
+                                         traits.find_custom_fan_mode_(mode, len), this->has_custom_fan_mode());
 }
 
 void Climate::clear_custom_fan_mode_() { this->custom_fan_mode_ = nullptr; }
@@ -695,7 +691,8 @@ void Climate::clear_custom_fan_mode_() { this->custom_fan_mode_ = nullptr; }
 bool Climate::set_preset_(ClimatePreset preset) { return set_primary_mode(this->preset, this->custom_preset_, preset); }
 
 bool Climate::set_custom_preset_(const char *preset, size_t len) {
-  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, this->find_custom_preset_(preset, len),
+  auto traits = this->get_traits();
+  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, traits.find_custom_preset_(preset, len),
                                         this->has_custom_preset());
 }
 
@@ -706,10 +703,6 @@ const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode) {
 }
 
 const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode, size_t len) {
-  if (this->supported_custom_fan_modes_) {
-    return vector_find(*this->supported_custom_fan_modes_, custom_fan_mode, len);
-  }
-  // Fallback for deprecated path: external components may set modes on ClimateTraits directly
   return this->get_traits().find_custom_fan_mode_(custom_fan_mode, len);
 }
 
@@ -718,10 +711,6 @@ const char *Climate::find_custom_preset_(const char *custom_preset) {
 }
 
 const char *Climate::find_custom_preset_(const char *custom_preset, size_t len) {
-  if (this->supported_custom_presets_) {
-    return vector_find(*this->supported_custom_presets_, custom_preset, len);
-  }
-  // Fallback for deprecated path: external components may set modes on ClimateTraits directly
   return this->get_traits().find_custom_preset_(custom_preset, len);
 }
 

esphome/components/climate/climate.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <vector>
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
@@ -235,28 +234,6 @@ class Climate : public EntityBase {
   void set_visual_max_humidity_override(float visual_max_humidity_override);
 #endif
 
-  /// Set the supported custom fan modes (stored on Climate, referenced by ClimateTraits).
-  void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
-    this->ensure_custom_fan_modes_().assign(modes.begin(), modes.end());
-  }
-  void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
-    this->ensure_custom_fan_modes_() = modes;
-  }
-  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
-    this->ensure_custom_fan_modes_().assign(modes, modes + N);
-  }
-
-  /// Set the supported custom presets (stored on Climate, referenced by ClimateTraits).
-  void set_supported_custom_presets(std::initializer_list<const char *> presets) {
-    this->ensure_custom_presets_().assign(presets.begin(), presets.end());
-  }
-  void set_supported_custom_presets(const std::vector<const char *> &presets) {
-    this->ensure_custom_presets_() = presets;
-  }
-  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
-    this->ensure_custom_presets_().assign(presets, presets + N);
-  }
-
   /// Check if a custom fan mode is currently active.
   bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
 
@@ -359,14 +336,13 @@ class Climate : public EntityBase {
    * called from publish_state()
    */
   void save_state_(const ClimateTraits &traits);
-  void save_state_() { this->save_state_(this->get_traits()); }
+  void save_state_() { this->save_state_(this->traits()); }
 
   void dump_traits_(const char *tag);
 
   LazyCallbackManager<void(Climate &)> state_callback_{};
   LazyCallbackManager<void(ClimateCall &)> control_callback_{};
   ESPPreferenceObject rtc_;
-
 #ifdef USE_CLIMATE_VISUAL_OVERRIDES
   float visual_min_temperature_override_{NAN};
   float visual_max_temperature_override_{NAN};
@@ -377,33 +353,16 @@ class Climate : public EntityBase {
 #endif
 
  private:
-  /// Lazy-allocate custom mode vectors (never freed — entity lives forever).
-  std::vector<const char *> &ensure_custom_fan_modes_() {
-    if (!this->supported_custom_fan_modes_) {
-      this->supported_custom_fan_modes_ = new std::vector<const char *>();  // NOLINT
-    }
-    return *this->supported_custom_fan_modes_;
-  }
-  std::vector<const char *> &ensure_custom_presets_() {
-    if (!this->supported_custom_presets_) {
-      this->supported_custom_presets_ = new std::vector<const char *>();  // NOLINT
-    }
-    return *this->supported_custom_presets_;
-  }
-
-  std::vector<const char *> *supported_custom_fan_modes_{nullptr};
-  std::vector<const char *> *supported_custom_presets_{nullptr};
-
   /** The active custom fan mode (private - enforces use of safe setters).
    *
-   * Points to an entry in supported_custom_fan_modes_ or nullptr.
+   * Points to an entry in traits.supported_custom_fan_modes_ or nullptr.
    * Use get_custom_fan_mode() to read, set_custom_fan_mode_() to modify.
    */
   const char *custom_fan_mode_{nullptr};
 
   /** The active custom preset (private - enforces use of safe setters).
    *
-   * Points to an entry in supported_custom_presets_ or nullptr.
+   * Points to an entry in traits.supported_custom_presets_ or nullptr.
    * Use get_custom_preset() to read, set_custom_preset_() to modify.
    */
   const char *custom_preset_{nullptr};

esphome/components/climate/climate_traits.cpp

@@ -2,33 +2,6 @@
 
 namespace esphome::climate {
 
-// Compat: shared empty vector for getters when no custom modes are set.
-// Remove in 2026.11.0 when deprecated ClimateTraits setters are removed
-// and getters can return const vector * instead of const vector &.
-static const std::vector<const char *> EMPTY_CUSTOM_MODES;  // NOLINT
-
-const std::vector<const char *> &ClimateTraits::get_supported_custom_fan_modes() const {
-  if (this->supported_custom_fan_modes_) {
-    return *this->supported_custom_fan_modes_;
-  }
-  // Compat: fall back to owned vector from deprecated setters. Remove in 2026.11.0.
-  if (!this->compat_custom_fan_modes_.empty()) {
-    return this->compat_custom_fan_modes_;
-  }
-  return EMPTY_CUSTOM_MODES;
-}
-
-const std::vector<const char *> &ClimateTraits::get_supported_custom_presets() const {
-  if (this->supported_custom_presets_) {
-    return *this->supported_custom_presets_;
-  }
-  // Compat: fall back to owned vector from deprecated setters. Remove in 2026.11.0.
-  if (!this->compat_custom_presets_.empty()) {
-    return this->compat_custom_presets_;
-  }
-  return EMPTY_CUSTOM_MODES;
-}
-
 int8_t ClimateTraits::get_target_temperature_accuracy_decimals() const {
   return step_to_accuracy_decimals(this->visual_target_temperature_step_);
 }

esphome/components/climate/climate_traits.h

@@ -147,45 +147,27 @@ class ClimateTraits {
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
-    if (!this->supported_fan_modes_.empty()) {
-      return true;
-    }
-    // Same precedence as get_supported_custom_fan_modes() getter
-    if (this->supported_custom_fan_modes_) {
-      return !this->supported_custom_fan_modes_->empty();
-    }
-    return !this->compat_custom_fan_modes_.empty();  // Compat: remove in 2026.11.0
+    return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
   const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_custom_fan_modes() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
   void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
-    // Compat: store in owned vector. Copies copy the vector (deprecated path still copies this vector).
-    this->compat_custom_fan_modes_ = modes;
+    this->supported_custom_fan_modes_ = modes;
   }
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_custom_fan_modes() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
   void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
-    this->compat_custom_fan_modes_ = modes;
+    this->supported_custom_fan_modes_ = modes;
   }
-  // Remove before 2026.11.0
-  template<size_t N>
-  ESPDEPRECATED("Call set_supported_custom_fan_modes() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
-  void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
-    this->compat_custom_fan_modes_.assign(modes, modes + N);
+  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
+    this->supported_custom_fan_modes_.assign(modes, modes + N);
   }
 
   // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
   void set_supported_custom_fan_modes(const std::vector<std::string> &modes) = delete;
   void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) = delete;
 
-  // Compat: returns const ref with empty fallback. In 2026.11.0 change to return const vector *.
-  const std::vector<const char *> &get_supported_custom_fan_modes() const;
+  const std::vector<const char *> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
   bool supports_custom_fan_mode(const char *custom_fan_mode) const {
-    return (this->supported_custom_fan_modes_ &&
-            vector_contains(*this->supported_custom_fan_modes_, custom_fan_mode)) ||
-           vector_contains(this->compat_custom_fan_modes_, custom_fan_mode);  // Compat: remove in 2026.11.0
+    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
   }
   bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
     return this->supports_custom_fan_mode(custom_fan_mode.c_str());
@@ -197,32 +179,23 @@ class ClimateTraits {
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
   const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
 
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_custom_presets() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
   void set_supported_custom_presets(std::initializer_list<const char *> presets) {
-    this->compat_custom_presets_ = presets;
+    this->supported_custom_presets_ = presets;
   }
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_custom_presets() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
   void set_supported_custom_presets(const std::vector<const char *> &presets) {
-    this->compat_custom_presets_ = presets;
+    this->supported_custom_presets_ = presets;
   }
-  // Remove before 2026.11.0
-  template<size_t N>
-  ESPDEPRECATED("Call set_supported_custom_presets() on the Climate entity instead. Removed in 2026.11.0", "2026.5.0")
-  void set_supported_custom_presets(const char *const (&presets)[N]) {
-    this->compat_custom_presets_.assign(presets, presets + N);
+  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
+    this->supported_custom_presets_.assign(presets, presets + N);
   }
 
   // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
   void set_supported_custom_presets(const std::vector<std::string> &presets) = delete;
   void set_supported_custom_presets(std::initializer_list<std::string> presets) = delete;
 
-  // Compat: returns const ref with empty fallback. In 2026.11.0 change to return const vector *.
-  const std::vector<const char *> &get_supported_custom_presets() const;
+  const std::vector<const char *> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
   bool supports_custom_preset(const char *custom_preset) const {
-    return (this->supported_custom_presets_ && vector_contains(*this->supported_custom_presets_, custom_preset)) ||
-           vector_contains(this->compat_custom_presets_, custom_preset);  // Compat: remove in 2026.11.0
+    return vector_contains(this->supported_custom_presets_, custom_preset);
   }
   bool supports_custom_preset(const std::string &custom_preset) const {
     return this->supports_custom_preset(custom_preset.c_str());
@@ -285,25 +258,13 @@ class ClimateTraits {
     }
   }
 
-  /// Set custom mode pointers (only Climate::get_traits() should call these).
-  void set_supported_custom_fan_modes_(const std::vector<const char *> *modes) {
-    this->supported_custom_fan_modes_ = modes;
-  }
-  void set_supported_custom_presets_(const std::vector<const char *> *presets) {
-    this->supported_custom_presets_ = presets;
-  }
-
   /// Find and return the matching custom fan mode pointer from supported modes, or nullptr if not found
   /// This is protected as it's an implementation detail - use Climate::find_custom_fan_mode_() instead
   const char *find_custom_fan_mode_(const char *custom_fan_mode) const {
     return this->find_custom_fan_mode_(custom_fan_mode, strlen(custom_fan_mode));
   }
   const char *find_custom_fan_mode_(const char *custom_fan_mode, size_t len) const {
-    if (this->supported_custom_fan_modes_) {
-      return vector_find(*this->supported_custom_fan_modes_, custom_fan_mode, len);
-    }
-    // Compat: check owned vector from deprecated setters. Remove in 2026.11.0.
-    return vector_find(this->compat_custom_fan_modes_, custom_fan_mode, len);
+    return vector_find(this->supported_custom_fan_modes_, custom_fan_mode, len);
   }
 
   /// Find and return the matching custom preset pointer from supported presets, or nullptr if not found
@@ -312,11 +273,7 @@ class ClimateTraits {
     return this->find_custom_preset_(custom_preset, strlen(custom_preset));
   }
   const char *find_custom_preset_(const char *custom_preset, size_t len) const {
-    if (this->supported_custom_presets_) {
-      return vector_find(*this->supported_custom_presets_, custom_preset, len);
-    }
-    // Compat: check owned vector from deprecated setters. Remove in 2026.11.0.
-    return vector_find(this->compat_custom_presets_, custom_preset, len);
+    return vector_find(this->supported_custom_presets_, custom_preset, len);
   }
 
   uint32_t feature_flags_{0};
@@ -332,17 +289,16 @@ class ClimateTraits {
   climate::ClimateSwingModeMask supported_swing_modes_;
   climate::ClimatePresetMask supported_presets_;
 
-  /** Custom mode storage - pointers to vectors owned by the Climate base class.
+  /** Custom mode storage using const char* pointers to eliminate std::string overhead.
    *
-   * ClimateTraits does not own this data; Climate stores the vectors and
-   * get_traits() wires these pointers automatically.
+   * Pointers must remain valid for the ClimateTraits lifetime. Safe patterns:
+   *  - String literals: set_supported_custom_fan_modes({"Turbo", "Silent"})
+   *  - Static const data: static const char* MODE = "Eco";
+   *
+   * Climate class setters validate pointers are from these vectors before storing.
    */
-  const std::vector<const char *> *supported_custom_fan_modes_{nullptr};
-  const std::vector<const char *> *supported_custom_presets_{nullptr};
-  // Compat: owned storage for deprecated setters. Copies copy the vector (copies include this vector).
-  // Remove in 2026.11.0.
-  std::vector<const char *> compat_custom_fan_modes_;
-  std::vector<const char *> compat_custom_presets_;
+  std::vector<const char *> supported_custom_fan_modes_;
+  std::vector<const char *> supported_custom_presets_;
 };
 
 }  // namespace esphome::climate

esphome/components/copy/fan/copy_fan.cpp

@@ -7,12 +7,6 @@ namespace copy {
 static const char *const TAG = "copy.fan";
 
 void CopyFan::setup() {
-  // Copy preset modes once from source fan — stored on Fan base class
-  auto source_traits = source_->get_traits();
-  if (source_traits.supports_preset_modes()) {
-    this->set_supported_preset_modes(source_traits.supported_preset_modes());
-  }
-
   source_->add_on_state_callback([this]() {
     this->copy_state_from_source_();
     this->publish_state();
@@ -45,8 +39,7 @@ fan::FanTraits CopyFan::get_traits() {
   traits.set_speed(base.supports_speed());
   traits.set_supported_speed_count(base.supported_speed_count());
   traits.set_direction(base.supports_direction());
-  // Preset modes are set once in setup() and wired via wire_preset_modes_()
-  this->wire_preset_modes_(traits);
+  traits.set_supported_preset_modes(base.supported_preset_modes());
   return traits;
 }
 

esphome/components/cover/__init__.py

@@ -300,16 +300,16 @@ async def cover_control_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
     if (stop := config.get(CONF_STOP)) is not None:
-        template_ = await cg.templatable(stop, args, cg.bool_)
+        template_ = await cg.templatable(stop, args, bool)
         cg.add(var.set_stop(template_))
     if (state := config.get(CONF_STATE)) is not None:
-        template_ = await cg.templatable(state, args, cg.float_)
+        template_ = await cg.templatable(state, args, float)
         cg.add(var.set_position(template_))
     if (position := config.get(CONF_POSITION)) is not None:
-        template_ = await cg.templatable(position, args, cg.float_)
+        template_ = await cg.templatable(position, args, float)
         cg.add(var.set_position(template_))
     if (tilt := config.get(CONF_TILT)) is not None:
-        template_ = await cg.templatable(tilt, args, cg.float_)
+        template_ = await cg.templatable(tilt, args, float)
         cg.add(var.set_tilt(template_))
     return var
 

esphome/components/demo/demo_climate.h

@@ -16,19 +16,6 @@ class DemoClimate : public climate::Climate, public Component {
  public:
   void set_type(DemoClimateType type) { type_ = type; }
   void setup() override {
-    // Set custom modes once during setup — stored on Climate base class, wired via get_traits()
-    switch (type_) {
-      case DemoClimateType::TYPE_1:
-        break;
-      case DemoClimateType::TYPE_2:
-        this->set_supported_custom_fan_modes({"Auto Low", "Auto High"});
-        this->set_supported_custom_presets({"My Preset"});
-        break;
-      case DemoClimateType::TYPE_3:
-        this->set_supported_custom_fan_modes({"Auto Low", "Auto High"});
-        break;
-    }
-    // Set initial state
     switch (type_) {
       case DemoClimateType::TYPE_1:
         this->current_temperature = 20.0;
@@ -118,13 +105,14 @@ class DemoClimate : public climate::Climate, public Component {
             climate::CLIMATE_FAN_DIFFUSE,
             climate::CLIMATE_FAN_QUIET,
         });
-        // Custom fan modes and presets are set once in setup()
+        traits.set_supported_custom_fan_modes({"Auto Low", "Auto High"});
         traits.set_supported_swing_modes({
             climate::CLIMATE_SWING_OFF,
             climate::CLIMATE_SWING_BOTH,
             climate::CLIMATE_SWING_VERTICAL,
             climate::CLIMATE_SWING_HORIZONTAL,
         });
+        traits.set_supported_custom_presets({"My Preset"});
         break;
       case DemoClimateType::TYPE_3:
         traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE |
@@ -135,7 +123,7 @@ class DemoClimate : public climate::Climate, public Component {
             climate::CLIMATE_MODE_HEAT,
             climate::CLIMATE_MODE_HEAT_COOL,
         });
-        // Custom fan modes are set once in setup()
+        traits.set_supported_custom_fan_modes({"Auto Low", "Auto High"});
         traits.set_supported_swing_modes({
             climate::CLIMATE_SWING_OFF,
             climate::CLIMATE_SWING_HORIZONTAL,

esphome/components/dfrobot_sen0395/__init__.py

@@ -159,31 +159,31 @@ async def dfrobot_sen0395_settings_to_code(config, action_id, template_arg, args
     await cg.register_parented(var, config[CONF_ID])
 
     if factory_reset_config := config.get(CONF_FACTORY_RESET):
-        template_ = await cg.templatable(factory_reset_config, args, cg.int8)
+        template_ = await cg.templatable(factory_reset_config, args, cg.int32)
         cg.add(var.set_factory_reset(template_))
 
     if CONF_DETECTION_SEGMENTS in config:
         segments = config[CONF_DETECTION_SEGMENTS]
 
         if len(segments) >= 2:
-            template_ = await cg.templatable(segments[0], args, cg.float_)
+            template_ = await cg.templatable(segments[0], args, float)
             cg.add(var.set_det_min1(template_))
-            template_ = await cg.templatable(segments[1], args, cg.float_)
+            template_ = await cg.templatable(segments[1], args, float)
             cg.add(var.set_det_max1(template_))
         if len(segments) >= 4:
-            template_ = await cg.templatable(segments[2], args, cg.float_)
+            template_ = await cg.templatable(segments[2], args, float)
             cg.add(var.set_det_min2(template_))
-            template_ = await cg.templatable(segments[3], args, cg.float_)
+            template_ = await cg.templatable(segments[3], args, float)
             cg.add(var.set_det_max2(template_))
         if len(segments) >= 6:
-            template_ = await cg.templatable(segments[4], args, cg.float_)
+            template_ = await cg.templatable(segments[4], args, float)
             cg.add(var.set_det_min3(template_))
-            template_ = await cg.templatable(segments[5], args, cg.float_)
+            template_ = await cg.templatable(segments[5], args, float)
             cg.add(var.set_det_max3(template_))
         if len(segments) >= 8:
-            template_ = await cg.templatable(segments[6], args, cg.float_)
+            template_ = await cg.templatable(segments[6], args, float)
             cg.add(var.set_det_min4(template_))
-            template_ = await cg.templatable(segments[7], args, cg.float_)
+            template_ = await cg.templatable(segments[7], args, float)
             cg.add(var.set_det_max4(template_))
     if CONF_OUTPUT_LATENCY in config:
         template_ = await cg.templatable(
@@ -200,7 +200,7 @@ async def dfrobot_sen0395_settings_to_code(config, action_id, template_arg, args
             template_ = template_.total_milliseconds / 1000
         cg.add(var.set_delay_after_disappear(template_))
     if CONF_SENSITIVITY in config:
-        template_ = await cg.templatable(config[CONF_SENSITIVITY], args, cg.int8)
+        template_ = await cg.templatable(config[CONF_SENSITIVITY], args, cg.int32)
         cg.add(var.set_sensitivity(template_))
 
     return var

esphome/components/esp32/crash_handler.cpp

@@ -59,59 +59,6 @@ static inline bool is_return_addr(uint32_t addr) {
 }
 #endif
 
-// --- Architecture-specific backtrace helpers ---
-// These run from IRAM during panic (no flash access).
-
-#if CONFIG_IDF_TARGET_ARCH_XTENSA
-// Walk Xtensa backtrace from an exception frame, writing PCs to out[].
-// Returns number of entries written.
-static uint8_t IRAM_ATTR walk_xtensa_backtrace(XtExcFrame *frame, uint32_t *out, uint8_t max) {
-  esp_backtrace_frame_t bt_frame = {
-      .pc = (uint32_t) frame->pc,
-      .sp = (uint32_t) frame->a1,
-      .next_pc = (uint32_t) frame->a0,
-      .exc_frame = frame,
-  };
-  uint8_t count = 0;
-  uint32_t first_pc = esp_cpu_process_stack_pc(bt_frame.pc);
-  if (is_code_addr(first_pc)) {
-    out[count++] = first_pc;
-  }
-  while (count < max && bt_frame.next_pc != 0) {
-    if (!esp_backtrace_get_next_frame(&bt_frame))
-      break;
-    uint32_t pc = esp_cpu_process_stack_pc(bt_frame.pc);
-    if (is_code_addr(pc)) {
-      out[count++] = pc;
-    }
-  }
-  return count;
-}
-#endif
-
-#if CONFIG_IDF_TARGET_ARCH_RISCV
-// Capture RISC-V backtrace: MEPC + RA from registers, then stack scan.
-// Returns total count; *reg_count receives number of register-sourced entries.
-static uint8_t IRAM_ATTR capture_riscv_backtrace(RvExcFrame *frame, uint32_t *out, uint8_t max, uint8_t *reg_count) {
-  uint8_t count = 0;
-  if (is_code_addr(frame->mepc)) {
-    out[count++] = frame->mepc;
-  }
-  if (is_code_addr(frame->ra) && frame->ra != frame->mepc) {
-    out[count++] = frame->ra;
-  }
-  *reg_count = count;
-  auto *scan_start = (uint32_t *) frame->sp;
-  for (uint32_t i = 0; i < 64 && count < max; i++) {
-    uint32_t val = scan_start[i];
-    if (is_code_addr(val) && val != frame->mepc && val != frame->ra) {
-      out[count++] = val;
-    }
-  }
-  return count;
-}
-#endif
-
 // Raw crash data written by the panic handler wrapper.
 // Lives in .noinit so it survives software reset but contains garbage after power cycle.
 // Validated by magic marker. Static linkage since it's only used within this file.
@@ -119,7 +66,7 @@ static uint8_t IRAM_ATTR capture_riscv_backtrace(RvExcFrame *frame, uint32_t *ou
 // Magic is second to validate the data. Remaining fields can change between versions.
 // Version is uint32_t because it would be padded to 4 bytes anyway before the next
 // uint32_t field, so we use the full width rather than wasting 3 bytes of padding.
-static constexpr uint32_t CRASH_DATA_VERSION = 2;
+static constexpr uint32_t CRASH_DATA_VERSION = 1;
 struct RawCrashData {
   uint32_t version;
   uint32_t magic;
@@ -130,13 +77,6 @@ struct RawCrashData {
   uint8_t pseudo_excause;   // Whether cause is a pseudo exception (Xtensa SoC-level panic)
   uint32_t backtrace[MAX_BACKTRACE];
   uint32_t cause;  // Architecture-specific: exccause (Xtensa) or mcause (RISC-V)
-  uint8_t crashed_core;
-#if SOC_CPU_CORES_NUM > 1
-  static_assert(SOC_CPU_CORES_NUM == 2, "Dual-core logic assumes exactly 2 cores");
-  uint8_t other_backtrace_count;
-  uint8_t other_reg_frame_count;
-  uint32_t other_backtrace[MAX_BACKTRACE];
-#endif
 };
 static RawCrashData __attribute__((section(".noinit")))
 s_raw_crash_data;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -160,28 +100,13 @@ void crash_handler_read_and_clear() {
       s_raw_crash_data.exception = 4;    // Default to PANIC_EXCEPTION_FAULT
     if (s_raw_crash_data.pseudo_excause > 1)
       s_raw_crash_data.pseudo_excause = 0;
-    if (s_raw_crash_data.crashed_core >= SOC_CPU_CORES_NUM)
-      s_raw_crash_data.crashed_core = 0;
-#if SOC_CPU_CORES_NUM > 1
-    if (s_raw_crash_data.other_backtrace_count > MAX_BACKTRACE)
-      s_raw_crash_data.other_backtrace_count = MAX_BACKTRACE;
-    if (s_raw_crash_data.other_reg_frame_count > s_raw_crash_data.other_backtrace_count)
-      s_raw_crash_data.other_reg_frame_count = s_raw_crash_data.other_backtrace_count;
-#endif
   }
-  // Don't clear magic here — crash data must survive OTA rollback reboots.
-  // Magic is cleared by crash_handler_clear() after an API client receives the data.
+  // Clear magic regardless so we don't re-report on next normal reboot
+  s_raw_crash_data.magic = 0;
 }
 
 bool crash_handler_has_data() { return s_crash_data_valid; }
 
-void crash_handler_clear() {
-  // Only clear the magic so data doesn't survive the next reboot.
-  // Keep s_crash_data_valid so crash_handler_log() still works for
-  // additional API clients connecting during this boot session.
-  s_raw_crash_data.magic = 0;
-}
-
 // Look up the exception cause as a human-readable string.
 // Tables mirror ESP-IDF's panic_arch_fill_info() which uses local static arrays
 // not exposed via any public API.
@@ -287,36 +212,6 @@ static const char *get_exception_type() {
   return "Unknown";
 }
 
-// Log backtrace entries, filtering stack-scanned addresses on RISC-V.
-static void log_backtrace(const uint32_t *addrs, uint8_t count, uint8_t reg_frame_count) {
-  uint8_t bt_num = 0;
-  for (uint8_t i = 0; i < count; i++) {
-    uint32_t addr = addrs[i];
-#if CONFIG_IDF_TARGET_ARCH_RISCV
-    if (i >= reg_frame_count && !is_return_addr(addr))
-      continue;
-    const char *source = (i < reg_frame_count) ? "backtrace" : "stack scan";
-#else
-    const char *source = "backtrace";
-#endif
-    ESP_LOGE(TAG, "  BT%d: 0x%08" PRIX32 "  (%s)", bt_num++, addr, source);
-  }
-}
-
-// Append backtrace addresses to the addr2line hint buffer.
-static int append_addrs_to_hint(char *buf, int size, int pos, const uint32_t *addrs, uint8_t count,
-                                uint8_t reg_frame_count) {
-  for (uint8_t i = 0; i < count && pos < size - 12; i++) {
-    uint32_t addr = addrs[i];
-#if CONFIG_IDF_TARGET_ARCH_RISCV
-    if (i >= reg_frame_count && !is_return_addr(addr))
-      continue;
-#endif
-    pos += snprintf(buf + pos, size - pos, " 0x%08" PRIX32, addr);
-  }
-  return pos;
-}
-
 // Intentionally uses separate ESP_LOGE calls per line instead of combining into
 // one multi-line log message. This ensures each address appears as its own line
 // on the serial console, making it possible to see partial output if the device
@@ -333,28 +228,33 @@ void crash_handler_log() {
   } else {
     ESP_LOGE(TAG, "  Reason: %s", get_exception_type());
   }
-  ESP_LOGE(TAG, "  Crashed core: %d", s_raw_crash_data.crashed_core);
   ESP_LOGE(TAG, "  PC:  0x%08" PRIX32 "  (fault location)", s_raw_crash_data.pc);
-  log_backtrace(s_raw_crash_data.backtrace, s_raw_crash_data.backtrace_count, s_raw_crash_data.reg_frame_count);
-
-#if SOC_CPU_CORES_NUM > 1
-  if (s_raw_crash_data.other_backtrace_count > 0) {
-    int other_core = 1 - s_raw_crash_data.crashed_core;
-    ESP_LOGE(TAG, "  Other core (%d) backtrace:", other_core);
-    log_backtrace(s_raw_crash_data.other_backtrace, s_raw_crash_data.other_backtrace_count,
-                  s_raw_crash_data.other_reg_frame_count);
-  }
+  uint8_t bt_num = 0;
+  for (uint8_t i = 0; i < s_raw_crash_data.backtrace_count; i++) {
+    uint32_t addr = s_raw_crash_data.backtrace[i];
+#if CONFIG_IDF_TARGET_ARCH_RISCV
+    // Register-sourced entries (MEPC/RA) are trusted; only filter stack-scanned ones.
+    if (i >= s_raw_crash_data.reg_frame_count && !is_return_addr(addr))
+      continue;
 #endif
-
+#if CONFIG_IDF_TARGET_ARCH_RISCV
+    const char *source = (i < s_raw_crash_data.reg_frame_count) ? "backtrace" : "stack scan";
+#else
+    const char *source = "backtrace";
+#endif
+    ESP_LOGE(TAG, "  BT%d: 0x%08" PRIX32 "  (%s)", bt_num++, addr, source);
+  }
   // Build addr2line hint with all captured addresses for easy copy-paste
   char hint[256];
   int pos = snprintf(hint, sizeof(hint), "Use: addr2line -pfiaC -e firmware.elf 0x%08" PRIX32, s_raw_crash_data.pc);
-  pos = append_addrs_to_hint(hint, sizeof(hint), pos, s_raw_crash_data.backtrace, s_raw_crash_data.backtrace_count,
-                             s_raw_crash_data.reg_frame_count);
-#if SOC_CPU_CORES_NUM > 1
-  append_addrs_to_hint(hint, sizeof(hint), pos, s_raw_crash_data.other_backtrace,
-                       s_raw_crash_data.other_backtrace_count, s_raw_crash_data.other_reg_frame_count);
+  for (uint8_t i = 0; i < s_raw_crash_data.backtrace_count && pos < (int) sizeof(hint) - 12; i++) {
+    uint32_t addr = s_raw_crash_data.backtrace[i];
+#if CONFIG_IDF_TARGET_ARCH_RISCV
+    if (i >= s_raw_crash_data.reg_frame_count && !is_return_addr(addr))
+      continue;
 #endif
+    pos += snprintf(hint + pos, sizeof(hint) - pos, " 0x%08" PRIX32, addr);
+  }
   ESP_LOGE(TAG, "%s", hint);
 }
 
@@ -376,54 +276,68 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
   s_raw_crash_data.reg_frame_count = 0;
   s_raw_crash_data.exception = (uint8_t) info->exception;
   s_raw_crash_data.pseudo_excause = info->pseudo_excause ? 1 : 0;
-  s_raw_crash_data.crashed_core = (uint8_t) info->core;
-#if SOC_CPU_CORES_NUM > 1
-  s_raw_crash_data.other_backtrace_count = 0;
-  s_raw_crash_data.other_reg_frame_count = 0;
-#endif
 
 #if CONFIG_IDF_TARGET_ARCH_XTENSA
   // Xtensa: walk the backtrace using the public API
   if (info->frame != nullptr) {
     auto *xt_frame = (XtExcFrame *) info->frame;
     s_raw_crash_data.cause = xt_frame->exccause;
-    s_raw_crash_data.backtrace_count = walk_xtensa_backtrace(xt_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE);
-  }
+    esp_backtrace_frame_t bt_frame = {
+        .pc = (uint32_t) xt_frame->pc,
+        .sp = (uint32_t) xt_frame->a1,
+        .next_pc = (uint32_t) xt_frame->a0,
+        .exc_frame = xt_frame,
+    };
 
-#if SOC_CPU_CORES_NUM > 1
-  // Capture the other core's backtrace from the global frame array.
-  // Both cores save their frames to g_exc_frames[] before esp_panic_handler
-  // is called, so the other core's frame is available here.
-  if (info->core >= 0 && info->core < SOC_CPU_CORES_NUM) {
-    int other_core = 1 - info->core;
-    auto *other_frame = (XtExcFrame *) g_exc_frames[other_core];
-    if (other_frame != nullptr) {
-      s_raw_crash_data.other_backtrace_count =
-          walk_xtensa_backtrace(other_frame, s_raw_crash_data.other_backtrace, MAX_BACKTRACE);
+    uint8_t count = 0;
+    // First frame PC
+    uint32_t first_pc = esp_cpu_process_stack_pc(bt_frame.pc);
+    if (is_code_addr(first_pc)) {
+      s_raw_crash_data.backtrace[count++] = first_pc;
     }
+    // Walk remaining frames
+    while (count < MAX_BACKTRACE && bt_frame.next_pc != 0) {
+      if (!esp_backtrace_get_next_frame(&bt_frame)) {
+        break;
+      }
+      uint32_t pc = esp_cpu_process_stack_pc(bt_frame.pc);
+      if (is_code_addr(pc)) {
+        s_raw_crash_data.backtrace[count++] = pc;
+      }
+    }
+    s_raw_crash_data.backtrace_count = count;
   }
-#endif
 
 #elif CONFIG_IDF_TARGET_ARCH_RISCV
   // RISC-V: capture MEPC + RA, then scan stack for code addresses
   if (info->frame != nullptr) {
     auto *rv_frame = (RvExcFrame *) info->frame;
     s_raw_crash_data.cause = rv_frame->mcause;
-    s_raw_crash_data.backtrace_count =
-        capture_riscv_backtrace(rv_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE, &s_raw_crash_data.reg_frame_count);
-  }
+    uint8_t count = 0;
 
-#if SOC_CPU_CORES_NUM > 1
-  // Capture the other core's backtrace from the global frame array.
-  if (info->core >= 0 && info->core < SOC_CPU_CORES_NUM) {
-    int other_core = 1 - info->core;
-    auto *other_frame = (RvExcFrame *) g_exc_frames[other_core];
-    if (other_frame != nullptr) {
-      s_raw_crash_data.other_backtrace_count = capture_riscv_backtrace(
-          other_frame, s_raw_crash_data.other_backtrace, MAX_BACKTRACE, &s_raw_crash_data.other_reg_frame_count);
+    // Save MEPC (fault PC) and RA (return address)
+    if (is_code_addr(rv_frame->mepc)) {
+      s_raw_crash_data.backtrace[count++] = rv_frame->mepc;
     }
+    if (is_code_addr(rv_frame->ra) && rv_frame->ra != rv_frame->mepc) {
+      s_raw_crash_data.backtrace[count++] = rv_frame->ra;
+    }
+
+    // Track how many entries came from registers (MEPC/RA) so we can
+    // skip return-address validation for them at log time.
+    s_raw_crash_data.reg_frame_count = count;
+
+    // Scan stack for code addresses — captures broadly during panic,
+    // filtered by is_return_addr() at log time when flash is accessible.
+    auto *scan_start = (uint32_t *) rv_frame->sp;
+    for (uint32_t i = 0; i < 64 && count < MAX_BACKTRACE; i++) {
+      uint32_t val = scan_start[i];
+      if (is_code_addr(val) && val != rv_frame->mepc && val != rv_frame->ra) {
+        s_raw_crash_data.backtrace[count++] = val;
+      }
+    }
+    s_raw_crash_data.backtrace_count = count;
   }
-#endif
 #endif
 
   // Write version and magic last — ensures all data is written before we mark it valid

esphome/components/esp32/crash_handler.h

@@ -4,18 +4,12 @@
 
 namespace esphome::esp32 {
 
-/// Read and validate crash data from NOINIT memory.
-/// Does not clear the magic marker — call crash_handler_clear() after
-/// the data has been delivered to an API client so it survives OTA rollback reboots.
+/// Read crash data from NOINIT memory and clear the magic marker.
 void crash_handler_read_and_clear();
 
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();
 
-/// Clear the magic marker and mark crash data as consumed.
-/// Call after the data has been delivered to an API client.
-void crash_handler_clear();
-
 /// Returns true if crash data was found this boot.
 bool crash_handler_has_data();
 

esphome/components/esp8266_pwm/output.py

@@ -62,6 +62,6 @@ async def to_code(config) -> None:
 async def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_FREQUENCY], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
     cg.add(var.set_frequency(template_))
     return var

esphome/components/ezo_pmp/__init__.py

@@ -202,7 +202,7 @@ async def ezo_pmp_dose_volume_over_time_to_code(config, action_id, template_arg,
     template_ = await cg.templatable(config[CONF_VOLUME], args, cg.double)
     cg.add(var.set_volume(template_))
 
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int_)
+    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int32)
     cg.add(var.set_duration(template_))
 
     return var
@@ -236,7 +236,7 @@ async def ezo_pmp_dose_with_constant_flow_rate_to_code(
     template_ = await cg.templatable(config[CONF_VOLUME_PER_MINUTE], args, cg.double)
     cg.add(var.set_volume(template_))
 
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int_)
+    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int32)
     cg.add(var.set_duration(template_))
 
     return var

esphome/components/fan/__init__.py

@@ -345,10 +345,10 @@ async def fan_turn_on_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
     if (oscillating := config.get(CONF_OSCILLATING)) is not None:
-        template_ = await cg.templatable(oscillating, args, cg.bool_)
+        template_ = await cg.templatable(oscillating, args, bool)
         cg.add(var.set_oscillating(template_))
     if (speed := config.get(CONF_SPEED)) is not None:
-        template_ = await cg.templatable(speed, args, cg.int_)
+        template_ = await cg.templatable(speed, args, cg.int32)
         cg.add(var.set_speed(template_))
     if (direction := config.get(CONF_DIRECTION)) is not None:
         template_ = await cg.templatable(direction, args, FanDirection)
@@ -370,7 +370,7 @@ async def fan_turn_on_to_code(config, action_id, template_arg, args):
 async def fan_cycle_speed_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_OFF_SPEED_CYCLE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_OFF_SPEED_CYCLE], args, bool)
     cg.add(var.set_no_off_cycle(template_))
     return var
 

esphome/components/fan/fan.cpp

@@ -9,22 +9,6 @@ namespace fan {
 
 static const char *const TAG = "fan";
 
-// Compat: shared empty vector for getter when no preset modes are set.
-// Remove in 2026.11.0 when deprecated FanTraits setters are removed
-// and getter can return const vector * instead of const vector &.
-static const std::vector<const char *> EMPTY_PRESET_MODES;  // NOLINT
-
-const std::vector<const char *> &FanTraits::supported_preset_modes() const {
-  if (this->preset_modes_) {
-    return *this->preset_modes_;
-  }
-  // Compat: fall back to owned vector from deprecated setters. Remove in 2026.11.0 (change return to const vector *).
-  if (!this->compat_preset_modes_.empty()) {
-    return this->compat_preset_modes_;
-  }
-  return EMPTY_PRESET_MODES;
-}
-
 // Fan direction strings indexed by FanDirection enum (0-1): FORWARD, REVERSE, plus UNKNOWN
 PROGMEM_STRING_TABLE(FanDirectionStrings, "FORWARD", "REVERSE", "UNKNOWN");
 
@@ -164,18 +148,6 @@ const char *Fan::find_preset_mode_(const char *preset_mode) {
 }
 
 const char *Fan::find_preset_mode_(const char *preset_mode, size_t len) {
-  if (preset_mode == nullptr || len == 0) {
-    return nullptr;
-  }
-  if (this->supported_preset_modes_) {
-    for (const char *mode : *this->supported_preset_modes_) {
-      if (strncmp(mode, preset_mode, len) == 0 && mode[len] == '\0') {
-        return mode;
-      }
-    }
-    return nullptr;
-  }
-  // Fallback for deprecated path: external components may set modes on FanTraits directly
   return this->get_traits().find_preset_mode(preset_mode, len);
 }
 
@@ -289,6 +261,8 @@ void Fan::save_state_() {
     return;
   }
 
+  auto traits = this->get_traits();
+
   FanRestoreState state{};
   state.state = this->state;
   state.oscillating = this->oscillating;
@@ -297,25 +271,12 @@ void Fan::save_state_() {
   state.preset_mode = FanRestoreState::NO_PRESET;
 
   if (this->has_preset_mode()) {
-    if (this->supported_preset_modes_) {
-      // New path: search Fan-owned vector directly
-      for (size_t i = 0; i < this->supported_preset_modes_->size(); i++) {
-        if ((*this->supported_preset_modes_)[i] == this->preset_mode_) {
-          state.preset_mode = i;
-          break;
-        }
-      }
-    } else {
-      // Compat: fall back to traits for deprecated path. Remove in 2026.11.0.
-      // Pointer comparison works because preset_mode_ and the compat vector both
-      // hold pointers to string literals in .rodata (stable addresses).
-      auto traits = this->get_traits();
-      const auto &preset_modes = traits.supported_preset_modes();
-      for (size_t i = 0; i < preset_modes.size(); i++) {
-        if (preset_modes[i] == this->preset_mode_) {
-          state.preset_mode = i;
-          break;
-        }
+    const auto &preset_modes = traits.supported_preset_modes();
+    // Find index of current preset mode (pointer comparison is safe since preset is from traits)
+    for (size_t i = 0; i < preset_modes.size(); i++) {
+      if (preset_modes[i] == this->preset_mode_) {
+        state.preset_mode = i;
+        break;
       }
     }
   }

esphome/components/fan/fan.h

@@ -130,14 +130,6 @@ class Fan : public EntityBase {
 
   virtual FanTraits get_traits() = 0;
 
-  /// Set the supported preset modes (stored on Fan, referenced by FanTraits via pointer).
-  void set_supported_preset_modes(std::initializer_list<const char *> preset_modes) {
-    this->ensure_preset_modes_().assign(preset_modes.begin(), preset_modes.end());
-  }
-  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) {
-    this->ensure_preset_modes_() = preset_modes;
-  }
-
   /// Set the restore mode of this fan.
   void set_restore_mode(FanRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
 
@@ -175,27 +167,11 @@ class Fan : public EntityBase {
   const char *find_preset_mode_(const char *preset_mode);
   const char *find_preset_mode_(const char *preset_mode, size_t len);
 
-  /// Wire the Fan-owned preset modes pointer into the given traits object.
-  void wire_preset_modes_(FanTraits &traits) {
-    if (this->supported_preset_modes_) {
-      traits.set_supported_preset_modes_(this->supported_preset_modes_);
-    }
-  }
-
   LazyCallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;
   FanRestoreMode restore_mode_;
 
  private:
-  /// Lazy-allocate preset modes vector (never freed — entity lives forever).
-  std::vector<const char *> &ensure_preset_modes_() {
-    if (!this->supported_preset_modes_) {
-      this->supported_preset_modes_ = new std::vector<const char *>();  // NOLINT
-    }
-    return *this->supported_preset_modes_;
-  }
-
-  std::vector<const char *> *supported_preset_modes_{nullptr};
   const char *preset_mode_{nullptr};
 };
 

esphome/components/fan/fan_traits.h

@@ -3,17 +3,12 @@
 #include <cstring>
 #include <vector>
 #include <initializer_list>
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 
 namespace fan {
 
-class Fan;  // Forward declaration
-
 class FanTraits {
-  friend class Fan;  // Allow Fan to access protected pointer setter
-
  public:
   FanTraits() = default;
   FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
@@ -35,64 +30,42 @@ class FanTraits {
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
-  // Compat: returns const ref with empty fallback. In 2026.11.0 change to return const vector *.
-  const std::vector<const char *> &supported_preset_modes() const;
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_preset_modes() on the Fan entity instead. Removed in 2026.11.0", "2026.5.0")
+  /// Return the preset modes supported by the fan.
+  const std::vector<const char *> &supported_preset_modes() const { return this->preset_modes_; }
+  /// Set the preset modes supported by the fan (from initializer list).
   void set_supported_preset_modes(std::initializer_list<const char *> preset_modes) {
-    // Compat: store in owned vector. Copies copy the vector (deprecated path still copies this vector).
-    this->compat_preset_modes_ = preset_modes;
-  }
-  // Remove before 2026.11.0
-  ESPDEPRECATED("Call set_supported_preset_modes() on the Fan entity instead. Removed in 2026.11.0", "2026.5.0")
-  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) {
-    this->compat_preset_modes_ = preset_modes;
+    this->preset_modes_ = preset_modes;
   }
+  /// Set the preset modes supported by the fan (from vector).
+  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) { this->preset_modes_ = preset_modes; }
 
   // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
   void set_supported_preset_modes(const std::vector<std::string> &preset_modes) = delete;
   void set_supported_preset_modes(std::initializer_list<std::string> preset_modes) = delete;
 
   /// Return if preset modes are supported
-  bool supports_preset_modes() const {
-    // Same precedence as supported_preset_modes() getter
-    if (this->preset_modes_) {
-      return !this->preset_modes_->empty();
-    }
-    return !this->compat_preset_modes_.empty();
-  }
+  bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
   /// Find and return the matching preset mode pointer from supported modes, or nullptr if not found.
   const char *find_preset_mode(const char *preset_mode) const {
     return this->find_preset_mode(preset_mode, preset_mode ? strlen(preset_mode) : 0);
   }
   const char *find_preset_mode(const char *preset_mode, size_t len) const {
-    if (preset_mode == nullptr || len == 0) {
+    if (preset_mode == nullptr || len == 0)
       return nullptr;
-    }
-    // Check pointer-based storage (new path) then compat owned vector (deprecated path)
-    const auto &modes = this->preset_modes_ ? *this->preset_modes_ : this->compat_preset_modes_;
-    for (const char *mode : modes) {
+    for (const char *mode : this->preset_modes_) {
       if (strncmp(mode, preset_mode, len) == 0 && mode[len] == '\0') {
-        return mode;
+        return mode;  // Return pointer from traits
       }
     }
     return nullptr;
   }
 
  protected:
-  /// Set the preset modes pointer (only Fan::wire_preset_modes_() should call this).
-  void set_supported_preset_modes_(const std::vector<const char *> *preset_modes) {
-    this->preset_modes_ = preset_modes;
-  }
-
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
-  const std::vector<const char *> *preset_modes_{nullptr};
-  // Compat: owned storage for deprecated setters. Copies copy the vector (copies include this vector).
-  // Remove in 2026.11.0.
-  std::vector<const char *> compat_preset_modes_;
+  std::vector<const char *> preset_modes_{};
 };
 
 }  // namespace fan

esphome/components/gdk101/gdk101.cpp

@@ -7,7 +7,7 @@ namespace gdk101 {
 
 static const char *const TAG = "gdk101";
 static constexpr uint8_t NUMBER_OF_READ_RETRIES = 5;
-static constexpr uint8_t NUMBER_OF_RESET_RETRIES = 30;
+static constexpr uint8_t NUMBER_OF_RESET_RETRIES = 10;
 static constexpr uint32_t RESET_INTERVAL_ID = 0;
 static constexpr uint32_t RESET_INTERVAL_MS = 1000;
 

esphome/components/grove_tb6612fng/__init__.py

@@ -78,7 +78,7 @@ async def grove_tb6612fng_run_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
+    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.int32)
     template_speed = await cg.templatable(config[CONF_SPEED], args, cg.uint16)
     cg.add(var.set_channel(template_channel))
     cg.add(var.set_speed(template_speed))
@@ -101,7 +101,7 @@ async def grove_tb6612fng_break_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
+    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.int32)
     cg.add(var.set_channel(template_channel))
     return var
 
@@ -121,7 +121,7 @@ async def grove_tb6612fng_stop_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
+    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.int32)
     cg.add(var.set_channel(template_channel))
     return var
 
@@ -175,6 +175,6 @@ async def grove_tb6612fng_change_address_to_code(config, action_id, template_arg
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
+    template_channel = await cg.templatable(config[CONF_ADDRESS], args, cg.int32)
     cg.add(var.set_address(template_channel))
     return var

esphome/components/hbridge/fan/hbridge_fan.cpp

@@ -30,6 +30,7 @@ fan::FanCall HBridgeFan::brake() {
 void HBridgeFan::setup() {
   // Construct traits before restore so preset modes can be looked up by index
   this->traits_ = fan::FanTraits(this->oscillating_ != nullptr, true, true, this->speed_count_);
+  this->traits_.set_supported_preset_modes(this->preset_modes_);
 
   auto restore = this->restore_state_();
   if (restore.has_value()) {

esphome/components/hbridge/fan/hbridge_fan.h

@@ -20,14 +20,11 @@ class HBridgeFan : public Component, public fan::Fan {
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
   void set_enable_pin(output::FloatOutput *enable) { enable_ = enable; }
-  void set_preset_modes(std::initializer_list<const char *> presets) { this->set_supported_preset_modes(presets); }
+  void set_preset_modes(std::initializer_list<const char *> presets) { preset_modes_ = presets; }
 
   void setup() override;
   void dump_config() override;
-  fan::FanTraits get_traits() override {
-    this->wire_preset_modes_(this->traits_);
-    return this->traits_;
-  }
+  fan::FanTraits get_traits() override { return this->traits_; }
 
   fan::FanCall brake();
 
@@ -39,6 +36,7 @@ class HBridgeFan : public Component, public fan::Fan {
   int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
+  std::vector<const char *> preset_modes_{};
 
   void control(const fan::FanCall &call) override;
   void write_state_();

esphome/components/hbridge/light/__init__.py

@@ -8,7 +8,7 @@ from .. import hbridge_ns
 CODEOWNERS = ["@DotNetDann"]
 
 HBridgeLightOutput = hbridge_ns.class_(
-    "HBridgeLightOutput", cg.Component, light.LightOutput
+    "HBridgeLightOutput", cg.PollingComponent, light.LightOutput
 )
 
 CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend(

esphome/components/hbridge/light/hbridge_light_output.h

@@ -1,17 +1,20 @@
 #pragma once
 
-#include "esphome/components/light/light_output.h"
-#include "esphome/components/output/float_output.h"
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
+#include "esphome/components/output/float_output.h"
+#include "esphome/components/light/light_output.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace hbridge {
 
-class HBridgeLightOutput : public Component, public light::LightOutput {
+// Using PollingComponent as the updates are more consistent and reduces flickering
+class HBridgeLightOutput : public PollingComponent, public light::LightOutput {
  public:
-  void set_pina_pin(output::FloatOutput *pina_pin) { this->pina_pin_ = pina_pin; }
-  void set_pinb_pin(output::FloatOutput *pinb_pin) { this->pinb_pin_ = pinb_pin; }
+  HBridgeLightOutput() : PollingComponent(1) {}
+
+  void set_pina_pin(output::FloatOutput *pina_pin) { pina_pin_ = pina_pin; }
+  void set_pinb_pin(output::FloatOutput *pinb_pin) { pinb_pin_ = pinb_pin; }
 
   light::LightTraits get_traits() override {
     auto traits = light::LightTraits();
@@ -21,16 +24,16 @@ class HBridgeLightOutput : public Component, public light::LightOutput {
     return traits;
   }
 
-  void setup() override { this->disable_loop(); }
+  void setup() override { this->forward_direction_ = false; }
 
-  void loop() override {
-    // Only called when both channels are active — alternate H-bridge direction
-    // each iteration to multiplex cold and warm white.
-    if (!this->forward_direction_) {
+  void update() override {
+    // This method runs around 60 times per second
+    // We cannot do the PWM ourselves so we are reliant on the hardware PWM
+    if (!this->forward_direction_) {  // First LED Direction
       this->pina_pin_->set_level(this->pina_duty_);
       this->pinb_pin_->set_level(0);
       this->forward_direction_ = true;
-    } else {
+    } else {  // Second LED Direction
       this->pina_pin_->set_level(0);
       this->pinb_pin_->set_level(this->pinb_duty_);
       this->forward_direction_ = false;
@@ -40,32 +43,15 @@ class HBridgeLightOutput : public Component, public light::LightOutput {
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
   void write_state(light::LightState *state) override {
-    float new_pina, new_pinb;
-    state->current_values_as_cwww(&new_pina, &new_pinb, false);
-
-    this->pina_duty_ = new_pina;
-    this->pinb_duty_ = new_pinb;
-
-    if (new_pina != 0.0f && new_pinb != 0.0f) {
-      // Both channels active — need loop to alternate H-bridge direction
-      this->high_freq_.start();
-      this->enable_loop();
-    } else {
-      // Zero or one channel active — drive pins directly, no multiplexing needed
-      this->high_freq_.stop();
-      this->disable_loop();
-      this->pina_pin_->set_level(new_pina);
-      this->pinb_pin_->set_level(new_pinb);
-    }
+    state->current_values_as_cwww(&this->pina_duty_, &this->pinb_duty_, false);
   }
 
  protected:
   output::FloatOutput *pina_pin_;
   output::FloatOutput *pinb_pin_;
-  float pina_duty_{0};
-  float pinb_duty_{0};
-  bool forward_direction_{false};
-  HighFrequencyLoopRequester high_freq_;
+  float pina_duty_ = 0;
+  float pinb_duty_ = 0;
+  bool forward_direction_ = false;
 };
 
 }  // namespace hbridge

esphome/components/htu21d/sensor.py

@@ -98,7 +98,7 @@ async def to_code(config):
 async def set_heater_level_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    level_ = await cg.templatable(config[CONF_LEVEL], args, cg.uint8)
+    level_ = await cg.templatable(config[CONF_LEVEL], args, cg.int32)
     cg.add(var.set_level(level_))
     return var
 
@@ -118,6 +118,6 @@ async def set_heater_level_to_code(config, action_id, template_arg, args):
 async def set_heater_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    status_ = await cg.templatable(config[CONF_STATUS], args, cg.bool_)
+    status_ = await cg.templatable(config[CONF_STATUS], args, bool)
     cg.add(var.set_status(status_))
     return var

esphome/components/integration/sensor.py

@@ -133,6 +133,6 @@ async def sensor_integration_reset_to_code(config, action_id, template_arg, args
 async def sensor_integration_set_value_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_VALUE], args, float)
     cg.add(var.set_value(template_))
     return var

esphome/components/json/json_util.cpp

@@ -140,11 +140,8 @@ SerializationBuffer<> JsonBuilder::serialize() {
     heap_size *= 2;
   }
   // Payload exceeds 5120 bytes - return truncated result
-  // heap_size was doubled after the last iteration, so the actual allocated
-  // buffer capacity is heap_size/2. Clamp to avoid writing past the buffer.
-  size_t max_content = heap_size / 2 - 1;
-  ESP_LOGW(TAG, "JSON payload too large, truncated to %zu bytes", max_content);
-  result.set_size_(max_content);
+  ESP_LOGW(TAG, "JSON payload too large, truncated to %zu bytes", size);
+  result.set_size_(size);
   return result;
 }
 

esphome/components/ledc/output.py

@@ -82,6 +82,6 @@ async def to_code(config):
 async def ledc_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_FREQUENCY], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
     cg.add(var.set_frequency(template_))
     return var

esphome/components/libretiny_pwm/output.py

@@ -43,6 +43,6 @@ async def to_code(config):
 async def libretiny_pwm_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_FREQUENCY], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
     cg.add(var.set_frequency(template_))
     return var

esphome/components/light/automation.py

@@ -183,18 +183,18 @@ async def light_control_to_code(config, action_id, template_arg, args):
     # (config_key, setter_name, c++ type)
     FIELDS = (
         (CONF_COLOR_MODE, "set_color_mode", ColorMode),
-        (CONF_STATE, "set_state", cg.bool_),
+        (CONF_STATE, "set_state", bool),
         (CONF_TRANSITION_LENGTH, "set_transition_length", cg.uint32),
         (CONF_FLASH_LENGTH, "set_flash_length", cg.uint32),
-        (CONF_BRIGHTNESS, "set_brightness", cg.float_),
-        (CONF_COLOR_BRIGHTNESS, "set_color_brightness", cg.float_),
-        (CONF_RED, "set_red", cg.float_),
-        (CONF_GREEN, "set_green", cg.float_),
-        (CONF_BLUE, "set_blue", cg.float_),
-        (CONF_WHITE, "set_white", cg.float_),
-        (CONF_COLOR_TEMPERATURE, "set_color_temperature", cg.float_),
-        (CONF_COLD_WHITE, "set_cold_white", cg.float_),
-        (CONF_WARM_WHITE, "set_warm_white", cg.float_),
+        (CONF_BRIGHTNESS, "set_brightness", float),
+        (CONF_COLOR_BRIGHTNESS, "set_color_brightness", float),
+        (CONF_RED, "set_red", float),
+        (CONF_GREEN, "set_green", float),
+        (CONF_BLUE, "set_blue", float),
+        (CONF_WHITE, "set_white", float),
+        (CONF_COLOR_TEMPERATURE, "set_color_temperature", float),
+        (CONF_COLD_WHITE, "set_cold_white", float),
+        (CONF_WARM_WHITE, "set_warm_white", float),
     )
     for conf_key, setter, type_ in FIELDS:
         if conf_key in config:
@@ -262,7 +262,7 @@ LIGHT_DIM_RELATIVE_ACTION_SCHEMA = cv.Schema(
 async def light_dim_relative_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    templ = await cg.templatable(config[CONF_RELATIVE_BRIGHTNESS], args, cg.float_)
+    templ = await cg.templatable(config[CONF_RELATIVE_BRIGHTNESS], args, float)
     cg.add(var.set_relative_brightness(templ))
     if CONF_TRANSITION_LENGTH in config:
         templ = await cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)

esphome/components/lvgl/automation.py

@@ -2,7 +2,6 @@ from collections.abc import Callable
 from typing import Any
 
 from esphome import automation
-from esphome.automation import StatelessLambdaAction
 import esphome.codegen as cg
 from esphome.components.display import validate_rotation
 import esphome.config_validation as cv
@@ -202,7 +201,7 @@ def _validate_rotation(value):
 
 @automation.register_action(
     "lvgl.display.set_rotation",
-    StatelessLambdaAction,
+    ObjUpdateAction,
     cv.maybe_simple_value(
         LVGL_SCHEMA.extend(
             {
@@ -215,7 +214,8 @@ def _validate_rotation(value):
 )
 async def lvgl_set_rotation(config, action_id, template_arg, args):
     lv_comp = await cg.get_variable(config[CONF_LVGL_ID])
-    async with LambdaContext(args, where=action_id) as context:
+    async with LambdaContext() as context:
+        add_line_marks(where=action_id)
         lv_add(lv_comp.set_rotation(config[CONF_ROTATION]))
     return cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
 

esphome/components/lvgl/widgets/tabview.py

@@ -2,7 +2,6 @@ from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_BUTTON,
     CONF_ID,
     CONF_INDEX,
     CONF_ITEMS,
@@ -74,7 +73,7 @@ class TabviewType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON
+        return CONF_BUTTONMATRIX, TYPE_FLEX
 
     async def to_code(self, w: Widget, config: dict):
         await w.set_property(

esphome/components/mcp23016/__init__.py

@@ -5,7 +5,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
     CONF_INPUT,
-    CONF_INTERRUPT_PIN,
     CONF_INVERTED,
     CONF_MODE,
     CONF_NUMBER,
@@ -25,7 +24,6 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.declare_id(MCP23016),
-            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -37,8 +35,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
-    if interrupt_pin := config.get(CONF_INTERRUPT_PIN):
-        cg.add(var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin)))
 
 
 def validate_mode(value):

esphome/components/mcp23016/mcp23016.cpp

@@ -24,22 +24,11 @@ void MCP23016::setup() {
 
   // all pins input
   this->write_reg_(MCP23016_IODIR1, 0xFFFF);
-
-  if (this->interrupt_pin_ != nullptr) {
-    this->interrupt_pin_->setup();
-    this->interrupt_pin_->attach_interrupt(&MCP23016::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE);
-    this->set_invalidate_on_read_(false);
-  }
-  this->disable_loop();
 }
 
-void IRAM_ATTR MCP23016::gpio_intr(MCP23016 *arg) { arg->enable_loop_soon_any_context(); }
 void MCP23016::loop() {
   // Invalidate cache at the start of each loop
   this->reset_pin_cache_();
-  if (this->interrupt_pin_ != nullptr) {
-    this->disable_loop();
-  }
 }
 bool MCP23016::digital_read_hw(uint8_t pin) { return this->read_reg_(MCP23016_GP1, &this->input_mask_); }
 
@@ -48,9 +37,6 @@ void MCP23016::digital_write_hw(uint8_t pin, bool value) { this->update_reg_(pin
 void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
   if (flags == gpio::FLAG_INPUT) {
     this->update_reg_(pin, true, MCP23016_IODIR1);
-    if (this->interrupt_pin_ == nullptr) {
-      this->enable_loop();
-    }
   } else if (flags == gpio::FLAG_OUTPUT) {
     this->update_reg_(pin, false, MCP23016_IODIR1);
   }

esphome/components/mcp23016/mcp23016.h

@@ -35,10 +35,7 @@ class MCP23016 : public Component, public i2c::I2CDevice, public gpio_expander::
 
   float get_setup_priority() const override;
 
-  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
-
  protected:
-  static void IRAM_ATTR gpio_intr(MCP23016 *arg);
   // Virtual methods from CachedGpioExpander
   bool digital_read_hw(uint8_t pin) override;
   bool digital_read_cache(uint8_t pin) override;
@@ -54,7 +51,6 @@ class MCP23016 : public Component, public i2c::I2CDevice, public gpio_expander::
   uint16_t olat_{0x0000};
   // Cache for input values (16-bit combined for both banks)
   uint16_t input_mask_{0x0000};
-  InternalGPIOPin *interrupt_pin_{nullptr};
 };
 
 class MCP23016GPIOPin : public GPIOPin {

esphome/components/media_player/__init__.py

@@ -305,7 +305,7 @@ _register_state_conditions()
 async def media_player_volume_set_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    volume = await cg.templatable(config[CONF_VOLUME], args, cg.float_)
+    volume = await cg.templatable(config[CONF_VOLUME], args, float)
     cg.add(var.set_volume(volume))
     return var
 

esphome/components/midea/ac_adapter.cpp

@@ -168,8 +168,8 @@ void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::
     traits.add_supported_preset(ClimatePreset::CLIMATE_PRESET_BOOST);
   if (capabilities.supportEcoPreset())
     traits.add_supported_preset(ClimatePreset::CLIMATE_PRESET_ECO);
-  // Frost protection custom preset is handled by AirConditioner directly
-  // since custom presets are stored on the Climate base class
+  if (capabilities.supportFrostProtectionPreset())
+    traits.set_supported_custom_presets({Constants::FREEZE_PROTECTION});
 }
 
 }  // namespace ac

esphome/components/midea/air_conditioner.cpp

@@ -24,25 +24,6 @@ template<typename T> void update_property(T &property, const T &value, bool &fla
 }
 
 void AirConditioner::on_status_change() {
-  // Add frost protection custom preset once when autoconf completes
-  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK &&
-      this->base_.getCapabilities().supportFrostProtectionPreset() && !this->frost_protection_set_) {
-    // Read existing presets (set by codegen), append frost protection, write back
-    const auto &existing = this->get_traits().get_supported_custom_presets();
-    bool found = false;
-    for (const char *p : existing) {
-      if (strcmp(p, Constants::FREEZE_PROTECTION) == 0) {
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      std::vector<const char *> merged(existing.begin(), existing.end());
-      merged.push_back(Constants::FREEZE_PROTECTION);
-      this->set_supported_custom_presets(merged);
-    }
-    this->frost_protection_set_ = true;
-  }
   bool need_publish = false;
   update_property(this->target_temperature, this->base_.getTargetTemp(), need_publish);
   update_property(this->current_temperature, this->base_.getIndoorTemp(), need_publish);
@@ -110,15 +91,17 @@ ClimateTraits AirConditioner::traits() {
   traits.set_supported_modes(this->supported_modes_);
   traits.set_supported_swing_modes(this->supported_swing_modes_);
   traits.set_supported_presets(this->supported_presets_);
-  // Custom fan modes and presets are stored on Climate base class and wired via get_traits()
+  if (!this->supported_custom_presets_.empty())
+    traits.set_supported_custom_presets(this->supported_custom_presets_);
+  if (!this->supported_custom_fan_modes_.empty())
+    traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
   /* + MINIMAL SET OF CAPABILITIES */
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_AUTO);
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_LOW);
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_MEDIUM);
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_HIGH);
-  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK) {
+  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK)
     Converters::to_climate_traits(traits, this->base_.getCapabilities());
-  }
   if (!traits.get_supported_modes().empty())
     traits.add_supported_mode(ClimateMode::CLIMATE_MODE_OFF);
   if (!traits.get_supported_swing_modes().empty())

esphome/components/midea/air_conditioner.h

@@ -46,8 +46,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(std::initializer_list<const char *> presets) { this->set_supported_custom_presets(presets); }
-  void set_custom_fan_modes(std::initializer_list<const char *> modes) { this->set_supported_custom_fan_modes(modes); }
+  void set_custom_presets(std::initializer_list<const char *> presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(std::initializer_list<const char *> modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
@@ -55,7 +55,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   ClimateModeMask supported_modes_{};
   ClimateSwingModeMask supported_swing_modes_{};
   ClimatePresetMask supported_presets_{};
-  bool frost_protection_set_{false};
+  std::vector<const char *> supported_custom_presets_{};
+  std::vector<const char *> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/modbus_controller/output/__init__.py

@@ -11,7 +11,6 @@ from .. import (
     modbus_controller_ns,
 )
 from ..const import (
-    CONF_CUSTOM_COMMAND,
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_TYPE,
     CONF_USE_WRITE_MULTIPLE,
@@ -36,10 +35,6 @@ CONFIG_SCHEMA = cv.typed_schema(
         "coil": output.BINARY_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend(
             {
                 cv.GenerateID(): cv.declare_id(ModbusBinaryOutput),
-                cv.Required(CONF_ADDRESS): cv.positive_int,
-                cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid(
-                    "custom_command is not supported for outputs"
-                ),
                 cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
                 cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
             }
@@ -47,10 +42,6 @@ CONFIG_SCHEMA = cv.typed_schema(
         "holding": output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend(
             {
                 cv.GenerateID(): cv.declare_id(ModbusFloatOutput),
-                cv.Required(CONF_ADDRESS): cv.positive_int,
-                cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid(
-                    "custom_command is not supported for outputs"
-                ),
                 cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(
                     SENSOR_VALUE_TYPE
                 ),

esphome/components/modbus_controller/text_sensor/__init__.py

@@ -61,7 +61,7 @@ async def to_code(config):
     response_size = config[CONF_RESPONSE_SIZE]
     reg_count = config[CONF_REGISTER_COUNT]
     if reg_count == 0:
-        reg_count = response_size // 2
+        reg_count = response_size / 2
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_REGISTER_TYPE],

esphome/components/mqtt/__init__.py

@@ -504,7 +504,7 @@ async def mqtt_publish_action_to_code(config, action_id, template_arg, args):
     cg.add(var.set_payload(template_))
     template_ = await cg.templatable(config[CONF_QOS], args, cg.uint8)
     cg.add(var.set_qos(template_))
-    template_ = await cg.templatable(config[CONF_RETAIN], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_RETAIN], args, bool)
     cg.add(var.set_retain(template_))
     return var
 
@@ -537,7 +537,7 @@ async def mqtt_publish_json_action_to_code(config, action_id, template_arg, args
     cg.add(var.set_payload(lambda_))
     template_ = await cg.templatable(config[CONF_QOS], args, cg.uint8)
     cg.add(var.set_qos(template_))
-    template_ = await cg.templatable(config[CONF_RETAIN], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_RETAIN], args, bool)
     cg.add(var.set_retain(template_))
     return var
 

esphome/components/nextion/binary_sensor/__init__.py

@@ -76,13 +76,13 @@ async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config[CONF_STATE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_STATE], args, bool)
     cg.add(var.set_state(template_))
 
-    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, bool)
     cg.add(var.set_publish_state(template_))
 
-    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, bool)
     cg.add(var.set_send_to_nextion(template_))
 
     return var

esphome/components/nextion/display.py

@@ -148,7 +148,7 @@ async def nextion_set_brightness_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config[CONF_BRIGHTNESS], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_BRIGHTNESS], args, float)
     cg.add(var.set_brightness(template_))
 
     return var

esphome/components/nextion/sensor/__init__.py

@@ -116,13 +116,13 @@ async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config[CONF_STATE], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_STATE], args, float)
     cg.add(var.set_state(template_))
 
-    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, bool)
     cg.add(var.set_publish_state(template_))
 
-    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, bool)
     cg.add(var.set_send_to_nextion(template_))
 
     return var

esphome/components/nextion/switch/__init__.py

@@ -58,13 +58,13 @@ async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    template_ = await cg.templatable(config[CONF_STATE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_STATE], args, bool)
     cg.add(var.set_state(template_))
 
-    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_PUBLISH_STATE], args, bool)
     cg.add(var.set_publish_state(template_))
 
-    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_SEND_TO_NEXTION], args, bool)
     cg.add(var.set_send_to_nextion(template_))
 
     return var

esphome/components/number/__init__.py

@@ -257,14 +257,10 @@ async def _build_number_automations(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await cg.register_component(trigger, conf)
         if CONF_ABOVE in conf:
-            template_ = await cg.templatable(
-                conf[CONF_ABOVE], [(float, "x")], cg.float_
-            )
+            template_ = await cg.templatable(conf[CONF_ABOVE], [(float, "x")], float)
             cg.add(trigger.set_min(template_))
         if CONF_BELOW in conf:
-            template_ = await cg.templatable(
-                conf[CONF_BELOW], [(float, "x")], cg.float_
-            )
+            template_ = await cg.templatable(conf[CONF_BELOW], [(float, "x")], float)
             cg.add(trigger.set_max(template_))
         await automation.build_automation(trigger, [(float, "x")], conf)
 
@@ -366,7 +362,7 @@ OPERATION_BASE_SCHEMA = cv.Schema(
 async def number_set_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_VALUE], args, float)
     cg.add(var.set_value(template_))
     return var
 
@@ -449,7 +445,7 @@ async def number_to_to_code(config, action_id, template_arg, args):
         to_ = await cg.templatable(operation, args, NumberOperation)
         cg.add(var.set_operation(to_))
         if (cycle := config.get(CONF_CYCLE)) is not None:
-            template_ = await cg.templatable(cycle, args, cg.bool_)
+            template_ = await cg.templatable(cycle, args, bool)
             cg.add(var.set_cycle(template_))
     if (mode := config.get(CONF_MODE)) is not None:
         template_ = await cg.templatable(

esphome/components/online_image/__init__.py

@@ -100,7 +100,7 @@ async def online_image_action_to_code(config, action_id, template_arg, args):
         template_ = await cg.templatable(config[CONF_URL], args, cg.std_string)
         cg.add(var.set_url(template_))
     if CONF_UPDATE in config:
-        template_ = await cg.templatable(config[CONF_UPDATE], args, cg.bool_)
+        template_ = await cg.templatable(config[CONF_UPDATE], args, bool)
         cg.add(var.set_update(template_))
     return var
 

esphome/components/output/__init__.py

@@ -104,7 +104,7 @@ async def output_turn_off_to_code(config, action_id, template_arg, args):
 async def output_set_level_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_LEVEL], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_LEVEL], args, float)
     cg.add(var.set_level(template_))
     return var
 
@@ -123,7 +123,7 @@ async def output_set_level_to_code(config, action_id, template_arg, args):
 async def output_set_min_power_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_MIN_POWER], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_MIN_POWER], args, float)
     cg.add(var.set_min_power(template_))
     return var
 
@@ -142,7 +142,7 @@ async def output_set_min_power_to_code(config, action_id, template_arg, args):
 async def output_set_max_power_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_MAX_POWER], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_MAX_POWER], args, float)
     cg.add(var.set_max_power(template_))
     return var
 

esphome/components/pca6416a/__init__.py

@@ -5,7 +5,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
     CONF_INPUT,
-    CONF_INTERRUPT_PIN,
     CONF_INVERTED,
     CONF_MODE,
     CONF_NUMBER,
@@ -26,12 +25,7 @@ PCA6416AGPIOPin = pca6416a_ns.class_(
 
 CONF_PCA6416A = "pca6416a"
 CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.declare_id(PCA6416AComponent),
-            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
-        }
-    )
+    cv.Schema({cv.Required(CONF_ID): cv.declare_id(PCA6416AComponent)})
     .extend(cv.COMPONENT_SCHEMA)
     .extend(i2c.i2c_device_schema(0x21))
 )
@@ -41,8 +35,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
-    if interrupt_pin := config.get(CONF_INTERRUPT_PIN):
-        cg.add(var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin)))
 
 
 def validate_mode(value):

esphome/components/pca6416a/pca6416a.cpp

@@ -49,22 +49,11 @@ void PCA6416AComponent::setup() {
 
   ESP_LOGD(TAG, "Initialization complete. Warning: %d, Error: %d", this->status_has_warning(),
            this->status_has_error());
-
-  if (this->interrupt_pin_ != nullptr) {
-    this->interrupt_pin_->setup();
-    this->interrupt_pin_->attach_interrupt(&PCA6416AComponent::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE);
-    this->set_invalidate_on_read_(false);
-  }
-  this->disable_loop();
 }
 
-void IRAM_ATTR PCA6416AComponent::gpio_intr(PCA6416AComponent *arg) { arg->enable_loop_soon_any_context(); }
 void PCA6416AComponent::loop() {
   // Invalidate cache at the start of each loop
   this->reset_pin_cache_();
-  if (this->interrupt_pin_ != nullptr) {
-    this->disable_loop();
-  }
 }
 
 void PCA6416AComponent::dump_config() {
@@ -73,7 +62,6 @@ void PCA6416AComponent::dump_config() {
   } else {
     ESP_LOGCONFIG(TAG, "PCA6416A:");
   }
-  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
@@ -113,9 +101,6 @@ void PCA6416AComponent::pin_mode(uint8_t pin, gpio::Flags flags) {
       this->update_register_(pin, true, pull_dir);
       this->update_register_(pin, false, pull_en);
     }
-    if (this->interrupt_pin_ == nullptr) {
-      this->enable_loop();
-    }
   } else if (flags == (gpio::FLAG_INPUT | gpio::FLAG_PULLUP)) {
     this->update_register_(pin, true, io_dir);
     if (has_pullup_) {
@@ -124,9 +109,6 @@ void PCA6416AComponent::pin_mode(uint8_t pin, gpio::Flags flags) {
     } else {
       ESP_LOGW(TAG, "Your PCA6416A does not support pull-up resistors");
     }
-    if (this->interrupt_pin_ == nullptr) {
-      this->enable_loop();
-    }
   } else if (flags == gpio::FLAG_OUTPUT) {
     this->update_register_(pin, false, io_dir);
   }

esphome/components/pca6416a/pca6416a.h

@@ -24,10 +24,7 @@ class PCA6416AComponent : public Component,
 
   void dump_config() override;
 
-  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
-
  protected:
-  static void IRAM_ATTR gpio_intr(PCA6416AComponent *arg);
   // Virtual methods from CachedGpioExpander
   bool digital_read_hw(uint8_t pin) override;
   bool digital_read_cache(uint8_t pin) override;
@@ -46,7 +43,6 @@ class PCA6416AComponent : public Component,
   esphome::i2c::ErrorCode last_error_;
   /// Only the PCAL6416A has pull-up resistors
   bool has_pullup_{false};
-  InternalGPIOPin *interrupt_pin_{nullptr};
 };
 
 /// Helper class to expose a PCA6416A pin as an internal input GPIO pin.

esphome/components/pid/climate.py

@@ -189,13 +189,13 @@ async def set_control_parameters(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
-    kp_template_ = await cg.templatable(config[CONF_KP], args, cg.float_)
+    kp_template_ = await cg.templatable(config[CONF_KP], args, float)
     cg.add(var.set_kp(kp_template_))
 
-    ki_template_ = await cg.templatable(config[CONF_KI], args, cg.float_)
+    ki_template_ = await cg.templatable(config[CONF_KI], args, float)
     cg.add(var.set_ki(ki_template_))
 
-    kd_template_ = await cg.templatable(config[CONF_KD], args, cg.float_)
+    kd_template_ = await cg.templatable(config[CONF_KD], args, float)
     cg.add(var.set_kd(kd_template_))
 
     return var

esphome/components/pipsolar/output/__init__.py

@@ -103,6 +103,6 @@ async def to_code(config):
 async def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_VALUE], args, float)
     cg.add(var.set_level(template_))
     return var

esphome/components/pmwcs3/sensor.py

@@ -137,6 +137,6 @@ PMWCS3_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
 async def pmwcs3newi2caddress_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, parent)
-    address = await cg.templatable(config[CONF_ADDRESS], args, cg.int_)
+    address = await cg.templatable(config[CONF_ADDRESS], args, cg.int32)
     cg.add(var.set_new_address(address))
     return var

esphome/components/pulse_counter/sensor.py

@@ -160,6 +160,6 @@ async def to_code(config):
 async def set_total_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.uint32)
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.int32)
     cg.add(var.set_total_pulses(template_))
     return var

esphome/components/pulse_meter/sensor.py

@@ -110,6 +110,6 @@ async def to_code(config):
 async def set_total_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.uint32)
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.int32)
     cg.add(var.set_total_pulses(template_))
     return var

esphome/components/qspi_dbi/__init__.py

@@ -1,8 +1,3 @@
 CODEOWNERS = ["@clydebarrow"]
 
 CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
-
-DEPRECATED_COMPONENT = """
-The 'qspi_dbi' component is deprecated and no new models will be added to it.
-New model PRs should target the newer and more performant 'mipi_spi' component.
-"""

esphome/components/qspi_dbi/display.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display, spi
@@ -31,7 +29,6 @@ from . import CONF_DRAW_FROM_ORIGIN
 from .models import DriverChip
 
 DEPENDENCIES = ["spi"]
-LOGGER = logging.getLogger(__name__)
 
 qspi_dbi_ns = cg.esphome_ns.namespace("qspi_dbi")
 QSPI_DBI = qspi_dbi_ns.class_(
@@ -157,15 +154,11 @@ CONFIG_SCHEMA = cv.All(
         upper=True,
         key=CONF_MODEL,
     ),
-    _validate,
     cv.only_on_esp32,
 )
 
 
 async def to_code(config):
-    LOGGER.warning(
-        "The 'qspi_dbi' component is deprecated, it is recommended to use 'mipi_spi' instead."
-    )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)
     await spi.register_spi_device(var, config, write_only=True)

esphome/components/remote_base/__init__.py

@@ -868,7 +868,7 @@ async def keeloq_action(var, config, args):
     cg.add(var.set_encrypted(template_))
     template_ = await cg.templatable(config[CONF_COMMAND], args, cg.uint8)
     cg.add(var.set_command(template_))
-    template_ = await cg.templatable(config[CONF_LEVEL], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_LEVEL], args, bool)
     cg.add(var.set_vlow(template_))
 
 
@@ -1580,7 +1580,7 @@ async def rc_switch_type_a_action(var, config, args):
     cg.add(
         var.set_device(await cg.templatable(config[CONF_DEVICE], args, cg.std_string))
     )
-    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, cg.bool_)))
+    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, bool)))
 
 
 @register_binary_sensor(
@@ -1605,7 +1605,7 @@ async def rc_switch_type_b_action(var, config, args):
     cg.add(var.set_protocol(proto))
     cg.add(var.set_address(await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)))
     cg.add(var.set_channel(await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)))
-    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, cg.bool_)))
+    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, bool)))
 
 
 @register_binary_sensor(
@@ -1638,7 +1638,7 @@ async def rc_switch_type_c_action(var, config, args):
     )
     cg.add(var.set_group(await cg.templatable(config[CONF_GROUP], args, cg.uint8)))
     cg.add(var.set_device(await cg.templatable(config[CONF_DEVICE], args, cg.uint8)))
-    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, cg.bool_)))
+    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, bool)))
 
 
 @register_binary_sensor(
@@ -1663,7 +1663,7 @@ async def rc_switch_type_d_action(var, config, args):
     cg.add(var.set_protocol(proto))
     cg.add(var.set_group(await cg.templatable(config[CONF_GROUP], args, cg.std_string)))
     cg.add(var.set_device(await cg.templatable(config[CONF_DEVICE], args, cg.uint8)))
-    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, cg.bool_)))
+    cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, bool)))
 
 
 @register_trigger("rc_switch", RCSwitchTrigger, RCSwitchData)

esphome/components/remote_transmitter/__init__.py

@@ -128,7 +128,7 @@ DIGITAL_WRITE_ACTION_SCHEMA = cv.maybe_simple_value(
 async def digital_write_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_TRANSMITTER_ID])
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.bool_)
+    template_ = await cg.templatable(config[CONF_VALUE], args, bool)
     cg.add(var.set_value(template_))
     return var
 

esphome/components/rp2040_pwm/output.py

@@ -47,6 +47,6 @@ async def to_code(config):
 async def rp2040_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_FREQUENCY], args, cg.float_)
+    template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
     cg.add(var.set_frequency(template_))
     return var

esphome/components/rpi_dpi_rgb/__init__.py

@@ -1,6 +1 @@
 CODEOWNERS = ["@clydebarrow"]
-
-DEPRECATED_COMPONENT = """
-The 'rpi_dpi_rgb' component is deprecated and no new models will be added to it.
-New model PRs should target the newer and more performant 'mipi_rgb' component.
-"""

esphome/components/rpi_dpi_rgb/display.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display
@@ -40,7 +38,6 @@ from esphome.const import (
 )
 
 DEPENDENCIES = ["esp32"]
-LOGGER = logging.getLogger(__name__)
 
 rpi_dpi_rgb_ns = cg.esphome_ns.namespace("rpi_dpi_rgb")
 RPI_DPI_RGB = rpi_dpi_rgb_ns.class_("RpiDpiRgb", display.Display, cg.Component)
@@ -129,9 +126,6 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    LOGGER.warning(
-        "The 'rpi_dpi_rgb' component is deprecated, it is recommended to use 'mipi_rgb' instead."
-    )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)
 

esphome/components/safe_mode/safe_mode.cpp

@@ -55,13 +55,11 @@ void SafeModeComponent::dump_config() {
 #if defined(USE_ESP32) && defined(USE_OTA_ROLLBACK)
   const esp_partition_t *last_invalid = esp_ota_get_last_invalid_partition();
   if (last_invalid != nullptr) {
-    ESP_LOGW(TAG,
-             "OTA rollback detected! Rolled back from partition '%s'\n"
-             " The device reset before the boot was marked successful",
-             last_invalid->label);
+    ESP_LOGW(TAG, "OTA rollback detected! Rolled back from partition '%s'", last_invalid->label);
+    ESP_LOGW(TAG, "The device reset before the boot was marked successful");
     if (esp_reset_reason() == ESP_RST_BROWNOUT) {
-      ESP_LOGW(TAG, "Last reset was due to brownout - check your power supply!\n"
-                    " See https://esphome.io/guides/faq.html#brownout-detector-was-triggered");
+      ESP_LOGW(TAG, "Last reset was due to brownout - check your power supply!");
+      ESP_LOGW(TAG, "See https://esphome.io/guides/faq.html#brownout-detector-was-triggered");
     }
   }
 #endif
@@ -88,8 +86,7 @@ void SafeModeComponent::mark_successful() {
 }
 
 void SafeModeComponent::loop() {
-  if (!this->boot_successful_ &&
-      (App.get_loop_component_start_time() - this->safe_mode_start_time_) > this->safe_mode_boot_is_good_after_) {
+  if (!this->boot_successful_ && (millis() - this->safe_mode_start_time_) > this->safe_mode_boot_is_good_after_) {
     // successful boot, reset counter
     ESP_LOGI(TAG, "Boot seems successful; resetting boot loop counter");
     this->mark_successful();

esphome/components/select/__init__.py

@@ -279,7 +279,7 @@ async def select_operation_to_code(config, action_id, template_arg, args):
         op_ = await cg.templatable(operation, args, SelectOperation)
         cg.add(var.set_operation(op_))
         if (cycle := config.get(CONF_CYCLE)) is not None:
-            template_ = await cg.templatable(cycle, args, cg.bool_)
+            template_ = await cg.templatable(cycle, args, bool)
             cg.add(var.set_cycle(template_))
     if (mode := config.get(CONF_MODE)) is not None:
         template_ = await cg.templatable(