[api] Pass pos by value through encode_varint_raw_loop

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

.clang-tidy.hash

@@ -1 +1 @@
-10c432ae818f9ed7fd4a0176a04467b1f2634363f5ec985045a6d72747f60b90
+f31f13994768b5b07e29624406c9b053bf4bb26e1623ac2bc1e9d4a9477502d6

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

@@ -4,6 +4,7 @@ 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,6 +281,24 @@ 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();
@@ -329,5 +347,6 @@ module.exports = {
   detectTests,
   detectPRTemplateCheckboxes,
   detectDeprecatedComponents,
+  detectMaintainerAccess,
   detectRequirements
 };

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

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

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

@@ -2,7 +2,8 @@ const {
   BOT_COMMENT_MARKER,
   CODEOWNERS_MARKER,
   TOO_BIG_MARKER,
-  DEPRECATED_COMPONENT_MARKER
+  DEPRECATED_COMPONENT_MARKER,
+  ORG_FORK_MARKER
 } = require('./constants');
 
 // Generate review messages
@@ -136,6 +137,63 @@ 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
+  handleReviews,
+  handleMaintainerAccessComment
 };

.github/workflows/ci.yml

@@ -868,7 +868,8 @@ jobs:
           python script/test_build_components.py \
             -e compile \
             -c "$component_list" \
-            -t "$platform" 2>&1 | \
+            -t "$platform" \
+            --base-only 2>&1 | \
             tee /dev/stderr | \
             python script/ci_memory_impact_extract.py \
               --output-env \
@@ -954,7 +955,8 @@ jobs:
           python script/test_build_components.py \
             -e compile \
             -c "$component_list" \
-            -t "$platform" 2>&1 | \
+            -t "$platform" \
+            --base-only 2>&1 | \
             tee /dev/stderr | \
             python script/ci_memory_impact_extract.py \
               --output-env \

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

@@ -2,30 +2,29 @@ name: Status check labels
 
 on:
   pull_request:
-    types: [labeled, unlabeled]
+    types: [opened, reopened, labeled, unlabeled, synchronize]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
 
 jobs:
   check:
-    name: Check ${{ matrix.label }}
+    name: Check blocking labels
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        label:
-          - needs-docs
-          - merge-after-release
-          - chained-pr
     steps:
-      - name: Check for ${{ matrix.label }} label
+      - name: Check for blocking labels
         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 hasLabel = labels.find(label => label.name === '${{ matrix.label }}');
-            if (hasLabel) {
-              core.setFailed('Pull request cannot be merged, it is labeled as ${{ matrix.label }}');
+            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(', ')}`);
             }

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.9
+    rev: v0.15.10
     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.4.5
+PROJECT_NUMBER         = 2026.5.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

docker/ha-addon-rootfs/etc/cont-init.d/40-device-builder.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/with-contenv bashio
-# ==============================================================================
-# Installs the latest prerelease of esphome-device-builder when the
-# `use_new_device_builder` config option is enabled.
-# This is a temporary install-on-boot step until esphome-device-builder
-# becomes a direct dependency of esphome.
-# ==============================================================================
-
-if ! bashio::config.true 'use_new_device_builder'; then
-  exit 0
-fi
-
-bashio::log.info "Installing latest prerelease of esphome-device-builder..."
-if command -v uv > /dev/null; then
-  uv pip install --system --no-cache-dir --prerelease=allow --upgrade \
-    esphome-device-builder ||
-    bashio::exit.nok "Failed installing esphome-device-builder."
-else
-  pip install --no-cache-dir --pre --upgrade esphome-device-builder ||
-    bashio::exit.nok "Failed installing esphome-device-builder."
-fi
-bashio::log.info "Installed esphome-device-builder."

docker/ha-addon-rootfs/etc/s6-overlay/s6-rc.d/esphome/run

@@ -49,12 +49,5 @@ if bashio::fs.directory_exists '/config/esphome/.esphome'; then
     rm -rf /config/esphome/.esphome
 fi
 
-if bashio::config.true 'use_new_device_builder'; then
-    bashio::log.info "Starting ESPHome Device Builder..."
-    exec esphome-device-builder /config/esphome \
-        --ha-addon \
-        --ingress-port "$(bashio::addon.ingress_port)"
-fi
-
 bashio::log.info "Starting ESPHome dashboard..."
 exec esphome dashboard /config/esphome --socket /var/run/esphome.sock --ha-addon

docker/ha-addon-rootfs/etc/s6-overlay/s6-rc.d/init-nginx/run

@@ -4,14 +4,6 @@
 # Community Hass.io Add-ons: ESPHome
 # Configures NGINX for use with ESPHome
 # ==============================================================================
-
-# When the new device builder is enabled it serves HA ingress directly,
-# so nginx is not used at all -- skip configuration.
-if bashio::config.true 'use_new_device_builder'; then
-    bashio::log.info "Skipping NGINX setup: new device builder serves ingress directly."
-    bashio::exit.ok
-fi
-
 mkdir -p /var/log/nginx
 
 # Generate Ingress configuration

docker/ha-addon-rootfs/etc/s6-overlay/s6-rc.d/nginx/run

@@ -5,14 +5,6 @@
 # Runs the NGINX proxy
 # ==============================================================================
 
-# The new device builder handles HA ingress itself, so nginx is bypassed.
-# Block the longrun forever so s6 keeps the dependency satisfied and does
-# not respawn it.
-if bashio::config.true 'use_new_device_builder'; then
-    bashio::log.info "NGINX bypassed: new device builder serves ingress directly."
-    exec sleep infinity
-fi
-
 bashio::log.info "Waiting for ESPHome dashboard to come up..."
 
 while [[ ! -S /var/run/esphome.sock ]]; do

esphome/__main__.py

@@ -750,15 +750,8 @@ def upload_using_esptool(
             platformio_api.FlashImage(
                 path=idedata.firmware_bin_path, offset=firmware_offset
             ),
+            *idedata.extra_flash_images,
         ]
-        for image in idedata.extra_flash_images:
-            if not image.path.is_file():
-                _LOGGER.warning(
-                    "Skipping missing flash image declared by platform: %s",
-                    image.path,
-                )
-                continue
-            flash_images.append(image)
 
     mcu = "esp8266"
     if CORE.is_esp32:

esphome/automation.py

@@ -598,7 +598,7 @@ async def component_resume_action_to_code(
     comp = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, comp)
     if CONF_UPDATE_INTERVAL in config:
-        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, cg.uint32)
+        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, int)
         cg.add(var.set_update_interval(template_))
     return var
 

esphome/bundle.py

@@ -98,13 +98,11 @@ _KNOWN_FILE_EXTENSIONS = frozenset(
 )
 
 
-# Matches !secret references in YAML text.  An optional surrounding
-# quote pair around the key is allowed and ignored: YAML treats
-# ``!secret 'foo'`` and ``!secret foo`` as the same key.  This is
-# intentionally a simple regex scan rather than a YAML parse — it may
-# match inside comments or multi-line strings, which is the conservative
-# direction (include more secrets rather than fewer).
-_SECRET_RE = re.compile(r"""!secret\s+['"]?([^\s'"]+)""")
+# Matches !secret references in YAML text.  This is intentionally a simple
+# regex scan rather than a YAML parse — it may match inside comments or
+# multi-line strings, which is the conservative direction (include more
+# secrets rather than fewer).
+_SECRET_RE = re.compile(r"!secret\s+(\S+)")
 
 
 def _find_used_secret_keys(yaml_files: list[Path]) -> set[str]:
@@ -153,8 +151,8 @@ class ConfigBundleCreator:
 
     def __init__(self, config: dict[str, Any]) -> None:
         self._config = config
-        self._config_dir = Path(CORE.config_dir).resolve()
-        self._config_path = Path(CORE.config_path).resolve()
+        self._config_dir = CORE.config_dir
+        self._config_path = CORE.config_path
         self._files: list[BundleFile] = []
         self._seen_paths: set[Path] = set()
         self._secrets_paths: set[Path] = set()
@@ -260,36 +258,21 @@ class ConfigBundleCreator:
     def _discover_yaml_includes(self) -> None:
         """Discover YAML files loaded during config parsing.
 
-        Deliberately uses a fresh re-parse and force-loads every deferred
-        ``IncludeFile`` to include *all* potentially-reachable includes,
-        even branches not selected by the local substitutions. Bundles are
-        meant to be compiled on another system where command-line
-        substitution overrides may choose a different branch — e.g.
-        ``!include network/${eth_model}/config.yaml`` must ship every
-        candidate so the remote build can pick any one.
-
-        Entries with unresolved substitution variables in the filename
-        path are skipped with a warning (they cannot be resolved without
-        the substitution pass).
+        We track files by wrapping _load_yaml_internal. The config has already
+        been loaded at this point (bundle is a POST_CONFIG_ACTION), so we
+        re-load just to discover the file list.
 
         Secrets files are tracked separately so we can filter them to
         only include the keys this config actually references.
         """
-        # Must be a fresh parse: IncludeFile.load() caches its result in
-        # _content, and we discover files by listening for loader calls. On
-        # an already-parsed tree the cache is populated, .load() returns
-        # without calling the loader, the listener never fires, and the
-        # referenced files would be silently dropped from the bundle.
         with yaml_util.track_yaml_loads() as loaded_files:
             try:
-                data = yaml_util.load_yaml(self._config_path)
+                yaml_util.load_yaml(self._config_path)
             except EsphomeError:
                 _LOGGER.debug(
                     "Bundle: re-loading YAML for include discovery failed, "
                     "proceeding with partial file list"
                 )
-            else:
-                _force_load_include_files(data)
 
         for fpath in loaded_files:
             if fpath == self._config_path.resolve():
@@ -625,57 +608,6 @@ def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
     tar.addfile(info, io.BytesIO(data))
 
 
-def _force_load_include_files(obj: Any, _seen: set[int] | None = None) -> None:
-    """Recursively resolve any ``IncludeFile`` instances in a YAML tree.
-
-    Nested ``!include`` returns a deferred ``IncludeFile`` that is only
-    resolved during the substitution pass. During bundle discovery we need
-    the referenced files to actually load so the ``track_yaml_loads``
-    listener fires for them.
-
-    ``IncludeFile`` instances with unresolved substitution variables in the
-    filename cannot be loaded — we skip and warn about those.
-    """
-    if _seen is None:
-        _seen = set()
-
-    if isinstance(obj, yaml_util.IncludeFile):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        if obj.has_unresolved_expressions():
-            _LOGGER.warning(
-                "Bundle: cannot resolve !include %s (referenced from %s) "
-                "with substitutions in path",
-                obj.file,
-                obj.parent_file,
-            )
-            return
-        try:
-            loaded = obj.load()
-        except EsphomeError as err:
-            _LOGGER.warning(
-                "Bundle: failed to load !include %s (referenced from %s): %s",
-                obj.file,
-                obj.parent_file,
-                err,
-            )
-            return
-        _force_load_include_files(loaded, _seen)
-    elif isinstance(obj, dict):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for value in obj.values():
-            _force_load_include_files(value, _seen)
-    elif isinstance(obj, (list, tuple)):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for item in obj:
-            _force_load_include_files(item, _seen)
-
-
 def _resolve_include_path(include_path: Any) -> Path | None:
     """Resolve an include path to absolute, skipping system includes."""
     if isinstance(include_path, str) and include_path.startswith("<"):

esphome/components/adc/sensor.py

@@ -2,11 +2,7 @@ import logging
 
 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
-from esphome.components.esp32 import (
-    get_esp32_variant,
-    include_builtin_idf_component,
-    require_adc_oneshot_iram,
-)
+from esphome.components.esp32 import get_esp32_variant, include_builtin_idf_component
 from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
 from esphome.components.zephyr import (
     zephyr_add_overlay,
@@ -28,7 +24,6 @@ from esphome.const import (
     PlatformFramework,
 )
 from esphome.core import CORE
-from esphome.types import ConfigType
 
 from . import (
     ATTENUATION_MODES,
@@ -70,13 +65,6 @@ def validate_config(config):
     return config
 
 
-def _require_adc_iram(config: ConfigType) -> ConfigType:
-    """Register ADC oneshot IRAM requirement during config validation."""
-    if CORE.is_esp32:
-        require_adc_oneshot_iram()
-    return config
-
-
 ADCSensor = adc_ns.class_(
     "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
@@ -107,7 +95,6 @@ CONFIG_SCHEMA = cv.All(
     )
     .extend(cv.polling_component_schema("60s")),
     validate_config,
-    _require_adc_iram,
 )
 
 CONF_ADC_CHANNEL_ID = "adc_channel_id"

esphome/components/ade7953_base/ade7953_base.cpp

@@ -8,6 +8,9 @@ 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;
 
@@ -18,7 +21,12 @@ void ADE7953::setup() {
 
   // The chip might take up to 100ms to initialise
   this->set_timeout(100, [this]() {
-    // this->ade_write_8(0x0010, 0x04);
+    // 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(0x00FE, 0xAD);
     this->ade_write_16(0x0120, 0x0030);
     // Set gains

esphome/components/ade7953_base/ade7953_base.h

@@ -9,31 +9,35 @@
 namespace esphome {
 namespace ade7953_base {
 
-static const uint8_t PGA_V_8 =
+static constexpr uint8_t PGA_V_8 =
     0x007;  // PGA_V,  (R/W) Default: 0x00, Unsigned, Voltage channel gain configuration (Bits[2:0])
-static const uint8_t PGA_IA_8 =
+static constexpr uint8_t PGA_IA_8 =
     0x008;  // PGA_IA, (R/W) Default: 0x00, Unsigned, Current Channel A gain configuration (Bits[2:0])
-static const uint8_t PGA_IB_8 =
+static constexpr uint8_t PGA_IB_8 =
     0x009;  // PGA_IB, (R/W) Default: 0x00, Unsigned, Current Channel B gain configuration (Bits[2:0])
 
-static const uint32_t AIGAIN_32 =
+static constexpr uint16_t CONFIG_16 = 0x102;  // CONFIG, (R/W) Default: 0x8004, Unsigned, Configuration register
+
+static constexpr uint16_t AIGAIN_32 =
     0x380;  // AIGAIN, (R/W)   Default: 0x400000, Unsigned,Current channel gain (Current Channel A)(32 bit)
-static const uint32_t AVGAIN_32 = 0x381;  // AVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
-static const uint32_t AWGAIN_32 =
+static constexpr uint16_t AVGAIN_32 =
+    0x381;  // AVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
+static constexpr uint16_t AWGAIN_32 =
     0x382;  // AWGAIN, (R/W)   Default: 0x400000, Unsigned,Active power gain (Current Channel A)(32 bit)
-static const uint32_t AVARGAIN_32 =
+static constexpr uint16_t AVARGAIN_32 =
     0x383;  // AVARGAIN, (R/W) Default: 0x400000, Unsigned, Reactive power gain (Current Channel A)(32 bit)
-static const uint32_t AVAGAIN_32 =
+static constexpr uint16_t AVAGAIN_32 =
     0x384;  // AVAGAIN, (R/W)  Default: 0x400000, Unsigned,Apparent power gain (Current Channel A)(32 bit)
 
-static const uint32_t BIGAIN_32 =
+static constexpr uint16_t BIGAIN_32 =
     0x38C;  // BIGAIN, (R/W)   Default: 0x400000, Unsigned,Current channel gain (Current Channel B)(32 bit)
-static const uint32_t BVGAIN_32 = 0x38D;  // BVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
-static const uint32_t BWGAIN_32 =
+static constexpr uint16_t BVGAIN_32 =
+    0x38D;  // BVGAIN, (R/W)   Default: 0x400000, Unsigned,Voltage channel gain(32 bit)
+static constexpr uint16_t BWGAIN_32 =
     0x38E;  // BWGAIN, (R/W)   Default: 0x400000, Unsigned,Active power gain (Current Channel B)(32 bit)
-static const uint32_t BVARGAIN_32 =
+static constexpr uint16_t BVARGAIN_32 =
     0x38F;  // BVARGAIN, (R/W) Default: 0x400000, Unsigned, Reactive power gain (Current Channel B)(32 bit)
-static const uint32_t BVAGAIN_32 =
+static constexpr uint16_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,6 +7,9 @@ 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();
@@ -32,6 +35,9 @@ 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_LEADING,
+                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH, spi::CLOCK_PHASE_TRAILING,
                                          spi::DATA_RATE_1MHZ> {
  public:
   void setup() override;

esphome/components/animation/animation.cpp

@@ -62,12 +62,7 @@ void Animation::set_frame(int frame) {
 }
 
 void Animation::update_data_start_() {
-  uint32_t image_size = this->get_width_stride() * this->height_;
-  // RGB565 with an alpha channel stores the alpha plane immediately after the RGB
-  // plane within each frame, so the per-frame stride includes the alpha bytes.
-  if (this->type_ == image::IMAGE_TYPE_RGB565 && this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
-    image_size += static_cast<uint32_t>(this->width_) * this->height_;
-  }
+  const uint32_t image_size = this->get_width_stride() * this->height_;
   this->data_start_ = this->animation_data_start_ + image_size * this->current_frame_;
 }
 

esphome/components/api/__init__.py

@@ -72,35 +72,17 @@ APIUnregisterServiceCallAction = api_ns.class_(
 
 UserServiceTrigger = api_ns.class_("UserServiceTrigger", automation.Trigger)
 ListEntitiesServicesArgument = api_ns.class_("ListEntitiesServicesArgument")
-# Owning element type for each YAML service variable type.  Used to derive both
-# the zero-copy native types and the owning fallback types below.
-_SERVICE_ARG_SCALAR_TYPES: dict[str, MockObj] = {
+SERVICE_ARG_NATIVE_TYPES: dict[str, MockObj] = {
     "bool": cg.bool_,
     "int": cg.int32,
     "float": cg.float_,
-    "string": cg.std_string,
-}
-SERVICE_ARG_NATIVE_TYPES: dict[str, MockObj] = {
-    # Scalars are passed by value; string uses a non-owning view into rx_buf_.
-    **_SERVICE_ARG_SCALAR_TYPES,
     "string": cg.StringRef,
-    # Arrays are passed as non-owning const references into rx_buf_.
-    **{
-        f"{name}[]": cg.FixedVector.template(t).operator("const").operator("ref")
-        for name, t in _SERVICE_ARG_SCALAR_TYPES.items()
-    },
-}
-# Owning fallback types used when the action chain contains non-synchronous actions
-# (delay, wait_until, script.wait, etc.).  The default non-owning types reference
-# storage in the receive buffer, which is reused once the synchronous portion of
-# the chain returns.  FixedVector is also non-copyable, so the deferred lambda
-# capture in DelayAction::play_complex would fail to compile.
-SERVICE_ARG_FALLBACK_TYPES: dict[str, MockObj] = {
-    "string": cg.std_string,
-    **{
-        f"{name}[]": cg.std_vector.template(t)
-        for name, t in _SERVICE_ARG_SCALAR_TYPES.items()
-    },
+    "bool[]": cg.FixedVector.template(cg.bool_).operator("const").operator("ref"),
+    "int[]": cg.FixedVector.template(cg.int32).operator("const").operator("ref"),
+    "float[]": cg.FixedVector.template(cg.float_).operator("const").operator("ref"),
+    "string[]": cg.FixedVector.template(cg.std_string)
+    .operator("const")
+    .operator("ref"),
 }
 CONF_ENCRYPTION = "encryption"
 CONF_BATCH_DELAY = "batch_delay"
@@ -400,20 +382,17 @@ async def to_code(config: ConfigType) -> None:
                     func_args.append((cg.bool_, "return_response"))
 
             # Check if action chain has non-synchronous actions that would make
-            # non-owning args (StringRef, const FixedVector&) dangle once the
-            # rx_buf_ is reused after a delay/wait_until/script.wait/etc.  The
-            # FixedVector references would also fail to compile because they
-            # are non-copyable and DelayAction captures args by value.
+            # non-owning StringRef dangle (rx_buf_ reused after delay)
             has_non_synchronous = automation.has_non_synchronous_actions(
                 conf.get(CONF_THEN, [])
             )
 
             service_arg_names: list[str] = []
             for name, var_ in conf[CONF_VARIABLES].items():
-                if has_non_synchronous and var_ in SERVICE_ARG_FALLBACK_TYPES:
-                    native = SERVICE_ARG_FALLBACK_TYPES[var_]
-                else:
-                    native = SERVICE_ARG_NATIVE_TYPES[var_]
+                native = SERVICE_ARG_NATIVE_TYPES[var_]
+                # Fall back to std::string for string args if non-synchronous actions exist
+                if has_non_synchronous and native is cg.StringRef:
+                    native = cg.std_string
                 service_template_args.append(native)
                 func_args.append((native, name))
                 service_arg_names.append(name)

esphome/components/api/api.proto

@@ -671,7 +671,6 @@ message SensorStateResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SENSOR";
   option (no_delay) = true;
-  option (speed_optimized) = true;
 
   fixed32 key = 1 [(force) = true];
   float state = 2;
@@ -778,10 +777,9 @@ message SubscribeLogsResponse {
   option (source) = SOURCE_SERVER;
   option (log) = false;
   option (no_delay) = false;
-  option (speed_optimized) = true;
 
-  LogLevel level = 1 [(force) = true];
-  bytes message = 3 [(force) = true];
+  LogLevel level = 1;
+  bytes message = 3;
 }
 
 // ==================== NOISE ENCRYPTION ====================
@@ -1640,7 +1638,6 @@ message BluetoothLERawAdvertisementsResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_BLUETOOTH_PROXY";
   option (no_delay) = true;
-  option (speed_optimized) = true;
 
   repeated BluetoothLERawAdvertisement advertisements = 1 [(fixed_array_with_length_define) = "BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE"];
 }

esphome/components/api/api_frame_helper.h

@@ -195,7 +195,10 @@ class APIFrameHelper {
   }
   // Get the frame footer size required by this protocol
   uint8_t frame_footer_size() const { return frame_footer_size_; }
-  // Check if socket has data ready to read
+  // 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.
   bool is_socket_ready() const { return socket_ != nullptr && socket_->ready(); }
   // Release excess memory from internal buffers after initial sync
   void release_buffers() {

esphome/components/api/api_options.proto

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

esphome/components/api/api_pb2.cpp

@@ -745,9 +745,7 @@ uint32_t ListEntitiesSensorResponse::calculate_size() const {
 #endif
   return size;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
   ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
@@ -757,9 +755,7 @@ SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) c
 #endif
   return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SensorStateResponse::calculate_size() const {
+uint32_t SensorStateResponse::calculate_size() const {
   uint32_t size = 0;
   size += 5;
   size += ProtoSize::calc_float(1, this->state);
@@ -916,22 +912,16 @@ bool SubscribeLogsRequest::decode_varint(uint32_t field_id, proto_varint_value_t
   }
   return true;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level), true);
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
-  ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_len_);
-  ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_ptr_, this->message_len_);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level));
+  ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->message_ptr_, this->message_len_);
   return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SubscribeLogsResponse::calculate_size() const {
+uint32_t SubscribeLogsResponse::calculate_size() const {
   uint32_t size = 0;
-  size += 2;
-  size += ProtoSize::calc_length_force(1, this->message_len_);
+  size += this->level ? 2 : 0;
+  size += ProtoSize::calc_length(1, this->message_len_);
   return size;
 }
 #ifdef USE_API_NOISE
@@ -2338,9 +2328,7 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
   }
   return true;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+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];
@@ -2362,9 +2350,7 @@ BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
   }
   return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-BluetoothLERawAdvertisementsResponse::calculate_size() const {
+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];

esphome/components/api/client.py

@@ -20,7 +20,6 @@ import contextlib
 from esphome.const import CONF_KEY, CONF_PORT, __version__
 from esphome.core import CORE
 from esphome.platformio_api import process_stacktrace
-from esphome.util import safe_print
 
 from . import CONF_ENCRYPTION
 
@@ -61,6 +60,7 @@ async def async_run_logs(
         noise_psk=noise_psk,
         addresses=addresses,  # Pass all addresses for automatic retry
     )
+    dashboard = CORE.dashboard
     backtrace_state = False
 
     # Try platform-specific stacktrace handler first, fall back to generic
@@ -82,11 +82,7 @@ async def async_run_logs(
             f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{nanoseconds:03}]"
         )
         for parsed_msg in parse_log_message(text, timestamp):
-            # safe_print handles the dashboard \033 escaping and falls back
-            # to backslashreplace encoding on stdouts that can't represent
-            # the wifi signal-bar block characters (Windows redirected
-            # cp1252 pipe).
-            safe_print(parsed_msg)
+            print(parsed_msg.replace("\033", "\\033") if dashboard else parsed_msg)
         for raw_line in text.splitlines():
             if platform_process_stacktrace:
                 backtrace_state = platform_process_stacktrace(

esphome/components/api/proto.h

@@ -298,15 +298,33 @@ 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 inline void encode_varint_raw_loop(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, T value) {
-    do {
+  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++) {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-      *pos++ = static_cast<uint8_t>(value | 0x80);
+      *pos++ = static_cast<uint8_t>(value) | 0x80;
       value >>= 7;
-    } while (value > 0x7F);
+      if (value <= 0x7F) {
+        PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+        *pos++ = static_cast<uint8_t>(value);
+        return pos;
+      }
+    }
     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) {
@@ -315,7 +333,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value);
       return;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    pos = 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,
@@ -331,7 +349,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value >> 7);
       return;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    pos = 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) {
@@ -340,7 +358,7 @@ class ProtoEncode {
       *pos++ = static_cast<uint8_t>(value);
       return;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    pos = 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) {
@@ -402,7 +420,7 @@ class ProtoEncode {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
       *pos++ = static_cast<uint8_t>(len);
     } else {
-      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
       PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     }
     std::memcpy(pos, string, len);

esphome/components/at581x/__init__.py

@@ -183,19 +183,19 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
         cg.add(var.set_sensing_distance(template_))
 
     if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
-        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        template_ = await cg.templatable(selfcheck, args, cg.int32)
         cg.add(var.set_poweron_selfcheck_time(template_))
 
     if protect := config.get(CONF_PROTECT_TIME):
-        template_ = await cg.templatable(protect, args, cg.int_)
+        template_ = await cg.templatable(protect, args, cg.int32)
         cg.add(var.set_protect_time(template_))
 
     if trig_base := config.get(CONF_TRIGGER_BASE):
-        template_ = await cg.templatable(trig_base, args, cg.int_)
+        template_ = await cg.templatable(trig_base, args, cg.int32)
         cg.add(var.set_trigger_base(template_))
 
     if trig_keep := config.get(CONF_TRIGGER_KEEP):
-        template_ = await cg.templatable(trig_keep, args, cg.int_)
+        template_ = await cg.templatable(trig_keep, args, cg.int32)
         cg.add(var.set_trigger_keep(template_))
 
     if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:

esphome/components/atm90e32/atm90e32.h

@@ -111,14 +111,14 @@ class ATM90E32Component : public PollingComponent,
 #endif
   float get_reference_voltage(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
+    return (phase >= 0 && phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
 #else
     return 120.0;  // Default voltage
 #endif
   }
   float get_reference_current(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
+    return (phase >= 0 && phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
 #else
     return 5.0f;   // Default current
 #endif

esphome/components/bm8563/bm8563.cpp

@@ -63,7 +63,7 @@ void BM8563::read_time() {
            rtc_time.day_of_week, rtc_time.hour, rtc_time.minute, rtc_time.second);
 
   rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
     ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
     return;
   }

esphome/components/canbus/__init__.py

@@ -162,6 +162,7 @@ async def canbus_action_to_code(config, action_id, template_arg, args):
     await cg.register_parented(var, config[CONF_CANBUS_ID])
 
     if (can_id := config.get(CONF_CAN_ID)) is not None:
+        can_id = await cg.templatable(can_id, args, cg.uint32)
         cg.add(var.set_can_id(can_id))
         cg.add(var.set_use_extended_id(config[CONF_USE_EXTENDED_ID]))
 

esphome/components/cc1101/cc1101.cpp

@@ -102,8 +102,6 @@ CC1101Component::CC1101Component() {
   memset(this->pa_table_, 0, sizeof(this->pa_table_));
 }
 
-void IRAM_ATTR CC1101Component::gpio_intr(CC1101Component *arg) { arg->enable_loop_soon_any_context(); }
-
 void CC1101Component::setup() {
   this->spi_setup();
   this->cs_->digital_write(true);
@@ -150,12 +148,11 @@ void CC1101Component::setup() {
   // Defer pin mode setup until after all components have completed setup()
   // This handles the case where remote_transmitter runs after CC1101 and changes pin mode
   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->gdo0_pin_->attach_interrupt(&CC1101Component::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
-      }
-    });
+    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();
   }
 }
 
@@ -167,7 +164,6 @@ void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float
 }
 
 void CC1101Component::loop() {
-  this->disable_loop();
   if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO) || this->gdo0_pin_ == nullptr ||
       !this->gdo0_pin_->digital_read()) {
     return;
@@ -248,7 +244,6 @@ void CC1101Component::begin_tx() {
   this->write_(Register::PKTCTRL0, 0x32);
   ESP_LOGV(TAG, "Beginning TX sequence");
   if (this->gdo0_pin_ != nullptr) {
-    this->gdo0_pin_->detach_interrupt();
     this->gdo0_pin_->pin_mode(gpio::FLAG_OUTPUT);
   }
   // Transition through IDLE to bypass CCA (Clear Channel Assessment) which can
@@ -678,12 +673,10 @@ void CC1101Component::set_packet_mode(bool value) {
     this->state_.GDO0_CFG = 0x0D;
   }
   if (this->initialized_) {
-    if (this->gdo0_pin_ != nullptr) {
-      if (value) {
-        this->gdo0_pin_->attach_interrupt(&CC1101Component::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
-      } else {
-        this->gdo0_pin_->detach_interrupt();
-      }
+    if (value) {
+      this->enable_loop();
+    } else {
+      this->disable_loop();
     }
     this->write_(Register::PKTCTRL0);
     this->write_(Register::PKTCTRL1);

esphome/components/cc1101/cc1101.h

@@ -93,7 +93,6 @@ class CC1101Component : public Component,
 
   // GDO pin for packet reception
   InternalGPIOPin *gdo0_pin_{nullptr};
-  static void IRAM_ATTR gpio_intr(CC1101Component *arg);
 
   // Packet handling
   void call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi);

esphome/components/deep_sleep/__init__.py

@@ -413,7 +413,7 @@ async def deep_sleep_enter_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 CONF_SLEEP_DURATION in config:
-        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.uint32)
+        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.int32)
         cg.add(var.set_sleep_duration(template_))
 
     if CONF_UNTIL in config:

esphome/components/ds1307/ds1307.cpp

@@ -44,7 +44,7 @@ void DS1307Component::read_time() {
       .year = uint16_t(ds1307_.reg.year + 10u * ds1307_.reg.year_10 + 2000),
   };
   rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
     ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
     return;
   }

esphome/components/esp32/__init__.py

@@ -128,30 +128,23 @@ ASSERTION_LEVELS = {
 SIGNING_SCHEMES = {
     "rsa3072": "CONFIG_SECURE_SIGNED_APPS_RSA_SCHEME",
     "ecdsa256": "CONFIG_SECURE_SIGNED_APPS_ECDSA_V2_SCHEME",
-    "ecdsa_v1": "CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME",
 }
 
-# Chip variants that only support one V2 signing scheme.
+# Chip variants that only support one signing scheme for Secure Boot V2.
 # Based on SOC_SECURE_BOOT_V2_RSA / SOC_SECURE_BOOT_V2_ECC in soc_caps.h.
-# Variants not listed in either set support both RSA and ECDSA V2
+# Variants not listed in either set support both RSA and ECDSA
 # (e.g. C5, C6, H2, P4). New variants should be added to the
 # appropriate set if they only support one scheme.
-# Note: VARIANT_ESP32 is not listed here because it supports V2 RSA only
-# when minimum_chip_revision >= 3.0, which requires special handling.
-SIGNED_OTA_V2_RSA_ONLY_VARIANTS = {
+SIGNED_OTA_RSA_ONLY_VARIANTS = {
+    VARIANT_ESP32,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
     VARIANT_ESP32C3,
 }
-SIGNED_OTA_V2_ECC_ONLY_VARIANTS = {
+SIGNED_OTA_ECC_ONLY_VARIANTS = {
     VARIANT_ESP32C2,
     VARIANT_ESP32C61,
 }
-# V1 ECDSA (Secure Boot V1) is only supported on the original ESP32.
-# Based on SOC_SECURE_BOOT_V1 in soc_caps.h.
-SIGNED_OTA_V1_ECDSA_VARIANTS = {
-    VARIANT_ESP32,
-}
 
 COMPILER_OPTIMIZATIONS = {
     "DEBUG": "CONFIG_COMPILER_OPTIMIZATION_DEBUG",
@@ -678,12 +671,11 @@ def _is_framework_url(source: str) -> bool:
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(3, 3, 8),
-    "latest": cv.Version(3, 3, 8),
-    "dev": cv.Version(3, 3, 8),
+    "recommended": cv.Version(3, 3, 7),
+    "latest": cv.Version(3, 3, 7),
+    "dev": cv.Version(3, 3, 7),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 8): cv.Version(55, 3, 38, "1"),
     cv.Version(3, 3, 7): cv.Version(55, 3, 37),
     cv.Version(3, 3, 6): cv.Version(55, 3, 36),
     cv.Version(3, 3, 5): cv.Version(55, 3, 35),
@@ -703,7 +695,6 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # These versions correspond to pioarduino/esp-idf releases
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
-    cv.Version(3, 3, 8): cv.Version(5, 5, 4),
     cv.Version(3, 3, 7): cv.Version(5, 5, 3, "1"),
     cv.Version(3, 3, 6): cv.Version(5, 5, 2),
     cv.Version(3, 3, 5): cv.Version(5, 5, 2),
@@ -723,15 +714,17 @@ ARDUINO_IDF_VERSION_LOOKUP = {
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(5, 5, 4),
-    "latest": cv.Version(5, 5, 4),
+    "recommended": cv.Version(5, 5, 3, "1"),
+    "latest": cv.Version(5, 5, 3, "1"),
     "dev": cv.Version(5, 5, 4),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
     cv.Version(
         6, 0, 0
     ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(5, 5, 4): cv.Version(55, 3, 38, "1"),
+    cv.Version(
+        5, 5, 4
+    ): "https://github.com/pioarduino/platform-espressif32.git#develop",
     cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
     cv.Version(5, 5, 3): cv.Version(55, 3, 37),
     cv.Version(5, 5, 2): cv.Version(55, 3, 37),
@@ -751,8 +744,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 38, "1"),
-    "latest": cv.Version(55, 3, 38, "1"),
+    "recommended": cv.Version(55, 3, 37),
+    "latest": cv.Version(55, 3, 37),
     "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }
 
@@ -998,73 +991,25 @@ def final_validate(config):
     if signed_ota := advanced.get(CONF_SIGNED_OTA_VERIFICATION):
         scheme = signed_ota[CONF_SIGNING_SCHEME]
         variant = config[CONF_VARIANT]
-        min_rev = advanced.get(CONF_MINIMUM_CHIP_REVISION)
-        scheme_path = [
-            CONF_FRAMEWORK,
-            CONF_ADVANCED,
-            CONF_SIGNED_OTA_VERIFICATION,
-            CONF_SIGNING_SCHEME,
-        ]
-
-        # V1 ECDSA is only available on the original ESP32
-        if scheme == "ecdsa_v1" and variant not in SIGNED_OTA_V1_ECDSA_VARIANTS:
+        scheme_variant_conflicts = {
+            "ecdsa256": (SIGNED_OTA_RSA_ONLY_VARIANTS, "rsa3072"),
+            "rsa3072": (SIGNED_OTA_ECC_ONLY_VARIANTS, "ecdsa256"),
+        }
+        if (conflict := scheme_variant_conflicts.get(scheme)) and variant in conflict[
+            0
+        ]:
             errs.append(
                 cv.Invalid(
-                    f"Signing scheme 'ecdsa_v1' is only supported on "
-                    f"{VARIANT_FRIENDLY[VARIANT_ESP32]}. "
-                    f"Use 'rsa3072' or 'ecdsa256' instead.",
-                    path=scheme_path,
+                    f"Signing scheme '{scheme}' is not supported on "
+                    f"{VARIANT_FRIENDLY[variant]}. Use '{conflict[1]}' instead.",
+                    path=[
+                        CONF_FRAMEWORK,
+                        CONF_ADVANCED,
+                        CONF_SIGNED_OTA_VERIFICATION,
+                        CONF_SIGNING_SCHEME,
+                    ],
                 )
             )
-        elif variant == VARIANT_ESP32:
-            # On ESP32, V2 RSA requires minimum_chip_revision >= 3.0
-            # Note: string comparison works here because cv.one_of constrains
-            # min_rev to known ESP32_CHIP_REVISIONS values ("0.0".."3.1").
-            if scheme == "rsa3072" and (min_rev is None or min_rev < "3.0"):
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme 'rsa3072' on {VARIANT_FRIENDLY[variant]} "
-                        f"requires minimum_chip_revision: '3.0' or higher "
-                        f"(Secure Boot V2 RSA needs chip revision 3.0+). "
-                        f"For older chip revisions, use 'ecdsa_v1' instead.",
-                        path=scheme_path,
-                    )
-                )
-            # ESP32 does not support V2 ECDSA (no SOC_SECURE_BOOT_V2_ECC)
-            elif scheme == "ecdsa256":
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme 'ecdsa256' is not supported on "
-                        f"{VARIANT_FRIENDLY[variant]}. Use 'rsa3072' (with "
-                        f"minimum_chip_revision: '3.0') or 'ecdsa_v1' instead.",
-                        path=scheme_path,
-                    )
-                )
-            # V1 on rev 3.0+ -- suggest V2 RSA for stronger security
-            elif scheme == "ecdsa_v1" and min_rev is not None and min_rev >= "3.0":
-                _LOGGER.info(
-                    "Using Secure Boot V1 ECDSA on %s rev %s. "
-                    "Consider using 'rsa3072' (Secure Boot V2 RSA) for "
-                    "stronger security on chip revision 3.0+.",
-                    VARIANT_FRIENDLY[variant],
-                    min_rev,
-                )
-        else:
-            # Non-ESP32 variants: check V2 scheme-variant compatibility
-            scheme_variant_conflicts = {
-                "ecdsa256": (SIGNED_OTA_V2_RSA_ONLY_VARIANTS, "rsa3072"),
-                "rsa3072": (SIGNED_OTA_V2_ECC_ONLY_VARIANTS, "ecdsa256"),
-            }
-            if (
-                conflict := scheme_variant_conflicts.get(scheme)
-            ) and variant in conflict[0]:
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme '{scheme}' is not supported on "
-                        f"{VARIANT_FRIENDLY[variant]}. Use '{conflict[1]}' instead.",
-                        path=scheme_path,
-                    )
-                )
         if CONF_OTA not in full_config:
             _LOGGER.warning(
                 "Signed OTA verification is enabled but no OTA component is configured. "
@@ -1113,7 +1058,6 @@ CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
 CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
 CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
 CONF_DISABLE_FATFS = "disable_fatfs"
-CONF_ADC_ONESHOT_IN_IRAM = "adc_oneshot_in_iram"
 
 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_*() functions
@@ -1127,7 +1071,6 @@ KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
 KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
 KEY_FATFS_REQUIRED = "fatfs_required"
 KEY_MBEDTLS_SHA512_REQUIRED = "mbedtls_sha512_required"
-KEY_ADC_ONESHOT_IRAM_REQUIRED = "adc_oneshot_iram_required"
 
 
 def require_vfs_select() -> None:
@@ -1225,17 +1168,6 @@ def require_fatfs() -> None:
     CORE.data[KEY_ESP32][KEY_FATFS_REQUIRED] = True
 
 
-def require_adc_oneshot_iram() -> None:
-    """Mark that ADC oneshot IRAM safety is required by a component.
-
-    Call this from components that use the ADC oneshot driver. When flash cache is
-    disabled (e.g., during NVS writes by WiFi, BLE, Zigbee, or power management),
-    the ADC oneshot read function must be in IRAM to avoid crashes.
-    This sets CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM.
-    """
-    CORE.data[KEY_ESP32][KEY_ADC_ONESHOT_IRAM_REQUIRED] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
     # Match operator followed by version-like string (digit or *)
@@ -1277,7 +1209,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
                 cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
                 cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
-                    *ESP32_CHIP_REVISIONS, string=True
+                    *ESP32_CHIP_REVISIONS
                 ),
                 cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
                 # DHCP server is needed for WiFi AP mode. When WiFi component is used,
@@ -1336,7 +1268,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
                 cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
                 cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
-                cv.Optional(CONF_ADC_ONESHOT_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
             }
         ),
@@ -1740,17 +1671,7 @@ async def to_code(config):
 
         # Wrap FILE*-based printf functions to eliminate newlib's _vfprintf_r
         # (~11 KB). See printf_stubs.cpp for implementation.
-        #
-        # The wrap is only beneficial against newlib. Picolibc's tinystdio
-        # implements vsnprintf by building a string-output FILE and calling
-        # vfprintf, so vfprintf is unconditionally linked in by any caller
-        # of snprintf/vsnprintf — effectively every build — and the wrap
-        # saves nothing while costing ~170 B of shim. IDF 5.x defaults to
-        # newlib on every variant; IDF 6.0+ switches to picolibc on every
-        # variant.
-        if conf[CONF_ADVANCED][CONF_ENABLE_FULL_PRINTF] or idf_version() >= cv.Version(
-            6, 0, 0
-        ):
+        if conf[CONF_ADVANCED][CONF_ENABLE_FULL_PRINTF]:
             cg.add_define("USE_FULL_PRINTF")
         else:
             for symbol in ("vprintf", "printf", "fprintf", "vfprintf"):
@@ -2147,16 +2068,6 @@ async def to_code(config):
     if advanced[CONF_DISABLE_REGI2C_IN_IRAM]:
         add_idf_sdkconfig_option("CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM", False)
 
-    # Place ADC oneshot control functions in IRAM for cache safety
-    # When flash cache is disabled (during NVS writes by WiFi, BLE, Zigbee, Thread,
-    # power management, etc.), ADC reads will crash if these functions are in flash.
-    # Components using ADC call require_adc_oneshot_iram() to force this.
-    if (
-        CORE.data[KEY_ESP32].get(KEY_ADC_ONESHOT_IRAM_REQUIRED, False)
-        or advanced[CONF_ADC_ONESHOT_IN_IRAM]
-    ):
-        add_idf_sdkconfig_option("CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM", True)
-
     # Disable FATFS support
     # Components that need FATFS (SD card, etc.) can call require_fatfs()
     if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):

esphome/components/esp32/boards.py

@@ -1960,10 +1960,6 @@ BOARDS = {
         "name": "Hornbill ESP32 Minima",
         "variant": VARIANT_ESP32,
     },
-    "huidu_hd_wf1": {
-        "name": "Huidu HD-WF1",
-        "variant": VARIANT_ESP32S2,
-    },
     "huidu_hd_wf2": {
         "name": "Huidu HD-WF2",
         "variant": VARIANT_ESP32S3,
@@ -2032,10 +2028,6 @@ BOARDS = {
         "name": "LilyGo T-Display-S3",
         "variant": VARIANT_ESP32S3,
     },
-    "lilygo-t-energy-s3": {
-        "name": "LilyGo T-Energy-S3",
-        "variant": VARIANT_ESP32S3,
-    },
     "lilygo-t3-s3": {
         "name": "LilyGo T3-S3",
         "variant": VARIANT_ESP32S3,
@@ -2297,18 +2289,10 @@ BOARDS = {
         "name": "S.ODI Ultra v1",
         "variant": VARIANT_ESP32,
     },
-    "seeed_xiao_esp32_s3_plus": {
-        "name": "Seeed Studio XIAO ESP32S3 Plus",
-        "variant": VARIANT_ESP32S3,
-    },
     "seeed_xiao_esp32c3": {
         "name": "Seeed Studio XIAO ESP32C3",
         "variant": VARIANT_ESP32C3,
     },
-    "seeed_xiao_esp32c5": {
-        "name": "Seeed Studio XIAO ESP32C5",
-        "variant": VARIANT_ESP32C5,
-    },
     "seeed_xiao_esp32c6": {
         "name": "Seeed Studio XIAO ESP32C6",
         "variant": VARIANT_ESP32C6,

esphome/components/esp32/gpio.py

@@ -172,16 +172,10 @@ def validate_gpio_pin(pin):
             exc,
         )
     else:
-        # `ignore_pin_validation_error` only suppresses an error raised by the
-        # variant's pin_validation above (e.g. SPI flash/PSRAM pins, invalid pin
-        # numbers). If that didn't raise, the option is a no-op -- warn so the
-        # user can clean it up, but don't block the build.
+        # Throw an exception if used for a pin that would not have resulted
+        # in a validation error anyway!
         if ignore_pin_validation_warning:
-            _LOGGER.warning(
-                "GPIO%d has no validation errors to ignore; "
-                "remove `ignore_pin_validation_error: true` from this pin.",
-                pin[CONF_NUMBER],
-            )
+            raise cv.Invalid(f"GPIO{pin[CONF_NUMBER]} is not a reserved pin")
 
     return pin
 

esphome/components/esp32/post_build.py.script

@@ -5,7 +5,6 @@ import json  # noqa: E402
 import os  # noqa: E402
 import pathlib  # noqa: E402
 import shutil  # noqa: E402
-import subprocess  # noqa: E402
 from glob import glob  # noqa: E402
 
 
@@ -26,114 +25,6 @@ def _parse_sdkconfig(sdkconfig_path):
     return options
 
 
-def _generate_v1_verification_key(env):
-    """Generate the V1 ECDSA verification key binary and assembly source file.
-
-    Secure Boot V1 embeds the public verification key directly in the app binary
-    as a compiled object (via a .S assembly file). The ESP-IDF CMake build generates
-    these files via custom commands, but PlatformIO's SCons bridge does not execute
-    them. This function replicates that logic:
-      1. Extracts the raw public key from the PEM signing key using espsecure.
-      2. Generates the .S assembly source that embeds the key bytes.
-    """
-    build_dir = pathlib.Path(env.subst("$BUILD_DIR"))
-    project_dir = pathlib.Path(env.subst("$PROJECT_DIR"))
-    pioenv = env.subst("$PIOENV")
-    sdkconfig = _parse_sdkconfig(project_dir / f"sdkconfig.{pioenv}")
-
-    if sdkconfig.get("CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME") != "y":
-        return
-
-    bin_path = build_dir / "signature_verification_key.bin"
-    asm_path = build_dir / "signature_verification_key.bin.S"
-
-    # Determine the source of the verification key
-    if sdkconfig.get("CONFIG_SECURE_BOOT_BUILD_SIGNED_BINARIES") == "y":
-        # Extract public key from the signing key
-        signing_key = sdkconfig.get("CONFIG_SECURE_BOOT_SIGNING_KEY")
-        if not signing_key:
-            return
-        signing_key_path = pathlib.Path(signing_key)
-        if not signing_key_path.exists():
-            print(f"Error: V1 ECDSA signing key not found: {signing_key_path}")
-            env.Exit(1)
-            return
-
-        if not bin_path.exists() or bin_path.stat().st_mtime < signing_key_path.stat().st_mtime:
-            python_exe = env.subst("$PYTHONEXE")
-            result = subprocess.run(
-                [python_exe, "-m", "espsecure", "extract_public_key",
-                 "--keyfile", str(signing_key_path), str(bin_path)],
-                capture_output=True, text=True,
-            )
-            if result.returncode != 0:
-                print(f"Error extracting V1 verification key: {result.stderr}")
-                env.Exit(1)
-                return
-            print(f"Extracted V1 ECDSA verification key from {signing_key_path.name}")
-    else:
-        # User-provided verification key -- should already be a raw binary file
-        verification_key = sdkconfig.get("CONFIG_SECURE_BOOT_VERIFICATION_KEY")
-        if not verification_key:
-            return
-        verification_key_path = pathlib.Path(verification_key)
-        if not verification_key_path.exists():
-            print(f"Error: Verification key not found: {verification_key_path}")
-            env.Exit(1)
-            return
-        shutil.copyfile(str(verification_key_path), str(bin_path))
-
-    if not bin_path.exists():
-        return
-
-    # Generate the .S assembly file from the binary key data.
-    # Replicates ESP-IDF's data_file_embed_asm.cmake with RENAME_TO=signature_verification_key_bin.
-    # The file is needed in both the app build dir and the bootloader build dir, since
-    # the bootloader also embeds the verification key when CONFIG_SECURE_SIGNED_ON_BOOT_NO_SECURE_BOOT
-    # is enabled. PlatformIO's SCons bridge does not execute the CMake custom commands that
-    # normally generate these files.
-    data = bin_path.read_bytes()
-    varname = "signature_verification_key_bin"
-
-    lines = []
-    lines.append(f"/* Data converted from {bin_path.name} */")
-    lines.append(".data")
-    lines.append("#if !defined (__APPLE__) && !defined (__linux__)")
-    lines.append(".section .rodata.embedded")
-    lines.append("#endif")
-    lines.append(f"\n.global {varname}")
-    lines.append(f"{varname}:")
-    lines.append(f"\n.global _binary_{varname}_start")
-    lines.append(f"_binary_{varname}_start: /* for objcopy compatibility */")
-
-    # Format binary data as .byte lines (16 bytes per line)
-    for i in range(0, len(data), 16):
-        chunk = data[i:i + 16]
-        hex_bytes = ", ".join(f"0x{b:02x}" for b in chunk)
-        lines.append(f".byte {hex_bytes}")
-
-    lines.append(f"\n.global _binary_{varname}_end")
-    lines.append(f"_binary_{varname}_end: /* for objcopy compatibility */")
-    lines.append(f"\n.global {varname}_length")
-    lines.append(f"{varname}_length:")
-    lines.append(f".long {len(data)}")
-    lines.append("")
-    lines.append('#if defined (__linux__)')
-    lines.append('.section .note.GNU-stack,"",@progbits')
-    lines.append("#endif")
-
-    asm_content = "\n".join(lines) + "\n"
-
-    # Write to app build dir and bootloader build dir
-    asm_path.write_text(asm_content)
-    bootloader_dir = build_dir / "bootloader"
-    if bootloader_dir.is_dir():
-        bootloader_bin = bootloader_dir / "signature_verification_key.bin"
-        bootloader_asm = bootloader_dir / "signature_verification_key.bin.S"
-        shutil.copyfile(str(bin_path), str(bootloader_bin))
-        bootloader_asm.write_text(asm_content)
-
-
 def sign_firmware(source, target, env):
     """
     Sign the firmware binary using espsecure.py if signed OTA verification is enabled.
@@ -164,12 +55,9 @@ def sign_firmware(source, target, env):
         env.Exit(1)
         return
 
-    # Determine espsecure signature version from the signing scheme:
-    # V1 ECDSA (Secure Boot V1) uses --version 1, V2 RSA/ECDSA use --version 2.
-    if sdkconfig.get("CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME") == "y":
-        sign_version = "1"
-    else:
-        sign_version = "2"
+    # ESPHome only exposes RSA3072 and ECDSA256 (both Secure Boot V2 schemes),
+    # so the espsecure signature version is always 2.
+    sign_version = "2"
 
     firmware_name = os.path.basename(env.subst("$PROGNAME")) + ".bin"
     firmware_path = build_dir / firmware_name
@@ -329,11 +217,6 @@ def esp32_copy_ota_bin(source, target, env):
     print(f"Copied firmware to {new_file_name}")
 
 
-# Generate V1 ECDSA verification key files before build starts.
-# Workaround for PlatformIO not executing CMake custom commands that extract
-# the public key and generate the .S assembly file for Secure Boot V1.
-_generate_v1_verification_key(env)  # noqa: F821
-
 # Run signing first, then merge, then ota copy
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", sign_firmware)  # noqa: F821
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", merge_factory_bin)  # noqa: F821

esphome/components/esp32/preferences.cpp

@@ -22,12 +22,6 @@ struct NVSData {
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-// open() runs from app_main() before the logger is initialized, so any failure
-// must be deferred until after global_logger is set. This is emitted from the
-// first make_preference() call, which runs from the generated setup() after
-// log->pre_setup() has run at EARLY_INIT priority.
-static esp_err_t s_open_err = ESP_OK;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 bool ESP32PreferenceBackend::save(const uint8_t *data, size_t len) {
   // try find in pending saves and update that
   for (auto &obj : s_pending_save) {
@@ -80,14 +74,12 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
 }
 
 void ESP32Preferences::open() {
-  // Runs from app_main() before the logger is initialized; any logging here
-  // must be deferred. See s_open_err and make_preference() below.
   nvs_flash_init();
   esp_err_t err = nvs_open("esphome", NVS_READWRITE, &this->nvs_handle);
   if (err == 0)
     return;
 
-  s_open_err = err;
+  ESP_LOGW(TAG, "nvs_open failed: %s - erasing NVS", esp_err_to_name(err));
   nvs_flash_deinit();
   nvs_flash_erase();
   nvs_flash_init();
@@ -99,14 +91,6 @@ void ESP32Preferences::open() {
 }
 
 ESPPreferenceObject ESP32Preferences::make_preference(size_t length, uint32_t type) {
-  if (s_open_err != ESP_OK) {
-    if (this->nvs_handle == 0) {
-      ESP_LOGW(TAG, "nvs_open failed: %s - NVS unavailable", esp_err_to_name(s_open_err));
-    } else {
-      ESP_LOGW(TAG, "nvs_open failed: %s - erased NVS", esp_err_to_name(s_open_err));
-    }
-    s_open_err = ESP_OK;
-  }
   auto *pref = new ESP32PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
   pref->nvs_handle = this->nvs_handle;
   pref->key = type;

esphome/components/esp32/printf_stubs.cpp

@@ -1,38 +1,32 @@
 /*
- * Linker wrap stubs for FILE*-based printf functions (newlib only).
+ * Linker wrap stubs for FILE*-based printf functions.
  *
  * ESP-IDF SDK components (gpio driver, ringbuf, log_write) reference
- * fprintf(), printf(), vprintf(), and vfprintf(), which on newlib pull
- * in _vfprintf_r (~11 KB) — a separate implementation from the one used
- * by snprintf/vsnprintf that handles FILE* stream I/O with buffering.
+ * fprintf(), printf(), vprintf(), and vfprintf() which pull in the full
+ * printf implementation (~11 KB on newlib's _vfprintf_r, ~2.8 KB on
+ * picolibc's vfprintf). This is a separate implementation from the one
+ * used by snprintf/vsnprintf that handles FILE* stream I/O with buffering
+ * and locking.
  *
  * ESPHome replaces the ESP-IDF log handler via esp_log_set_vprintf_(),
  * so the SDK's vprintf() path is dead code at runtime. The fprintf()
  * and printf() calls in SDK components are only in debug/assert paths
  * (gpio_dump_io_configuration, ringbuf diagnostics) that are either
  * GC'd or never called. Crash backtraces and panic output are
- * unaffected; they use esp_rom_printf() which is a ROM function and
- * does not go through libc.
+ * unaffected — they use esp_rom_printf() which is a ROM function
+ * and does not go through libc.
  *
- * This wrap is newlib-only. On picolibc, vsnprintf is implemented as
- * vfprintf into a string-output FILE, so vfprintf is unconditionally
- * linked in by any caller of snprintf/vsnprintf and the wrap can never
- * elide it — it just adds shim cost. Codegen forces USE_FULL_PRINTF
- * on picolibc builds (IDF 6.0+ on all variants) so this file compiles
- * to nothing there; the #error below catches a desynchronised gate.
+ * These stubs redirect through vsnprintf() (which uses _svfprintf_r
+ * already in the binary) and fwrite(), allowing the linker to
+ * dead-code eliminate _vfprintf_r.
  *
- * Saves ~11 KB of flash on newlib.
+ * Saves ~11 KB of flash.
  *
- * To disable this wrap on newlib, set enable_full_printf: true in the
- * esp32 advanced config section.
+ * To disable these wraps, set enable_full_printf: true in the esp32
+ * advanced config section.
  */
 
 #if defined(USE_ESP_IDF) && !defined(USE_FULL_PRINTF)
-
-#ifdef __PICOLIBC__
-#error "printf wrap is net-negative on picolibc; codegen should set USE_FULL_PRINTF"
-#endif
-
 #include <cstdarg>
 #include <cstdio>
 
@@ -40,9 +34,6 @@
 
 namespace esphome::esp32 {}
 
-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" {
-
 static constexpr size_t PRINTF_BUFFER_SIZE = 512;
 
 // These stubs are essentially dead code at runtime — ESPHome replaces the
@@ -64,16 +55,14 @@ static int write_printf_buffer(FILE *stream, char *buf, int len) {
   return len;
 }
 
+// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+extern "C" {
+
 int __wrap_vprintf(const char *fmt, va_list ap) {
   char buf[PRINTF_BUFFER_SIZE];
   return write_printf_buffer(stdout, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
 }
 
-int __wrap_vfprintf(FILE *stream, const char *fmt, va_list ap) {
-  char buf[PRINTF_BUFFER_SIZE];
-  return write_printf_buffer(stream, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
-}
-
 int __wrap_printf(const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
@@ -82,6 +71,11 @@ int __wrap_printf(const char *fmt, ...) {
   return len;
 }
 
+int __wrap_vfprintf(FILE *stream, const char *fmt, va_list ap) {
+  char buf[PRINTF_BUFFER_SIZE];
+  return write_printf_buffer(stream, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
+}
+
 int __wrap_fprintf(FILE *stream, const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);

esphome/components/esp32_touch/esp32_touch.cpp

@@ -216,7 +216,6 @@ void ESP32TouchComponent::setup() {
   // Do initial oneshot scans to populate baseline values
   for (uint32_t i = 0; i < ONESHOT_SCAN_COUNT; i++) {
     err = touch_sensor_trigger_oneshot_scanning(this->sens_handle_, ONESHOT_SCAN_TIMEOUT_MS);
-    App.feed_wdt();  // 3 scans with 2s timeout might exceed WDT, so feed it here to be safe
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Oneshot scan %" PRIu32 " failed: %s", i, esp_err_to_name(err));
     }

esphome/components/ethernet/ethernet_component.h

@@ -221,7 +221,7 @@ class EthernetComponent final : public Component {
   int reset_pin_{-1};
   int phy_addr_spi_{-1};
   int clock_speed_;
-  spi_host_device_t interface_{SPI2_HOST};
+  spi_host_device_t interface_{SPI3_HOST};
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   uint32_t polling_interval_{0};
 #endif

esphome/components/globals/__init__.py

@@ -108,13 +108,8 @@ async def globals_set_to_code(config, action_id, template_arg, args):
     full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])
     template_arg = cg.TemplateArguments(full_id.type, *template_arg)
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    # Use the global's value_type alias as the lambda return type so
-    # TemplatableFn stores a direct function pointer instead of going through
-    # the deprecated converting trampoline when the value expression deduces
-    # to a different type (e.g. int literal assigned to a float global).
-    value_type = cg.RawExpression(f"{full_id.type}::value_type")
     templ = await cg.templatable(
-        config[CONF_VALUE], args, value_type, to_exp=cg.RawExpression
+        config[CONF_VALUE], args, None, to_exp=cg.RawExpression, wrap_constant=True
     )
     cg.add(var.set_value(templ))
     return var

esphome/components/i2s_audio/microphone/__init__.py

@@ -36,7 +36,7 @@ I2SAudioMicrophone = i2s_audio_ns.class_(
 )
 
 INTERNAL_ADC_VARIANTS = [esp32.VARIANT_ESP32]
-PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3, esp32.VARIANT_ESP32P4]
+PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3]
 
 
 def _validate_esp32_variant(config):

esphome/components/ili9xxx/ili9xxx_defines.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cstdint>
-
 namespace esphome {
 namespace ili9xxx {
 

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -229,10 +229,6 @@ void ILI9XXXDisplay::update() {
 }
 
 void ILI9XXXDisplay::display_() {
-  // buffer may be null if allocation failed
-  if (this->buffer_ == nullptr) {
-    return;
-  }
   // check if something was displayed
   if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_)) {
     return;

esphome/components/image/__init__.py

@@ -28,6 +28,7 @@ from esphome.const import (
     CONF_URL,
 )
 from esphome.core import CORE, HexInt
+from esphome.final_validate import full_config
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -675,16 +676,12 @@ def _final_validate(config):
     :param config:
     :return:
     """
-    config = config.copy()
-    for c in config:
-        if byte_order := c.get(CONF_BYTE_ORDER):
-            if byte_order == "BIG_ENDIAN":
-                _LOGGER.warning(
-                    "The image '%s' is configured with big-endian byte order, little-endian is expected",
-                    c.get(CONF_FILE),
-                )
-        else:
-            c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
+    fv = full_config.get()
+    if "lvgl" in fv and not all(CONF_BYTE_ORDER in x for x in config):
+        config = config.copy()
+        for c in config:
+            if not c.get(CONF_BYTE_ORDER):
+                c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
     return config
 
 
@@ -744,28 +741,21 @@ async def write_image(config, all_frames=False):
         if frame_count <= 1:
             _LOGGER.warning("Image file %s has no animation frames", path)
 
-    # Encode each frame with its own encoder and concatenate. This keeps every
-    # frame self-contained on disk (e.g. RGB565+alpha emits [RGB plane | alpha plane]
-    # per frame) so animation frame stepping in image.cpp / animation.cpp stays
-    # correct without needing to know the total frame count.
-    byte_order = config.get(CONF_BYTE_ORDER)
-    combined_data: list[int] = []
-    encoder: ImageEncoder | None = None
+    total_rows = height * frame_count
+    encoder = IMAGE_TYPE[type](width, total_rows, transparency, dither, invert_alpha)
+    if byte_order := config.get(CONF_BYTE_ORDER):
+        # Check for valid type has already been done in validate_settings
+        encoder.set_big_endian(byte_order == "BIG_ENDIAN")
     for frame_index in range(frame_count):
         image.seek(frame_index)
-        encoder = IMAGE_TYPE[type](width, height, transparency, dither, invert_alpha)
-        if byte_order is not None:
-            # Check for valid type has already been done in validate_settings
-            encoder.set_big_endian(byte_order == "BIG_ENDIAN")
         pixels = encoder.convert(image.resize((width, height)), path).getdata()
         for row in range(height):
             for col in range(width):
                 encoder.encode(pixels[row * width + col])
             encoder.end_row()
         encoder.end_image()
-        combined_data.extend(encoder.data)
 
-    rhs = [HexInt(x) for x in combined_data]
+    rhs = [HexInt(x) for x in encoder.data]
     prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
     image_type = get_image_type_enum(type)
     trans_value = get_transparency_enum(encoder.transparency)

esphome/components/image/image.cpp

@@ -189,7 +189,7 @@ Color Image::get_rgb_pixel_(int x, int y) const {
 }
 Color Image::get_rgb565_pixel_(int x, int y) const {
   const uint8_t *pos = this->data_start_ + (x + y * this->width_) * this->bpp_ / 8;
-  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos + 1), progmem_read_byte(pos));
+  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos), progmem_read_byte(pos + 1));
   auto r = (rgb565 & 0xF800) >> 11;
   auto g = (rgb565 & 0x07E0) >> 5;
   auto b = rgb565 & 0x001F;

esphome/components/ld2412/ld2412.cpp

@@ -766,38 +766,32 @@ void LD2412Component::get_distance_resolution_() { this->send_command_(CMD_QUERY
 void LD2412Component::query_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
 
 void LD2412Component::set_basic_config() {
-  uint8_t min_gate = 1;
-  uint8_t max_gate = TOTAL_GATES;
-  uint16_t timeout = DEFAULT_PRESENCE_TIMEOUT;
-  uint8_t out_pin_level = 0x01;
-
 #ifdef USE_NUMBER
-  if (this->min_distance_gate_number_ != nullptr) {
-    if (!this->min_distance_gate_number_->has_state())
-      return;
-    min_gate = static_cast<int>(this->min_distance_gate_number_->state);
-  }
-  if (this->max_distance_gate_number_ != nullptr) {
-    if (!this->max_distance_gate_number_->has_state())
-      return;
-    max_gate = static_cast<int>(this->max_distance_gate_number_->state) + 1;
-  }
-  if (this->timeout_number_ != nullptr) {
-    if (!this->timeout_number_->has_state())
-      return;
-    timeout = static_cast<int>(this->timeout_number_->state);
+  if (!this->min_distance_gate_number_->has_state() || !this->max_distance_gate_number_->has_state() ||
+      !this->timeout_number_->has_state()) {
+    return;
   }
 #endif
 #ifdef USE_SELECT
-  if (this->out_pin_level_select_ != nullptr) {
-    if (!this->out_pin_level_select_->has_state())
-      return;
-    out_pin_level = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option().c_str());
+  if (!this->out_pin_level_select_->has_state()) {
+    return;
   }
 #endif
 
   uint8_t value[5] = {
-      lowbyte(min_gate), lowbyte(max_gate), lowbyte(timeout), highbyte(timeout), out_pin_level,
+#ifdef USE_NUMBER
+      lowbyte(static_cast<int>(this->min_distance_gate_number_->state)),
+      lowbyte(static_cast<int>(this->max_distance_gate_number_->state) + 1),
+      lowbyte(static_cast<int>(this->timeout_number_->state)),
+      highbyte(static_cast<int>(this->timeout_number_->state)),
+#else
+      1,    TOTAL_GATES, DEFAULT_PRESENCE_TIMEOUT, 0,
+#endif
+#ifdef USE_SELECT
+      find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option().c_str()),
+#else
+      0x01,  // Default value if not using select
+#endif
   };
   this->set_config_mode_(true);
   this->send_command_(CMD_BASIC_CONF, value, sizeof(value));

esphome/components/light/addressable_light.cpp

@@ -58,12 +58,6 @@ void AddressableLightTransformer::start() {
   // our transition will handle brightness, disable brightness in correction.
   this->light_.correction_.set_local_brightness(255);
   this->target_color_ *= to_uint8_scale(end_values.get_brightness() * end_values.get_state());
-
-  // Uniformity scan is deferred to the first apply() call. start() can run before the underlying
-  // LED output's setup() has allocated its frame buffer (e.g. on_boot at priority > HARDWARE
-  // triggering a transition), and reading through ESPColorView would deref a null buffer.
-  this->uniform_start_scanned_ = false;
-  this->uniform_start_is_uniform_ = false;
 }
 
 inline constexpr uint8_t subtract_scaled_difference(uint8_t a, uint8_t b, int32_t scale) {
@@ -103,57 +97,12 @@ optional<LightColorValues> AddressableLightTransformer::apply() {
   // non-linear when applying small deltas.
 
   if (smoothed_progress > this->last_transition_progress_ && this->last_transition_progress_ < 1.f) {
-    // Lazy uniformity scan: deferred from start() so the LED output's setup() has run and the
-    // frame buffer is valid. When every LED already has the same color (the common case: plain
-    // turn_on/turn_off on a uniform strip), interpolate math-only against a single start color.
-    // Avoiding the per-step read-back through the 8-bit stored byte prevents gamma round-trip
-    // quantization from stalling the fade at low values (e.g. gamma 2.8 pre-gamma values <27
-    // round to stored 0, freezing progress).
-    if (!this->uniform_start_scanned_) {
-      this->uniform_start_scanned_ = true;
-      if (this->light_.size() > 0) {
-        Color first = this->light_[0].get();
-        bool uniform = true;
-        for (int32_t i = 1; i < this->light_.size(); i++) {
-          if (this->light_[i].get() != first) {
-            uniform = false;
-            break;
-          }
-        }
-        if (uniform) {
-          this->uniform_start_color_ = first;
-          this->uniform_start_is_uniform_ = true;
-        }
-      }
-    }
-    if (this->uniform_start_is_uniform_) {
-      // All LEDs started at the same color: compute the interpolated value once and write it to
-      // every LED. No read-back, so each LED's stored byte advances through every gamma threshold
-      // as smoothed_progress crosses it, instead of stalling at 0 for low pre-gamma values.
-      //
-      // Trade-off: any mid-transition writes to individual LEDs (e.g. from a user lambda) will be
-      // overwritten on the next apply() here. The fallback path below would have respected them
-      // via its read-back. Concurrent per-LED mutation during a transition isn't a pattern we
-      // support, so this is acceptable.
-      // lerp(start, target, progress) via existing helper: target - (target-start)*(1-progress).
-      const Color &start = this->uniform_start_color_;
-      int32_t remaining = int32_t(256.f * (1.f - smoothed_progress));
-      uint8_t r = subtract_scaled_difference(this->target_color_.red, start.red, remaining);
-      uint8_t g = subtract_scaled_difference(this->target_color_.green, start.green, remaining);
-      uint8_t b = subtract_scaled_difference(this->target_color_.blue, start.blue, remaining);
-      uint8_t w = subtract_scaled_difference(this->target_color_.white, start.white, remaining);
-      for (auto led : this->light_) {
-        led.set_rgbw(r, g, b, w);
-      }
-    } else {
-      int32_t scale =
-          int32_t(256.f * std::max((1.f - smoothed_progress) / (1.f - this->last_transition_progress_), 0.f));
-      for (auto led : this->light_) {
-        led.set_rgbw(subtract_scaled_difference(this->target_color_.red, led.get_red(), scale),
-                     subtract_scaled_difference(this->target_color_.green, led.get_green(), scale),
-                     subtract_scaled_difference(this->target_color_.blue, led.get_blue(), scale),
-                     subtract_scaled_difference(this->target_color_.white, led.get_white(), scale));
-      }
+    int32_t scale = int32_t(256.f * std::max((1.f - smoothed_progress) / (1.f - this->last_transition_progress_), 0.f));
+    for (auto led : this->light_) {
+      led.set_rgbw(subtract_scaled_difference(this->target_color_.red, led.get_red(), scale),
+                   subtract_scaled_difference(this->target_color_.green, led.get_green(), scale),
+                   subtract_scaled_difference(this->target_color_.blue, led.get_blue(), scale),
+                   subtract_scaled_difference(this->target_color_.white, led.get_white(), scale));
     }
     this->last_transition_progress_ = smoothed_progress;
     this->light_.schedule_show();

esphome/components/light/addressable_light.h

@@ -115,9 +115,6 @@ class AddressableLightTransformer : public LightTransformer {
   AddressableLight &light_;
   float last_transition_progress_{0.0f};
   Color target_color_{};
-  Color uniform_start_color_{};
-  bool uniform_start_scanned_{false};
-  bool uniform_start_is_uniform_{false};
 };
 
 }  // namespace esphome::light

esphome/components/lvgl/__init__.py

@@ -44,7 +44,6 @@ from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj
 from esphome.final_validate import full_config
 from esphome.helpers import write_file_if_changed
-from esphome.writer import clean_build
 from esphome.yaml_util import load_yaml
 
 from . import defines as df, helpers, lv_validation as lvalid, widgets
@@ -342,7 +341,7 @@ async def to_code(configs):
                 df.LOGGER.info("LVGL will use hardware rotation via display driver")
             else:
                 rotation_type = RotationType.ROTATION_SOFTWARE
-                if CORE.is_esp32 and get_esp32_variant() == VARIANT_ESP32P4:
+                if get_esp32_variant() == VARIANT_ESP32P4:
                     df.LOGGER.info("LVGL will use software rotation (PPA accelerated)")
                 else:
                     df.LOGGER.info("LVGL will use software rotation")
@@ -452,8 +451,7 @@ async def to_code(configs):
         df.add_define(f"LV_DRAW_SW_SUPPORT_{fmt}", "1")
 
     lv_conf_h_file = CORE.relative_src_path(LV_CONF_FILENAME)
-    if write_file_if_changed(lv_conf_h_file, generate_lv_conf_h()):
-        clean_build(clear_pio_cache=False)
+    write_file_if_changed(lv_conf_h_file, generate_lv_conf_h())
     cg.add_build_flag("-DLV_CONF_H=1")
     # handle windows paths in a way that doesn't break the generated C++
     lv_conf_h_path = Path(lv_conf_h_file).as_posix()

esphome/components/lvgl/hello_world.yaml

@@ -89,12 +89,10 @@
                       id: hello_world_label_
                       text: "Hello World!"
                       align: center
-            - container:
+            - obj:
                 id: hello_world_qrcode_
                 outline_width: 0
                 border_width: 0
-                height: 100
-                width: 100
                 hidden: !lambda |-
                     return lv_obj_get_width(lv_screen_active()) < 300 && lv_obj_get_height(lv_screen_active()) < 400;
                 widgets:

esphome/components/lvgl/lvgl_esphome.cpp

@@ -454,12 +454,10 @@ void LVTouchListener::update(const touchscreen::TouchPoints_t &tpoints) {
 
 #ifdef USE_LVGL_METER
 
-int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int32_t value) {
+int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int value) {
   auto *scale = lv_obj_get_parent(obj);
   auto min_value = lv_scale_get_range_min_value(scale);
-  auto max_value = lv_scale_get_range_max_value(scale);
-  value = clamp(value, min_value, max_value);
-  return ((value - min_value) * lv_scale_get_angle_range(scale) / (max_value - min_value) +
+  return ((value - min_value) * lv_scale_get_angle_range(scale) / (lv_scale_get_range_max_value(scale) - min_value) +
           lv_scale_get_rotation((scale))) %
          360;
 }
@@ -644,28 +642,26 @@ void LvglComponent::write_random_() {
   int iterations = 6 - lv_display_get_inactive_time(this->disp_) / 60000;
   if (iterations <= 0)
     iterations = 1;
-  int16_t width = lv_display_get_horizontal_resolution(this->disp_);
-  int16_t height = lv_display_get_vertical_resolution(this->disp_);
   while (iterations-- != 0) {
-    int32_t col = random_uint32() % width;
+    int32_t col = random_uint32() % this->width_;
     col = col / this->draw_rounding * this->draw_rounding;
-    int32_t row = random_uint32() % height;
+    int32_t row = random_uint32() % this->height_;
     row = row / this->draw_rounding * this->draw_rounding;
     // size will be between 8 and 32, and a multiple of draw_rounding
     int32_t size = (random_uint32() % 25 + 8) / this->draw_rounding * this->draw_rounding;
-    lv_area_t area{.x1 = col, .y1 = row, .x2 = col + size - 1, .y2 = row + size - 1};
+    lv_area_t area{col, row, col + size - 1, row + size - 1};
     // clip to display bounds just in case
-    if (area.x2 >= width)
-      area.x2 = width - 1;
-    if (area.y2 >= height)
-      area.y2 = height - 1;
+    if (area.x2 >= this->width_)
+      area.x2 = this->width_ - 1;
+    if (area.y2 >= this->height_)
+      area.y2 = this->height_ - 1;
 
     // line_len can't exceed 1024, and minimum buffer size is 2048, so this won't overflow the buffer
     size_t line_len = lv_area_get_width(&area) * lv_area_get_height(&area) / 2;
     for (size_t i = 0; i != line_len; i++) {
-      reinterpret_cast<uint32_t *>(this->draw_buf_)[i] = random_uint32();
+      ((uint32_t *) (this->draw_buf_))[i] = random_uint32();
     }
-    this->draw_buffer_(&area, reinterpret_cast<lv_color_data *>(this->draw_buf_));
+    this->draw_buffer_(&area, (lv_color_data *) this->draw_buf_);
   }
 }
 

esphome/components/lvgl/lvgl_esphome.h

@@ -76,23 +76,16 @@ inline void lv_style_set_text_font(lv_style_t *style, const font::Font *font) {
 }
 #endif
 #if defined(USE_LVGL_IMAGE) && defined(USE_IMAGE)
-#if LV_USE_IMAGE
-// Shortcut / overload, so that the source of an image widget can easily be updated from within a lambda.
-inline void lv_image_set_src(lv_obj_t *obj, image::Image *image) { ::lv_image_set_src(obj, image->get_lv_image_dsc()); }
-#endif  // LV_USE_IMAGE
+// Shortcut / overload, so that the source of an image can easily be updated
+// from within a lambda.
+inline void lv_image_set_src(lv_obj_t *obj, image::Image *image) { lv_image_set_src(obj, image->get_lv_image_dsc()); }
 
 inline void lv_obj_set_style_bitmap_mask_src(lv_obj_t *obj, image::Image *image, lv_style_selector_t selector) {
-  ::lv_obj_set_style_bitmap_mask_src(obj, image->get_lv_image_dsc(), selector);
+  lv_obj_set_style_bitmap_mask_src(obj, image->get_lv_image_dsc(), selector);
 }
 
 inline void lv_obj_set_style_bg_image_src(lv_obj_t *obj, image::Image *image, lv_style_selector_t selector) {
-  ::lv_obj_set_style_bg_image_src(obj, image->get_lv_image_dsc(), selector);
-}
-inline void lv_style_set_bg_image_src(lv_style_t *style, image::Image *image) {
-  ::lv_style_set_bg_image_src(style, image->get_lv_image_dsc());
-}
-inline void lv_style_set_bitmap_mask_src(lv_style_t *style, image::Image *image) {
-  ::lv_style_set_bitmap_mask_src(style, image->get_lv_image_dsc());
+  lv_obj_set_style_bg_image_src(obj, image->get_lv_image_dsc(), selector);
 }
 #endif  // USE_LVGL_IMAGE
 #ifdef USE_LVGL_ANIMIMG
@@ -112,7 +105,7 @@ inline void lv_animimg_set_src(lv_obj_t *img, std::vector<image::Image *> images
 #endif  // USE_LVGL_ANIMIMG
 
 #ifdef USE_LVGL_METER
-int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int32_t value);
+int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int value);
 #endif
 
 // Parent class for things that wrap an LVGL object

esphome/components/lvgl/widgets/arc.py

@@ -77,11 +77,8 @@ class ArcType(NumberType):
                 # start_angle and end_angle are mapped to bg_start_angle and bg_end_angle
                 prop = str(prop)
                 if prop.endswith("_angle"):
-                    await w.set_property(
-                        "bg_" + prop, await validator.process(config.get(prop))
-                    )
-                else:
-                    await w.set_property(prop, config, processor=validator)
+                    prop = "bg_" + prop
+                await w.set_property(prop, config, processor=validator)
         if CONF_ADJUSTABLE in config:
             if not config[CONF_ADJUSTABLE]:
                 lv_obj.remove_style(w.obj, nullptr, LV_PART.KNOB)

esphome/components/lvgl/widgets/keyboard.py

@@ -52,23 +52,19 @@ class KeyboardType(WidgetType):
         if mode := config.get(CONF_MODE):
             await w.set_property(CONF_MODE, await KEYBOARD_MODES.process(mode))
         if textarea := config.get(CONF_TEXTAREA):
-            if not is_widget_completed(textarea):
-                # Can only happen for an initial config, where the keyboard is configured before the
-                # textarea, so it's ok to always emit into the global context
-                async def add_textarea():
-                    async with LvContext():
-                        await w.set_property(
-                            CONF_TEXTAREA,
-                            (await get_widgets(config, CONF_TEXTAREA))[0].obj,
-                        )
+            # If a textarea is configured, it must be generated before the keyboard can attach it.
+            # If not yet configured, defer the attachment code.
 
-                CORE.add_job(add_textarea)
+            async def add_textarea():
+                async with LvContext():
+                    await w.set_property(
+                        CONF_TEXTAREA, (await get_widgets(config, CONF_TEXTAREA))[0].obj
+                    )
+
+            if is_widget_completed(textarea):
+                await add_textarea()
             else:
-                # Handles updates in automations, and properly ordered initial config. Code is generated
-                # into the enclosing context (main or lambda)
-                await w.set_property(
-                    CONF_TEXTAREA, (await get_widgets(config, CONF_TEXTAREA))[0].obj
-                )
+                CORE.add_job(add_textarea)
 
 
 keyboard_spec = KeyboardType()

esphome/components/lvgl/widgets/tabview.py

@@ -22,7 +22,7 @@ from ..defines import (
     literal,
 )
 from ..lv_validation import animated, lv_int, size
-from ..lvcode import LocalVariable, lv, lv_assign, lv_expr, lv_obj, lv_Pvariable
+from ..lvcode import LocalVariable, lv, lv_assign, lv_expr, lv_obj
 from ..schemas import container_schema, part_schema
 from ..types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr
 from . import Widget, WidgetType, add_widgets, get_widgets, set_obj_properties
@@ -83,8 +83,8 @@ class TabviewType(WidgetType):
         await w.set_property("tab_bar_size", await size.process(config[CONF_SIZE]))
         for tab_conf in config[CONF_TABS]:
             w_id = tab_conf[CONF_ID]
-            tab_obj = lv_Pvariable(lv_tab_t, w_id)
-            tab_widget = Widget.create(w_id, tab_obj, obj_spec, tab_conf)
+            tab_obj = cg.Pvariable(w_id, cg.nullptr, type_=lv_tab_t)
+            tab_widget = Widget.create(w_id, tab_obj, obj_spec)
             lv_assign(tab_obj, lv_expr.tabview_add_tab(w.obj, tab_conf[CONF_NAME]))
             await set_obj_properties(tab_widget, tab_conf)
             await add_widgets(tab_widget, tab_conf)

esphome/components/mcp23016/mcp23016.cpp

@@ -37,10 +37,7 @@ void IRAM_ATTR MCP23016::gpio_intr(MCP23016 *arg) { arg->enable_loop_soon_any_co
 void MCP23016::loop() {
   // Invalidate cache at the start of each loop
   this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+  if (this->interrupt_pin_ != nullptr) {
     this->disable_loop();
   }
 }

esphome/components/mcp23xxx_base/__init__.py

@@ -2,7 +2,6 @@ from esphome import pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ALLOW_OTHER_USES,
     CONF_ID,
     CONF_INPUT,
     CONF_INTERRUPT,
@@ -31,29 +30,10 @@ MCP23XXX_INTERRUPT_MODES = {
     "FALLING": MCP23XXXInterruptMode.MCP23XXX_FALLING,
 }
 
-
-def _validate_interrupt_pin(value):
-    # The MCP component owns INT polarity (active-low, hardcoded falling-edge ISR)
-    # and installs a single ISR per GPIO, so neither inversion nor sharing is supported.
-    value = pins.internal_gpio_input_pin_schema(value)
-    if value.get(CONF_INVERTED):
-        raise cv.Invalid(
-            f"'{CONF_INVERTED}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
-            "the MCP23xxx INT line is fixed active-low"
-        )
-    if value.get(CONF_ALLOW_OTHER_USES):
-        raise cv.Invalid(
-            f"'{CONF_ALLOW_OTHER_USES}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
-            "sharing the interrupt pin between multiple MCP23xxx (or other components) "
-            "is not implemented. Remove the interrupt_pin to fall back to polling."
-        )
-    return value
-
-
 MCP23XXX_CONFIG_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_OPEN_DRAIN_INTERRUPT, default=False): cv.boolean,
-        cv.Optional(CONF_INTERRUPT_PIN): _validate_interrupt_pin,
+        cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/mcp23xxx_base/mcp23xxx_base.h

@@ -21,10 +21,7 @@ template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander:
 
   void loop() override {
     this->reset_pin_cache_();
-    // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-    // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-    // stale state forever; keep looping until the line is released so we self-heal.
-    if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+    if (this->interrupt_pin_ != nullptr) {
       this->disable_loop();
     }
   }

esphome/components/mdns/__init__.py

@@ -170,7 +170,7 @@ async def to_code(config):
             cg.add_library("LEAmDNS", None)
 
     if CORE.is_esp32:
-        add_idf_component(name="espressif/mdns", ref="1.11.0")
+        add_idf_component(name="espressif/mdns", ref="1.10.0")
 
     cg.add_define("USE_MDNS")
 

esphome/components/micro_wake_word/__init__.py

@@ -451,8 +451,6 @@ async def to_code(config):
     ota.request_ota_state_listeners()
 
     esp32.add_idf_component(name="espressif/esp-tflite-micro", ref="1.3.3~1")
-    # Pin esp-nn for stable future builds (esp-tflite-micro depends on esp-nn)
-    esp32.add_idf_component(name="espressif/esp-nn", ref="1.1.2")
 
     cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
     cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")

esphome/components/micro_wake_word/streaming_model.cpp

@@ -29,6 +29,14 @@ void VADModel::log_model_config() {
 bool StreamingModel::load_model_() {
   RAMAllocator<uint8_t> arena_allocator;
 
+  if (this->tensor_arena_ == nullptr) {
+    this->tensor_arena_ = arena_allocator.allocate(this->tensor_arena_size_);
+    if (this->tensor_arena_ == nullptr) {
+      ESP_LOGE(TAG, "Could not allocate the streaming model's tensor arena.");
+      return false;
+    }
+  }
+
   if (this->var_arena_ == nullptr) {
     this->var_arena_ = arena_allocator.allocate(STREAMING_MODEL_VARIABLE_ARENA_SIZE);
     if (this->var_arena_ == nullptr) {
@@ -45,26 +53,6 @@ bool StreamingModel::load_model_() {
     return false;
   }
 
-  // Probe for the actual required tensor arena size if not yet determined
-  if (!this->tensor_arena_size_probed_) {
-    size_t probed_size = this->probe_arena_size_();
-    if (probed_size > 0) {
-      ESP_LOGD(TAG, "Probed tensor arena size: %zu bytes", probed_size);
-      this->tensor_arena_size_ = probed_size;
-    } else {
-      ESP_LOGW(TAG, "Arena size probe failed, using manifest size: %zu bytes", this->tensor_arena_size_);
-    }
-    this->tensor_arena_size_probed_ = true;
-  }
-
-  if (this->tensor_arena_ == nullptr) {
-    this->tensor_arena_ = arena_allocator.allocate(this->tensor_arena_size_);
-    if (this->tensor_arena_ == nullptr) {
-      ESP_LOGE(TAG, "Could not allocate the streaming model's tensor arena.");
-      return false;
-    }
-  }
-
   if (this->interpreter_ == nullptr) {
     this->interpreter_ =
         make_unique<tflite::MicroInterpreter>(tflite::GetModel(this->model_start_), this->streaming_op_resolver_,
@@ -106,70 +94,6 @@ bool StreamingModel::load_model_() {
   return true;
 }
 
-size_t StreamingModel::probe_arena_size_() {
-  RAMAllocator<uint8_t> arena_allocator;
-
-  // Try with the manifest size first, then escalates to 1.5, then 2x if it fails. Different platforms and different
-  // versions of the esp-nn library require different amounts of memory, so the manifest size may not always be correct,
-  // and probing allows us to find the actual required size for the current build and platform. Aligns test sizes to 16
-  // bytes.
-  size_t attempt_sizes[] = {(this->tensor_arena_size_ + 15) & ~15, (this->tensor_arena_size_ * 3 / 2 + 15) & ~15,
-                            (this->tensor_arena_size_ * 2 + 15) & ~15};
-
-  for (size_t attempt_size : attempt_sizes) {
-    uint8_t *probe_arena = arena_allocator.allocate(attempt_size);
-    if (probe_arena == nullptr) {
-      continue;
-    }
-
-    // Verify the model works at all with this arena size
-    auto probe_interpreter = make_unique<tflite::MicroInterpreter>(
-        tflite::GetModel(this->model_start_), this->streaming_op_resolver_, probe_arena, attempt_size, this->mrv_);
-
-    if (probe_interpreter->AllocateTensors() != kTfLiteOk) {
-      probe_interpreter.reset();
-      arena_allocator.deallocate(probe_arena, attempt_size);
-      this->ma_ = tflite::MicroAllocator::Create(this->var_arena_, STREAMING_MODEL_VARIABLE_ARENA_SIZE);
-      this->mrv_ = tflite::MicroResourceVariables::Create(this->ma_, 20);
-      continue;
-    }
-
-    // Try to shrink the arena. Start with arena_used_bytes() + 16 (rounded to 16-byte alignment).
-    // If that works, use it. Otherwise, try midpoints between that and the full size until one succeeds.
-    size_t lower = (probe_interpreter->arena_used_bytes() + 16 + 15) & ~15;
-    probe_interpreter.reset();
-    this->ma_ = tflite::MicroAllocator::Create(this->var_arena_, STREAMING_MODEL_VARIABLE_ARENA_SIZE);
-    this->mrv_ = tflite::MicroResourceVariables::Create(this->ma_, 20);
-
-    size_t upper = attempt_size;
-
-    while (lower < upper) {
-      auto test_interpreter = make_unique<tflite::MicroInterpreter>(
-          tflite::GetModel(this->model_start_), this->streaming_op_resolver_, probe_arena, lower, this->mrv_);
-
-      bool ok = test_interpreter->AllocateTensors() == kTfLiteOk;
-
-      test_interpreter.reset();
-      this->ma_ = tflite::MicroAllocator::Create(this->var_arena_, STREAMING_MODEL_VARIABLE_ARENA_SIZE);
-      this->mrv_ = tflite::MicroResourceVariables::Create(this->ma_, 20);
-
-      if (ok) {
-        // Found a working size smaller than the full arena
-        upper = lower + 16;  // Pad by 16 bytes to be safe for future allocations
-        break;
-      }
-
-      // Try the midpoint between current attempt and full size
-      lower = ((lower + upper) / 2 + 15) & ~15;
-    }
-
-    arena_allocator.deallocate(probe_arena, attempt_size);
-    return upper;
-  }
-
-  return 0;
-}
-
 void StreamingModel::unload_model() {
   this->interpreter_.reset();
 

esphome/components/micro_wake_word/streaming_model.h

@@ -63,10 +63,6 @@ class StreamingModel {
   /// @brief Allocates tensor and variable arenas and sets up the model interpreter
   /// @return True if successful, false otherwise
   bool load_model_();
-  /// @brief Probes the actual required tensor arena size by trial allocation.
-  /// Tries the manifest size first, then 2x if that fails.
-  /// @return The required arena size rounded up to 16-byte alignment, or 0 on failure.
-  size_t probe_arena_size_();
   /// @brief Returns true if successfully registered the streaming model's TensorFlow operations
   bool register_streaming_ops_(tflite::MicroMutableOpResolver<20> &op_resolver);
 
@@ -74,7 +70,6 @@ class StreamingModel {
 
   bool loaded_{false};
   bool enabled_{true};
-  bool tensor_arena_size_probed_{false};
   bool unprocessed_probability_status_{false};
   uint8_t current_stride_step_{0};
   int16_t ignore_windows_{-MIN_SLICES_BEFORE_DETECTION};

esphome/components/midea/air_conditioner.cpp

@@ -28,8 +28,7 @@ void AirConditioner::on_status_change() {
   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
-    auto traits = this->get_traits();
-    const auto &existing = traits.get_supported_custom_presets();
+    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) {

esphome/components/mipi_spi/display.py

@@ -195,7 +195,7 @@ def model_schema(config):
                     "big_endian", "little_endian", lower=True
                 ),
                 model.option(CONF_COLOR_DEPTH, 16): cv.one_of(*color_depth, lower=True),
-                model.option(CONF_DRAW_ROUNDING, 1): power_of_two,
+                model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
                 model.option(CONF_PIXEL_MODE, DISPLAY_16BIT): cv.one_of(
                     *pixel_modes, lower=True
                 ),
@@ -297,9 +297,9 @@ def _final_validate(config):
 
         buffer_size = color_depth // 8 * width * height // frac
         # Target a buffer size of 20kB, except for large displays, which shouldn't end up here
-        fraction = min(20000.0, buffer_size // 4) / buffer_size
+        fraction = min(20000.0, buffer_size // 16) / buffer_size
         config[CONF_BUFFER_SIZE] = 1.0 / next(
-            (x for x in range(2, 8) if fraction >= 1 / x), 8
+            x for x in range(2, 17) if fraction >= 1 / x
         )
 
 

esphome/components/mipi_spi/mipi_spi.h

@@ -234,9 +234,9 @@ class MipiSpi : public display::Display,
   }
 
   void dump_config() override {
-    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT,
-                         (uint8_t) MADCTL, this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_,
-                         this->cs_, this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
+    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT, MADCTL,
+                         this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_,
+                         this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
                          HAS_HARDWARE_ROTATION);
   }
 
@@ -305,7 +305,7 @@ class MipiSpi : public display::Display,
       this->write_command_(BRIGHTNESS, this->brightness_.value());
 
     // calculate new madctl value from base value adjusted for rotation
-    uint8_t madctl = (uint8_t) MADCTL;  // lower 8 bits only
+    uint8_t madctl = MADCTL;  // lower 8 bits only
     constexpr bool use_flips = (MADCTL & MADCTL_FLIP_FLAG) != 0;
     constexpr uint8_t x_mask = use_flips ? MADCTL_XFLIP : MADCTL_MX;
     constexpr uint8_t y_mask = use_flips ? MADCTL_YFLIP : MADCTL_MY;
@@ -546,12 +546,13 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
     }
     // for updates with a small buffer, we repeatedly call the writer_ function, clipping the height to a fraction of
     // the display height,
-    auto increment = (this->get_height_internal() / FRACTION / ROUNDING) * ROUNDING;
-    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal(); this->start_line_ = this->end_line_) {
+    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal();
+         this->start_line_ += this->get_height_internal() / FRACTION) {
 #if ESPHOME_LOG_LEVEL == ESPHOME_LOG_LEVEL_VERBOSE
       auto lap = millis();
 #endif
-      this->end_line_ = clamp_at_most(this->start_line_ + increment, this->get_height_internal());
+      this->end_line_ =
+          clamp_at_most(this->start_line_ + this->get_height_internal() / FRACTION, this->get_height_internal());
       if (this->auto_clear_enabled_) {
         this->clear();
       }
@@ -573,13 +574,12 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
       // Some chips require that the drawing window be aligned on certain boundaries
       this->x_low_ = this->x_low_ / ROUNDING * ROUNDING;
       this->y_low_ = this->y_low_ / ROUNDING * ROUNDING;
-      this->x_high_ = round_buffer(this->x_high_ + 1) - 1;
-      this->y_high_ = clamp_at_most(round_buffer(this->y_high_ + 1) - 1, this->end_line_ - 1);
+      this->x_high_ = (this->x_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
+      this->y_high_ = (this->y_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
       int w = this->x_high_ - this->x_low_ + 1;
       int h = this->y_high_ - this->y_low_ + 1;
       this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_,
-                              this->y_low_ - this->start_line_,
-                              round_buffer(this->get_width_internal()) - w - this->x_low_);
+                              this->y_low_ - this->start_line_, round_buffer(this->get_width_internal()) - w);
       // invalidate watermarks
       this->x_low_ = this->get_width_internal();
       this->y_low_ = this->get_height_internal();

esphome/components/mitsubishi_cn105/mitsubishi_cn105_climate.cpp

@@ -7,7 +7,7 @@ namespace esphome::mitsubishi_cn105 {
 static const char *const TAG = "mitsubishi_cn105.climate";
 
 static constexpr std::array MODE_MAP{
-    std::pair{MitsubishiCN105::Mode::AUTO, climate::CLIMATE_MODE_HEAT_COOL},
+    std::pair{MitsubishiCN105::Mode::AUTO, climate::CLIMATE_MODE_AUTO},
     std::pair{MitsubishiCN105::Mode::HEAT, climate::CLIMATE_MODE_HEAT},
     std::pair{MitsubishiCN105::Mode::DRY, climate::CLIMATE_MODE_DRY},
     std::pair{MitsubishiCN105::Mode::COOL, climate::CLIMATE_MODE_COOL},
@@ -76,13 +76,23 @@ void MitsubishiCN105Climate::loop() {
 climate::ClimateTraits MitsubishiCN105Climate::traits() {
   climate::ClimateTraits traits;
 
-  for (const auto &p : MODE_MAP) {
-    traits.add_supported_mode(p.second);
-  }
+  traits.set_supported_modes({
+      climate::CLIMATE_MODE_OFF,
+      climate::CLIMATE_MODE_COOL,
+      climate::CLIMATE_MODE_HEAT,
+      climate::CLIMATE_MODE_DRY,
+      climate::CLIMATE_MODE_FAN_ONLY,
+      climate::CLIMATE_MODE_AUTO,
+  });
 
-  for (const auto &p : FAN_MODE_MAP) {
-    traits.add_supported_fan_mode(p.second);
-  }
+  traits.set_supported_fan_modes({
+      climate::CLIMATE_FAN_AUTO,
+      climate::CLIMATE_FAN_QUIET,
+      climate::CLIMATE_FAN_LOW,
+      climate::CLIMATE_FAN_MEDIUM,
+      climate::CLIMATE_FAN_MIDDLE,
+      climate::CLIMATE_FAN_HIGH,
+  });
 
   traits.set_visual_min_temperature(16.0f);
   traits.set_visual_max_temperature(31.0f);

esphome/components/nextion/nextion.cpp

@@ -36,9 +36,8 @@ bool Nextion::send_command_(const std::string &command) {
   }
 
 #ifdef USE_NEXTION_COMMAND_SPACING
-  const uint32_t now = App.get_loop_component_start_time();
-  if (!this->connection_state_.ignore_is_setup_ && !this->command_pacer_.can_send(now)) {
-    ESP_LOGN(TAG, "Command spacing: delaying '%s'", command.c_str());
+  if (!this->connection_state_.ignore_is_setup_ && !this->command_pacer_.can_send()) {
+    ESP_LOGN(TAG, "Command spacing: delaying command '%s'", command.c_str());
     return false;
   }
 #endif  // USE_NEXTION_COMMAND_SPACING
@@ -49,16 +48,6 @@ bool Nextion::send_command_(const std::string &command) {
   const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF};
   this->write_array(to_send, sizeof(to_send));
 
-#ifdef USE_NEXTION_COMMAND_SPACING
-  // Mark sent immediately after writing to UART. The pacer enforces inter-command
-  // spacing from the transmit side. Marking on ACK (0x01) would leave last_command_time_
-  // at zero indefinitely, making can_send() always return true and spacing a no-op.
-  // ignore_is_setup_ commands (setup/init sequence) bypass spacing intentionally.
-  if (!this->connection_state_.ignore_is_setup_) {
-    this->command_pacer_.mark_sent(now);
-  }
-#endif  // USE_NEXTION_COMMAND_SPACING
-
   return true;
 }
 
@@ -264,8 +253,11 @@ bool Nextion::send_command(const char *command) {
   if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
     return false;
 
-  this->add_no_result_to_queue_with_command_("command", command);
-  return true;
+  if (this->send_command_(command)) {
+    this->add_no_result_to_queue_("command");
+    return true;
+  }
+  return false;
 }
 
 bool Nextion::send_command_printf(const char *format, ...) {
@@ -282,8 +274,11 @@ bool Nextion::send_command_printf(const char *format, ...) {
     return false;
   }
 
-  this->add_no_result_to_queue_with_command_("command_printf", buffer);
-  return true;
+  if (this->send_command_(buffer)) {
+    this->add_no_result_to_queue_("command_printf");
+    return true;
+  }
+  return false;
 }
 
 #ifdef NEXTION_PROTOCOL_LOG
@@ -354,43 +349,25 @@ void Nextion::loop() {
   }
 
 #ifdef USE_NEXTION_COMMAND_SPACING
+  // Try to send any pending commands if spacing allows
   this->process_pending_in_queue_();
-#ifdef USE_NEXTION_WAVEFORM
-  if (!this->waveform_queue_.empty()) {
-    this->check_pending_waveform_();
-  }
-#endif  // USE_NEXTION_WAVEFORM
 #endif  // USE_NEXTION_COMMAND_SPACING
 }
 
 #ifdef USE_NEXTION_COMMAND_SPACING
 void Nextion::process_pending_in_queue_() {
-#ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
-  size_t commands_sent = 0;
-#endif  // USE_NEXTION_MAX_COMMANDS_PER_LOOP
+  if (this->nextion_queue_.empty() || !this->command_pacer_.can_send()) {
+    return;
+  }
 
-  for (auto *item : this->nextion_queue_) {
-    if (item == nullptr || item->pending_command.empty()) {
-      continue;  // Already sent, waiting for ACK — skip, don't stop
+  // Check if first item in queue has a pending command
+  auto *front_item = this->nextion_queue_.front();
+  if (front_item && !front_item->pending_command.empty()) {
+    if (this->send_command_(front_item->pending_command)) {
+      // Command sent successfully, clear the pending command
+      front_item->pending_command.clear();
+      ESP_LOGVV(TAG, "Pending command sent: %s", front_item->component->get_variable_name().c_str());
     }
-
-#ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
-    if (++commands_sent > this->max_commands_per_loop_) {
-      ESP_LOGV(TAG, "Pending cmds: loop limit reached, deferring");
-      break;
-    }
-#endif  // USE_NEXTION_MAX_COMMANDS_PER_LOOP
-
-    const uint32_t now = App.get_loop_component_start_time();
-    if (!this->command_pacer_.can_send(now)) {
-      break;  // Spacing not elapsed, stop for this loop iteration
-    }
-
-    if (!this->send_command_(item->pending_command)) {
-      break;  // Unexpected send failure, stop
-    }
-    item->pending_command.clear();
-    ESP_LOGVV(TAG, "Pending cmd sent: %s", item->component->get_variable_name().c_str());
   }
 }
 #endif  // USE_NEXTION_COMMAND_SPACING
@@ -493,6 +470,10 @@ void Nextion::process_nextion_commands_() {
             this->setup_callback_.call();
           }
         }
+#ifdef USE_NEXTION_COMMAND_SPACING
+        this->command_pacer_.mark_sent();  // Here is where we should mark the command as sent
+        ESP_LOGN(TAG, "Command spacing: marked command sent");
+#endif
         break;
       case 0x02:  // invalid Component ID or name was used
         ESP_LOGW(TAG, "Invalid component ID/name");
@@ -641,7 +622,6 @@ void Nextion::process_nextion_commands_() {
         } else {
           ESP_LOGN(TAG, "String resp: '%s' id: %s type: %s", to_process.c_str(), component->get_variable_name().c_str(),
                    component->get_queue_type_string());
-          component->set_state_from_string(to_process, true, false);
         }
 
         delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
@@ -1099,18 +1079,10 @@ void Nextion::add_no_result_to_queue_(const std::string &variable_name) {
 }
 
 /**
- * @brief Send a command and enqueue it for response tracking.
+ * @brief
  *
- * Callers are responsible for checking is_sleeping() before calling this
- * method. The sleep guard is deliberately absent here because some callers
- * (e.g. add_no_result_to_queue_with_ignore_sleep_printf_()) are explicitly
- * sleep-safe and must bypass it.
- *
- * If USE_NEXTION_COMMAND_SPACING is enabled and the pacer is not ready,
- * the command is saved in the queue entry for retry rather than dropped.
- *
- * @param variable_name Name of the variable or component associated with the command.
- * @param command       The raw command string to send.
+ * @param variable_name Variable name for the queue
+ * @param command
  */
 void Nextion::add_no_result_to_queue_with_command_(const std::string &variable_name, const std::string &command) {
   if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || command.empty())
@@ -1291,22 +1263,9 @@ void Nextion::add_to_get_queue(NextionComponentBase *component) {
 
   std::string command = "get " + component->get_variable_name_to_send();
 
-#ifdef USE_NEXTION_COMMAND_SPACING
-  // Always enqueue first so the response handler is present when the command
-  // is eventually sent. Store the command for retry if spacing blocked it;
-  // process_pending_in_queue_() will transmit it when the pacer allows.
-  nextion_queue->pending_command = command;
-  this->nextion_queue_.push_back(nextion_queue);
-  if (this->send_command_(command)) {
-    nextion_queue->pending_command.clear();
-  }
-#else   // USE_NEXTION_COMMAND_SPACING
   if (this->send_command_(command)) {
     this->nextion_queue_.push_back(nextion_queue);
-  } else {
-    delete nextion_queue;  // NOLINT(cppcoreguidelines-owning-memory)
   }
-#endif  // USE_NEXTION_COMMAND_SPACING
 }
 
 #ifdef USE_NEXTION_WAVEFORM
@@ -1350,10 +1309,10 @@ void Nextion::check_pending_waveform_() {
   char command[24];  // "addt " + uint8 + "," + uint8 + "," + uint8 + null = max 17 chars
   buf_append_printf(command, sizeof(command), 0, "addt %u,%u,%zu", component->get_component_id(),
                     component->get_wave_channel_id(), buffer_to_send);
-  // If spacing or setup state blocks the send, leave the entry at the front
-  // of waveform_queue_ for retry on the next loop iteration via
-  // check_pending_waveform_(). Only pop on a successful send.
-  this->send_command_(command);
+  if (!this->send_command_(command)) {
+    delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
+    this->waveform_queue_.pop();
+  }
 }
 #endif  // USE_NEXTION_WAVEFORM
 

esphome/components/nextion/nextion.h

@@ -55,20 +55,15 @@ class NextionCommandPacer {
   uint8_t get_spacing() const { return spacing_ms_; }
 
   /**
-   * @brief Check if enough time has passed to send the next command.
-   * @param now Current timestamp in milliseconds (use App.get_loop_component_start_time()
-   *            for consistency with the rest of the queue timing).
-   * @return true if the spacing interval has elapsed since the last command was sent.
+   * @brief Check if enough time has passed to send next command
+   * @return true if enough time has passed since last command
    */
-  bool can_send(uint32_t now) const { return (now - last_command_time_) >= spacing_ms_; }
+  bool can_send() const { return (millis() - last_command_time_) >= spacing_ms_; }
 
   /**
-   * @brief Record the transmit timestamp for the most recently sent command.
-   * @param now Current timestamp in milliseconds, as returned by
-   *            App.get_loop_component_start_time(). Must use the same clock
-   *            source as can_send() to avoid unsigned underflow.
+   * @brief Mark a command as sent, updating the timing
    */
-  void mark_sent(uint32_t now) { last_command_time_ = now; }
+  void mark_sent() { last_command_time_ = millis(); }
 
  private:
   uint8_t spacing_ms_;

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -16,13 +16,6 @@ namespace esphome::nextion {
 static const char *const TAG = "nextion.upload.arduino";
 static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;
 
-// Timeout for display acknowledgment during TFT upload (ms).
-// A single value is used for all chunks; the happy path returns as soon as
-// 0x05/0x08 arrives, so this only bounds failed-detection latency. Field
-// reports showed the previous 500ms steady-state value was too tight for
-// some firmware variants.
-static constexpr uint32_t NEXTION_UPLOAD_ACK_TIMEOUT_MS = 5000;
-
 // Followed guide
 // https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
 
@@ -87,14 +80,14 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
       recv_string.clear();
       this->write_array(buffer, buffer_size);
       App.feed_wdt();
-      this->recv_ret_string_(recv_string, NEXTION_UPLOAD_ACK_TIMEOUT_MS, true);
+      this->recv_ret_string_(recv_string, this->upload_first_chunk_sent_ ? 500 : 5000, true);
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
       ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,
                EspClass::getFreeHeap());
       this->upload_first_chunk_sent_ = true;
       if (recv_string.empty()) {
-        ESP_LOGW(TAG, "No response from display after %" PRIu32 "ms", NEXTION_UPLOAD_ACK_TIMEOUT_MS);
+        ESP_LOGW(TAG, "No response from display during upload");
         allocator.deallocate(buffer, 4096);
         buffer = nullptr;
         return -1;

esphome/components/nextion/nextion_upload_esp32.cpp

@@ -19,13 +19,6 @@ namespace esphome::nextion {
 static const char *const TAG = "nextion.upload.esp32";
 static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;
 
-// Timeout for display acknowledgment during TFT upload (ms).
-// A single value is used for all chunks; the happy path returns as soon as
-// 0x05/0x08 arrives, so this only bounds failed-detection latency. Field
-// reports showed the previous 500ms steady-state value was too tight for
-// some firmware variants.
-static constexpr uint32_t NEXTION_UPLOAD_ACK_TIMEOUT_MS = 5000;
-
 // Followed guide
 // https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
 
@@ -103,7 +96,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
       recv_string.clear();
       this->write_array(buffer, buffer_size);
       App.feed_wdt();
-      this->recv_ret_string_(recv_string, NEXTION_UPLOAD_ACK_TIMEOUT_MS, true);
+      this->recv_ret_string_(recv_string, upload_first_chunk_sent_ ? 500 : 5000, true);
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
 #ifdef USE_PSRAM
@@ -116,7 +109,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
 #endif
       upload_first_chunk_sent_ = true;
       if (recv_string.empty()) {
-        ESP_LOGW(TAG, "No response from display after %" PRIu32 "ms", NEXTION_UPLOAD_ACK_TIMEOUT_MS);
+        ESP_LOGW(TAG, "No response from display during upload");
         allocator.deallocate(buffer, 4096);
         buffer = nullptr;
         return -1;

esphome/components/packages/__init__.py

@@ -8,11 +8,8 @@ from typing import Any
 from esphome import git, yaml_util
 from esphome.components.substitutions import (
     ContextVars,
-    ErrList,
     push_context,
-    raise_first_undefined,
     resolve_include,
-    resolve_substitutions_block,
     substitute,
 )
 from esphome.components.substitutions.jinja import has_jinja
@@ -48,18 +45,6 @@ def is_remote_package(package_config: dict) -> bool:
     return CONF_URL in package_config
 
 
-def is_package_definition(value: object) -> bool:
-    """Returns True if the value looks like a package definition rather than a config fragment.
-
-    Package definitions are IncludeFile objects, git URL shorthand strings, or
-    remote package dicts (containing a ``url:`` key).  Config fragments are
-    plain dicts that represent component configuration.
-    """
-    return isinstance(value, (yaml_util.IncludeFile, str)) or (
-        isinstance(value, dict) and is_remote_package(value)
-    )
-
-
 def valid_package_contents(package_config: dict) -> dict:
     """Validate that a package looks like a plausible ESPHome config fragment.
 
@@ -324,23 +309,20 @@ def _walk_packages(
         return config
     packages = config[CONF_PACKAGES]
 
-    with cv.prepend_path(CONF_PACKAGES):
-        if isinstance(packages, yaml_util.IncludeFile):
-            # If the packages key is an IncludeFile, resolve it first before processing.
-            packages, _ = resolve_include(packages, [], context, strict_undefined=False)
-        if not isinstance(packages, (dict, list)):
-            raise cv.Invalid(
-                f"Packages must be a key to value mapping or list, got {type(packages)} instead"
-            )
+    if not isinstance(packages, (dict, list)):
+        raise cv.Invalid(
+            f"Packages must be a key to value mapping or list, got {type(packages)} instead"
+        )
 
+    with cv.prepend_path(CONF_PACKAGES):
         if not isinstance(packages, dict):
             _walk_package_list(packages, callback, context)
         elif (result := _walk_package_dict(packages, callback, context)) is not None:
-            if not validate_deprecated or any(
-                is_package_definition(v) for v in packages.values()
-            ):
+            if not validate_deprecated:
                 raise result
             # Fallback: treat the dict as a single deprecated package.
+            # Note: this catches *any* cv.Invalid from the callback, which may
+            # mask real validation errors in named package dicts.
             # This block can be removed once the single-package
             # deprecation period (2026.7.0) is over.
             config[CONF_PACKAGES] = [packages]
@@ -362,19 +344,12 @@ def _substitute_package_definition(
     if isinstance(package_config, str) or (
         isinstance(package_config, dict) and is_remote_package(package_config)
     ):
-        # Collect undefined-variable errors (rather than raising strict) so the
-        # path walked through a remote-package dict is preserved and the user
-        # sees which field (url / path / ref / ...) referenced the undefined
-        # variable.
-        errors: ErrList = []
         package_config = substitute(
             item=package_config,
             path=[],
             parent_context=context_vars or ContextVars(),
             strict_undefined=False,
-            errors=errors,
         )
-        raise_first_undefined(errors, package_config, "package definition")
     return package_config
 
 
@@ -486,9 +461,6 @@ class _PackageProcessor:
         self, package_config: dict | str, context_vars: ContextVars | None
     ) -> dict:
         """Resolve a single package and recurse into any nested packages."""
-        from_remote = isinstance(package_config, dict) and is_remote_package(
-            package_config
-        )
         package_config = self.resolve_package(package_config, context_vars)
         self.collect_substitutions(package_config)
 
@@ -498,18 +470,7 @@ class _PackageProcessor:
         # Push context from !include vars on the package root and on the packages key
         context_vars = push_context(package_config, context_vars)
         context_vars = push_context(package_config[CONF_PACKAGES], context_vars)
-        # Disable the deprecated single-package fallback for remote
-        # packages.  _process_remote_package returns dicts with
-        # already-resolved values that is_package_definition cannot
-        # distinguish from config fragments, so the fallback would
-        # always fire and mask real errors with wrong paths
-        # (packages->0 instead of packages-><name>).
-        return _walk_packages(
-            package_config,
-            self.process_package,
-            context_vars,
-            validate_deprecated=not from_remote,
-        )
+        return _walk_packages(package_config, self.process_package, context_vars)
 
 
 def do_packages_pass(
@@ -526,12 +487,7 @@ def do_packages_pass(
     if CONF_PACKAGES not in config:
         return config
 
-    with cv.prepend_path(CONF_SUBSTITUTIONS):
-        substitutions = UserDict(
-            resolve_substitutions_block(
-                config.pop(CONF_SUBSTITUTIONS, {}), command_line_substitutions
-            )
-        )
+    substitutions = UserDict(config.pop(CONF_SUBSTITUTIONS, {}))
     processor = _PackageProcessor(
         substitutions, command_line_substitutions, skip_update
     )

esphome/components/pca6416a/pca6416a.cpp

@@ -62,10 +62,7 @@ void IRAM_ATTR PCA6416AComponent::gpio_intr(PCA6416AComponent *arg) { arg->enabl
 void PCA6416AComponent::loop() {
   // Invalidate cache at the start of each loop
   this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+  if (this->interrupt_pin_ != nullptr) {
     this->disable_loop();
   }
 }

esphome/components/pca9554/pca9554.cpp

@@ -50,10 +50,8 @@ void IRAM_ATTR PCA9554Component::gpio_intr(PCA9554Component *arg) { arg->enable_
 void PCA9554Component::loop() {
   // Invalidate the cache so the next digital_read() triggers a fresh I2C read
   this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+  if (this->interrupt_pin_ != nullptr) {
+    // Interrupt-driven: disable loop until next interrupt fires
     this->disable_loop();
   }
 }

esphome/components/pcf85063/pcf85063.cpp

@@ -44,7 +44,7 @@ void PCF85063Component::read_time() {
       .year = uint16_t(pcf85063_.reg.year + 10u * pcf85063_.reg.year_10 + 2000),
   };
   rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
     ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
     return;
   }

esphome/components/pcf8563/pcf8563.cpp

@@ -44,7 +44,7 @@ void PCF8563Component::read_time() {
       .year = uint16_t(pcf8563_.reg.year + 10u * pcf8563_.reg.year_10 + 2000),
   };
   rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
     ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
     return;
   }

esphome/components/pcf8574/pcf8574.cpp

@@ -31,10 +31,8 @@ void IRAM_ATTR PCF8574Component::gpio_intr(PCF8574Component *arg) { arg->enable_
 void PCF8574Component::loop() {
   // Invalidate the cache so the next digital_read() triggers a fresh I2C read
   this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+  if (this->interrupt_pin_ != nullptr) {
+    // Interrupt-driven: disable loop until next interrupt fires
     this->disable_loop();
   }
 }

esphome/components/pi4ioe5v6408/pi4ioe5v6408.cpp

@@ -82,10 +82,7 @@ void PI4IOE5V6408Component::pin_mode(uint8_t pin, gpio::Flags flags) {
 
 void PI4IOE5V6408Component::loop() {
   this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+  if (this->interrupt_pin_ != nullptr) {
     this->disable_loop();
   }
 }

esphome/components/qmc5883l/qmc5883l.cpp

@@ -100,7 +100,7 @@ void QMC5883LComponent::update() {
   // ROL_PNT in setup and reading 7 bytes starting at the status register.
   // If status and all three axes are desired, using ROL_PNT saves you 3 bytes.
   // But simply not reading status saves you 4 bytes always and is much simpler.
-  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
+  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG) {
     err = this->read_register(QMC5883L_REGISTER_STATUS, &status, 1);
     if (err != i2c::ERROR_OK) {
       char buf[32];
@@ -165,7 +165,7 @@ void QMC5883LComponent::update() {
     temp = int16_t(raw_temp) * 0.01f;
   }
 
-  ESP_LOGV(TAG, "Got x=%0.02fµT y=%0.02fµT z=%0.02fµT heading=%0.01f° temperature=%0.01f°C status=%u", x, y, z, heading,
+  ESP_LOGD(TAG, "Got x=%0.02fµT y=%0.02fµT z=%0.02fµT heading=%0.01f° temperature=%0.01f°C status=%u", x, y, z, heading,
            temp, status);
 
   if (this->x_sensor_ != nullptr)

esphome/components/rotary_encoder/sensor.py

@@ -129,6 +129,6 @@ async def to_code(config):
 async def sensor_template_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_VALUE], args, cg.int_)
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.int32)
     cg.add(var.set_value(template_))
     return var

esphome/components/rp2040/helpers.cpp

@@ -9,7 +9,7 @@
 #include <WiFi.h>
 #include <pico/cyw43_arch.h>  // For cyw43_arch_lwip_begin/end (LwIPLock)
 #elif defined(USE_ETHERNET)
-#include <lwip_wrap.h>  // For LWIPMutex — LwIPLock mirrors its semantics (see below)
+#include <LwipEthernet.h>  // For ethernet_arch_lwip_begin/end (LwIPLock)
 #include "esphome/components/ethernet/ethernet_component.h"
 #endif
 #include <hardware/structs/rosc.h>
@@ -43,18 +43,9 @@ IRAM_ATTR InterruptLock::~InterruptLock() { restore_interrupts(state_); }
 // main loop, corrupting the shared rx_buf_ pbuf chain (use-after-free, pbuf_cat
 // assertion failures). See esphome#10681.
 //
-// WiFi uses cyw43_arch_lwip_begin/end.
-//
-// For wired Ethernet, taking only the async_context lock is NOT enough. The
-// W5500 GPIO IRQ path (LwipIntfDev::_irq) checks arduino-pico's `__inLWIP`
-// counter to decide whether to defer packet processing. If we hold the
-// async_context lock without bumping `__inLWIP`, an interrupt-driven packet
-// arrival re-enters lwIP from IRQ context and corrupts pbufs (the `pbuf_cat`
-// assertion crash on wiznet-w5500-evb-pico). We mirror arduino-pico's
-// LWIPMutex (cores/rp2040/lwip_wrap.h) exactly: bump `__inLWIP`, take the
-// lock, and on release re-unmask any GPIO IRQs that were deferred while we
-// held it. We can't `using LwIPLock = LWIPMutex;` in helpers.h because
-// pulling lwip_wrap.h there poisons many TUs with lwIP types.
+// WiFi uses cyw43_arch_lwip_begin/end; Ethernet uses ethernet_arch_lwip_begin/end.
+// Both acquire the async_context recursive mutex to prevent IRQ callbacks from
+// firing during critical sections.
 //
 // When neither WiFi nor Ethernet is configured, this is a no-op since
 // there's no network stack and no lwip callbacks to race with.
@@ -62,18 +53,8 @@ IRAM_ATTR InterruptLock::~InterruptLock() { restore_interrupts(state_); }
 LwIPLock::LwIPLock() { cyw43_arch_lwip_begin(); }
 LwIPLock::~LwIPLock() { cyw43_arch_lwip_end(); }
 #elif defined(USE_ETHERNET)
-LwIPLock::LwIPLock() {
-  __inLWIP++;
-  ethernet_arch_lwip_begin();
-}
-LwIPLock::~LwIPLock() {
-  ethernet_arch_lwip_end();
-  __inLWIP--;
-  if (__needsIRQEN && !__inLWIP) {
-    __needsIRQEN = false;
-    ethernet_arch_lwip_gpio_unmask();
-  }
-}
+LwIPLock::LwIPLock() { ethernet_arch_lwip_begin(); }
+LwIPLock::~LwIPLock() { ethernet_arch_lwip_end(); }
 #else
 LwIPLock::LwIPLock() {}
 LwIPLock::~LwIPLock() {}

esphome/components/runtime_image/runtime_image.cpp

@@ -127,9 +127,9 @@ void RuntimeImage::draw_pixel(int x, int y, const Color &color) {
       uint32_t pos = this->get_position_(x, y);
       Color mapped_color = color;
       this->map_chroma_key(mapped_color);
-      this->buffer_[pos + 0] = mapped_color.b;
+      this->buffer_[pos + 0] = mapped_color.r;
       this->buffer_[pos + 1] = mapped_color.g;
-      this->buffer_[pos + 2] = mapped_color.r;
+      this->buffer_[pos + 2] = mapped_color.b;
       if (this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
         this->buffer_[pos + 3] = color.w;
       }

esphome/components/runtime_stats/runtime_stats.cpp

@@ -32,101 +32,40 @@ void RuntimeStatsCollector::log_stats_() {
            " Period stats (last %" PRIu32 "ms): %zu active components",
            this->log_interval_, count);
 
-  // Sum component time so we can derive main-loop overhead
-  // (active loop time minus time attributable to component loop()s).
-  // Period sum iterates the active-in-period subset; total sum must iterate
-  // all components since total_active_time_us_ includes iterations where
-  // currently-idle components previously ran.
-  uint64_t period_component_sum_us = 0;
+  if (count == 0) {
+    return;
+  }
+
+  // Sort by period runtime (descending)
+  std::sort(sorted, sorted + count, compare_period_time);
+
+  // Log top components by period runtime
   for (size_t i = 0; i < count; i++) {
-    period_component_sum_us += sorted[i]->runtime_stats_.period_time_us;
-  }
-  uint64_t total_component_sum_us = 0;
-  for (auto *component : components) {
-    total_component_sum_us += component->runtime_stats_.total_time_us;
-  }
-
-  if (count > 0) {
-    // Sort by period runtime (descending)
-    std::sort(sorted, sorted + count, compare_period_time);
-
-    // Log top components by period runtime
-    for (size_t i = 0; i < count; i++) {
-      const auto &stats = sorted[i]->runtime_stats_;
-      ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
-               LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.period_count,
-               stats.period_count > 0 ? stats.period_time_us / (float) stats.period_count / 1000.0f : 0.0f,
-               stats.period_max_time_us / 1000.0f, stats.period_time_us / 1000.0f);
-    }
-  }
-
-  // Main-loop overhead for the period: active wall time minus component time.
-  // active = sum of per-iteration loop time excluding yield/sleep.
-  if (this->period_active_count_ > 0) {
-    uint64_t active = this->period_active_time_us_;
-    uint64_t overhead = active > period_component_sum_us ? active - period_component_sum_us : 0;
-    // Use double for µs→ms conversion so multi-day uptimes (where total
-    // microsecond counters exceed float's ~7-digit mantissa) keep resolution.
-    ESP_LOGI(TAG,
-             "  main_loop: iters=%" PRIu64 ", active_avg=%.3fms, active_max=%.2fms, active_total=%.1fms, "
-             "overhead_total=%.1fms",
-             this->period_active_count_,
-             static_cast<double>(active) / static_cast<double>(this->period_active_count_) / 1000.0,
-             static_cast<double>(this->period_active_max_us_) / 1000.0, static_cast<double>(active) / 1000.0,
-             static_cast<double>(overhead) / 1000.0);
-    uint64_t before = this->period_before_time_us_;
-    uint64_t tail = this->period_tail_time_us_;
-    uint64_t accounted = before + tail;
-    uint64_t inter = overhead > accounted ? overhead - accounted : 0;
-    ESP_LOGI(TAG, "  main_loop_overhead_section: before=%.1fms, tail=%.1fms, inter_component=%.1fms",
-             static_cast<double>(before) / 1000.0, static_cast<double>(tail) / 1000.0,
-             static_cast<double>(inter) / 1000.0);
+    const auto &stats = sorted[i]->runtime_stats_;
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.period_count,
+             stats.period_count > 0 ? stats.period_time_us / (float) stats.period_count / 1000.0f : 0.0f,
+             stats.period_max_time_us / 1000.0f, stats.period_time_us / 1000.0f);
   }
 
   // Log total stats since boot (only for active components - idle ones haven't changed)
   ESP_LOGI(TAG, " Total stats (since boot): %zu active components", count);
 
-  if (count > 0) {
-    // Re-sort by total runtime for all-time stats
-    std::sort(sorted, sorted + count, compare_total_time);
+  // Re-sort by total runtime for all-time stats
+  std::sort(sorted, sorted + count, compare_total_time);
 
-    for (size_t i = 0; i < count; i++) {
-      const auto &stats = sorted[i]->runtime_stats_;
-      ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
-               LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.total_count,
-               stats.total_count > 0 ? stats.total_time_us / (float) stats.total_count / 1000.0f : 0.0f,
-               stats.total_max_time_us / 1000.0f, stats.total_time_us / 1000.0);
-    }
-  }
-
-  if (this->total_active_count_ > 0) {
-    uint64_t active = this->total_active_time_us_;
-    uint64_t overhead = active > total_component_sum_us ? active - total_component_sum_us : 0;
-    ESP_LOGI(TAG,
-             "  main_loop: iters=%" PRIu64 ", active_avg=%.3fms, active_max=%.2fms, active_total=%.1fms, "
-             "overhead_total=%.1fms",
-             this->total_active_count_,
-             static_cast<double>(active) / static_cast<double>(this->total_active_count_) / 1000.0,
-             static_cast<double>(this->total_active_max_us_) / 1000.0, static_cast<double>(active) / 1000.0,
-             static_cast<double>(overhead) / 1000.0);
-    uint64_t before = this->total_before_time_us_;
-    uint64_t tail = this->total_tail_time_us_;
-    uint64_t accounted = before + tail;
-    uint64_t inter = overhead > accounted ? overhead - accounted : 0;
-    ESP_LOGI(TAG, "  main_loop_overhead_section: before=%.1fms, tail=%.1fms, inter_component=%.1fms",
-             static_cast<double>(before) / 1000.0, static_cast<double>(tail) / 1000.0,
-             static_cast<double>(inter) / 1000.0);
+  for (size_t i = 0; i < count; i++) {
+    const auto &stats = sorted[i]->runtime_stats_;
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.total_count,
+             stats.total_count > 0 ? stats.total_time_us / (float) stats.total_count / 1000.0f : 0.0f,
+             stats.total_max_time_us / 1000.0f, stats.total_time_us / 1000.0);
   }
 
   // Reset period stats
   for (auto *component : components) {
     component->runtime_stats_.reset_period();
   }
-  this->period_active_count_ = 0;
-  this->period_active_time_us_ = 0;
-  this->period_active_max_us_ = 0;
-  this->period_before_time_us_ = 0;
-  this->period_tail_time_us_ = 0;
 }
 
 bool RuntimeStatsCollector::compare_period_time(Component *a, Component *b) {

esphome/components/runtime_stats/runtime_stats.h

@@ -29,31 +29,6 @@ class RuntimeStatsCollector {
   // Process any pending stats printing (should be called after component loop)
   void process_pending_stats(uint32_t current_time);
 
-  // Record the wall time of one main loop iteration excluding the yield/sleep.
-  // Called once per loop from Application::loop().
-  //   active_us = total time between loop start and just before yield.
-  //   before_us = time spent in before_loop_tasks_ (scheduler + ISR enable_loop).
-  //   tail_us   = time spent in after_loop_tasks_ + the trailing record/stats prefix.
-  // Residual overhead at log time = active − Σ(component) − before − tail,
-  // which captures per-iteration inter-component bookkeeping (set_current_component,
-  // WarnIfComponentBlockingGuard construction/destruction, feed_wdt_with_time calls,
-  // the for-loop itself).
-  void record_loop_active(uint32_t active_us, uint32_t before_us, uint32_t tail_us) {
-    this->period_active_count_++;
-    this->period_active_time_us_ += active_us;
-    if (active_us > this->period_active_max_us_)
-      this->period_active_max_us_ = active_us;
-    this->total_active_count_++;
-    this->total_active_time_us_ += active_us;
-    if (active_us > this->total_active_max_us_)
-      this->total_active_max_us_ = active_us;
-
-    this->period_before_time_us_ += before_us;
-    this->total_before_time_us_ += before_us;
-    this->period_tail_time_us_ += tail_us;
-    this->total_tail_time_us_ += tail_us;
-  }
-
  protected:
   void log_stats_();
   // Static comparators — member functions have friend access, lambdas do not
@@ -62,22 +37,6 @@ class RuntimeStatsCollector {
 
   uint32_t log_interval_;
   uint32_t next_log_time_{0};
-
-  // Main loop active-time stats (wall time per iteration, excluding yield/sleep).
-  // Counters are uint64_t — at sub-millisecond loop times a uint32_t can wrap in
-  // a few weeks of uptime, which is well within ESPHome device lifetimes.
-  uint64_t period_active_count_{0};
-  uint64_t period_active_time_us_{0};
-  uint32_t period_active_max_us_{0};
-  uint64_t total_active_count_{0};
-  uint64_t total_active_time_us_{0};
-  uint32_t total_active_max_us_{0};
-
-  // Split of overhead sections — accumulated per iteration.
-  uint64_t period_before_time_us_{0};
-  uint64_t total_before_time_us_{0};
-  uint64_t period_tail_time_us_{0};
-  uint64_t total_tail_time_us_{0};
 };
 
 }  // namespace runtime_stats

esphome/components/rx8130/rx8130.cpp

@@ -81,7 +81,7 @@ void RX8130Component::read_time() {
       .year = static_cast<uint16_t>(bcd2dec(date[6]) + 2000),
   };
   rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
     ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
     return;
   }

esphome/components/safe_mode/safe_mode.cpp

@@ -55,11 +55,13 @@ 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'", last_invalid->label);
-    ESP_LOGW(TAG, "The device reset before the boot was marked successful");
+    ESP_LOGW(TAG,
+             "OTA rollback detected! Rolled back from partition '%s'\n"
+             " The device reset before the boot was marked successful",
+             last_invalid->label);
     if (esp_reset_reason() == ESP_RST_BROWNOUT) {
-      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");
+      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");
     }
   }
 #endif
@@ -86,7 +88,8 @@ void SafeModeComponent::mark_successful() {
 }
 
 void SafeModeComponent::loop() {
-  if (!this->boot_successful_ && (millis() - this->safe_mode_start_time_) > this->safe_mode_boot_is_good_after_) {
+  if (!this->boot_successful_ &&
+      (App.get_loop_component_start_time() - 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/socket/bsd_sockets_impl.h

@@ -112,6 +112,8 @@ class BSDSocketImpl {
   int setblocking(bool blocking);
   int loop() { return 0; }
 
+  /// Check if the socket has buffered data ready to read.
+  /// See the ready() contract in socket.h — callers must drain or track remaining data.
   bool ready() const;
 
   int get_fd() const { return this->fd_; }

esphome/components/socket/lwip_raw_tcp_impl.h

@@ -96,6 +96,8 @@ class LWIPRawImpl : public LWIPRawCommon {
     errno = ENOSYS;
     return -1;
   }
+  // Check if the socket has buffered data ready to read.
+  // See the ready() contract in socket.h — callers must drain or track remaining data.
   // Intentionally unlocked — this is a polling check called every loop iteration.
   // A stale read at worst delays processing by one loop tick; the actual I/O in
   // read() holds the lwip lock and re-checks properly. See esphome#10681.

esphome/components/socket/lwip_sockets_impl.h

@@ -78,6 +78,8 @@ class LwIPSocketImpl {
   int setblocking(bool blocking);
   int loop() { return 0; }
 
+  /// Check if the socket has buffered data ready to read.
+  /// See the ready() contract in socket.h — callers must drain or track remaining data.
   bool ready() const;
 
   int get_fd() const { return this->fd_; }

esphome/components/socket/socket.h

@@ -53,6 +53,19 @@ bool socket_ready_fd(int fd, bool loop_monitored);
 
 // Inline ready() — defined here because it depends on socket_ready/socket_ready_fd
 // declared above, while the impl headers are included before those declarations.
+//
+// Contract (applies to ALL socket implementations — each platform implements
+// ready() differently, but this contract holds regardless of the mechanism):
+// ready() checks if the socket has buffered data ready to read. When it returns
+// true, the caller MUST read until it would block (EAGAIN/EWOULDBLOCK), or until
+// read() returns 0 to indicate EOF / connection closed, or track that it stopped
+// early and retry without calling ready(). The next call to ready() will only
+// report new data correctly if all callers fulfill this contract. Failing to
+// drain the socket may cause ready() to return false while data remains readable.
+//
+// In practice each socket is owned by a single component, so this contract is
+// straightforward to fulfill — but the owning component must be aware of it,
+// especially if it limits how many messages it processes per loop iteration.
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
 inline bool Socket::ready() const {
 #ifdef USE_LWIP_FAST_SELECT

esphome/components/st7789v/display.py

@@ -45,8 +45,8 @@ MODELS = {
         presets={
             CONF_HEIGHT: 240,
             CONF_WIDTH: 135,
-            CONF_OFFSET_HEIGHT: 40,
-            CONF_OFFSET_WIDTH: 52,
+            CONF_OFFSET_HEIGHT: 52,
+            CONF_OFFSET_WIDTH: 40,
             CONF_CS_PIN: "GPIO5",
             CONF_DC_PIN: "GPIO16",
             CONF_RESET_PIN: "GPIO23",
@@ -68,8 +68,8 @@ MODELS = {
         presets={
             CONF_HEIGHT: 280,
             CONF_WIDTH: 240,
-            CONF_OFFSET_HEIGHT: 20,
-            CONF_OFFSET_WIDTH: 0,
+            CONF_OFFSET_HEIGHT: 0,
+            CONF_OFFSET_WIDTH: 20,
         }
     ),
     "ADAFRUIT_S2_TFT_FEATHER_240X135": model_spec(
@@ -77,8 +77,8 @@ MODELS = {
         presets={
             CONF_HEIGHT: 240,
             CONF_WIDTH: 135,
-            CONF_OFFSET_HEIGHT: 40,
-            CONF_OFFSET_WIDTH: 52,
+            CONF_OFFSET_HEIGHT: 52,
+            CONF_OFFSET_WIDTH: 40,
             CONF_CS_PIN: "GPIO7",
             CONF_DC_PIN: "GPIO39",
             CONF_RESET_PIN: "GPIO40",
@@ -89,8 +89,8 @@ MODELS = {
         presets={
             CONF_HEIGHT: 320,
             CONF_WIDTH: 170,
-            CONF_OFFSET_HEIGHT: 0,
-            CONF_OFFSET_WIDTH: 35,
+            CONF_OFFSET_HEIGHT: 35,
+            CONF_OFFSET_WIDTH: 0,
             CONF_ROTATION: 270,
             CONF_CS_PIN: "GPIO10",
             CONF_DC_PIN: "GPIO13",
@@ -102,8 +102,8 @@ MODELS = {
         presets={
             CONF_HEIGHT: 320,
             CONF_WIDTH: 172,
-            CONF_OFFSET_HEIGHT: 0,
-            CONF_OFFSET_WIDTH: 34,
+            CONF_OFFSET_HEIGHT: 34,
+            CONF_OFFSET_WIDTH: 0,
             CONF_ROTATION: 90,
             CONF_CS_PIN: "GPIO21",
             CONF_DC_PIN: "GPIO22",

esphome/components/substitutions/__init__.py

@@ -30,56 +30,6 @@ ErrList = list[tuple[UndefinedError, SubstitutionPath, Any]]
 jinja = Jinja()
 
 
-def raise_first_undefined(
-    errors: ErrList,
-    source: Any,
-    context_label: str,
-) -> None:
-    """If *errors* is non-empty, raise ``cv.Invalid`` for the first undefined variable.
-
-    The raised error names the missing variable, the path walked into *source*
-    (for nested dicts, e.g. ``url`` or ``ref``), and the YAML source location
-    when *source* carries one. Only the first error is surfaced; the user will
-    re-run after fixing it and any remaining undefined variables will be
-    reported then.
-
-    ``context_label`` is the noun describing where the undefined variable
-    appeared (e.g. ``"package definition"``).
-    """
-    if not errors:
-        return
-    err, err_path, err_value = errors[0]
-    if len(errors) > 1:
-        # Log any further undefined variables so debug-level output covers
-        # the full set, even though only the first is surfaced to the user.
-        extras = ", ".join(
-            f"{e.message} at '{'->'.join(str(p) for p in p_path)}'"
-            for e, p_path, _ in errors[1:]
-        )
-        _LOGGER.debug("Additional undefined variables in %s: %s", context_label, extras)
-    # Prefer the location of the offending scalar (e.g. the `url:` value) over
-    # the enclosing package-definition dict so the message points at the exact
-    # line/column that carries the undefined variable.
-    location_node = (
-        err_value
-        if isinstance(err_value, ESPHomeDataBase) and err_value.esp_range is not None
-        else source
-    )
-    location = ""
-    if (
-        isinstance(location_node, ESPHomeDataBase)
-        and location_node.esp_range is not None
-    ):
-        mark = location_node.esp_range.start_mark
-        # DocumentLocation.line/column are 0-based (from the YAML Mark). Render
-        # as 1-based to match config.line_info() and editor line numbering.
-        location = f" (in {mark.document} {mark.line + 1}:{mark.column + 1})"
-    field = f" at '{'->'.join(str(p) for p in err_path)}'" if err_path else ""
-    raise cv.Invalid(
-        f"Undefined variable in {context_label}{field}: {err.message}{location}"
-    )
-
-
 def validate_substitution_key(value: Any) -> str:
     """Validate and normalize a substitution key, stripping a leading ``$`` if present."""
     value = cv.string(value)
@@ -297,18 +247,7 @@ def _push_context(
         """Resolve a variable, recursively resolving any dependencies it references."""
         value = unresolved_vars.pop(key, Missing)
         if value is Missing:
-            # Either already resolved (in resolved_vars) or currently being
-            # resolved (self-reference from inside a dict-valued substitution).
-            # Returning what we have lets sibling references inside a dict
-            # value, e.g. ``${device.manufacturer}`` inside ``device.name``,
-            # see literal sibling values during their own resolution.
-            return resolved_vars.get(key, Missing)
-        if isinstance(value, dict):
-            # Dict-valued substitutions form a namespace; eagerly publish the
-            # original mapping so its members can reference each other while
-            # the dict's own substitution pass is still running. The entry is
-            # replaced with the fully-substituted dict once recursion returns.
-            resolved_vars[key] = value
+            return Missing
         try:
             value = substitute(value, [], resolver_context, True)
         except UndefinedError as err:
@@ -475,34 +414,6 @@ def _warn_unresolved_variables(errors: ErrList) -> None:
         )
 
 
-def resolve_substitutions_block(
-    substitutions: Any,
-    command_line_substitutions: dict[str, Any] | None,
-) -> dict[str, Any]:
-    """Resolve a deferred ``substitutions: !include file.yaml`` and validate the shape.
-
-    The caller is responsible for wrapping the call in
-    ``cv.prepend_path(CONF_SUBSTITUTIONS)`` for error reporting.
-    ``command_line_substitutions`` seeds the filename context so
-    ``substitutions: !include ${var}.yaml`` can reference CLI-provided vars.
-    """
-    if isinstance(substitutions, IncludeFile):
-        # Single-shot resolution — matches ``_walk_packages`` for the
-        # ``packages: !include`` entry point.  Chained includes (an include that
-        # itself loads another ``!include`` at the top level) are not supported.
-        substitutions, _ = resolve_include(
-            substitutions,
-            [],
-            ContextVars(command_line_substitutions or {}),
-            strict_undefined=False,
-        )
-    if not isinstance(substitutions, dict):
-        raise cv.Invalid(
-            f"Substitutions must be a key to value mapping, got {type(substitutions)}"
-        )
-    return substitutions
-
-
 def do_substitution_pass(
     config: OrderedDict, command_line_substitutions: dict[str, Any] | None = None
 ) -> OrderedDict:
@@ -518,9 +429,10 @@ def do_substitution_pass(
     # Use merge_dicts_ordered to preserve OrderedDict type for move_to_end()
     substitutions = config.pop(CONF_SUBSTITUTIONS, {})
     with cv.prepend_path(CONF_SUBSTITUTIONS):
-        substitutions = resolve_substitutions_block(
-            substitutions, command_line_substitutions
-        )
+        if not isinstance(substitutions, dict):
+            raise cv.Invalid(
+                f"Substitutions must be a key to value mapping, got {type(substitutions)}"
+            )
         substitutions = merge_dicts_ordered(
             substitutions, command_line_substitutions or {}
         )

esphome/components/sx126x/__init__.py

@@ -200,11 +200,11 @@ CONFIG_SCHEMA = (
                 cv.hex_int, cv.Range(min=0, max=0xFFFF)
             ),
             cv.Optional(CONF_DEVIATION, default="5kHz"): cv.All(
-                cv.frequency, cv.int_range(min=0, max=100000)
+                cv.frequency, cv.float_range(min=0, max=100000)
             ),
             cv.Required(CONF_DIO1_PIN): pins.gpio_input_pin_schema,
             cv.Required(CONF_FREQUENCY): cv.All(
-                cv.frequency, cv.int_range(min=int(137e6), max=int(1020e6))
+                cv.frequency, cv.float_range(min=137.0e6, max=1020.0e6)
             ),
             cv.Required(CONF_HW_VERSION): cv.one_of(
                 "sx1261", "sx1262", "sx1268", "llcc68", lower=True

esphome/components/sx126x/sx126x.cpp

@@ -104,17 +104,11 @@ void SX126x::write_register_(uint16_t reg, uint8_t *data, uint8_t size) {
   delayMicroseconds(SWITCHING_DELAY_US);
 }
 
-void IRAM_ATTR SX126x::gpio_intr(SX126x *arg) { arg->enable_loop_soon_any_context(); }
-
 void SX126x::setup() {
   // setup pins
   this->busy_pin_->setup();
   this->rst_pin_->setup();
   this->dio1_pin_->setup();
-  if (this->dio1_pin_->is_internal()) {
-    static_cast<InternalGPIOPin *>(this->dio1_pin_)
-        ->attach_interrupt(&SX126x::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
-  }
 
   // start spi
   this->spi_setup();
@@ -354,9 +348,6 @@ void SX126x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
 }
 
 void SX126x::loop() {
-  if (this->dio1_pin_->is_internal()) {
-    this->disable_loop();
-  }
   if (!this->dio1_pin_->digital_read()) {
     return;
   }

esphome/components/sx126x/sx126x.h

@@ -3,7 +3,6 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
-#include "esphome/core/hal.h"
 #include "sx126x_reg.h"
 #include <utility>
 #include <vector>
@@ -101,7 +100,6 @@ class SX126x : public Component,
   Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:
-  static void IRAM_ATTR gpio_intr(SX126x *arg);
   void configure_fsk_ook_();
   void configure_lora_();
   void set_packet_params_(uint8_t payload_length);