[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>

.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

@@ -235,19 +235,20 @@ async function detectDeprecatedComponents(github, context, changedFiles) {
     }
   }
 
-  // Get PR head to fetch files from the PR branch
-  const prNumber = context.payload.pull_request.number;
+  // Get base branch ref to check if deprecation already exists for the component
+  // This prevents flagging a PR that simply adds deprecation
+  const baseRef = context.payload.pull_request.base.ref;
 
   // Check each component's __init__.py for DEPRECATED_COMPONENT constant
   for (const component of components) {
     const initFile = `esphome/components/${component}/__init__.py`;
     try {
-      // Fetch file content from PR head using GitHub API
+      // Fetch file content from base branch using GitHub API
       const { data: fileData } = await github.rest.repos.getContent({
         owner,
         repo,
         path: initFile,
-        ref: `refs/pull/${prNumber}/head`
+        ref: baseRef
       });
 
       // Decode base64 content
@@ -280,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();
@@ -328,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

@@ -339,7 +339,7 @@ jobs:
           echo "binary=$BINARY" >> $GITHUB_OUTPUT
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@d872884a306dd4853acf0f584f4b706cf0cc72a2 # v4
+        uses: CodSpeedHQ/action@db35df748deb45fdef0960669f57d627c1956c30 # v4
         with:
           run: ${{ steps.build.outputs.binary }}
           mode: simulation
@@ -723,7 +723,7 @@ jobs:
           cache-key: ${{ needs.common.outputs.cache-key }}
       - uses: esphome/pre-commit-action@43cd1109c09c544d97196f7730ee5b2e0cc6d81e # v3.0.1 fork with pinned actions/cache
         env:
-          SKIP: pylint,clang-tidy-hash
+          SKIP: pylint,clang-tidy-hash,ci-custom
       - uses: pre-commit-ci/lite-action@5d6cc0eb514c891a40562a58a8e71576c5c7fb43 # v1.1.0
         if: always()
 
@@ -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/pr-title-check.yml

@@ -3,6 +3,9 @@ name: PR Title Check
 on:
   pull_request:
     types: [opened, edited, synchronize, reopened]
+    branches-ignore:
+      - release
+      - beta
 
 permissions:
   contents: read

.github/workflows/release.yml

@@ -70,7 +70,7 @@ jobs:
           pip3 install build
           python3 -m build
       - name: Publish
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
         with:
           skip-existing: true
 
@@ -102,12 +102,12 @@ jobs:
         uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Log in to docker hub
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -182,13 +182,13 @@ jobs:
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
         if: matrix.registry == 'ghcr'
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}

.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.8
+    rev: v0.15.10
     hooks:
       # Run the linter.
       - id: ruff
@@ -65,3 +65,7 @@ repos:
         files: ^(\.clang-tidy|platformio\.ini|requirements_dev\.txt)$
         pass_filenames: false
         additional_dependencies: []
+      - id: ci-custom
+        name: ci-custom
+        entry: python3 script/run-in-env.py script/ci-custom.py
+        language: system

CODEOWNERS

@@ -142,12 +142,13 @@ esphome/components/dlms_meter/* @SimonFischer04
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its
-esphome/components/dsmr/* @glmnet @PolarGoose @zuidwijk
+esphome/components/dsmr/* @glmnet @PolarGoose
 esphome/components/duty_time/* @dudanov
 esphome/components/ee895/* @Stock-M
 esphome/components/ektf2232/touchscreen/* @jesserockz
 esphome/components/emc2101/* @ellull
 esphome/components/emmeti/* @E440QF
+esphome/components/emontx/* @FredM67 @glynhudson @TrystanLea
 esphome/components/ens160/* @latonita
 esphome/components/ens160_base/* @latonita @vincentscode
 esphome/components/ens160_i2c/* @latonita

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.0-dev
+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

esphome/__main__.py

@@ -1083,7 +1083,7 @@ def command_config(args: ArgsProtocol, config: ConfigType) -> int | None:
     # add the console decoration so the front-end can hide the secrets
     if not args.show_secrets:
         output = re.sub(
-            r"(password|key|psk|ssid)\: (.+)", r"\1: \\033[5m\2\\033[6m", output
+            r"(password|key|psk|ssid)\: (.+)", r"\1: \\033[8m\2\\033[28m", output
         )
     if not CORE.quiet:
         safe_print(output)
@@ -1242,6 +1242,38 @@ def command_clean(args: ArgsProtocol, config: ConfigType) -> int | None:
     return 0
 
 
+def command_bundle(args: ArgsProtocol, config: ConfigType) -> int | None:
+    from esphome.bundle import BUNDLE_EXTENSION, ConfigBundleCreator
+
+    creator = ConfigBundleCreator(config)
+
+    if args.list_only:
+        files = creator.discover_files()
+        for bf in sorted(files, key=lambda f: f.path):
+            safe_print(f"  {bf.path}")
+        _LOGGER.info("Found %d files", len(files))
+        return 0
+
+    result = creator.create_bundle()
+
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        stem = CORE.config_path.stem
+        output_path = CORE.config_dir / f"{stem}{BUNDLE_EXTENSION}"
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(result.data)
+
+    _LOGGER.info(
+        "Bundle created: %s (%d files, %.1f KB)",
+        output_path,
+        len(result.files),
+        len(result.data) / 1024,
+    )
+    return 0
+
+
 def command_dashboard(args: ArgsProtocol) -> int | None:
     from esphome.dashboard import dashboard
 
@@ -1517,6 +1549,7 @@ POST_CONFIG_ACTIONS = {
     "rename": command_rename,
     "discover": command_discover,
     "analyze-memory": command_analyze_memory,
+    "bundle": command_bundle,
 }
 
 SIMPLE_CONFIG_ACTIONS = [
@@ -1818,6 +1851,24 @@ def parse_args(argv):
         "configuration", help="Your YAML configuration file(s).", nargs="+"
     )
 
+    parser_bundle = subparsers.add_parser(
+        "bundle",
+        help="Create a self-contained config bundle for remote compilation.",
+    )
+    parser_bundle.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_bundle.add_argument(
+        "-o",
+        "--output",
+        help="Output path for the bundle archive.",
+    )
+    parser_bundle.add_argument(
+        "--list-only",
+        help="List discovered files without creating the archive.",
+        action="store_true",
+    )
+
     # Keep backward compatibility with the old command line format of
     # esphome <config> <command>.
     #
@@ -1896,6 +1947,16 @@ def run_esphome(argv):
         _LOGGER.warning("Skipping secrets file %s", conf_path)
         return 0
 
+    # Bundle support: if the configuration is a .esphomebundle, extract it
+    # and rewrite conf_path to the extracted YAML config.
+    from esphome.bundle import is_bundle_path, prepare_bundle_for_compile
+
+    if is_bundle_path(conf_path):
+        _LOGGER.info("Extracting config bundle %s...", conf_path)
+        conf_path = prepare_bundle_for_compile(conf_path)
+        # Update the argument so downstream code sees the extracted path
+        args.configuration[0] = str(conf_path)
+
     CORE.config_path = conf_path
     CORE.dashboard = args.dashboard
 

esphome/automation.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass, field
 import logging
 
 import esphome.codegen as cg
@@ -715,3 +716,35 @@ async def build_callback_automation(
     # MockObjs (not user input), and there's no Expression type for positional
     # aggregate initialization (StructInitializer uses named fields).
     cg.add(getattr(parent, callback_method)(cg.RawExpression(f"{forwarder}{{{obj}}}")))
+
+
+@dataclass(frozen=True, slots=True)
+class CallbackAutomation:
+    """A single callback automation entry for build_callback_automations."""
+
+    conf_key: str
+    callback_method: str
+    args: TemplateArgsType = field(default_factory=list)
+    forwarder: MockObj | MockObjClass | None = None
+
+
+async def build_callback_automations(
+    parent: MockObj,
+    config: ConfigType,
+    entries: tuple[CallbackAutomation, ...],
+) -> None:
+    """Build multiple callback automations from a tuple of entries.
+
+    :param parent: The component object (e.g., button, sensor).
+    :param config: The full component config dict.
+    :param entries: Tuple of CallbackAutomation entries to process.
+    """
+    for entry in entries:
+        for conf in config.get(entry.conf_key, []):
+            await build_callback_automation(
+                parent,
+                entry.callback_method,
+                entry.args,
+                conf,
+                forwarder=entry.forwarder,
+            )

esphome/bundle.py

@@ -0,0 +1,699 @@
+"""Config bundle creator and extractor for ESPHome.
+
+A bundle is a self-contained .tar.gz archive containing a YAML config
+and every local file it depends on. Bundles can be created from a config
+and compiled directly: ``esphome compile my_device.esphomebundle.tar.gz``
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+import io
+import json
+import logging
+from pathlib import Path
+import re
+import shutil
+import tarfile
+from typing import Any
+
+from esphome import const, yaml_util
+from esphome.const import (
+    CONF_ESPHOME,
+    CONF_EXTERNAL_COMPONENTS,
+    CONF_INCLUDES,
+    CONF_INCLUDES_C,
+    CONF_PATH,
+    CONF_SOURCE,
+    CONF_TYPE,
+)
+from esphome.core import CORE, EsphomeError
+
+_LOGGER = logging.getLogger(__name__)
+
+BUNDLE_EXTENSION = ".esphomebundle.tar.gz"
+MANIFEST_FILENAME = "manifest.json"
+CURRENT_MANIFEST_VERSION = 1
+MAX_DECOMPRESSED_SIZE = 500 * 1024 * 1024  # 500 MB
+MAX_MANIFEST_SIZE = 1024 * 1024  # 1 MB
+
+# Directories preserved across bundle extractions (build caches)
+_PRESERVE_DIRS = (".esphome", ".pioenvs", ".pio")
+_BUNDLE_STAGING_DIR = ".bundle_staging"
+
+
+class ManifestKey(StrEnum):
+    """Keys used in bundle manifest.json."""
+
+    MANIFEST_VERSION = "manifest_version"
+    ESPHOME_VERSION = "esphome_version"
+    CONFIG_FILENAME = "config_filename"
+    FILES = "files"
+    HAS_SECRETS = "has_secrets"
+
+
+# String prefixes that are never local file paths
+_NON_PATH_PREFIXES = ("http://", "https://", "ftp://", "mdi:", "<")
+
+# File extensions recognized when resolving relative path strings.
+# A relative string with one of these extensions is resolved against the
+# config directory and included if the file exists.
+_KNOWN_FILE_EXTENSIONS = frozenset(
+    {
+        # Fonts
+        ".ttf",
+        ".otf",
+        ".woff",
+        ".woff2",
+        ".pcf",
+        ".bdf",
+        # Images
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".bmp",
+        ".gif",
+        ".svg",
+        ".ico",
+        ".webp",
+        # Certificates
+        ".pem",
+        ".crt",
+        ".key",
+        ".der",
+        ".p12",
+        ".pfx",
+        # C/C++ includes
+        ".h",
+        ".hpp",
+        ".c",
+        ".cpp",
+        ".ino",
+        # Web assets
+        ".css",
+        ".js",
+        ".html",
+    }
+)
+
+
+# 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]:
+    """Scan YAML files for ``!secret <key>`` references."""
+    keys: set[str] = set()
+    for fpath in yaml_files:
+        try:
+            text = fpath.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        for match in _SECRET_RE.finditer(text):
+            keys.add(match.group(1))
+    return keys
+
+
+@dataclass
+class BundleFile:
+    """A file to include in the bundle."""
+
+    path: str  # Relative path inside the archive
+    source: Path  # Absolute path on disk
+
+
+@dataclass
+class BundleResult:
+    """Result of creating a bundle."""
+
+    data: bytes
+    manifest: dict[str, Any]
+    files: list[BundleFile]
+
+
+@dataclass
+class BundleManifest:
+    """Parsed and validated bundle manifest."""
+
+    manifest_version: int
+    esphome_version: str
+    config_filename: str
+    files: list[str]
+    has_secrets: bool
+
+
+class ConfigBundleCreator:
+    """Creates a self-contained bundle from an ESPHome config."""
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        self._config = config
+        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()
+
+    def discover_files(self) -> list[BundleFile]:
+        """Discover all files needed for the bundle."""
+        self._files = []
+        self._seen_paths = set()
+        self._secrets_paths = set()
+
+        # The main config file
+        self._add_file(self._config_path)
+
+        # Phase 1: YAML includes (tracked during config loading)
+        self._discover_yaml_includes()
+
+        # Phase 2: Component-referenced files from validated config
+        self._discover_component_files()
+
+        return list(self._files)
+
+    def create_bundle(self) -> BundleResult:
+        """Create the bundle archive."""
+        files = self.discover_files()
+
+        # Determine which secret keys are actually referenced by the
+        # bundled YAML files so we only ship those, not the entire
+        # secrets.yaml which may contain secrets for other devices.
+        yaml_sources = [
+            bf.source for bf in files if bf.source.suffix in (".yaml", ".yml")
+        ]
+        used_secret_keys = _find_used_secret_keys(yaml_sources)
+        filtered_secrets = self._build_filtered_secrets(used_secret_keys)
+
+        has_secrets = bool(filtered_secrets)
+        if has_secrets:
+            _LOGGER.warning(
+                "Bundle contains secrets (e.g. Wi-Fi passwords). "
+                "Do not share it with untrusted parties."
+            )
+
+        manifest = self._build_manifest(files, has_secrets=has_secrets)
+
+        buf = io.BytesIO()
+        with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+            # Add manifest first
+            manifest_data = json.dumps(manifest, indent=2).encode("utf-8")
+            _add_bytes_to_tar(tar, MANIFEST_FILENAME, manifest_data)
+
+            # Add filtered secrets files
+            for rel_path, data in sorted(filtered_secrets.items()):
+                _add_bytes_to_tar(tar, rel_path, data)
+
+            # Add files in sorted order for determinism, skipping secrets
+            # files which were already added above with filtered content
+            for bf in sorted(files, key=lambda f: f.path):
+                if bf.source in self._secrets_paths:
+                    continue
+                self._add_to_tar(tar, bf)
+
+        return BundleResult(data=buf.getvalue(), manifest=manifest, files=files)
+
+    def _add_file(self, abs_path: Path) -> bool:
+        """Add a file to the bundle. Returns False if already added."""
+        abs_path = abs_path.resolve()
+        if abs_path in self._seen_paths:
+            return False
+        if not abs_path.is_file():
+            _LOGGER.warning("Bundle: skipping missing file %s", abs_path)
+            return False
+
+        rel_path = self._relative_to_config_dir(abs_path)
+        if rel_path is None:
+            _LOGGER.warning(
+                "Bundle: skipping file outside config directory: %s", abs_path
+            )
+            return False
+
+        self._seen_paths.add(abs_path)
+        self._files.append(BundleFile(path=rel_path, source=abs_path))
+        return True
+
+    def _add_directory(self, abs_path: Path) -> None:
+        """Recursively add all files in a directory."""
+        abs_path = abs_path.resolve()
+        if not abs_path.is_dir():
+            _LOGGER.warning("Bundle: skipping missing directory %s", abs_path)
+            return
+        for child in sorted(abs_path.rglob("*")):
+            if child.is_file() and "__pycache__" not in child.parts:
+                self._add_file(child)
+
+    def _relative_to_config_dir(self, abs_path: Path) -> str | None:
+        """Get a path relative to the config directory. Returns None if outside.
+
+        Always uses forward slashes for consistency in tar archives.
+        """
+        try:
+            return abs_path.relative_to(self._config_dir).as_posix()
+        except ValueError:
+            return None
+
+    def _discover_yaml_includes(self) -> None:
+        """Discover YAML files loaded during config parsing.
+
+        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.
+        """
+        with yaml_util.track_yaml_loads() as loaded_files:
+            try:
+                yaml_util.load_yaml(self._config_path)
+            except EsphomeError:
+                _LOGGER.debug(
+                    "Bundle: re-loading YAML for include discovery failed, "
+                    "proceeding with partial file list"
+                )
+
+        for fpath in loaded_files:
+            if fpath == self._config_path.resolve():
+                continue  # Already added as config
+            if fpath.name in const.SECRETS_FILES:
+                self._secrets_paths.add(fpath)
+            self._add_file(fpath)
+
+    def _discover_component_files(self) -> None:
+        """Walk the validated config for file references.
+
+        Uses a generic recursive walk to find file paths instead of
+        hardcoding per-component knowledge about config dict formats.
+        After validation, components typically resolve paths to absolute
+        using CORE.relative_config_path() or cv.file_(). Relative paths
+        with known file extensions are also resolved and checked.
+
+        Core ESPHome concepts that use relative paths or directories
+        are handled explicitly.
+        """
+        config = self._config
+
+        # Generic walk: find all file paths in the validated config
+        self._walk_config_for_files(config)
+
+        # --- Core ESPHome concepts needing explicit handling ---
+
+        # esphome.includes / includes_c - can be relative paths and directories
+        esphome_conf = config.get(CONF_ESPHOME, {})
+        for include_path in esphome_conf.get(CONF_INCLUDES, []):
+            resolved = _resolve_include_path(include_path)
+            if resolved is None:
+                continue
+            if resolved.is_dir():
+                self._add_directory(resolved)
+            else:
+                self._add_file(resolved)
+        for include_path in esphome_conf.get(CONF_INCLUDES_C, []):
+            resolved = _resolve_include_path(include_path)
+            if resolved is not None:
+                self._add_file(resolved)
+
+        # external_components with source: local - directories
+        for ext_conf in config.get(CONF_EXTERNAL_COMPONENTS, []):
+            source = ext_conf.get(CONF_SOURCE, {})
+            if not isinstance(source, dict):
+                continue
+            if source.get(CONF_TYPE) != "local":
+                continue
+            path = source.get(CONF_PATH)
+            if not path:
+                continue
+            p = Path(path)
+            if not p.is_absolute():
+                p = CORE.relative_config_path(p)
+            self._add_directory(p)
+
+    def _walk_config_for_files(self, obj: Any) -> None:
+        """Recursively walk the config dict looking for file path references."""
+        if isinstance(obj, dict):
+            for value in obj.values():
+                self._walk_config_for_files(value)
+        elif isinstance(obj, (list, tuple)):
+            for item in obj:
+                self._walk_config_for_files(item)
+        elif isinstance(obj, Path):
+            if obj.is_absolute() and obj.is_file():
+                self._add_file(obj)
+        elif isinstance(obj, str):
+            self._check_string_path(obj)
+
+    def _check_string_path(self, value: str) -> None:
+        """Check if a string value is a local file reference."""
+        # Fast exits for strings that cannot be file paths
+        if len(value) < 2 or "\n" in value:
+            return
+        if value.startswith(_NON_PATH_PREFIXES):
+            return
+        # File paths must contain a path separator or a dot (for extension)
+        if "/" not in value and "\\" not in value and "." not in value:
+            return
+
+        p = Path(value)
+
+        # Absolute path - check if it points to an existing file
+        if p.is_absolute():
+            if p.is_file():
+                self._add_file(p)
+            return
+
+        # Relative path with a known file extension - likely a component
+        # validator that forgot to resolve to absolute via cv.file_() or
+        # CORE.relative_config_path(). Warn and try to resolve.
+        if p.suffix.lower() in _KNOWN_FILE_EXTENSIONS:
+            _LOGGER.warning(
+                "Bundle: non-absolute path in validated config: %s "
+                "(component validator should return absolute paths)",
+                value,
+            )
+            resolved = CORE.relative_config_path(p)
+            if resolved.is_file():
+                self._add_file(resolved)
+
+    def _build_filtered_secrets(self, used_keys: set[str]) -> dict[str, bytes]:
+        """Build filtered secrets files containing only the referenced keys.
+
+        Returns a dict mapping relative archive path to YAML bytes.
+        """
+        if not used_keys or not self._secrets_paths:
+            return {}
+
+        result: dict[str, bytes] = {}
+        for secrets_path in self._secrets_paths:
+            rel_path = self._relative_to_config_dir(secrets_path)
+            if rel_path is None:
+                continue
+            try:
+                all_secrets = yaml_util.load_yaml(secrets_path, clear_secrets=False)
+            except EsphomeError:
+                _LOGGER.warning("Bundle: failed to load secrets file %s", secrets_path)
+                continue
+            if not isinstance(all_secrets, dict):
+                continue
+            filtered = {k: v for k, v in all_secrets.items() if k in used_keys}
+            if filtered:
+                data = yaml_util.dump(filtered, show_secrets=True).encode("utf-8")
+                result[rel_path] = data
+        return result
+
+    def _build_manifest(
+        self, files: list[BundleFile], *, has_secrets: bool
+    ) -> dict[str, Any]:
+        """Build the manifest.json content."""
+        return {
+            ManifestKey.MANIFEST_VERSION: CURRENT_MANIFEST_VERSION,
+            ManifestKey.ESPHOME_VERSION: const.__version__,
+            ManifestKey.CONFIG_FILENAME: self._config_path.name,
+            ManifestKey.FILES: [f.path for f in files],
+            ManifestKey.HAS_SECRETS: has_secrets,
+        }
+
+    @staticmethod
+    def _add_to_tar(tar: tarfile.TarFile, bf: BundleFile) -> None:
+        """Add a BundleFile to the tar archive with deterministic metadata."""
+        with open(bf.source, "rb") as f:
+            _add_bytes_to_tar(tar, bf.path, f.read())
+
+
+def extract_bundle(
+    bundle_path: Path,
+    target_dir: Path | None = None,
+) -> Path:
+    """Extract a bundle archive and return the path to the config YAML.
+
+    Sanity checks reject path traversal, symlinks, absolute paths, and
+    oversized archives to prevent accidental file overwrites or extraction
+    outside the target directory.  These are **not** a security boundary —
+    bundles are assumed to come from the user's own machine or a trusted
+    build pipeline.
+
+    Args:
+        bundle_path: Path to the .tar.gz bundle file.
+        target_dir: Directory to extract into. If None, extracts next to
+                     the bundle file in a directory named after it.
+
+    Returns:
+        Absolute path to the extracted config YAML file.
+
+    Raises:
+        EsphomeError: If the bundle is invalid or extraction fails.
+    """
+
+    bundle_path = bundle_path.resolve()
+    if not bundle_path.is_file():
+        raise EsphomeError(f"Bundle file not found: {bundle_path}")
+
+    if target_dir is None:
+        target_dir = _default_target_dir(bundle_path)
+
+    target_dir = target_dir.resolve()
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # Read and validate the archive
+    try:
+        with tarfile.open(bundle_path, "r:gz") as tar:
+            manifest = _read_manifest_from_tar(tar)
+            _validate_tar_members(tar, target_dir)
+            tar.extractall(path=target_dir, filter="data")
+    except tarfile.TarError as err:
+        raise EsphomeError(f"Failed to extract bundle: {err}") from err
+
+    config_filename = manifest[ManifestKey.CONFIG_FILENAME]
+    config_path = target_dir / config_filename
+    if not config_path.is_file():
+        raise EsphomeError(
+            f"Bundle manifest references config '{config_filename}' "
+            f"but it was not found in the archive"
+        )
+
+    return config_path
+
+
+def read_bundle_manifest(bundle_path: Path) -> BundleManifest:
+    """Read and validate the manifest from a bundle without full extraction.
+
+    Args:
+        bundle_path: Path to the .tar.gz bundle file.
+
+    Returns:
+        Parsed BundleManifest.
+
+    Raises:
+        EsphomeError: If the manifest is missing, invalid, or version unsupported.
+    """
+
+    try:
+        with tarfile.open(bundle_path, "r:gz") as tar:
+            manifest = _read_manifest_from_tar(tar)
+    except tarfile.TarError as err:
+        raise EsphomeError(f"Failed to read bundle: {err}") from err
+
+    return BundleManifest(
+        manifest_version=manifest[ManifestKey.MANIFEST_VERSION],
+        esphome_version=manifest.get(ManifestKey.ESPHOME_VERSION, "unknown"),
+        config_filename=manifest[ManifestKey.CONFIG_FILENAME],
+        files=manifest.get(ManifestKey.FILES, []),
+        has_secrets=manifest.get(ManifestKey.HAS_SECRETS, False),
+    )
+
+
+def _read_manifest_from_tar(tar: tarfile.TarFile) -> dict[str, Any]:
+    """Read and validate manifest.json from an open tar archive."""
+
+    try:
+        member = tar.getmember(MANIFEST_FILENAME)
+    except KeyError:
+        raise EsphomeError("Invalid bundle: missing manifest.json") from None
+
+    f = tar.extractfile(member)
+    if f is None:
+        raise EsphomeError("Invalid bundle: manifest.json is not a regular file")
+
+    if member.size > MAX_MANIFEST_SIZE:
+        raise EsphomeError(
+            f"Invalid bundle: manifest.json too large "
+            f"({member.size} bytes, max {MAX_MANIFEST_SIZE})"
+        )
+
+    try:
+        manifest = json.loads(f.read())
+    except (json.JSONDecodeError, UnicodeDecodeError) as err:
+        raise EsphomeError(f"Invalid bundle: malformed manifest.json: {err}") from err
+
+    # Version check
+    version = manifest.get(ManifestKey.MANIFEST_VERSION)
+    if version is None:
+        raise EsphomeError("Invalid bundle: manifest.json missing 'manifest_version'")
+    if not isinstance(version, int) or version < 1:
+        raise EsphomeError(
+            f"Invalid bundle: manifest_version must be a positive integer, got {version!r}"
+        )
+    if version > CURRENT_MANIFEST_VERSION:
+        raise EsphomeError(
+            f"Bundle manifest version {version} is newer than this ESPHome "
+            f"version supports (max {CURRENT_MANIFEST_VERSION}). "
+            f"Please upgrade ESPHome to compile this bundle."
+        )
+
+    # Required fields
+    if ManifestKey.CONFIG_FILENAME not in manifest:
+        raise EsphomeError("Invalid bundle: manifest.json missing 'config_filename'")
+
+    return manifest
+
+
+def _validate_tar_members(tar: tarfile.TarFile, target_dir: Path) -> None:
+    """Sanity-check tar members to prevent mistakes and accidental overwrites.
+
+    This is not a security boundary — bundles are created locally or come
+    from a trusted build pipeline.  The checks catch malformed archives
+    and common mistakes (stray absolute paths, ``..`` components) that
+    could silently overwrite unrelated files.
+    """
+
+    total_size = 0
+    for member in tar.getmembers():
+        # Reject absolute paths (Unix and Windows)
+        if member.name.startswith(("/", "\\")):
+            raise EsphomeError(
+                f"Invalid bundle: absolute path in archive: {member.name}"
+            )
+
+        # Reject path traversal (split on both / and \ for cross-platform)
+        parts = re.split(r"[/\\]", member.name)
+        if ".." in parts:
+            raise EsphomeError(
+                f"Invalid bundle: path traversal in archive: {member.name}"
+            )
+
+        # Reject symlinks
+        if member.issym() or member.islnk():
+            raise EsphomeError(f"Invalid bundle: symlink in archive: {member.name}")
+
+        # Ensure extraction stays within target_dir
+        target_path = (target_dir / member.name).resolve()
+        if not target_path.is_relative_to(target_dir):
+            raise EsphomeError(
+                f"Invalid bundle: file would extract outside target: {member.name}"
+            )
+
+        # Track total decompressed size
+        total_size += member.size
+        if total_size > MAX_DECOMPRESSED_SIZE:
+            raise EsphomeError(
+                f"Invalid bundle: decompressed size exceeds "
+                f"{MAX_DECOMPRESSED_SIZE // (1024 * 1024)}MB limit"
+            )
+
+
+def is_bundle_path(path: Path) -> bool:
+    """Check if a path looks like a bundle file."""
+    return path.name.lower().endswith(BUNDLE_EXTENSION)
+
+
+def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
+    """Add in-memory bytes to a tar archive with deterministic metadata."""
+    info = tarfile.TarInfo(name=name)
+    info.size = len(data)
+    info.mtime = 0
+    info.uid = 0
+    info.gid = 0
+    info.mode = 0o644
+    tar.addfile(info, io.BytesIO(data))
+
+
+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("<"):
+        return None  # System include, not a local file
+    p = Path(include_path)
+    if not p.is_absolute():
+        p = CORE.relative_config_path(p)
+    return p
+
+
+def _default_target_dir(bundle_path: Path) -> Path:
+    """Compute the default extraction directory for a bundle."""
+    name = bundle_path.name
+    if name.lower().endswith(BUNDLE_EXTENSION):
+        name = name[: -len(BUNDLE_EXTENSION)]
+    return bundle_path.parent / name
+
+
+def _restore_preserved_dirs(preserved: dict[str, Path], target_dir: Path) -> None:
+    """Move preserved build cache directories back into target_dir.
+
+    If the bundle contained entries under a preserved directory name,
+    the extracted copy is removed so the original cache always wins.
+    """
+    for dirname, src in preserved.items():
+        dst = target_dir / dirname
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.move(str(src), str(dst))
+
+
+def prepare_bundle_for_compile(
+    bundle_path: Path,
+    target_dir: Path | None = None,
+) -> Path:
+    """Extract a bundle for compilation, preserving build caches.
+
+    Unlike extract_bundle(), this preserves .esphome/ and .pioenvs/
+    directories in the target if they already exist (for incremental builds).
+
+    Args:
+        bundle_path: Path to the .tar.gz bundle file.
+        target_dir: Directory to extract into. Must be specified for
+                     build server use.
+
+    Returns:
+        Absolute path to the extracted config YAML file.
+    """
+
+    bundle_path = bundle_path.resolve()
+    if not bundle_path.is_file():
+        raise EsphomeError(f"Bundle file not found: {bundle_path}")
+
+    if target_dir is None:
+        target_dir = _default_target_dir(bundle_path)
+
+    target_dir = target_dir.resolve()
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    preserved: dict[str, Path] = {}
+
+    # Temporarily move preserved dirs out of the way
+    staging = target_dir / _BUNDLE_STAGING_DIR
+    for dirname in _PRESERVE_DIRS:
+        src = target_dir / dirname
+        if src.is_dir():
+            dst = staging / dirname
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(src), str(dst))
+            preserved[dirname] = dst
+
+    try:
+        # Clean non-preserved content and extract fresh
+        for item in target_dir.iterdir():
+            if item.name == _BUNDLE_STAGING_DIR:
+                continue
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+
+        config_path = extract_bundle(bundle_path, target_dir)
+    finally:
+        # Restore preserved dirs (idempotent) and clean staging
+        _restore_preserved_dirs(preserved, target_dir)
+        if staging.is_dir():
+            shutil.rmtree(staging)
+
+    return config_path

esphome/codegen.py

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

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/ads1118/__init__.py

@@ -12,11 +12,15 @@ CONF_ADS1118_ID = "ads1118_id"
 ads1118_ns = cg.esphome_ns.namespace("ads1118")
 ADS1118 = ads1118_ns.class_("ADS1118", cg.Component, spi.SPIDevice)
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(ADS1118),
-    }
-).extend(spi.spi_device_schema(cs_pin_required=True))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1118),
+        }
+    )
+    .extend(spi.spi_device_schema(cs_pin_required=True))
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):

esphome/components/ags10/sensor.py

@@ -35,7 +35,7 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(AGS10Component),
-            cv.Optional(CONF_TVOC): sensor.sensor_schema(
+            cv.Required(CONF_TVOC): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PARTS_PER_BILLION,
                 icon=ICON_RADIATOR,
                 accuracy_decimals=0,
@@ -97,7 +97,7 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
 async def ags10newi2caddress_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    address = await cg.templatable(config[CONF_ADDRESS], args, int)
+    address = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
     cg.add(var.set_new_address(address))
     return var
 
@@ -112,7 +112,9 @@ AGS10_SET_ZERO_POINT_ACTION_MODE = {
 AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.use_id(AGS10Component),
-        cv.Required(CONF_MODE): cv.enum(AGS10_SET_ZERO_POINT_ACTION_MODE, upper=True),
+        cv.Required(CONF_MODE): cv.templatable(
+            cv.enum(AGS10_SET_ZERO_POINT_ACTION_MODE, upper=True)
+        ),
         cv.Optional(CONF_VALUE, default=0xFFFF): cv.templatable(cv.uint16_t),
     },
 )
@@ -127,8 +129,10 @@ AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
 async def ags10setzeropoint_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    mode = await cg.templatable(config.get(CONF_MODE), args, enumerate)
+    mode = await cg.templatable(
+        config.get(CONF_MODE), args, AGS10SetZeroPointActionMode
+    )
     cg.add(var.set_mode(mode))
-    value = await cg.templatable(config[CONF_VALUE], args, int)
+    value = await cg.templatable(config[CONF_VALUE], args, cg.uint16)
     cg.add(var.set_value(value))
     return var

esphome/components/aic3204/audio_dac.py

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

esphome/components/alarm_control_panel/__init__.py

@@ -111,42 +111,66 @@ ALARM_CONTROL_PANEL_CONDITION_SCHEMA = maybe_simple_id(
 )
 
 
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_STATE, "add_on_state_callback", forwarder=StateAnyForwarder
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_TRIGGERED,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_TRIGGERED
+        ),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_ARMING,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(AlarmControlPanelState.ACP_STATE_ARMING),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_PENDING,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_PENDING
+        ),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_ARMED_HOME,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_ARMED_HOME
+        ),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_ARMED_NIGHT,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_ARMED_NIGHT
+        ),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_ARMED_AWAY,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_ARMED_AWAY
+        ),
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_DISARMED,
+        "add_on_state_callback",
+        forwarder=StateEnterForwarder.template(
+            AlarmControlPanelState.ACP_STATE_DISARMED
+        ),
+    ),
+    automation.CallbackAutomation(CONF_ON_CLEARED, "add_on_cleared_callback"),
+    automation.CallbackAutomation(CONF_ON_CHIME, "add_on_chime_callback"),
+    automation.CallbackAutomation(CONF_ON_READY, "add_on_ready_callback"),
+)
+
+
 @setup_entity("alarm_control_panel")
 async def setup_alarm_control_panel_core_(var, config):
-    for conf in config.get(CONF_ON_STATE, []):
-        await automation.build_callback_automation(
-            var, "add_on_state_callback", [], conf, forwarder=StateAnyForwarder
-        )
-    _STATE_ENTER_MAP = {
-        CONF_ON_TRIGGERED: AlarmControlPanelState.ACP_STATE_TRIGGERED,
-        CONF_ON_ARMING: AlarmControlPanelState.ACP_STATE_ARMING,
-        CONF_ON_PENDING: AlarmControlPanelState.ACP_STATE_PENDING,
-        CONF_ON_ARMED_HOME: AlarmControlPanelState.ACP_STATE_ARMED_HOME,
-        CONF_ON_ARMED_NIGHT: AlarmControlPanelState.ACP_STATE_ARMED_NIGHT,
-        CONF_ON_ARMED_AWAY: AlarmControlPanelState.ACP_STATE_ARMED_AWAY,
-        CONF_ON_DISARMED: AlarmControlPanelState.ACP_STATE_DISARMED,
-    }
-    for conf_key, state_enum in _STATE_ENTER_MAP.items():
-        for conf in config.get(conf_key, []):
-            await automation.build_callback_automation(
-                var,
-                "add_on_state_callback",
-                [],
-                conf,
-                forwarder=StateEnterForwarder.template(state_enum),
-            )
-    for conf in config.get(CONF_ON_CLEARED, []):
-        await automation.build_callback_automation(
-            var, "add_on_cleared_callback", [], conf
-        )
-    for conf in config.get(CONF_ON_CHIME, []):
-        await automation.build_callback_automation(
-            var, "add_on_chime_callback", [], conf
-        )
-    for conf in config.get(CONF_ON_READY, []):
-        await automation.build_callback_automation(
-            var, "add_on_ready_callback", [], conf
-        )
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
     if web_server_config := config.get(CONF_WEB_SERVER):
         await web_server.add_entity_config(var, web_server_config)
     if mqtt_id := config.get(CONF_MQTT_ID):

esphome/components/alpha3/sensor.py

@@ -9,6 +9,10 @@ from esphome.const import (
     CONF_POWER,
     CONF_SPEED,
     CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
     UNIT_AMPERE,
     UNIT_CUBIC_METER_PER_HOUR,
     UNIT_METER,
@@ -27,26 +31,35 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_FLOW): sensor.sensor_schema(
                 unit_of_measurement=UNIT_CUBIC_METER_PER_HOUR,
                 accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_HEAD): sensor.sensor_schema(
                 unit_of_measurement=UNIT_METER,
                 accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_POWER): sensor.sensor_schema(
                 unit_of_measurement=UNIT_WATT,
                 accuracy_decimals=2,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_CURRENT): sensor.sensor_schema(
                 unit_of_measurement=UNIT_AMPERE,
                 accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_SPEED): sensor.sensor_schema(
                 unit_of_measurement=UNIT_REVOLUTIONS_PER_MINUTE,
                 accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_VOLT,
                 accuracy_decimals=2,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
         }
     )

esphome/components/am43/sensor/__init__.py

@@ -8,6 +8,7 @@ from esphome.const import (
     DEVICE_CLASS_BATTERY,
     ENTITY_CATEGORY_DIAGNOSTIC,
     ICON_BRIGHTNESS_5,
+    STATE_CLASS_MEASUREMENT,
     UNIT_PERCENT,
 )
 
@@ -26,11 +27,13 @@ CONFIG_SCHEMA = (
                 device_class=DEVICE_CLASS_BATTERY,
                 accuracy_decimals=0,
                 entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PERCENT,
                 icon=ICON_BRIGHTNESS_5,
                 accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
         }
     )

esphome/components/analog_threshold/analog_threshold_binary_sensor.h

@@ -19,8 +19,8 @@ class AnalogThresholdBinarySensor : public Component, public binary_sensor::Bina
 
  protected:
   sensor::Sensor *sensor_{nullptr};
-  TemplatableValue<float> upper_threshold_{};
-  TemplatableValue<float> lower_threshold_{};
+  TemplatableFn<float> upper_threshold_{};
+  TemplatableFn<float> lower_threshold_{};
   bool raw_state_{false};  // Pre-filter state for hysteresis logic
 };
 

esphome/components/analog_threshold/binary_sensor.py

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

esphome/components/api/api.proto

@@ -129,11 +129,12 @@ message HelloResponse {
 
   // A string identifying the server (ESP); like client info this may be empty
   // and only exists for debugging/logging purposes.
-  // For example "ESPHome v1.10.0 on ESP8266"
-  string server_info = 3;
+  // Currently set to ESPHOME_VERSION string literal.
+  string server_info = 3 [(max_data_length) = 32, (force) = true];
 
-  // The name of the server (App.get_name())
-  string name = 4;
+  // The name of the server (App.get_name() - device hostname)
+  // max_data_length matches ESPHOME_DEVICE_NAME_MAX_LEN (validated by validate_hostname)
+  string name = 4 [(max_data_length) = 31, (force) = true];
 }
 
 // DEPRECATED in ESPHome 2026.1.0 - Password authentication is no longer supported.
@@ -196,12 +197,14 @@ message DeviceInfoRequest {
 
 message AreaInfo {
   uint32 area_id = 1;
-  string name = 2;
+  // max_data_length matches core/config.FRIENDLY_NAME_MAX_LEN via AREA_SCHEMA
+  string name = 2 [(max_data_length) = 120, (force) = true];
 }
 
 message DeviceInfo {
   uint32 device_id = 1;
-  string name = 2;
+  // max_data_length matches core/config.FRIENDLY_NAME_MAX_LEN via DEVICE_SCHEMA
+  string name = 2 [(max_data_length) = 120, (force) = true];
   uint32 area_id = 3;
 }
 
@@ -216,6 +219,16 @@ message SerialProxyInfo {
   SerialProxyPortType port_type = 2;  // Port type (RS232, RS485)
 }
 
+// DeviceInfoResponse max_data_length values:
+//   name = 31 (ESPHOME_DEVICE_NAME_MAX_LEN, validated by validate_hostname)
+//   friendly_name = 120 (core/config.FRIENDLY_NAME_MAX_LEN)
+//   mac_address/bluetooth_mac_address = 17 (MAC_ADDRESS_PRETTY_BUFFER_SIZE - 1, constexpr)
+//   esphome_version = 32 (ESPHOME_VERSION string literal)
+//   compilation_time = 25 (Application::BUILD_TIME_STR_SIZE - 1, constexpr)
+//   manufacturer = 20 (longest hardcoded literal: "Nordic Semiconductor")
+//   model = 127 (core/config.BOARD_MAX_LENGTH, validated in platform schemas)
+//   project_name/project_version = 127 (core/config.PROJECT_MAX_LENGTH)
+//   suggested_area = 120 (core/config.FRIENDLY_NAME_MAX_LEN via AREA_SCHEMA)
 message DeviceInfoResponse {
   option (id) = 10;
   option (source) = SOURCE_SERVER;
@@ -224,28 +237,30 @@ message DeviceInfoResponse {
   // with older ESPHome versions that still send this field.
   bool uses_password = 1 [deprecated = true];
 
-  // The name of the node, given by "App.set_name()"
-  string name = 2;
+  // The name of the node, given by "App.set_name()" - device hostname
+  string name = 2 [(max_data_length) = 31, (force) = true];
 
   // The mac address of the device. For example "AC:BC:32:89:0E:A9"
-  string mac_address = 3;
+  string mac_address = 3 [(max_data_length) = 17, (force) = true];
 
   // A string describing the ESPHome version. For example "1.10.0"
-  string esphome_version = 4;
+  string esphome_version = 4 [(max_data_length) = 32, (force) = true];
 
   // A string describing the date of compilation, this is generated by the compiler
   // and therefore may not be in the same format all the time.
   // If the user isn't using ESPHome, this will also not be set.
-  string compilation_time = 5;
+  string compilation_time = 5 [(max_data_length) = 25, (force) = true];
 
   // The model of the board. For example NodeMCU
-  string model = 6;
+  // max_data_length matches core/config.BOARD_MAX_LENGTH (validated in platform schemas)
+  string model = 6 [(max_data_length) = 127, (force) = true];
 
   bool has_deep_sleep = 7 [(field_ifdef) = "USE_DEEP_SLEEP"];
 
   // The esphome project details if set
-  string project_name = 8 [(field_ifdef) = "ESPHOME_PROJECT_NAME"];
-  string project_version = 9 [(field_ifdef) = "ESPHOME_PROJECT_NAME"];
+  // max_data_length matches core/config.PROJECT_MAX_LENGTH
+  string project_name = 8 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME"];
+  string project_version = 9 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME"];
 
   uint32 webserver_port = 10 [(field_ifdef) = "USE_WEBSERVER"];
 
@@ -253,18 +268,18 @@ message DeviceInfoResponse {
   uint32 legacy_bluetooth_proxy_version = 11 [deprecated=true, (field_ifdef) = "USE_BLUETOOTH_PROXY"];
   uint32 bluetooth_proxy_feature_flags = 15 [(field_ifdef) = "USE_BLUETOOTH_PROXY"];
 
-  string manufacturer = 12;
+  string manufacturer = 12 [(max_data_length) = 20, (force) = true];
 
-  string friendly_name = 13;
+  string friendly_name = 13 [(max_data_length) = 120, (force) = true];
 
   // Deprecated in API version 1.10
   uint32 legacy_voice_assistant_version = 14 [deprecated=true, (field_ifdef) = "USE_VOICE_ASSISTANT"];
   uint32 voice_assistant_feature_flags = 17 [(field_ifdef) = "USE_VOICE_ASSISTANT"];
 
-  string suggested_area = 16 [(field_ifdef) = "USE_AREAS"];
+  string suggested_area = 16 [(max_data_length) = 120, (force) = true, (field_ifdef) = "USE_AREAS"];
 
   // The Bluetooth mac address of the device. For example "AC:BC:32:89:0E:AA"
-  string bluetooth_mac_address = 18 [(field_ifdef) = "USE_BLUETOOTH_PROXY"];
+  string bluetooth_mac_address = 18 [(max_data_length) = 17, (force) = true, (field_ifdef) = "USE_BLUETOOTH_PROXY"];
 
   // Supports receiving and saving api encryption key
   bool api_encryption_supported = 19 [(field_ifdef) = "USE_API_NOISE"];
@@ -308,6 +323,12 @@ enum EntityCategory {
   ENTITY_CATEGORY_DIAGNOSTIC = 2;
 }
 
+// Entity field max_data_length values match Python validation constants:
+//   name/object_id = 120 (config_validation.NAME_MAX_LENGTH)
+//   icon = 63 (core/config.ICON_MAX_LENGTH)
+//   device_class = 47 (core/config.DEVICE_CLASS_MAX_LENGTH)
+//   unit_of_measurement = 63 (core/config.UNIT_OF_MEASUREMENT_MAX_LENGTH)
+
 // ==================== BINARY SENSOR ====================
 message ListEntitiesBinarySensorResponse {
   option (id) = 12;
@@ -315,15 +336,15 @@ message ListEntitiesBinarySensorResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_BINARY_SENSOR";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string device_class = 5;
+  string device_class = 5 [(max_data_length) = 47];
   bool is_status_binary_sensor = 6;
   bool disabled_by_default = 7;
-  string icon = 8 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 8 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 9;
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -349,17 +370,17 @@ message ListEntitiesCoverResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_COVER";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool assumed_state = 5;
   bool supports_position = 6;
   bool supports_tilt = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
   bool disabled_by_default = 9;
-  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 11;
   bool supports_stop = 12;
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
@@ -433,9 +454,9 @@ message ListEntitiesFanResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_FAN";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool supports_oscillation = 5;
@@ -443,7 +464,7 @@ message ListEntitiesFanResponse {
   bool supports_direction = 7;
   int32 supported_speed_count = 8;
   bool disabled_by_default = 9;
-  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 11;
   repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "std::vector<const char *>"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
@@ -521,9 +542,9 @@ message ListEntitiesLightResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_LIGHT";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   repeated ColorMode supported_color_modes = 12 [(container_pointer_no_template) = "light::ColorModeMask"];
@@ -540,7 +561,7 @@ message ListEntitiesLightResponse {
   float max_mireds = 10;
   repeated string effects = 11 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool disabled_by_default = 13;
-  string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 15;
   uint32 device_id = 16 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -626,16 +647,16 @@ message ListEntitiesSensorResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SENSOR";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
-  string unit_of_measurement = 6;
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
+  string unit_of_measurement = 6 [(max_data_length) = 63];
   int32 accuracy_decimals = 7;
   bool force_update = 8;
-  string device_class = 9;
+  string device_class = 9 [(max_data_length) = 47];
   SensorStateClass state_class = 10;
   // Last reset type removed in 2021.9.0
   // Deprecated in API version 1.5
@@ -666,16 +687,16 @@ message ListEntitiesSwitchResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SWITCH";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool assumed_state = 6;
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
-  string device_class = 9;
+  string device_class = 9 [(max_data_length) = 47];
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
 message SwitchStateResponse {
@@ -708,15 +729,15 @@ message ListEntitiesTextSensorResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_TEXT_SENSOR";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message TextSensorStateResponse {
@@ -971,12 +992,12 @@ message ListEntitiesCameraResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_CAMERA";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
   bool disabled_by_default = 5;
-  string icon = 6 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 6 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -1056,9 +1077,9 @@ message ListEntitiesClimateResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_CLIMATE";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool supports_current_temperature = 5; // Deprecated: use feature_flags
@@ -1078,7 +1099,7 @@ message ListEntitiesClimateResponse {
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
   repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
   bool disabled_by_default = 18;
-  string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 20;
   float visual_current_temperature_step = 21;
   bool supports_current_humidity = 22; // Deprecated: use feature_flags
@@ -1167,10 +1188,10 @@ message ListEntitiesWaterHeaterResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_WATER_HEATER";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string name = 3 [(max_data_length) = 120, (force) = true];
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 5;
   EntityCategory entity_category = 6;
   uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
@@ -1243,20 +1264,20 @@ message ListEntitiesNumberResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_NUMBER";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   float min_value = 6;
   float max_value = 7;
   float step = 8;
   bool disabled_by_default = 9;
   EntityCategory entity_category = 10;
-  string unit_of_measurement = 11;
+  string unit_of_measurement = 11 [(max_data_length) = 63];
   NumberMode mode = 12;
-  string device_class = 13;
+  string device_class = 13 [(max_data_length) = 47];
   uint32 device_id = 14 [(field_ifdef) = "USE_DEVICES"];
 }
 message NumberStateResponse {
@@ -1292,12 +1313,12 @@ message ListEntitiesSelectResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SELECT";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   repeated string options = 6 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
@@ -1336,12 +1357,12 @@ message ListEntitiesSirenResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SIREN";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool supports_duration = 8;
@@ -1399,12 +1420,12 @@ message ListEntitiesLockResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_LOCK";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   bool assumed_state = 8;
@@ -1448,15 +1469,15 @@ message ListEntitiesButtonResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_BUTTON";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message ButtonCommandRequest {
@@ -1515,12 +1536,12 @@ message ListEntitiesMediaPlayerResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_MEDIA_PLAYER";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
 
@@ -1604,9 +1625,10 @@ message BluetoothLEAdvertisementResponse {
 }
 
 message BluetoothLERawAdvertisement {
+  option (inline_encode) = true;
   uint64 address = 1 [(force) = true];
   sint32 rssi = 2 [(force) = true];
-  uint32 address_type = 3;
+  uint32 address_type = 3 [(max_value) = 4];
 
   bytes data = 4 [(fixed_array_size) = 62, (force) = true];
 }
@@ -2103,11 +2125,11 @@ message ListEntitiesAlarmControlPanelResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_ALARM_CONTROL_PANEL";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 supported_features = 8;
@@ -2150,11 +2172,11 @@ message ListEntitiesTextResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_TEXT";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
 
@@ -2198,12 +2220,12 @@ message ListEntitiesDateResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_DATETIME_DATE";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2245,12 +2267,12 @@ message ListEntitiesTimeResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_DATETIME_TIME";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2292,15 +2314,15 @@ message ListEntitiesEventResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_EVENT";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
 
   repeated string event_types = 9 [(container_pointer_no_template) = "FixedVector<const char *>"];
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
@@ -2323,15 +2345,15 @@ message ListEntitiesValveResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_VALVE";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
 
   bool assumed_state = 9;
   bool supports_position = 10;
@@ -2378,12 +2400,12 @@ message ListEntitiesDateTimeResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_DATETIME_DATETIME";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2421,15 +2443,15 @@ message ListEntitiesUpdateResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_UPDATE";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8;
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message UpdateStateResponse {
@@ -2504,10 +2526,10 @@ message ListEntitiesInfraredResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_INFRARED";
 
-  string object_id = 1;
+  string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3;
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON"];
+  string name = 3 [(max_data_length) = 120, (force) = true];
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 5;
   EntityCategory entity_category = 6;
   uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];

esphome/components/api/api_connection.cpp

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

esphome/components/api/api_connection.h

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

esphome/components/api/api_frame_helper.cpp

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

esphome/components/api/api_frame_helper.h

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

esphome/components/api/api_frame_helper_noise.cpp

@@ -47,15 +47,8 @@ static constexpr size_t API_MAX_LOG_BYTES = 168;
               format_hex_pretty_to(hex_buf_, (buffer).data(), \
                                    (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
   } while (0)
-#define LOG_PACKET_SENDING(data, len) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Sending raw: %s", \
-              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
-  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
-#define LOG_PACKET_SENDING(data, len) ((void) 0)
 #endif
 
 /// Convert a noise error code to a readable error
@@ -244,132 +237,144 @@ APIError APINoiseFrameHelper::try_read_frame_() {
  * If an error occurred, returns that error. Only returns OK if the transport is ready for data
  * traffic.
  */
+// Split into per-state methods so the compiler doesn't allocate stack space
+// for all branches simultaneously. On RP2040 the core0 stack lives in a 4KB
+// scratch RAM bank; the Noise crypto path (curve25519) needs ~2KB+ of stack,
+// so every byte saved in the caller matters.
 APIError APINoiseFrameHelper::state_action_() {
-  int err;
-  APIError aerr;
-  if (state_ == State::INITIALIZE) {
-    HELPER_LOG("Bad state for method: %d", (int) state_);
-    return APIError::BAD_STATE;
+  switch (this->state_) {
+    case State::INITIALIZE:
+      HELPER_LOG("Bad state for method: %d", (int) this->state_);
+      return APIError::BAD_STATE;
+    case State::CLIENT_HELLO:
+      return this->state_action_client_hello_();
+    case State::SERVER_HELLO:
+      return this->state_action_server_hello_();
+    case State::HANDSHAKE:
+      return this->state_action_handshake_();
+    case State::CLOSED:
+    case State::FAILED:
+      return APIError::BAD_STATE;
+    default:
+      return APIError::OK;
   }
-  if (state_ == State::CLIENT_HELLO) {
-    // waiting for client hello
-    aerr = this->try_read_frame_();
-    if (aerr != APIError::OK) {
-      return handle_handshake_frame_error_(aerr);
-    }
-    // ignore contents, may be used in future for flags
-    // Resize for: existing prologue + 2 size bytes + frame data
-    size_t old_size = this->prologue_.size();
-    size_t rx_size = this->rx_buf_.size();
-    this->prologue_.resize(old_size + 2 + rx_size);
-    this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
-    this->prologue_[old_size + 1] = (uint8_t) rx_size;
-    if (rx_size > 0) {
-      std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), rx_size);
-    }
-
-    state_ = State::SERVER_HELLO;
+}
+APIError APINoiseFrameHelper::state_action_client_hello_() {
+  // waiting for client hello
+  APIError aerr = this->try_read_frame_();
+  if (aerr != APIError::OK) {
+    return handle_handshake_frame_error_(aerr);
   }
-  if (state_ == State::SERVER_HELLO) {
-    // send server hello
-    const auto &name = App.get_name();
-    char mac[MAC_ADDRESS_BUFFER_SIZE];
-    get_mac_address_into_buffer(mac);
-
-    // Calculate positions and sizes
-    size_t name_len = name.size() + 1;  // including null terminator
-    size_t name_offset = 1;
-    size_t mac_offset = name_offset + name_len;
-    size_t total_size = 1 + name_len + MAC_ADDRESS_BUFFER_SIZE;
-
-    // 1 (proto) + name (max ESPHOME_DEVICE_NAME_MAX_LEN) + 1 (name null)
-    // + mac (MAC_ADDRESS_BUFFER_SIZE - 1) + 1 (mac null)
-    constexpr size_t max_msg_size = 1 + ESPHOME_DEVICE_NAME_MAX_LEN + 1 + MAC_ADDRESS_BUFFER_SIZE;
-    uint8_t msg[max_msg_size];
-
-    // chosen proto
-    msg[0] = 0x01;
-
-    // node name, terminated by null byte
-    std::memcpy(msg + name_offset, name.c_str(), name_len);
-    // node mac, terminated by null byte
-    std::memcpy(msg + mac_offset, mac, MAC_ADDRESS_BUFFER_SIZE);
-
-    aerr = write_frame_(msg, total_size);
-    if (aerr != APIError::OK)
-      return aerr;
-
-    // start handshake
-    aerr = init_handshake_();
-    if (aerr != APIError::OK)
-      return aerr;
-
-    state_ = State::HANDSHAKE;
+  // ignore contents, may be used in future for flags
+  // Resize for: existing prologue + 2 size bytes + frame data
+  size_t old_size = this->prologue_.size();
+  size_t rx_size = this->rx_buf_.size();
+  this->prologue_.resize(old_size + 2 + rx_size);
+  this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
+  this->prologue_[old_size + 1] = (uint8_t) rx_size;
+  if (rx_size > 0) {
+    std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), rx_size);
   }
-  if (state_ == State::HANDSHAKE) {
-    int action = noise_handshakestate_get_action(handshake_);
-    if (action == NOISE_ACTION_READ_MESSAGE) {
-      // waiting for handshake msg
-      aerr = this->try_read_frame_();
-      if (aerr != APIError::OK) {
-        return handle_handshake_frame_error_(aerr);
-      }
 
-      if (this->rx_buf_.empty()) {
-        send_explicit_handshake_reject_(LOG_STR("Empty handshake message"));
-        return APIError::BAD_HANDSHAKE_ERROR_BYTE;
-      } else if (this->rx_buf_[0] != 0x00) {
-        HELPER_LOG("Bad handshake error byte: %u", this->rx_buf_[0]);
-        send_explicit_handshake_reject_(LOG_STR("Bad handshake error byte"));
-        return APIError::BAD_HANDSHAKE_ERROR_BYTE;
-      }
-
-      NoiseBuffer mbuf;
-      noise_buffer_init(mbuf);
-      noise_buffer_set_input(mbuf, this->rx_buf_.data() + 1, this->rx_buf_.size() - 1);
-      err = noise_handshakestate_read_message(handshake_, &mbuf, nullptr);
-      if (err != 0) {
-        // Special handling for MAC failure
-        send_explicit_handshake_reject_(err == NOISE_ERROR_MAC_FAILURE ? LOG_STR("Handshake MAC failure")
-                                                                       : LOG_STR("Handshake error"));
-        return handle_noise_error_(err, LOG_STR("noise_handshakestate_read_message"),
-                                   APIError::HANDSHAKESTATE_READ_FAILED);
-      }
-
-      aerr = check_handshake_finished_();
-      if (aerr != APIError::OK)
-        return aerr;
-    } else if (action == NOISE_ACTION_WRITE_MESSAGE) {
-      uint8_t buffer[65];
-      NoiseBuffer mbuf;
-      noise_buffer_init(mbuf);
-      noise_buffer_set_output(mbuf, buffer + 1, sizeof(buffer) - 1);
-
-      err = noise_handshakestate_write_message(handshake_, &mbuf, nullptr);
-      APIError aerr_write = handle_noise_error_(err, LOG_STR("noise_handshakestate_write_message"),
-                                                APIError::HANDSHAKESTATE_WRITE_FAILED);
-      if (aerr_write != APIError::OK)
-        return aerr_write;
-      buffer[0] = 0x00;  // success
-
-      aerr = write_frame_(buffer, mbuf.size + 1);
-      if (aerr != APIError::OK)
-        return aerr;
-      aerr = check_handshake_finished_();
-      if (aerr != APIError::OK)
-        return aerr;
-    } else {
-      // bad state for action
-      state_ = State::FAILED;
-      HELPER_LOG("Bad action for handshake: %d", action);
-      return APIError::HANDSHAKESTATE_BAD_STATE;
-    }
-  }
-  if (state_ == State::CLOSED || state_ == State::FAILED) {
-    return APIError::BAD_STATE;
-  }
+  state_ = State::SERVER_HELLO;
   return APIError::OK;
 }
+APIError APINoiseFrameHelper::state_action_server_hello_() {
+  // send server hello
+  const auto &name = App.get_name();
+  char mac[MAC_ADDRESS_BUFFER_SIZE];
+  get_mac_address_into_buffer(mac);
+
+  // Calculate positions and sizes
+  size_t name_len = name.size() + 1;  // including null terminator
+  size_t name_offset = 1;
+  size_t mac_offset = name_offset + name_len;
+  size_t total_size = 1 + name_len + MAC_ADDRESS_BUFFER_SIZE;
+
+  // 1 (proto) + name (max ESPHOME_DEVICE_NAME_MAX_LEN) + 1 (name null)
+  // + mac (MAC_ADDRESS_BUFFER_SIZE - 1) + 1 (mac null)
+  constexpr size_t max_msg_size = 1 + ESPHOME_DEVICE_NAME_MAX_LEN + 1 + MAC_ADDRESS_BUFFER_SIZE;
+  uint8_t msg[max_msg_size];
+
+  // chosen proto
+  msg[0] = 0x01;
+
+  // node name, terminated by null byte
+  std::memcpy(msg + name_offset, name.c_str(), name_len);
+  // node mac, terminated by null byte
+  std::memcpy(msg + mac_offset, mac, MAC_ADDRESS_BUFFER_SIZE);
+
+  APIError aerr = write_frame_(msg, total_size);
+  if (aerr != APIError::OK)
+    return aerr;
+
+  // start handshake
+  aerr = init_handshake_();
+  if (aerr != APIError::OK)
+    return aerr;
+
+  state_ = State::HANDSHAKE;
+  return APIError::OK;
+}
+APIError APINoiseFrameHelper::state_action_handshake_() {
+  int action = noise_handshakestate_get_action(this->handshake_);
+  if (action == NOISE_ACTION_READ_MESSAGE) {
+    return this->state_action_handshake_read_();
+  } else if (action == NOISE_ACTION_WRITE_MESSAGE) {
+    return this->state_action_handshake_write_();
+  }
+  // bad state for action
+  this->state_ = State::FAILED;
+  HELPER_LOG("Bad action for handshake: %d", action);
+  return APIError::HANDSHAKESTATE_BAD_STATE;
+}
+APIError APINoiseFrameHelper::state_action_handshake_read_() {
+  APIError aerr = this->try_read_frame_();
+  if (aerr != APIError::OK) {
+    return this->handle_handshake_frame_error_(aerr);
+  }
+
+  if (this->rx_buf_.empty()) {
+    this->send_explicit_handshake_reject_(LOG_STR("Empty handshake message"));
+    return APIError::BAD_HANDSHAKE_ERROR_BYTE;
+  } else if (this->rx_buf_[0] != 0x00) {
+    HELPER_LOG("Bad handshake error byte: %u", this->rx_buf_[0]);
+    this->send_explicit_handshake_reject_(LOG_STR("Bad handshake error byte"));
+    return APIError::BAD_HANDSHAKE_ERROR_BYTE;
+  }
+
+  NoiseBuffer mbuf;
+  noise_buffer_init(mbuf);
+  noise_buffer_set_input(mbuf, this->rx_buf_.data() + 1, this->rx_buf_.size() - 1);
+  int err = noise_handshakestate_read_message(this->handshake_, &mbuf, nullptr);
+  if (err != 0) {
+    // Special handling for MAC failure
+    this->send_explicit_handshake_reject_(err == NOISE_ERROR_MAC_FAILURE ? LOG_STR("Handshake MAC failure")
+                                                                         : LOG_STR("Handshake error"));
+    return this->handle_noise_error_(err, LOG_STR("noise_handshakestate_read_message"),
+                                     APIError::HANDSHAKESTATE_READ_FAILED);
+  }
+
+  return this->check_handshake_finished_();
+}
+APIError APINoiseFrameHelper::state_action_handshake_write_() {
+  uint8_t buffer[65];
+  NoiseBuffer mbuf;
+  noise_buffer_init(mbuf);
+  noise_buffer_set_output(mbuf, buffer + 1, sizeof(buffer) - 1);
+
+  int err = noise_handshakestate_write_message(this->handshake_, &mbuf, nullptr);
+  APIError aerr = this->handle_noise_error_(err, LOG_STR("noise_handshakestate_write_message"),
+                                            APIError::HANDSHAKESTATE_WRITE_FAILED);
+  if (aerr != APIError::OK)
+    return aerr;
+  buffer[0] = 0x00;  // success
+
+  aerr = this->write_frame_(buffer, mbuf.size + 1);
+  if (aerr != APIError::OK)
+    return aerr;
+  return this->check_handshake_finished_();
+}
 void APINoiseFrameHelper::send_explicit_handshake_reject_(const LogString *reason) {
   // Max reject message: "Bad handshake packet len" (24) + 1 (failure byte) = 25 bytes
   uint8_t data[32];
@@ -452,65 +457,83 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   buffer->type = type;
   return APIError::OK;
 }
-APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) {
-  APIError aerr = this->check_data_state_();
+// Encrypt a single noise message in place and return the encrypted frame length.
+// Returns APIError::OK on success.
+APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
+                                                     uint16_t &encrypted_len_out) {
+  // Write noise header
+  buf_start[0] = 0x01;  // indicator
+  // buf_start[1], buf_start[2] to be set after encryption
+
+  // Write message header (to be encrypted)
+  constexpr uint8_t msg_offset = 3;
+  buf_start[msg_offset] = static_cast<uint8_t>(message_type >> 8);      // type high byte
+  buf_start[msg_offset + 1] = static_cast<uint8_t>(message_type);       // type low byte
+  buf_start[msg_offset + 2] = static_cast<uint8_t>(payload_size >> 8);  // data_len high byte
+  buf_start[msg_offset + 3] = static_cast<uint8_t>(payload_size);       // data_len low byte
+  // payload data is already in the buffer starting at offset + 7
+
+  // Encrypt the message in place
+  NoiseBuffer mbuf;
+  noise_buffer_init(mbuf);
+  noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + payload_size, 4 + payload_size + this->frame_footer_size_);
+
+  int err = noise_cipherstate_encrypt(this->send_cipher_, &mbuf);
+  APIError aerr =
+      this->handle_noise_error_(err, LOG_STR("noise_cipherstate_encrypt"), APIError::CIPHERSTATE_ENCRYPT_FAILED);
   if (aerr != APIError::OK)
     return aerr;
 
-  if (messages.empty()) {
-    return APIError::OK;
-  }
+  // Fill in the encrypted size
+  buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
+  buf_start[2] = static_cast<uint8_t>(mbuf.size);
 
+  encrypted_len_out = static_cast<uint16_t>(3 + mbuf.size);  // indicator + size + encrypted data
+  return APIError::OK;
+}
+
+APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
+#ifdef ESPHOME_DEBUG_API
+  assert(this->state_ == State::DATA);
+#endif
+
+  // Resize buffer to include footer space for Noise MAC
+  if (this->frame_footer_size_)
+    buffer.get_buffer()->resize(buffer.get_buffer()->size() + this->frame_footer_size_);
+
+  uint16_t payload_size =
+      static_cast<uint16_t>(buffer.get_buffer()->size() - HEADER_PADDING - this->frame_footer_size_);
+  uint8_t *buf_start = buffer.get_buffer()->data();
+  uint16_t encrypted_len;
+  APIError aerr = this->encrypt_noise_message_(buf_start, payload_size, type, encrypted_len);
+  if (aerr != APIError::OK)
+    return aerr;
+  return this->write_raw_fast_buf_(buf_start, encrypted_len);
+}
+
+APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) {
+#ifdef ESPHOME_DEBUG_API
+  assert(this->state_ == State::DATA);
+  assert(!messages.empty());
+#endif
+
+  // Noise messages are already contiguous in the buffer:
+  // HEADER_PADDING (7) exactly matches the fixed header size, and
+  // footer space (16) is consumed by the encryption MAC.
   uint8_t *buffer_data = buffer.get_buffer()->data();
-
-  // Stack-allocated iovec array - no heap allocation
-  StaticVector<struct iovec, MAX_MESSAGES_PER_BATCH> iovs;
+  uint8_t *write_start = buffer_data + messages[0].offset;
   uint16_t total_write_len = 0;
 
-  // We need to encrypt each message in place
   for (const auto &msg : messages) {
-    // The buffer already has padding at offset
     uint8_t *buf_start = buffer_data + msg.offset;
-
-    // Write noise header
-    buf_start[0] = 0x01;  // indicator
-    // buf_start[1], buf_start[2] to be set after encryption
-
-    // Write message header (to be encrypted)
-    constexpr uint8_t msg_offset = 3;
-    buf_start[msg_offset] = static_cast<uint8_t>(msg.message_type >> 8);      // type high byte
-    buf_start[msg_offset + 1] = static_cast<uint8_t>(msg.message_type);       // type low byte
-    buf_start[msg_offset + 2] = static_cast<uint8_t>(msg.payload_size >> 8);  // data_len high byte
-    buf_start[msg_offset + 3] = static_cast<uint8_t>(msg.payload_size);       // data_len low byte
-    // payload data is already in the buffer starting at offset + 7
-
-    // Make sure we have space for MAC
-    // The buffer should already have been sized appropriately
-
-    // Encrypt the message in place
-    NoiseBuffer mbuf;
-    noise_buffer_init(mbuf);
-    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + msg.payload_size,
-                           4 + msg.payload_size + frame_footer_size_);
-
-    int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
-    APIError aerr =
-        handle_noise_error_(err, LOG_STR("noise_cipherstate_encrypt"), APIError::CIPHERSTATE_ENCRYPT_FAILED);
+    uint16_t encrypted_len;
+    APIError aerr = this->encrypt_noise_message_(buf_start, msg.payload_size, msg.message_type, encrypted_len);
     if (aerr != APIError::OK)
       return aerr;
-
-    // Fill in the encrypted size
-    buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
-    buf_start[2] = static_cast<uint8_t>(mbuf.size);
-
-    // Add iovec for this encrypted message
-    size_t msg_len = static_cast<size_t>(3 + mbuf.size);  // indicator + size + encrypted data
-    iovs.push_back({buf_start, msg_len});
-    total_write_len += msg_len;
+    total_write_len += encrypted_len;
   }
 
-  // Send all encrypted messages in one writev call
-  return this->write_raw_(iovs.data(), iovs.size(), total_write_len);
+  return this->write_raw_fast_buf_(write_start, total_write_len);
 }
 
 APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
@@ -519,16 +542,16 @@ APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
   header[1] = (uint8_t) (len >> 8);
   header[2] = (uint8_t) len;
 
+  if (len == 0) {
+    return this->write_raw_buf_(header, 3);
+  }
   struct iovec iov[2];
   iov[0].iov_base = header;
   iov[0].iov_len = 3;
-  if (len == 0) {
-    return this->write_raw_(iov, 1, 3);  // Just header
-  }
   iov[1].iov_base = const_cast<uint8_t *>(data);
   iov[1].iov_len = len;
 
-  return this->write_raw_(iov, 2, 3 + len);  // Header + data
+  return this->write_raw_iov_(iov, 2, 3 + len);
 }
 
 /** Initiate the data structures for the handshake.
@@ -594,7 +617,7 @@ APIError APINoiseFrameHelper::check_handshake_finished_() {
   if (aerr != APIError::OK)
     return aerr;
 
-  frame_footer_size_ = noise_cipherstate_get_mac_length(send_cipher_);
+  this->frame_footer_size_ = noise_cipherstate_get_mac_length(send_cipher_);
 
   HELPER_LOG("Handshake complete!");
   noise_handshakestate_free(handshake_);

esphome/components/api/api_frame_helper_noise.h

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

esphome/components/api/api_frame_helper_plaintext.cpp

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

esphome/components/api/api_frame_helper_plaintext.h

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

esphome/components/api/api_options.proto

@@ -22,6 +22,7 @@ extend google.protobuf.MessageOptions {
     optional bool log = 1039 [default=true];
     optional bool no_delay = 1040 [default=false];
     optional string base_class = 1041;
+    optional bool inline_encode = 1042 [default=false];
 }
 
 extend google.protobuf.FieldOptions {
@@ -96,4 +97,16 @@ extend google.protobuf.FieldOptions {
     // variant of the calc_ method. Use on fields that are almost always non-default
     // to eliminate dead branches on hot paths.
     optional bool force = 50016 [default=false];
+
+    // max_value: Maximum value a field can have.
+    // When max_value < 128, the code generator emits constant-size calculations
+    // and direct byte writes instead of varint branching, since the encoded varint
+    // is guaranteed to be 1 byte.
+    optional uint32 max_value = 50017;
+
+    // max_data_length: Maximum length of a string or bytes field.
+    // When max_data_length < 128, the code generator emits constant-size
+    // length varint calculations and direct byte writes, since the length
+    // varint is guaranteed to be 1 byte.
+    optional uint32 max_data_length = 50018;
 }

esphome/components/api/api_pb2.h

@@ -412,7 +412,7 @@ class HelloResponse final : public ProtoMessage {
   uint32_t api_version_minor{0};
   StringRef server_info{};
   StringRef name{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -477,7 +477,7 @@ class AreaInfo final : public ProtoMessage {
  public:
   uint32_t area_id{0};
   StringRef name{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -492,7 +492,7 @@ class DeviceInfo final : public ProtoMessage {
   uint32_t device_id{0};
   StringRef name{};
   uint32_t area_id{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -506,7 +506,7 @@ class SerialProxyInfo final : public ProtoMessage {
  public:
   StringRef name{};
   enums::SerialProxyPortType port_type{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -574,7 +574,7 @@ class DeviceInfoResponse final : public ProtoMessage {
 #ifdef USE_SERIAL_PROXY
   std::array<SerialProxyInfo, SERIAL_PROXY_COUNT> serial_proxies{};
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -605,7 +605,7 @@ class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class{};
   bool is_status_binary_sensor{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -622,7 +622,7 @@ class BinarySensorStateResponse final : public StateResponseProtoMessage {
 #endif
   bool state{false};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -644,7 +644,7 @@ class ListEntitiesCoverResponse final : public InfoResponseProtoMessage {
   bool supports_tilt{false};
   StringRef device_class{};
   bool supports_stop{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -662,7 +662,7 @@ class CoverStateResponse final : public StateResponseProtoMessage {
   float position{0.0f};
   float tilt{0.0f};
   enums::CoverOperation current_operation{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -704,7 +704,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_direction{false};
   int32_t supported_speed_count{0};
   const std::vector<const char *> *supported_preset_modes{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -724,7 +724,7 @@ class FanStateResponse final : public StateResponseProtoMessage {
   enums::FanDirection direction{};
   int32_t speed_level{0};
   StringRef preset_mode{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -771,7 +771,7 @@ class ListEntitiesLightResponse final : public InfoResponseProtoMessage {
   float min_mireds{0.0f};
   float max_mireds{0.0f};
   const FixedVector<const char *> *effects{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -798,7 +798,7 @@ class LightStateResponse final : public StateResponseProtoMessage {
   float cold_white{0.0f};
   float warm_white{0.0f};
   StringRef effect{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -862,7 +862,7 @@ class ListEntitiesSensorResponse final : public InfoResponseProtoMessage {
   bool force_update{false};
   StringRef device_class{};
   enums::SensorStateClass state_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -879,7 +879,7 @@ class SensorStateResponse final : public StateResponseProtoMessage {
 #endif
   float state{0.0f};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -898,7 +898,7 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
 #endif
   bool assumed_state{false};
   StringRef device_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -914,7 +914,7 @@ class SwitchStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("switch_state_response"); }
 #endif
   bool state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -948,7 +948,7 @@ class ListEntitiesTextSensorResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_text_sensor_response"); }
 #endif
   StringRef device_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -965,7 +965,7 @@ class TextSensorStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1004,7 +1004,7 @@ class SubscribeLogsResponse final : public ProtoMessage {
     this->message_ptr_ = data;
     this->message_len_ = len;
   }
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1037,7 +1037,7 @@ class NoiseEncryptionSetKeyResponse final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("noise_encryption_set_key_response"); }
 #endif
   bool success{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1051,7 +1051,7 @@ class HomeassistantServiceMap final : public ProtoMessage {
  public:
   StringRef key{};
   StringRef value{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1080,7 +1080,7 @@ class HomeassistantActionRequest final : public ProtoMessage {
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   StringRef response_template{};
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1124,7 +1124,7 @@ class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
   StringRef entity_id{};
   StringRef attribute{};
   bool once{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1215,7 +1215,7 @@ class ListEntitiesServicesArgument final : public ProtoMessage {
  public:
   StringRef name{};
   enums::ServiceArgType type{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1234,7 +1234,7 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
   uint32_t key{0};
   FixedVector<ListEntitiesServicesArgument> args{};
   enums::SupportsResponseType supports_response{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1304,7 +1304,7 @@ class ExecuteServiceResponse final : public ProtoMessage {
   const uint8_t *response_data{nullptr};
   uint16_t response_data_len{0};
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1321,7 +1321,7 @@ class ListEntitiesCameraResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_camera_response"); }
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1343,7 +1343,7 @@ class CameraImageResponse final : public StateResponseProtoMessage {
     this->data_len_ = len;
   }
   bool done{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1394,7 +1394,7 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   float visual_min_humidity{0.0f};
   float visual_max_humidity{0.0f};
   uint32_t feature_flags{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1422,7 +1422,7 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
   StringRef custom_preset{};
   float current_humidity{0.0f};
   float target_humidity{0.0f};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1480,7 +1480,7 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
   float target_temperature_step{0.0f};
   const water_heater::WaterHeaterModeMask *supported_modes{};
   uint32_t supported_features{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1501,7 +1501,7 @@ class WaterHeaterStateResponse final : public StateResponseProtoMessage {
   uint32_t state{0};
   float target_temperature_low{0.0f};
   float target_temperature_high{0.0f};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1545,7 +1545,7 @@ class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
   StringRef unit_of_measurement{};
   enums::NumberMode mode{};
   StringRef device_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1562,7 +1562,7 @@ class NumberStateResponse final : public StateResponseProtoMessage {
 #endif
   float state{0.0f};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1596,7 +1596,7 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_select_response"); }
 #endif
   const FixedVector<const char *> *options{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1613,7 +1613,7 @@ class SelectStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1650,7 +1650,7 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
   const FixedVector<const char *> *tones{};
   bool supports_duration{false};
   bool supports_volume{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1666,7 +1666,7 @@ class SirenStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("siren_state_response"); }
 #endif
   bool state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1711,7 +1711,7 @@ class ListEntitiesLockResponse final : public InfoResponseProtoMessage {
   bool supports_open{false};
   bool requires_code{false};
   StringRef code_format{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1727,7 +1727,7 @@ class LockStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("lock_state_response"); }
 #endif
   enums::LockState state{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1764,7 +1764,7 @@ class ListEntitiesButtonResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_button_response"); }
 #endif
   StringRef device_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1796,7 +1796,7 @@ class MediaPlayerSupportedFormat final : public ProtoMessage {
   uint32_t num_channels{0};
   enums::MediaPlayerFormatPurpose purpose{};
   uint32_t sample_bytes{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1814,7 +1814,7 @@ class ListEntitiesMediaPlayerResponse final : public InfoResponseProtoMessage {
   bool supports_pause{false};
   std::vector<MediaPlayerSupportedFormat> supported_formats{};
   uint32_t feature_flags{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1832,7 +1832,7 @@ class MediaPlayerStateResponse final : public StateResponseProtoMessage {
   enums::MediaPlayerState state{};
   float volume{0.0f};
   bool muted{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1888,8 +1888,6 @@ class BluetoothLERawAdvertisement final : public ProtoMessage {
   uint32_t address_type{0};
   uint8_t data[62]{};
   uint8_t data_len{0};
-  void encode(ProtoWriteBuffer &buffer) const;
-  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1905,7 +1903,7 @@ class BluetoothLERawAdvertisementsResponse final : public ProtoMessage {
 #endif
   std::array<BluetoothLERawAdvertisement, BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE> advertisements{};
   uint16_t advertisements_len{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1942,7 +1940,7 @@ class BluetoothDeviceConnectionResponse final : public ProtoMessage {
   bool connected{false};
   uint32_t mtu{0};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1970,7 +1968,7 @@ class BluetoothGATTDescriptor final : public ProtoMessage {
   std::array<uint64_t, 2> uuid{};
   uint32_t handle{0};
   uint32_t short_uuid{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1985,7 +1983,7 @@ class BluetoothGATTCharacteristic final : public ProtoMessage {
   uint32_t properties{0};
   FixedVector<BluetoothGATTDescriptor> descriptors{};
   uint32_t short_uuid{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1999,7 +1997,7 @@ class BluetoothGATTService final : public ProtoMessage {
   uint32_t handle{0};
   FixedVector<BluetoothGATTCharacteristic> characteristics{};
   uint32_t short_uuid{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2016,7 +2014,7 @@ class BluetoothGATTGetServicesResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   std::vector<BluetoothGATTService> services{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2032,7 +2030,7 @@ class BluetoothGATTGetServicesDoneResponse final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_get_services_done_response"); }
 #endif
   uint64_t address{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2071,7 +2069,7 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2166,7 +2164,7 @@ class BluetoothGATTNotifyDataResponse final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2184,7 +2182,7 @@ class BluetoothConnectionsFreeResponse final : public ProtoMessage {
   uint32_t free{0};
   uint32_t limit{0};
   std::array<uint64_t, BLUETOOTH_PROXY_MAX_CONNECTIONS> allocated{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2202,7 +2200,7 @@ class BluetoothGATTErrorResponse final : public ProtoMessage {
   uint64_t address{0};
   uint32_t handle{0};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2219,7 +2217,7 @@ class BluetoothGATTWriteResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   uint32_t handle{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2236,7 +2234,7 @@ class BluetoothGATTNotifyResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   uint32_t handle{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2254,7 +2252,7 @@ class BluetoothDevicePairingResponse final : public ProtoMessage {
   uint64_t address{0};
   bool paired{false};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2272,7 +2270,7 @@ class BluetoothDeviceUnpairingResponse final : public ProtoMessage {
   uint64_t address{0};
   bool success{false};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2290,7 +2288,7 @@ class BluetoothDeviceClearCacheResponse final : public ProtoMessage {
   uint64_t address{0};
   bool success{false};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2308,7 +2306,7 @@ class BluetoothScannerStateResponse final : public ProtoMessage {
   enums::BluetoothScannerState state{};
   enums::BluetoothScannerMode mode{};
   enums::BluetoothScannerMode configured_mode{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2354,7 +2352,7 @@ class VoiceAssistantAudioSettings final : public ProtoMessage {
   uint32_t noise_suppression_level{0};
   uint32_t auto_gain{0};
   float volume_multiplier{0.0f};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2374,7 +2372,7 @@ class VoiceAssistantRequest final : public ProtoMessage {
   uint32_t flags{0};
   VoiceAssistantAudioSettings audio_settings{};
   StringRef wake_word_phrase{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2436,7 +2434,7 @@ class VoiceAssistantAudio final : public ProtoDecodableMessage {
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
   bool end{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2494,7 +2492,7 @@ class VoiceAssistantAnnounceFinished final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("voice_assistant_announce_finished"); }
 #endif
   bool success{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2507,7 +2505,7 @@ class VoiceAssistantWakeWord final : public ProtoMessage {
   StringRef id{};
   StringRef wake_word{};
   std::vector<std::string> trained_languages{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2557,7 +2555,7 @@ class VoiceAssistantConfigurationResponse final : public ProtoMessage {
   std::vector<VoiceAssistantWakeWord> available_wake_words{};
   const std::vector<std::string> *active_wake_words{};
   uint32_t max_active_wake_words{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2592,7 +2590,7 @@ class ListEntitiesAlarmControlPanelResponse final : public InfoResponseProtoMess
   uint32_t supported_features{0};
   bool requires_code{false};
   bool requires_code_to_arm{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2608,7 +2606,7 @@ class AlarmControlPanelStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("alarm_control_panel_state_response"); }
 #endif
   enums::AlarmControlPanelState state{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2647,7 +2645,7 @@ class ListEntitiesTextResponse final : public InfoResponseProtoMessage {
   uint32_t max_length{0};
   StringRef pattern{};
   enums::TextMode mode{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2664,7 +2662,7 @@ class TextStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2698,7 +2696,7 @@ class ListEntitiesDateResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_date_response"); }
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2717,7 +2715,7 @@ class DateStateResponse final : public StateResponseProtoMessage {
   uint32_t year{0};
   uint32_t month{0};
   uint32_t day{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2752,7 +2750,7 @@ class ListEntitiesTimeResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_time_response"); }
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2771,7 +2769,7 @@ class TimeStateResponse final : public StateResponseProtoMessage {
   uint32_t hour{0};
   uint32_t minute{0};
   uint32_t second{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2808,7 +2806,7 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class{};
   const FixedVector<const char *> *event_types{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2824,7 +2822,7 @@ class EventResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("event_response"); }
 #endif
   StringRef event_type{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2845,7 +2843,7 @@ class ListEntitiesValveResponse final : public InfoResponseProtoMessage {
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_stop{false};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2862,7 +2860,7 @@ class ValveStateResponse final : public StateResponseProtoMessage {
 #endif
   float position{0.0f};
   enums::ValveOperation current_operation{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2897,7 +2895,7 @@ class ListEntitiesDateTimeResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_date_time_response"); }
 #endif
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2914,7 +2912,7 @@ class DateTimeStateResponse final : public StateResponseProtoMessage {
 #endif
   bool missing_state{false};
   uint32_t epoch_seconds{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2948,7 +2946,7 @@ class ListEntitiesUpdateResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_update_response"); }
 #endif
   StringRef device_class{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -2972,7 +2970,7 @@ class UpdateStateResponse final : public StateResponseProtoMessage {
   StringRef title{};
   StringRef release_summary{};
   StringRef release_url{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3007,7 +3005,7 @@ class ZWaveProxyFrame final : public ProtoDecodableMessage {
 #endif
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3026,7 +3024,7 @@ class ZWaveProxyRequest final : public ProtoDecodableMessage {
   enums::ZWaveProxyRequestType type{};
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3047,7 +3045,7 @@ class ListEntitiesInfraredResponse final : public InfoResponseProtoMessage {
 #endif
   uint32_t capabilities{0};
   uint32_t receiver_frequency{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3094,7 +3092,7 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
 #endif
   uint32_t key{0};
   const std::vector<int32_t> *timings{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3138,7 +3136,7 @@ class SerialProxyDataReceived final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3204,7 +3202,7 @@ class SerialProxyGetModemPinsResponse final : public ProtoMessage {
 #endif
   uint32_t instance{0};
   uint32_t line_states{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3239,7 +3237,7 @@ class SerialProxyRequestResponse final : public ProtoMessage {
   enums::SerialProxyRequestType type{};
   enums::SerialProxyStatus status{};
   StringRef error_message{};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -3277,7 +3275,7 @@ class BluetoothSetConnectionParamsResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   int32_t error{0};
-  void encode(ProtoWriteBuffer &buffer) const;
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;

esphome/components/api/proto.cpp

@@ -145,14 +145,15 @@ uint32_t ProtoDecodableMessage::count_repeated_field(const uint8_t *buffer, size
 //   [tag][v1][v2][body ..... body]
 //                                ^-- pos_ = element end, within buffer
 void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const void *value,
-                                          void (*encode_fn)(const void *, ProtoWriteBuffer &)) {
+                                          uint8_t *(*encode_fn)(const void *,
+                                                                ProtoWriteBuffer &PROTO_ENCODE_DEBUG_PARAM)) {
   this->encode_field_raw(field_id, 2);
   // Reserve 1 byte for length varint (optimistic: submessage < 128 bytes)
   uint8_t *len_pos = this->pos_;
   this->debug_check_bounds_(1);
   this->pos_++;
   uint8_t *body_start = this->pos_;
-  encode_fn(value, *this);
+  this->pos_ = encode_fn(value, *this PROTO_ENCODE_DEBUG_INIT(this->buffer_));
   uint32_t body_size = static_cast<uint32_t>(this->pos_ - body_start);
   if (body_size < 128) [[likely]] {
     // Common case: 1-byte varint, just backpatch
@@ -173,22 +174,27 @@ void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const void *value,
 
 // Non-template core for encode_optional_sub_message.
 void ProtoWriteBuffer::encode_optional_sub_message(uint32_t field_id, uint32_t nested_size, const void *value,
-                                                   void (*encode_fn)(const void *, ProtoWriteBuffer &)) {
+                                                   uint8_t *(*encode_fn)(const void *,
+                                                                         ProtoWriteBuffer &PROTO_ENCODE_DEBUG_PARAM)) {
   if (nested_size == 0)
     return;
   this->encode_field_raw(field_id, 2);
   this->encode_varint_raw(nested_size);
 #ifdef ESPHOME_DEBUG_API
   uint8_t *start = this->pos_;
-  encode_fn(value, *this);
+  this->pos_ = encode_fn(value, *this PROTO_ENCODE_DEBUG_INIT(this->buffer_));
   if (static_cast<uint32_t>(this->pos_ - start) != nested_size)
     this->debug_check_encode_size_(field_id, nested_size, this->pos_ - start);
 #else
-  encode_fn(value, *this);
+  this->pos_ = encode_fn(value, *this PROTO_ENCODE_DEBUG_INIT(this->buffer_));
 #endif
 }
 
 #ifdef ESPHOME_DEBUG_API
+void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *end, const char *caller) {
+  ESP_LOGE(TAG, "Proto encode bounds check failed in %s: need %zu bytes, %td available", caller, bytes, end - pos);
+  abort();
+}
 void ProtoWriteBuffer::debug_check_bounds_(size_t bytes, const char *caller) {
   if (this->pos_ + bytes > this->buffer_->data() + this->buffer_->size()) {
     ESP_LOGE(TAG, "ProtoWriteBuffer bounds check failed in %s: bytes=%zu offset=%td buf_size=%zu", caller, bytes,
@@ -201,6 +207,7 @@ void ProtoWriteBuffer::debug_check_encode_size_(uint32_t field_id, uint32_t expe
            expected, actual);
   abort();
 }
+
 #endif
 
 void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {

esphome/components/api/proto.h

@@ -25,6 +25,19 @@ constexpr uint8_t WIRE_TYPE_LENGTH_DELIMITED = 2;  // string, bytes, embedded me
 constexpr uint8_t WIRE_TYPE_FIXED32 = 5;           // fixed32, sfixed32, float
 constexpr uint8_t WIRE_TYPE_MASK = 0b111;          // Mask to extract wire type from tag
 
+// Reinterpret float bits as uint32_t without floating-point comparison.
+// Used by both encode_float() and calc_float() to ensure identical zero checks.
+// Uses union type-punning which is a GCC/Clang extension (not standard C++),
+// but bit_cast/memcpy don't optimize to a no-op on xtensa-gcc (ESP8266).
+inline uint32_t float_to_raw(float value) {
+  union {
+    float f;
+    uint32_t u;
+  } v;
+  v.f = value;
+  return v.u;
+}
+
 // Helper functions for ZigZag encoding/decoding
 inline constexpr uint32_t encode_zigzag32(int32_t value) {
   return (static_cast<uint32_t>(value) << 1) ^ (static_cast<uint32_t>(value >> 31));
@@ -195,6 +208,26 @@ class Proto32Bit {
 
 // NOTE: Proto64Bit class removed - wire type 1 (64-bit fixed) not supported
 
+// Debug bounds checking for proto encode functions.
+// In debug mode (ESPHOME_DEBUG_API), an extra end-of-buffer pointer is threaded
+// through the entire encode chain. In production, these expand to nothing.
+#ifdef ESPHOME_DEBUG_API
+#define PROTO_ENCODE_DEBUG_PARAM , uint8_t *proto_debug_end_
+#define PROTO_ENCODE_DEBUG_ARG , proto_debug_end_
+#define PROTO_ENCODE_DEBUG_INIT(buf) , (buf)->data() + (buf)->size()
+#define PROTO_ENCODE_CHECK_BOUNDS(pos, n) \
+  do { \
+    if ((pos) + (n) > proto_debug_end_) \
+      proto_check_bounds_failed(pos, n, proto_debug_end_, __builtin_FUNCTION()); \
+  } while (0)
+void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *end, const char *caller);
+#else
+#define PROTO_ENCODE_DEBUG_PARAM
+#define PROTO_ENCODE_DEBUG_ARG
+#define PROTO_ENCODE_DEBUG_INIT(buf)
+#define PROTO_ENCODE_CHECK_BOUNDS(pos, n)
+#endif
+
 class ProtoWriteBuffer {
  public:
   ProtoWriteBuffer(APIBuffer *buffer) : buffer_(buffer), pos_(buffer->data() + buffer->size()) {}
@@ -207,15 +240,6 @@ class ProtoWriteBuffer {
     }
     this->encode_varint_raw_slow_(value);
   }
-  void encode_varint_raw_64(uint64_t value) {
-    while (value > 0x7F) {
-      this->debug_check_bounds_(1);
-      *this->pos_++ = static_cast<uint8_t>(value | 0x80);
-      value >>= 7;
-    }
-    this->debug_check_bounds_(1);
-    *this->pos_++ = static_cast<uint8_t>(value);
-  }
   /**
    * Encode a field key (tag/wire type combination).
    *
@@ -229,123 +253,6 @@ class ProtoWriteBuffer {
    * Following https://protobuf.dev/programming-guides/encoding/#structure
    */
   void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
-  /// Write a single precomputed tag byte. Tag must be < 128.
-  inline void write_raw_byte(uint8_t b) ESPHOME_ALWAYS_INLINE {
-    this->debug_check_bounds_(1);
-    *this->pos_++ = b;
-  }
-  /// Write raw bytes to the buffer (no tag, no length prefix).
-  inline void encode_raw(const void *data, size_t len) ESPHOME_ALWAYS_INLINE {
-    this->debug_check_bounds_(len);
-    std::memcpy(this->pos_, data, len);
-    this->pos_ += len;
-  }
-  /// Write a precomputed tag byte + 32-bit value in one operation.
-  /// Tag must be a single-byte varint (< 128). No zero check.
-  inline void write_tag_and_fixed32(uint8_t tag, uint32_t value) ESPHOME_ALWAYS_INLINE {
-    this->debug_check_bounds_(5);
-    this->pos_[0] = tag;
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    std::memcpy(this->pos_ + 1, &value, 4);
-#else
-    this->pos_[1] = static_cast<uint8_t>(value & 0xFF);
-    this->pos_[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
-    this->pos_[3] = static_cast<uint8_t>((value >> 16) & 0xFF);
-    this->pos_[4] = static_cast<uint8_t>((value >> 24) & 0xFF);
-#endif
-    this->pos_ += 5;
-  }
-  void encode_string(uint32_t field_id, const char *string, size_t len, bool force = false) {
-    if (len == 0 && !force)
-      return;
-
-    this->encode_field_raw(field_id, 2);  // type 2: Length-delimited string
-    this->encode_varint_raw(len);
-    // Direct memcpy into pre-sized buffer — avoids push_back() per-byte capacity checks
-    // and vector::insert() iterator overhead. ~10-11x faster for 16-32 byte strings.
-    this->debug_check_bounds_(len);
-    std::memcpy(this->pos_, string, len);
-    this->pos_ += len;
-  }
-  void encode_string(uint32_t field_id, const std::string &value, bool force = false) {
-    this->encode_string(field_id, value.data(), value.size(), force);
-  }
-  void encode_string(uint32_t field_id, const StringRef &ref, bool force = false) {
-    this->encode_string(field_id, ref.c_str(), ref.size(), force);
-  }
-  void encode_bytes(uint32_t field_id, const uint8_t *data, size_t len, bool force = false) {
-    this->encode_string(field_id, reinterpret_cast<const char *>(data), len, force);
-  }
-  void encode_uint32(uint32_t field_id, uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    this->encode_field_raw(field_id, 0);  // type 0: Varint - uint32
-    this->encode_varint_raw(value);
-  }
-  void encode_uint64(uint32_t field_id, uint64_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    this->encode_field_raw(field_id, 0);  // type 0: Varint - uint64
-    this->encode_varint_raw_64(value);
-  }
-  void encode_bool(uint32_t field_id, bool value, bool force = false) {
-    if (!value && !force)
-      return;
-    this->encode_field_raw(field_id, 0);  // type 0: Varint - bool
-    this->debug_check_bounds_(1);
-    *this->pos_++ = value ? 0x01 : 0x00;
-  }
-  void encode_fixed32(uint32_t field_id, uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-
-    this->encode_field_raw(field_id, 5);  // type 5: 32-bit fixed32
-    this->debug_check_bounds_(4);
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    // Protobuf fixed32 is little-endian, so direct copy works
-    std::memcpy(this->pos_, &value, 4);
-    this->pos_ += 4;
-#else
-    *this->pos_++ = (value >> 0) & 0xFF;
-    *this->pos_++ = (value >> 8) & 0xFF;
-    *this->pos_++ = (value >> 16) & 0xFF;
-    *this->pos_++ = (value >> 24) & 0xFF;
-#endif
-  }
-  // NOTE: Wire type 1 (64-bit fixed: double, fixed64, sfixed64) is intentionally
-  // not supported to reduce overhead on embedded systems. All ESPHome devices are
-  // 32-bit microcontrollers where 64-bit operations are expensive. If 64-bit support
-  // is needed in the future, the necessary encoding/decoding functions must be added.
-  void encode_float(uint32_t field_id, float value, bool force = false) {
-    if (value == 0.0f && !force)
-      return;
-
-    union {
-      float value;
-      uint32_t raw;
-    } val{};
-    val.value = value;
-    this->encode_fixed32(field_id, val.raw);
-  }
-  void encode_int32(uint32_t field_id, int32_t value, bool force = false) {
-    if (value < 0) {
-      // negative int32 is always 10 byte long
-      this->encode_int64(field_id, value, force);
-      return;
-    }
-    this->encode_uint32(field_id, static_cast<uint32_t>(value), force);
-  }
-  void encode_int64(uint32_t field_id, int64_t value, bool force = false) {
-    this->encode_uint64(field_id, static_cast<uint64_t>(value), force);
-  }
-  void encode_sint32(uint32_t field_id, int32_t value, bool force = false) {
-    this->encode_uint32(field_id, encode_zigzag32(value), force);
-  }
-  void encode_sint64(uint32_t field_id, int64_t value, bool force = false) {
-    this->encode_uint64(field_id, encode_zigzag64(value), force);
-  }
-  /// Encode a packed repeated sint32 field (zero-copy from vector)
-  void encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values);
   /// Single-pass encode for repeated submessage elements.
   /// Thin template wrapper; all buffer work is in the non-template core.
   template<typename T> void encode_sub_message(uint32_t field_id, const T &value);
@@ -353,12 +260,17 @@ class ProtoWriteBuffer {
   /// Thin template wrapper; all buffer work is in the non-template core.
   template<typename T> void encode_optional_sub_message(uint32_t field_id, const T &value);
 
+  // NOLINTBEGIN(readability-identifier-naming)
   // Non-template core for encode_sub_message — backpatch approach.
-  void encode_sub_message(uint32_t field_id, const void *value, void (*encode_fn)(const void *, ProtoWriteBuffer &));
+  void encode_sub_message(uint32_t field_id, const void *value,
+                          uint8_t *(*encode_fn)(const void *, ProtoWriteBuffer &PROTO_ENCODE_DEBUG_PARAM));
   // Non-template core for encode_optional_sub_message.
   void encode_optional_sub_message(uint32_t field_id, uint32_t nested_size, const void *value,
-                                   void (*encode_fn)(const void *, ProtoWriteBuffer &));
+                                   uint8_t *(*encode_fn)(const void *, ProtoWriteBuffer &PROTO_ENCODE_DEBUG_PARAM));
+  // NOLINTEND(readability-identifier-naming)
   APIBuffer *get_buffer() const { return buffer_; }
+  uint8_t *get_pos() const { return pos_; }
+  void set_pos(uint8_t *pos) { pos_ = pos; }
 
  protected:
   // Slow path for encode_varint_raw values >= 128, outlined to keep fast path small
@@ -375,6 +287,244 @@ class ProtoWriteBuffer {
   uint8_t *pos_;
 };
 
+// Varint encoding thresholds — used by both proto_encode_* free functions and ProtoSize.
+constexpr uint32_t VARINT_MAX_1_BYTE = 1 << 7;   // 128
+constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
+
+/// Static encode helpers for generated encode() functions.
+/// Generated code hoists buffer.pos_ into a local uint8_t *__restrict__ pos,
+/// then calls these methods which take pos by reference. No struct, no overhead.
+/// For sub-messages, pos is synced back to buffer before the call and reloaded after.
+class ProtoEncode {
+ public:
+  /// Write a multi-byte varint directly through a pos pointer.
+  /// Unrolled based on the compile-time max varint length for T
+  /// (5 bytes for uint32_t, 10 bytes for uint64_t). The explicit unroll gives
+  /// the compiler straight-line code with early exits instead of a
+  /// data-dependent back-edge branch, which measurably speeds up BLE raw
+  /// advertisement MAC encoding (always 7-byte varints) among other hot paths.
+  ///
+  /// Takes/returns pos by value so this function can remain out-of-line without
+  /// forcing the caller to spill pos to memory on every byte write. Callers
+  /// (which are ALWAYS_INLINE) should assign the returned pos back to their
+  /// local. Code size win vs. inlining the whole unroll at every call site.
+  template<typename T>
+  static uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, T value) {
+    constexpr int MAX_VARINT_BYTES = (sizeof(T) * 8 + 6) / 7;  // 5 for u32, 10 for u64
+#pragma GCC unroll 10
+    for (int i = 0; i < MAX_VARINT_BYTES - 1; i++) {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+      *pos++ = static_cast<uint8_t>(value) | 0x80;
+      value >>= 7;
+      if (value <= 0x7F) {
+        PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+        *pos++ = static_cast<uint8_t>(value);
+        return pos;
+      }
+    }
+    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) {
+    if (value < VARINT_MAX_1_BYTE) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+      *pos++ = static_cast<uint8_t>(value);
+      return;
+    }
+    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,
+                                                                   uint32_t value) {
+    if (value < VARINT_MAX_1_BYTE) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+      *pos++ = static_cast<uint8_t>(value);
+      return;
+    }
+    if (value < VARINT_MAX_2_BYTE) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 2);
+      *pos++ = static_cast<uint8_t>(value | 0x80);
+      *pos++ = static_cast<uint8_t>(value >> 7);
+      return;
+    }
+    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) {
+    if (value < VARINT_MAX_1_BYTE) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+      *pos++ = static_cast<uint8_t>(value);
+      return;
+    }
+    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) {
+    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
+  }
+  /// Write a single precomputed tag byte. Tag must be < 128.
+  static inline void ESPHOME_ALWAYS_INLINE write_raw_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint8_t b) {
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+    *pos++ = b;
+  }
+  /// Reserve one byte for later backpatch (e.g., sub-message length).
+  /// Advances pos past the reserved byte without writing a value.
+  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+    pos++;
+  }
+  /// Write raw bytes to the buffer (no tag, no length prefix).
+  static inline void ESPHOME_ALWAYS_INLINE encode_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                      const void *data, size_t len) {
+    PROTO_ENCODE_CHECK_BOUNDS(pos, len);
+    std::memcpy(pos, data, len);
+    pos += len;
+  }
+  /// Encode tag + 1-byte length + raw string data. For strings with max_data_length < 128.
+  /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
+  static inline void encode_short_string_force(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag,
+                                               const StringRef &ref) {
+#ifdef ESPHOME_DEBUG_API
+    assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
+#endif
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 2 + ref.size());
+    pos[0] = tag;
+    pos[1] = static_cast<uint8_t>(ref.size());
+    std::memcpy(pos + 2, ref.c_str(), ref.size());
+    pos += 2 + ref.size();
+  }
+  /// Write a precomputed tag byte + 32-bit value in one operation.
+  static inline void ESPHOME_ALWAYS_INLINE write_tag_and_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                 uint8_t tag, uint32_t value) {
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 5);
+    pos[0] = tag;
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    std::memcpy(pos + 1, &value, 4);
+#else
+    pos[1] = static_cast<uint8_t>(value & 0xFF);
+    pos[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
+    pos[3] = static_cast<uint8_t>((value >> 16) & 0xFF);
+    pos[4] = static_cast<uint8_t>((value >> 24) & 0xFF);
+#endif
+    pos += 5;
+  }
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const char *string, size_t len, bool force = false) {
+    if (len == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
+    if (len < VARINT_MAX_1_BYTE) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
+      *pos++ = static_cast<uint8_t>(len);
+    } else {
+      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      PROTO_ENCODE_CHECK_BOUNDS(pos, len);
+    }
+    std::memcpy(pos, string, len);
+    pos += len;
+  }
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const std::string &value, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size(), force);
+  }
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const StringRef &ref, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size(), force);
+  }
+  static inline void encode_bytes(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                  const uint8_t *data, size_t len, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len, force);
+  }
+  static inline void encode_uint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   uint32_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  static inline void encode_uint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   uint64_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  static inline void encode_bool(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, bool value,
+                                 bool force = false) {
+    if (!value && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
+    *pos++ = value ? 0x01 : 0x00;
+  }
+  static inline void encode_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                    uint32_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 4);
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    std::memcpy(pos, &value, 4);
+    pos += 4;
+#else
+    *pos++ = (value >> 0) & 0xFF;
+    *pos++ = (value >> 8) & 0xFF;
+    *pos++ = (value >> 16) & 0xFF;
+    *pos++ = (value >> 24) & 0xFF;
+#endif
+  }
+  // NOTE: Wire type 1 (64-bit fixed: double, fixed64, sfixed64) is intentionally
+  // not supported to reduce overhead on embedded systems. All ESPHome devices are
+  // 32-bit microcontrollers where 64-bit operations are expensive. If 64-bit support
+  // is needed in the future, the necessary encoding/decoding functions must be added.
+  static inline void encode_float(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, float value,
+                                  bool force = false) {
+    uint32_t raw = float_to_raw(value);
+    if (raw == 0 && !force)
+      return;
+    encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, raw);
+  }
+  static inline void encode_int32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int32_t value,
+                                  bool force = false) {
+    if (value < 0) {
+      // negative int32 is always 10 byte long
+      encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+      return;
+    }
+    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value), force);
+  }
+  static inline void encode_int64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int64_t value,
+                                  bool force = false) {
+    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+  }
+  static inline void encode_sint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   int32_t value, bool force = false) {
+    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value), force);
+  }
+  static inline void encode_sint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   int64_t value, bool force = false) {
+    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value), force);
+  }
+  /// Sub-message encoding: sync pos to buffer, delegate, get pos from return value.
+  template<typename T>
+  static inline void encode_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, ProtoWriteBuffer &buffer,
+                                        uint32_t field_id, const T &value) {
+    buffer.set_pos(pos);
+    buffer.encode_sub_message(field_id, value);
+    pos = buffer.get_pos();
+  }
+  template<typename T>
+  static inline void encode_optional_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                 ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
+    buffer.set_pos(pos);
+    buffer.encode_optional_sub_message(field_id, value);
+    pos = buffer.get_pos();
+  }
+};
+
 #ifdef HAS_PROTO_MESSAGE_DUMP
 /**
  * Fixed-size buffer for message dumps - avoids heap allocation.
@@ -470,7 +620,7 @@ class ProtoMessage {
   // All call sites use templates to preserve the concrete type, so virtual
   // dispatch is not needed. This eliminates per-message vtable entries for
   // encode/calculate_size, saving ~1.3 KB of flash across all message types.
-  void encode(ProtoWriteBuffer &buffer) const {}
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { return buffer.get_pos(); }
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   virtual const char *dump_to(DumpBuffer &out) const = 0;
@@ -512,12 +662,24 @@ class ProtoDecodableMessage : public ProtoMessage {
 
 class ProtoSize {
  public:
-  // Varint encoding thresholds: values below each threshold fit in N bytes
-  static constexpr uint32_t VARINT_THRESHOLD_1_BYTE = 1 << 7;   // 128
-  static constexpr uint32_t VARINT_THRESHOLD_2_BYTE = 1 << 14;  // 16384
+  // Varint encoding thresholds — use namespace-level constants for 1/2 byte,
+  // class-level for 3/4 byte (only used within ProtoSize).
+  static constexpr uint32_t VARINT_THRESHOLD_1_BYTE = VARINT_MAX_1_BYTE;
+  static constexpr uint32_t VARINT_THRESHOLD_2_BYTE = VARINT_MAX_2_BYTE;
   static constexpr uint32_t VARINT_THRESHOLD_3_BYTE = 1 << 21;  // 2097152
   static constexpr uint32_t VARINT_THRESHOLD_4_BYTE = 1 << 28;  // 268435456
 
+  // Varint encoded length for a 16-bit value (1, 2, or 3 bytes).
+  // Fully inline — no slow path call for values >= 128.
+  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint16(uint16_t value) {
+    return value < VARINT_THRESHOLD_1_BYTE ? 1 : (value < VARINT_THRESHOLD_2_BYTE ? 2 : 3);
+  }
+
+  // Varint encoded length for an 8-bit value (1 or 2 bytes).
+  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint8(uint8_t value) {
+    return value < VARINT_THRESHOLD_1_BYTE ? 1 : 2;
+  }
+
   /**
    * @brief Calculates the size in bytes needed to encode a uint32_t value as a varint
    *
@@ -531,6 +693,17 @@ class ProtoSize {
       return varint_wide(value);
     return varint_slow(value);
   }
+  /// Size of a varint expected to be 1-2 bytes (e.g. zigzag RSSI, small lengths).
+  /// Inlines both checks; falls back to slow path for 3+ bytes.
+  static constexpr inline uint32_t ESPHOME_ALWAYS_INLINE varint_short(uint32_t value) {
+    if (value < VARINT_THRESHOLD_1_BYTE) [[likely]]
+      return 1;
+    if (value < VARINT_THRESHOLD_2_BYTE) [[likely]]
+      return 2;
+    if (__builtin_is_constant_evaluated())
+      return varint_wide(value);
+    return varint_slow(value);
+  }
 
  private:
   // Slow path for varint >= 128, outlined to keep fast path small
@@ -635,8 +808,8 @@ class ProtoSize {
   }
   static constexpr uint32_t calc_bool(uint32_t field_id_size, bool value) { return value ? field_id_size + 1 : 0; }
   static constexpr uint32_t calc_bool_force(uint32_t field_id_size) { return field_id_size + 1; }
-  static constexpr uint32_t calc_float(uint32_t field_id_size, float value) {
-    return value != 0.0f ? field_id_size + 4 : 0;
+  static uint32_t calc_float(uint32_t field_id_size, float value) {
+    return float_to_raw(value) != 0 ? field_id_size + 4 : 0;
   }
   static constexpr uint32_t calc_fixed32(uint32_t field_id_size, uint32_t value) {
     return value ? field_id_size + 4 : 0;
@@ -645,10 +818,10 @@ class ProtoSize {
     return value ? field_id_size + 4 : 0;
   }
   static constexpr uint32_t calc_sint32(uint32_t field_id_size, int32_t value) {
-    return value ? field_id_size + varint(encode_zigzag32(value)) : 0;
+    return value ? field_id_size + varint_short(encode_zigzag32(value)) : 0;
   }
   static constexpr inline uint32_t ESPHOME_ALWAYS_INLINE calc_sint32_force(uint32_t field_id_size, int32_t value) {
-    return field_id_size + varint(encode_zigzag32(value));
+    return field_id_size + varint_short(encode_zigzag32(value));
   }
   static constexpr uint32_t calc_int64(uint32_t field_id_size, int64_t value) {
     return value ? field_id_size + varint(value) : 0;
@@ -691,28 +864,9 @@ class ProtoSize {
 
 // Implementation of methods that depend on ProtoSize being fully defined
 
-// Implementation of encode_packed_sint32 - must be after ProtoSize is defined
-inline void ProtoWriteBuffer::encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values) {
-  if (values.empty())
-    return;
-
-  // Calculate packed size
-  size_t packed_size = 0;
-  for (int value : values) {
-    packed_size += ProtoSize::varint(encode_zigzag32(value));
-  }
-
-  // Write tag (LENGTH_DELIMITED) + length + all zigzag-encoded values
-  this->encode_field_raw(field_id, WIRE_TYPE_LENGTH_DELIMITED);
-  this->encode_varint_raw(packed_size);
-  for (int value : values) {
-    this->encode_varint_raw(encode_zigzag32(value));
-  }
-}
-
 // Encode thunk — converts void* back to concrete type for direct encode() call
-template<typename T> void proto_encode_msg(const void *msg, ProtoWriteBuffer &buf) {
-  static_cast<const T *>(msg)->encode(buf);
+template<typename T> uint8_t *proto_encode_msg(const void *msg, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
+  return static_cast<const T *>(msg)->encode(buf PROTO_ENCODE_DEBUG_ARG);
 }
 
 // Thin template wrapper; delegates to non-template core in proto.cpp.

esphome/components/api/user_services.h

@@ -275,7 +275,7 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
 
  protected:
   APIServer *parent_;
-  TemplatableValue<bool, Ts...> success_{true};
+  TemplatableFn<bool, Ts...> success_{[](Ts...) -> bool { return true; }};
   TemplatableValue<std::string, Ts...> error_message_{""};
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
   std::function<void(Ts..., JsonObject)> json_builder_;

esphome/components/as3935/sensor.py

@@ -6,6 +6,7 @@ from esphome.const import (
     CONF_LIGHTNING_ENERGY,
     ICON_FLASH,
     ICON_SIGNAL_DISTANCE_VARIANT,
+    STATE_CLASS_MEASUREMENT,
     UNIT_KILOMETER,
 )
 
@@ -20,13 +21,14 @@ CONFIG_SCHEMA = cv.Schema(
             unit_of_measurement=UNIT_KILOMETER,
             icon=ICON_SIGNAL_DISTANCE_VARIANT,
             accuracy_decimals=1,
+            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional(CONF_LIGHTNING_ENERGY): sensor.sensor_schema(
             icon=ICON_FLASH,
             accuracy_decimals=1,
         ),
     }
-).extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):

esphome/components/at581x/__init__.py

@@ -169,53 +169,43 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
 
     # Radar configuration
     if frontend_reset := config.get(CONF_HW_FRONTEND_RESET):
-        template_ = await cg.templatable(frontend_reset, args, int)
+        template_ = await cg.templatable(frontend_reset, args, cg.int8)
         cg.add(var.set_hw_frontend_reset(template_))
 
     if freq := config.get(CONF_FREQUENCY):
-        template_ = await cg.templatable(freq, args, float)
-        template_ = int(template_ / 1000000)
+        if not cg.is_template(freq):
+            freq = int(freq / 1000000)
+        template_ = await cg.templatable(freq, args, cg.int_)
         cg.add(var.set_frequency(template_))
 
-    if sens_dist := config.get(CONF_SENSING_DISTANCE):
-        template_ = await cg.templatable(sens_dist, args, int)
+    if (sens_dist := config.get(CONF_SENSING_DISTANCE)) is not None:
+        template_ = await cg.templatable(sens_dist, args, cg.int_)
         cg.add(var.set_sensing_distance(template_))
 
     if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
-        template_ = await cg.templatable(selfcheck, args, float)
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds
-        template_ = int(template_)
+        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, float)
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds
-        template_ = int(template_)
+        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, float)
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds
-        template_ = int(template_)
+        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, float)
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds
-        template_ = int(template_)
+        template_ = await cg.templatable(trig_keep, args, cg.int32)
         cg.add(var.set_trigger_keep(template_))
 
-    if stage_gain := config.get(CONF_STAGE_GAIN):
-        template_ = await cg.templatable(stage_gain, args, int)
+    if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
+        template_ = await cg.templatable(stage_gain, args, cg.int_)
         cg.add(var.set_stage_gain(template_))
 
     if power := config.get(CONF_POWER_CONSUMPTION):
-        template_ = await cg.templatable(power, args, float)
-        template_ = int(template_ * 1000000)
+        if not cg.is_template(power):
+            power = int(power * 1000000)
+        template_ = await cg.templatable(power, args, cg.int_)
         cg.add(var.set_power_consumption(template_))
 
     return var

esphome/components/atm90e26/sensor.py

@@ -14,6 +14,7 @@ from esphome.const import (
     CONF_VOLTAGE,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_REACTIVE_POWER,
@@ -103,6 +104,7 @@ CONFIG_SCHEMA = (
                 unit_of_measurement=UNIT_HERTZ,
                 icon=ICON_CURRENT_AC,
                 accuracy_decimals=1,
+                device_class=DEVICE_CLASS_FREQUENCY,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Required(CONF_LINE_FREQUENCY): cv.enum(LINE_FREQS, upper=True),

esphome/components/atm90e32/sensor.py

@@ -20,6 +20,7 @@ from esphome.const import (
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_REACTIVE_POWER,
@@ -131,7 +132,6 @@ ATM90E32_PHASE_SCHEMA = cv.Schema(
         cv.Optional(CONF_PHASE_ANGLE): sensor.sensor_schema(
             unit_of_measurement=UNIT_DEGREES,
             accuracy_decimals=2,
-            device_class=DEVICE_CLASS_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional(CONF_HARMONIC_POWER): sensor.sensor_schema(
@@ -166,6 +166,7 @@ CONFIG_SCHEMA = (
                 unit_of_measurement=UNIT_HERTZ,
                 icon=ICON_CURRENT_AC,
                 accuracy_decimals=1,
+                device_class=DEVICE_CLASS_FREQUENCY,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_CHIP_TEMPERATURE): sensor.sensor_schema(

esphome/components/audio/__init__.py

@@ -210,6 +210,7 @@ async def to_code(config):
     data = _get_data()
     if data.flac_support:
         cg.add_define("USE_AUDIO_FLAC_SUPPORT")
+        add_idf_component(name="esphome/micro-flac", ref="0.1.1")
     if data.mp3_support:
         cg.add_define("USE_AUDIO_MP3_SUPPORT")
     if data.opus_support:

esphome/components/audio/audio_decoder.cpp

@@ -84,13 +84,10 @@ esp_err_t AudioDecoder::start(AudioFileType audio_file_type) {
   switch (this->audio_file_type_) {
 #ifdef USE_AUDIO_FLAC_SUPPORT
     case AudioFileType::FLAC:
-      this->flac_decoder_ = make_unique<esp_audio_libs::flac::FLACDecoder>();
-      // CRC check slows down decoding by 15-20% on an ESP32-S3. FLAC sources in ESPHome are either from an http source
-      // or built into the firmware, so the data integrity is already verified by the time it gets to the decoder,
-      // making the CRC check unnecessary.
-      this->flac_decoder_->set_crc_check_enabled(false);
+      this->flac_decoder_ = make_unique<micro_flac::FLACDecoder>();
       this->free_buffer_required_ =
           this->output_transfer_buffer_->capacity();  // Adjusted and reallocated after reading the header
+      this->decoder_buffers_internally_ = true;
       break;
 #endif
 #ifdef USE_AUDIO_MP3_SUPPORT
@@ -268,59 +265,45 @@ AudioDecoderState AudioDecoder::decode(bool stop_gracefully) {
 
 #ifdef USE_AUDIO_FLAC_SUPPORT
 FileDecoderState AudioDecoder::decode_flac_() {
-  if (!this->audio_stream_info_.has_value()) {
-    // Header hasn't been read
-    auto result = this->flac_decoder_->read_header(this->input_buffer_->data(), this->input_buffer_->available());
+  size_t bytes_consumed, samples_decoded;
 
-    if (result > esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
-      // Serrious error reading FLAC header, there is no recovery
-      return FileDecoderState::FAILED;
+  micro_flac::FLACDecoderResult result = this->flac_decoder_->decode(
+      this->input_buffer_->data(), this->input_buffer_->available(), this->output_transfer_buffer_->get_buffer_end(),
+      this->output_transfer_buffer_->free(), bytes_consumed, samples_decoded);
+
+  if (result == micro_flac::FLAC_DECODER_SUCCESS) {
+    if (samples_decoded > 0 && this->audio_stream_info_.has_value()) {
+      this->output_transfer_buffer_->increase_buffer_length(
+          this->audio_stream_info_.value().samples_to_bytes(samples_decoded));
     }
-
-    size_t bytes_consumed = this->flac_decoder_->get_bytes_index();
     this->input_buffer_->consume(bytes_consumed);
+  } else if (result == micro_flac::FLAC_DECODER_HEADER_READY) {
+    // Header just parsed, stream info now available
+    const auto &info = this->flac_decoder_->get_stream_info();
+    this->audio_stream_info_ = audio::AudioStreamInfo(info.bits_per_sample(), info.num_channels(), info.sample_rate());
 
-    if (result == esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
-      return FileDecoderState::MORE_TO_PROCESS;
-    }
-
-    // Reallocate the output transfer buffer to the smallest necessary size
-    this->free_buffer_required_ = flac_decoder_->get_output_buffer_size_bytes();
+    // Reallocate the output transfer buffer to the required size
+    this->free_buffer_required_ = this->flac_decoder_->get_output_buffer_size_samples() * info.bytes_per_sample();
     if (!this->output_transfer_buffer_->reallocate(this->free_buffer_required_)) {
-      // Couldn't reallocate output buffer
       return FileDecoderState::FAILED;
     }
-
-    this->audio_stream_info_ =
-        audio::AudioStreamInfo(this->flac_decoder_->get_sample_depth(), this->flac_decoder_->get_num_channels(),
-                               this->flac_decoder_->get_sample_rate());
-
-    return FileDecoderState::MORE_TO_PROCESS;
-  }
-
-  uint32_t output_samples = 0;
-  auto result = this->flac_decoder_->decode_frame(this->input_buffer_->data(), this->input_buffer_->available(),
-                                                  this->output_transfer_buffer_->get_buffer_end(), &output_samples);
-
-  if (result == esp_audio_libs::flac::FLAC_DECODER_ERROR_OUT_OF_DATA) {
-    // Not an issue, just needs more data that we'll get next time.
-    return FileDecoderState::POTENTIALLY_FAILED;
-  }
-
-  size_t bytes_consumed = this->flac_decoder_->get_bytes_index();
-  this->input_buffer_->consume(bytes_consumed);
-
-  if (result > esp_audio_libs::flac::FLAC_DECODER_ERROR_OUT_OF_DATA) {
-    // Corrupted frame, don't retry with current buffer content, wait for new sync
-    return FileDecoderState::POTENTIALLY_FAILED;
-  }
-
-  // We have successfully decoded some input data and have new output data
-  this->output_transfer_buffer_->increase_buffer_length(
-      this->audio_stream_info_.value().samples_to_bytes(output_samples));
-
-  if (result == esp_audio_libs::flac::FLAC_DECODER_NO_MORE_FRAMES) {
+    this->input_buffer_->consume(bytes_consumed);
+  } else if (result == micro_flac::FLAC_DECODER_END_OF_STREAM) {
+    this->input_buffer_->consume(bytes_consumed);
     return FileDecoderState::END_OF_FILE;
+  } else if (result == micro_flac::FLAC_DECODER_NEED_MORE_DATA) {
+    this->input_buffer_->consume(bytes_consumed);
+    return FileDecoderState::MORE_TO_PROCESS;
+  } else if (result == micro_flac::FLAC_DECODER_ERROR_OUTPUT_TOO_SMALL) {
+    // Reallocate to decode the frame on the next call
+    const auto &info = this->flac_decoder_->get_stream_info();
+    this->free_buffer_required_ = this->flac_decoder_->get_output_buffer_size_samples() * info.bytes_per_sample();
+    if (!this->output_transfer_buffer_->reallocate(this->free_buffer_required_)) {
+      return FileDecoderState::FAILED;
+    }
+  } else {
+    ESP_LOGE(TAG, "FLAC decoder failed: %d", static_cast<int>(result));
+    return FileDecoderState::POTENTIALLY_FAILED;
   }
 
   return FileDecoderState::MORE_TO_PROCESS;

esphome/components/audio/audio_decoder.h

@@ -16,14 +16,16 @@
 #include "esp_err.h"
 
 // esp-audio-libs
-#ifdef USE_AUDIO_FLAC_SUPPORT
-#include <flac_decoder.h>
-#endif
 #ifdef USE_AUDIO_MP3_SUPPORT
 #include <mp3_decoder.h>
 #endif
 #include <wav_decoder.h>
 
+// micro-flac
+#ifdef USE_AUDIO_FLAC_SUPPORT
+#include <micro_flac/flac_decoder.h>
+#endif
+
 // micro-opus
 #ifdef USE_AUDIO_OPUS_SUPPORT
 #include <micro_opus/ogg_opus_decoder.h>
@@ -119,7 +121,7 @@ class AudioDecoder {
   std::unique_ptr<esp_audio_libs::wav_decoder::WAVDecoder> wav_decoder_;
 #ifdef USE_AUDIO_FLAC_SUPPORT
   FileDecoderState decode_flac_();
-  std::unique_ptr<esp_audio_libs::flac::FLACDecoder> flac_decoder_;
+  std::unique_ptr<micro_flac::FLACDecoder> flac_decoder_;
 #endif
 #ifdef USE_AUDIO_MP3_SUPPORT
   FileDecoderState decode_mp3_();

esphome/components/audio_adc/__init__.py

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

esphome/components/audio_dac/__init__.py

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

esphome/components/bedjet/climate/bedjet_climate.cpp

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

esphome/components/bedjet/climate/bedjet_climate.h

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

esphome/components/bh1900nux/sensor.py

@@ -12,7 +12,7 @@ CODEOWNERS = ["@B48D81EFCC"]
 
 sensor_ns = cg.esphome_ns.namespace("bh1900nux")
 BH1900NUXSensor = sensor_ns.class_(
-    "BH1900NUXSensor", cg.PollingComponent, i2c.I2CDevice
+    "BH1900NUXSensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice
 )
 
 CONFIG_SCHEMA = (

esphome/components/binary_sensor/__init__.py

@@ -390,7 +390,7 @@ def validate_multi_click_timing(value):
         new_state = v_.get(CONF_STATE, not state)
         if new_state == state:
             raise cv.Invalid(
-                f"Timings must have alternating state. Indices {i} and {i + 1} have the same state {state}"
+                f"Timings must have alternating state. Indices {i - 1} and {i} have the same state {state}"
             )
         if max_length is not None and max_length < min_length:
             raise cv.Invalid(
@@ -531,16 +531,31 @@ def binary_sensor_schema(
     return _BINARY_SENSOR_SCHEMA.extend(schema)
 
 
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_PRESS,
+        "add_on_state_callback",
+        forwarder=automation.TriggerOnTrueForwarder,
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_RELEASE,
+        "add_on_state_callback",
+        forwarder=automation.TriggerOnFalseForwarder,
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_STATE, "add_on_state_callback", [(bool, "x")]
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_STATE_CHANGE,
+        "add_full_state_callback",
+        [(cg.optional.template(bool), "x_previous"), (cg.optional.template(bool), "x")],
+    ),
+)
+
+
 @coroutine_with_priority(CoroPriority.AUTOMATION)
 async def _build_binary_sensor_automations(var, config):
-    for conf_key, forwarder in (
-        (CONF_ON_PRESS, automation.TriggerOnTrueForwarder),
-        (CONF_ON_RELEASE, automation.TriggerOnFalseForwarder),
-    ):
-        for conf in config.get(conf_key, []):
-            await automation.build_callback_automation(
-                var, "add_on_state_callback", [], conf, forwarder=forwarder
-            )
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
     for conf in config.get(CONF_ON_CLICK, []):
         trigger = cg.new_Pvariable(
@@ -572,22 +587,6 @@ async def _build_binary_sensor_automations(var, config):
         await cg.register_component(trigger, conf)
         await automation.build_automation(trigger, [], conf)
 
-    for conf in config.get(CONF_ON_STATE, []):
-        await automation.build_callback_automation(
-            var, "add_on_state_callback", [(bool, "x")], conf
-        )
-
-    for conf in config.get(CONF_ON_STATE_CHANGE, []):
-        await automation.build_callback_automation(
-            var,
-            "add_full_state_callback",
-            [
-                (cg.optional.template(bool), "x_previous"),
-                (cg.optional.template(bool), "x"),
-            ],
-            conf,
-        )
-
 
 @setup_entity("binary_sensor")
 async def setup_binary_sensor_core_(var, config):

esphome/components/binary_sensor/filter.h

@@ -36,7 +36,7 @@ class TimeoutFilter : public Filter, public Component {
   template<typename T> void set_timeout_value(T timeout) { this->timeout_delay_ = timeout; }
 
  protected:
-  TemplatableValue<uint32_t> timeout_delay_{};
+  TemplatableFn<uint32_t> timeout_delay_{};
 };
 
 class DelayedOnOffFilter final : public Filter, public Component {
@@ -49,8 +49,8 @@ class DelayedOnOffFilter final : public Filter, public Component {
   template<typename T> void set_off_delay(T delay) { this->off_delay_ = delay; }
 
  protected:
-  TemplatableValue<uint32_t> on_delay_{};
-  TemplatableValue<uint32_t> off_delay_{};
+  TemplatableFn<uint32_t> on_delay_{};
+  TemplatableFn<uint32_t> off_delay_{};
 };
 
 class DelayedOnFilter : public Filter, public Component {
@@ -62,7 +62,7 @@ class DelayedOnFilter : public Filter, public Component {
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
 
  protected:
-  TemplatableValue<uint32_t> delay_{};
+  TemplatableFn<uint32_t> delay_{};
 };
 
 class DelayedOffFilter : public Filter, public Component {
@@ -74,7 +74,7 @@ class DelayedOffFilter : public Filter, public Component {
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
 
  protected:
-  TemplatableValue<uint32_t> delay_{};
+  TemplatableFn<uint32_t> delay_{};
 };
 
 class InvertFilter : public Filter {
@@ -155,7 +155,7 @@ class SettleFilter : public Filter, public Component {
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
 
  protected:
-  TemplatableValue<uint32_t> delay_{};
+  TemplatableFn<uint32_t> delay_{};
   bool steady_{true};
 };
 

esphome/components/bl0940/number/__init__.py

@@ -89,6 +89,6 @@ async def to_code(config):
             )
             await cg.register_component(var, conf)
 
-            if restore_value := config.get(CONF_RESTORE_VALUE):
+            if restore_value := conf.get(CONF_RESTORE_VALUE):
                 cg.add(var.set_restore_value(restore_value))
             cg.add(getattr(bl0940, setter_method)(var))

esphome/components/bl0940/sensor.py

@@ -126,7 +126,7 @@ def set_reference_values(config):
         config.setdefault(CONF_POWER_REFERENCE, DEFAULT_BL0940_LEGACY_PREF)
         config.setdefault(CONF_ENERGY_REFERENCE, DEFAULT_BL0940_LEGACY_EREF)
     else:
-        vref = config.get(CONF_VOLTAGE_REFERENCE, DEFAULT_BL0940_VREF)
+        vref = config.get(CONF_REFERENCE_VOLTAGE, DEFAULT_BL0940_VREF)
         r_one = config.get(CONF_RESISTOR_ONE, DEFAULT_BL0940_R1)
         r_two = config.get(CONF_RESISTOR_TWO, DEFAULT_BL0940_R2)
         r_shunt = config.get(CONF_RESISTOR_SHUNT, DEFAULT_BL0940_RL)

esphome/components/ble_client/text_sensor/__init__.py

@@ -88,7 +88,7 @@ async def to_code(config):
         )
         cg.add(var.set_char_uuid128(uuid128))
 
-    if descriptor_uuid := config:
+    if descriptor_uuid := config.get(CONF_DESCRIPTOR_UUID):
         if len(descriptor_uuid) == len(esp32_ble_tracker.bt_uuid16_format):
             cg.add(var.set_descr_uuid16(esp32_ble_tracker.as_hex(descriptor_uuid)))
         elif len(descriptor_uuid) == len(esp32_ble_tracker.bt_uuid32_format):

esphome/components/bmp581_spi/sensor.py

@@ -31,7 +31,7 @@ BMP581SPIComponent = bmp581_ns.class_(
 def check_spi_mode(config):
     spi_mode = config.get(CONF_SPI_MODE)
     if spi_mode not in VALID_SPI_MODES:
-        raise cv.Invalid("BMP581 only supports SPI mode 3")
+        raise cv.Invalid("BMP581 only supports SPI mode 0 or mode 3")
     return config
 
 

esphome/components/bp1658cj/output.py

@@ -14,7 +14,7 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
     {
         cv.GenerateID(CONF_BP1658CJ_ID): cv.use_id(BP1658CJ),
         cv.Required(CONF_ID): cv.declare_id(Channel),
-        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=65535),
+        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=4),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/button/__init__.py

@@ -79,12 +79,14 @@ def button_schema(
     return _BUTTON_SCHEMA.extend(schema)
 
 
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(CONF_ON_PRESS, "add_on_press_callback"),
+)
+
+
 @setup_entity("button")
 async def setup_button_core_(var, config):
-    for conf in config.get(CONF_ON_PRESS, []):
-        await automation.build_callback_automation(
-            var, "add_on_press_callback", [], conf
-        )
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
     setup_device_class(config)
 

esphome/components/button/button.cpp

@@ -16,7 +16,7 @@ void log_button(const char *tag, const char *prefix, const char *type, Button *o
 }
 
 void Button::press() {
-  ESP_LOGD(TAG, "'%s' Pressed.", this->get_name().c_str());
+  ESP_LOGV(TAG, "'%s' Pressed.", this->get_name().c_str());
   this->press_action();
   this->press_callback_.call();
 }

esphome/components/canbus/__init__.py

@@ -161,7 +161,7 @@ async def canbus_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_CANBUS_ID])
 
-    if can_id := config.get(CONF_CAN_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/__init__.py

@@ -423,11 +423,10 @@ def _register_setter_actions():
             var = cg.new_Pvariable(action_id, template_arg)
             await cg.register_parented(var, config[CONF_ID])
             data = config[CONF_VALUE]
-            if cg.is_template(data):
-                templ_ = await cg.templatable(data, args, _type)
-                cg.add(getattr(var, _setter)(templ_))
-            else:
-                cg.add(getattr(var, _setter)(_map[data] if _map else data))
+            if _map and not cg.is_template(data):
+                data = _map[data]
+            templ_ = await cg.templatable(data, args, _type)
+            cg.add(getattr(var, _setter)(templ_))
             return var
 
         automation.register_action(

esphome/components/cc1101/cc1101.cpp

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

esphome/components/cd74hc4067/__init__.py

@@ -9,9 +9,7 @@ MULTI_CONF = True
 
 cd74hc4067_ns = cg.esphome_ns.namespace("cd74hc4067")
 
-CD74HC4067Component = cd74hc4067_ns.class_(
-    "CD74HC4067Component", cg.Component, cg.PollingComponent
-)
+CD74HC4067Component = cd74hc4067_ns.class_("CD74HC4067Component", cg.Component)
 
 CONF_PIN_S0 = "pin_s0"
 CONF_PIN_S1 = "pin_s1"

esphome/components/climate/__init__.py

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

esphome/components/climate/climate.cpp

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

esphome/components/climate/climate.h

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

esphome/components/climate/climate_traits.cpp

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

esphome/components/climate/climate_traits.h

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

esphome/components/const/__init__.py

@@ -32,4 +32,6 @@ ICON_CURRENT_DC = "mdi:current-dc"
 ICON_SOLAR_PANEL = "mdi:solar-panel"
 ICON_SOLAR_POWER = "mdi:solar-power"
 
+KEY_METADATA = "metadata"
+
 UNIT_AMPERE_HOUR = "Ah"

esphome/components/copy/fan/copy_fan.cpp

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

esphome/components/cover/__init__.py

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

esphome/components/cs5460a/sensor.py

@@ -12,6 +12,7 @@ from esphome.const import (
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
     UNIT_AMPERE,
     UNIT_VOLT,
     UNIT_WATT,
@@ -82,16 +83,19 @@ CONFIG_SCHEMA = cv.All(
                 unit_of_measurement=UNIT_VOLT,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_CURRENT): sensor.sensor_schema(
                 unit_of_measurement=UNIT_AMPERE,
                 accuracy_decimals=1,
                 device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_POWER): sensor.sensor_schema(
                 unit_of_measurement=UNIT_WATT,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
         }
     )

esphome/components/cse7766/sensor.py

@@ -32,52 +32,56 @@ DEPENDENCIES = ["uart"]
 cse7766_ns = cg.esphome_ns.namespace("cse7766")
 CSE7766Component = cse7766_ns.class_("CSE7766Component", cg.Component, uart.UARTDevice)
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(CSE7766Component),
-        cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_CURRENT): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_POWER): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_ENERGY): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional(CONF_APPARENT_POWER): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT_AMPS,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT_AMPS_REACTIVE,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-    }
-).extend(uart.UART_DEVICE_SCHEMA)
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CSE7766Component),
+            cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT): sensor.sensor_schema(
+                unit_of_measurement=UNIT_AMPERE,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_POWER): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ENERGY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT_HOURS,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_ENERGY,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
+            ),
+            cv.Optional(CONF_APPARENT_POWER): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT_AMPS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_APPARENT_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT_AMPS_REACTIVE,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_REACTIVE_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_POWER_FACTOR,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(uart.UART_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     "cse7766", baud_rate=4800, parity="EVEN", require_rx=True
 )

esphome/components/cst226/binary_sensor/__init__.py

@@ -15,10 +15,14 @@ CST226Button = cst226_ns.class_(
     cg.Parented.template(CST226Touchscreen),
 )
 
-CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(CST226Button).extend(
-    {
-        cv.GenerateID(CONF_CST226_ID): cv.use_id(CST226Touchscreen),
-    }
+CONFIG_SCHEMA = (
+    binary_sensor.binary_sensor_schema(CST226Button)
+    .extend(
+        {
+            cv.GenerateID(CONF_CST226_ID): cv.use_id(CST226Touchscreen),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
 

esphome/components/datetime/__init__.py

@@ -204,7 +204,8 @@ async def datetime_date_set_to_code(config, action_id, template_arg, args):
             ("month", date_config[CONF_MONTH]),
             ("year", date_config[CONF_YEAR]),
         )
-        cg.add(action_var.set_date(date_struct))
+        template_ = await cg.templatable(date_struct, args, cg.ESPTime)
+        cg.add(action_var.set_date(template_))
     return action_var
 
 
@@ -236,7 +237,8 @@ async def datetime_time_set_to_code(config, action_id, template_arg, args):
             ("minute", time_config[CONF_MINUTE]),
             ("hour", time_config[CONF_HOUR]),
         )
-        cg.add(action_var.set_time(time_struct))
+        template_ = await cg.templatable(time_struct, args, cg.ESPTime)
+        cg.add(action_var.set_time(template_))
     return action_var
 
 
@@ -271,5 +273,6 @@ async def datetime_datetime_set_to_code(config, action_id, template_arg, args):
             ("month", datetime_config[CONF_MONTH]),
             ("year", datetime_config[CONF_YEAR]),
         )
-        cg.add(action_var.set_datetime(datetime_struct))
+        template_ = await cg.templatable(datetime_struct, args, cg.ESPTime)
+        cg.add(action_var.set_datetime(template_))
     return action_var

esphome/components/debug/sensor.py

@@ -8,12 +8,14 @@ from esphome.const import (
     CONF_FRAGMENTATION,
     CONF_FREE,
     CONF_LOOP_TIME,
+    DEVICE_CLASS_FREQUENCY,
     ENTITY_CATEGORY_DIAGNOSTIC,
     ICON_COUNTER,
     ICON_TIMER,
     PLATFORM_BK72XX,
     PLATFORM_LN882X,
     PLATFORM_RTL87XX,
+    STATE_CLASS_MEASUREMENT,
     UNIT_BYTES,
     UNIT_HERTZ,
     UNIT_MILLISECOND,
@@ -38,12 +40,14 @@ CONFIG_SCHEMA = {
         icon=ICON_COUNTER,
         accuracy_decimals=0,
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        state_class=STATE_CLASS_MEASUREMENT,
     ),
     cv.Optional(CONF_BLOCK): sensor.sensor_schema(
         unit_of_measurement=UNIT_BYTES,
         icon=ICON_COUNTER,
         accuracy_decimals=0,
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        state_class=STATE_CLASS_MEASUREMENT,
     ),
     cv.Optional(CONF_FRAGMENTATION): cv.All(
         cv.Any(
@@ -59,6 +63,7 @@ CONFIG_SCHEMA = {
             icon=ICON_COUNTER,
             accuracy_decimals=1,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            state_class=STATE_CLASS_MEASUREMENT,
         ),
     ),
     cv.Optional(CONF_MIN_FREE): cv.All(
@@ -72,6 +77,7 @@ CONFIG_SCHEMA = {
             icon=ICON_COUNTER,
             accuracy_decimals=0,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            state_class=STATE_CLASS_MEASUREMENT,
         ),
     ),
     cv.Optional(CONF_LOOP_TIME): sensor.sensor_schema(
@@ -79,6 +85,7 @@ CONFIG_SCHEMA = {
         icon=ICON_TIMER,
         accuracy_decimals=0,
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        state_class=STATE_CLASS_MEASUREMENT,
     ),
     cv.Optional(CONF_PSRAM): cv.All(
         cv.only_on_esp32,
@@ -88,6 +95,7 @@ CONFIG_SCHEMA = {
             icon=ICON_COUNTER,
             accuracy_decimals=0,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            state_class=STATE_CLASS_MEASUREMENT,
         ),
     ),
     cv.Optional(CONF_CPU_FREQUENCY): cv.All(
@@ -95,7 +103,9 @@ CONFIG_SCHEMA = {
             unit_of_measurement=UNIT_HERTZ,
             icon="mdi:speedometer",
             accuracy_decimals=0,
+            device_class=DEVICE_CLASS_FREQUENCY,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            state_class=STATE_CLASS_MEASUREMENT,
         ),
     ),
 }

esphome/components/deep_sleep/__init__.py

@@ -266,8 +266,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_WAKEUP_PIN): validate_wakeup_pin,
             cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(
                 cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
-                cv.enum(WAKEUP_PIN_MODES),
-                upper=True,
+                cv.enum(WAKEUP_PIN_MODES, upper=True),
             ),
             cv.Optional(CONF_ESP32_EXT1_WAKEUP): cv.All(
                 cv.only_on_esp32,

esphome/components/demo/demo_climate.h

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

esphome/components/dfplayer/__init__.py

@@ -64,15 +64,19 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 )
 
 
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_FINISHED_PLAYBACK, "add_on_finished_playback_callback"
+    ),
+)
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
 
-    for conf in config.get(CONF_ON_FINISHED_PLAYBACK, []):
-        await automation.build_callback_automation(
-            var, "add_on_finished_playback_callback", [], conf
-        )
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
 @automation.register_action(
@@ -122,7 +126,7 @@ async def dfplayer_previous_to_code(config, action_id, template_arg, args):
 async def dfplayer_play_mp3_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_FILE], args, float)
+    template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
     cg.add(var.set_file(template_))
     return var
 
@@ -143,10 +147,10 @@ async def dfplayer_play_mp3_to_code(config, action_id, template_arg, args):
 async def dfplayer_play_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_FILE], args, float)
+    template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
     cg.add(var.set_file(template_))
     if CONF_LOOP in config:
-        template_ = await cg.templatable(config[CONF_LOOP], args, float)
+        template_ = await cg.templatable(config[CONF_LOOP], args, cg.bool_)
         cg.add(var.set_loop(template_))
     return var
 
@@ -167,13 +171,13 @@ async def dfplayer_play_to_code(config, action_id, template_arg, args):
 async def dfplayer_play_folder_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_FOLDER], args, float)
+    template_ = await cg.templatable(config[CONF_FOLDER], args, cg.uint16)
     cg.add(var.set_folder(template_))
     if CONF_FILE in config:
-        template_ = await cg.templatable(config[CONF_FILE], args, float)
+        template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
         cg.add(var.set_file(template_))
     if CONF_LOOP in config:
-        template_ = await cg.templatable(config[CONF_LOOP], args, float)
+        template_ = await cg.templatable(config[CONF_LOOP], args, cg.bool_)
         cg.add(var.set_loop(template_))
     return var
 
@@ -213,7 +217,7 @@ async def dfplayer_set_device_to_code(config, action_id, template_arg, args):
 async def dfplayer_set_volume_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_VOLUME], args, float)
+    template_ = await cg.templatable(config[CONF_VOLUME], args, cg.uint8)
     cg.add(var.set_volume(template_))
     return var
 

esphome/components/dfrobot_sen0395/__init__.py

@@ -97,7 +97,7 @@ def range_segment_list(input):
         )
 
     largest_distance = -1
-    for distance in input:
+    for i, distance in enumerate(input):
         if isinstance(distance, cv.Lambda):
             continue
         m = cv.distance(distance)
@@ -112,7 +112,7 @@ def range_segment_list(input):
             )
         largest_distance = m
         # Replace distance object with meters float
-        input[input.index(distance)] = m
+        input[i] = m
 
     return input
 
@@ -159,31 +159,31 @@ async def dfrobot_sen0395_settings_to_code(config, action_id, template_arg, args
     await cg.register_parented(var, config[CONF_ID])
 
     if factory_reset_config := config.get(CONF_FACTORY_RESET):
-        template_ = await cg.templatable(factory_reset_config, args, int)
+        template_ = await cg.templatable(factory_reset_config, args, cg.int8)
         cg.add(var.set_factory_reset(template_))
 
     if CONF_DETECTION_SEGMENTS in config:
         segments = config[CONF_DETECTION_SEGMENTS]
 
         if len(segments) >= 2:
-            template_ = await cg.templatable(segments[0], args, float)
+            template_ = await cg.templatable(segments[0], args, cg.float_)
             cg.add(var.set_det_min1(template_))
-            template_ = await cg.templatable(segments[1], args, float)
+            template_ = await cg.templatable(segments[1], args, cg.float_)
             cg.add(var.set_det_max1(template_))
         if len(segments) >= 4:
-            template_ = await cg.templatable(segments[2], args, float)
+            template_ = await cg.templatable(segments[2], args, cg.float_)
             cg.add(var.set_det_min2(template_))
-            template_ = await cg.templatable(segments[3], args, float)
+            template_ = await cg.templatable(segments[3], args, cg.float_)
             cg.add(var.set_det_max2(template_))
         if len(segments) >= 6:
-            template_ = await cg.templatable(segments[4], args, float)
+            template_ = await cg.templatable(segments[4], args, cg.float_)
             cg.add(var.set_det_min3(template_))
-            template_ = await cg.templatable(segments[5], args, float)
+            template_ = await cg.templatable(segments[5], args, cg.float_)
             cg.add(var.set_det_max3(template_))
         if len(segments) >= 8:
-            template_ = await cg.templatable(segments[6], args, float)
+            template_ = await cg.templatable(segments[6], args, cg.float_)
             cg.add(var.set_det_min4(template_))
-            template_ = await cg.templatable(segments[7], args, float)
+            template_ = await cg.templatable(segments[7], args, cg.float_)
             cg.add(var.set_det_max4(template_))
     if CONF_OUTPUT_LATENCY in config:
         template_ = await cg.templatable(
@@ -200,7 +200,7 @@ async def dfrobot_sen0395_settings_to_code(config, action_id, template_arg, args
             template_ = template_.total_milliseconds / 1000
         cg.add(var.set_delay_after_disappear(template_))
     if CONF_SENSITIVITY in config:
-        template_ = await cg.templatable(config[CONF_SENSITIVITY], args, int)
+        template_ = await cg.templatable(config[CONF_SENSITIVITY], args, cg.int8)
         cg.add(var.set_sensitivity(template_))
 
     return var

esphome/components/display/__init__.py

@@ -1,6 +1,9 @@
+from dataclasses import dataclass
+
 from esphome import automation, core
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
+from esphome.components.const import KEY_METADATA
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_AUTO_CLEAR_ENABLED,
@@ -16,7 +19,9 @@ from esphome.const import (
     SCHEDULER_DONT_RUN,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.cpp_generator import MockObj
 
+DOMAIN = "display"
 IS_PLATFORM_COMPONENT = True
 
 display_ns = cg.esphome_ns.namespace("display")
@@ -112,8 +117,9 @@ FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
 
 
 async def setup_display_core_(var, config):
-    if CONF_ROTATION in config:
-        cg.add(var.set_rotation(DISPLAY_ROTATIONS[config[CONF_ROTATION]]))
+    if rotation := config.get(CONF_ROTATION, 0):
+        # Default initialised value for rotation is 0
+        cg.add(var.set_rotation(DISPLAY_ROTATIONS[rotation]))
 
     if (auto_clear := config.get(CONF_AUTO_CLEAR_ENABLED)) is not None:
         # Default to true if pages or lambda is specified. Ideally this would be done during validation, but
@@ -146,6 +152,39 @@ async def setup_display_core_(var, config):
         cg.add(var.show_test_card())
 
 
+# Storage of display metadata in a central location, accessible via the id
+
+
+@dataclass(frozen=True)
+class DisplayMetaData:
+    width: int = 0
+    height: int = 0
+    has_writer: bool = False
+    has_hardware_rotation: bool = False
+
+
+def get_all_display_metadata() -> dict[str, DisplayMetaData]:
+    """Get all display metadata."""
+    return CORE.data.setdefault(DOMAIN, {}).setdefault(KEY_METADATA, {})
+
+
+def get_display_metadata(display_id: str) -> DisplayMetaData | None:
+    """Get display metadata by ID for use by other components."""
+    return get_all_display_metadata().get(display_id, DisplayMetaData())
+
+
+def add_metadata(
+    id: str | MockObj,
+    width: int,
+    height: int,
+    has_writer: bool,
+    has_hardware_rotation: bool = False,
+):
+    get_all_display_metadata()[str(id)] = DisplayMetaData(
+        width, height, has_writer, has_hardware_rotation
+    )
+
+
 async def register_display(var, config):
     await cg.register_component(var, config)
     await setup_display_core_(var, config)
@@ -168,7 +207,8 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
         cg.add(var.set_page(template_))
     else:
         paren = await cg.get_variable(config[CONF_ID])
-        cg.add(var.set_page(paren))
+        template_ = await cg.templatable(paren, args, DisplayPagePtr)
+        cg.add(var.set_page(template_))
     return var
 
 

esphome/components/display/display.h

@@ -704,7 +704,7 @@ class Display : public PollingComponent {
   void add_on_page_change_trigger(DisplayOnPageChangeTrigger *t) { this->on_page_change_triggers_.push_back(t); }
 
   /// Internal method to set the display rotation with.
-  void set_rotation(DisplayRotation rotation);
+  virtual void set_rotation(DisplayRotation rotation);
 
   // Internal method to set display auto clearing.
   void set_auto_clear(bool auto_clear_enabled) { this->auto_clear_enabled_ = auto_clear_enabled; }

esphome/components/display_menu_base/__init__.py

@@ -119,7 +119,7 @@ DisplayMenuOnPrevTrigger = display_menu_base_ns.class_(
 
 
 def validate_format(format):
-    if re.search(r"^%([+-])*(\d+)*(\.\d+)*[fg]$", format) is None:
+    if re.search(r"^%[+-]*(\d+)?(\.\d+)?[fg]$", format) is None:
         raise cv.Invalid(
             f"{CONF_FORMAT}: has to specify a printf-like format string specifying exactly one f or g type conversion, '{format}' provided"
         )

esphome/components/dsmr/__init__.py

@@ -4,7 +4,7 @@ from esphome.components import uart
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_UART_ID
 
-CODEOWNERS = ["@glmnet", "@zuidwijk", "@PolarGoose"]
+CODEOWNERS = ["@glmnet", "@PolarGoose"]
 
 MULTI_CONF = True
 
@@ -16,6 +16,7 @@ CONF_DECRYPTION_KEY = "decryption_key"
 CONF_DSMR_ID = "dsmr_id"
 CONF_GAS_MBUS_ID = "gas_mbus_id"
 CONF_WATER_MBUS_ID = "water_mbus_id"
+CONF_THERMAL_MBUS_ID = "thermal_mbus_id"
 CONF_MAX_TELEGRAM_LENGTH = "max_telegram_length"
 CONF_REQUEST_INTERVAL = "request_interval"
 CONF_REQUEST_PIN = "request_pin"
@@ -35,7 +36,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_CRC_CHECK, default=True): cv.boolean,
             cv.Optional(CONF_GAS_MBUS_ID, default=1): cv.int_,
             cv.Optional(CONF_WATER_MBUS_ID, default=2): cv.int_,
-            cv.Optional(CONF_MAX_TELEGRAM_LENGTH, default=1500): cv.int_,
+            cv.Optional(CONF_THERMAL_MBUS_ID, default=3): cv.int_,
+            cv.Optional(CONF_MAX_TELEGRAM_LENGTH, default=1500): cv.int_range(min=1),
             cv.Optional(CONF_REQUEST_PIN): pins.gpio_output_pin_schema,
             cv.Optional(
                 CONF_REQUEST_INTERVAL, default="0ms"
@@ -44,7 +46,9 @@ CONFIG_SCHEMA = cv.All(
                 CONF_RECEIVE_TIMEOUT, default="200ms"
             ): cv.positive_time_period_milliseconds,
         }
-    ).extend(uart.UART_DEVICE_SCHEMA),
+    )
+    .extend(uart.UART_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
 )
 
 
@@ -64,6 +68,7 @@ async def to_code(config):
 
     cg.add_build_flag("-DDSMR_GAS_MBUS_ID=" + str(config[CONF_GAS_MBUS_ID]))
     cg.add_build_flag("-DDSMR_WATER_MBUS_ID=" + str(config[CONF_WATER_MBUS_ID]))
+    cg.add_build_flag("-DDSMR_THERMAL_MBUS_ID=" + str(config[CONF_THERMAL_MBUS_ID]))
 
     # DSMR Parser
     cg.add_library("esphome/dsmr_parser", "1.1.0")

esphome/components/dsmr/sensor.py

@@ -122,42 +122,52 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional("total_imported_energy"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_delivered_tariff1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_delivered_tariff2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_delivered_tariff3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_delivered_tariff4"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("total_exported_energy"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_returned_tariff1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_returned_tariff2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_returned_tariff3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("reactive_energy_returned_tariff4"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
         cv.Optional("power_delivered"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOWATT,

esphome/components/e131/__init__.py

@@ -29,7 +29,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(): cv.declare_id(E131Component),
         cv.Optional(CONF_METHOD, default="MULTICAST"): cv.one_of(*METHODS, upper=True),
     }
-)
+).extend(cv.COMPONENT_SCHEMA)
 
 
 async def to_code(config):

esphome/components/emontx/__init__.py

@@ -0,0 +1,152 @@
+from dataclasses import dataclass, field
+
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import uart
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_COMMAND,
+    CONF_ID,
+    CONF_ON_DATA,
+    CONF_RX_BUFFER_SIZE,
+    CONF_UART_ID,
+)
+from esphome.core import CORE
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+AUTO_LOAD = ["json"]
+CODEOWNERS = ["@FredM67", "@TrystanLea", "@glynhudson"]
+DEPENDENCIES = ["uart"]
+
+emontx_ns = cg.esphome_ns.namespace("emontx")
+EmonTx = emontx_ns.class_("EmonTx", cg.Component, uart.UARTDevice)
+
+# Action to send command to emonTx
+EmonTxSendCommandAction = emontx_ns.class_("EmonTxSendCommandAction", automation.Action)
+
+CONF_EMONTX_ID = "emontx_id"
+CONF_TAG_NAME = "tag_name"
+CONF_ON_JSON = "on_json"
+
+DOMAIN = "emontx"
+
+MINIMUM_RX_BUFFER_SIZE = 2048
+
+
+@dataclass
+class EmonTxData:
+    sensor_counts: dict[str, int] = field(default_factory=dict)
+
+
+def _get_data() -> EmonTxData:
+    if DOMAIN not in CORE.data:
+        CORE.data[DOMAIN] = EmonTxData()
+    return CORE.data[DOMAIN]
+
+
+# Main configuration schema
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(EmonTx),
+            cv.Optional(CONF_ON_JSON): automation.validate_automation({}),
+            cv.Optional(CONF_ON_DATA): automation.validate_automation({}),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(uart.UART_DEVICE_SCHEMA)
+)
+
+
+def final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+
+    # Count sensors registered to this hub (IDs are resolved at final_validate stage)
+    hub_id = str(config[CONF_ID])
+    sensor_count = sum(
+        1
+        for s in full_config.get("sensor", [])
+        if s.get("platform") == "emontx" and str(s.get(CONF_EMONTX_ID)) == hub_id
+    )
+    _get_data().sensor_counts[hub_id] = sensor_count
+
+    # Ensure UART RX buffer size is large enough to handle data bursts from firmware
+    for uart_conf in full_config["uart"]:
+        if uart_conf[CONF_ID] == config[CONF_UART_ID]:
+            current_buffer_size = uart_conf[CONF_RX_BUFFER_SIZE]
+            if current_buffer_size < MINIMUM_RX_BUFFER_SIZE:
+                raise cv.Invalid(
+                    f"Component emontx requires UART '{config[CONF_UART_ID]}' to have "
+                    f"rx_buffer_size of at least {MINIMUM_RX_BUFFER_SIZE} bytes "
+                    f"(currently set to {current_buffer_size} bytes). "
+                    f"Please add 'rx_buffer_size: {MINIMUM_RX_BUFFER_SIZE}' to your uart configuration.",
+                    path=[CONF_UART_ID],
+                )
+            break
+
+    # Validate UART settings
+    schema = uart.final_validate_device_schema(
+        "emontx",
+        baud_rate=115200,
+        require_tx=False,
+        require_rx=True,
+        data_bits=8,
+        parity="NONE",
+        stop_bits=1,
+    )
+    return schema(config)
+
+
+FINAL_VALIDATE_SCHEMA = final_validate
+
+
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_JSON,
+        "add_on_json_callback",
+        [(cg.JsonObject, "json"), (cg.std_string, "raw_json")],
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_DATA, "add_on_data_callback", [(cg.std_string, "data")]
+    ),
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+
+    # Initialize sensor storage with count from final_validate
+    sensor_count = _get_data().sensor_counts.get(str(config[CONF_ID]), 0)
+    if sensor_count > 0:
+        cg.add(var.init_sensors(sensor_count))
+
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
+
+
+# Action: emontx.send_command
+
+EMONTX_SEND_COMMAND_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.use_id(EmonTx),
+        cv.Required(CONF_COMMAND): cv.templatable(cv.string),
+    }
+)
+
+
+@automation.register_action(
+    "emontx.send_command",
+    EmonTxSendCommandAction,
+    EMONTX_SEND_COMMAND_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def emontx_send_command_action_to_code(
+    config: ConfigType, action_id, template_arg, args
+) -> None:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.std_string)
+    cg.add(var.set_command(template_))
+    return var

esphome/components/emontx/emontx.cpp

@@ -0,0 +1,116 @@
+#include "emontx.h"
+#include "esphome/core/log.h"
+#include "esphome/components/json/json_util.h"
+
+namespace esphome::emontx {
+
+static const char *const TAG = "emontx";
+
+void EmonTx::setup() { this->buffer_pos_ = 0; }
+
+/**
+ * @brief Implements the main loop for parsing data from the serial port.
+ *
+ * @details Continuously processes incoming UART data line-by-line:
+ * 1. Fire on_data callbacks for all received lines
+ * 2. If line starts with '{', parse as JSON and update sensors/callbacks
+ */
+void EmonTx::loop() {
+  // Read all available data to prevent UART buffer overflow
+  while (this->available() > 0) {
+    uint8_t received = this->read();
+
+    if (received == '\r') {
+      continue;  // Ignore CR
+    } else if (received == '\n') {
+      // End of line - process the buffer
+      if (this->buffer_pos_ > 0) {
+        // Null-terminate for safe logging and c_str() use
+        size_t len = this->buffer_pos_;
+        this->buffer_[len] = '\0';
+        this->buffer_pos_ = 0;
+
+        StringRef line(this->buffer_.data(), len);
+        ESP_LOGD(TAG, "Received line: %s", line.c_str());
+
+        // Fire data callbacks for all received lines
+        this->data_callbacks_.call(line);
+
+        // Check if this line is JSON (starts with '{')
+        if (this->buffer_[0] == '{') {
+          ESP_LOGV(TAG, "Line is JSON, parsing...");
+          this->parse_json_(this->buffer_.data(), len);
+        }
+      }
+    } else if (this->buffer_pos_ >= MAX_LINE_LENGTH) {
+      ESP_LOGW(TAG, "Buffer overflow (>%zu bytes), discarding buffer", MAX_LINE_LENGTH);
+      this->buffer_pos_ = 0;
+    } else {
+      this->buffer_[this->buffer_pos_++] = static_cast<char>(received);
+    }
+  }
+}
+
+void EmonTx::parse_json_(const char *data, size_t len) {
+  bool success = json::parse_json(reinterpret_cast<const uint8_t *>(data), len, [this, data, len](JsonObject root) {
+#ifdef USE_SENSOR
+    for (auto &sensor_pair : this->sensors_) {
+      auto val = root[sensor_pair.first];
+      if (val.is<JsonVariant>()) {
+        float value = val;
+        ESP_LOGV(TAG, "Updating sensor '%s' with value: %.2f", sensor_pair.first, value);
+        sensor_pair.second->publish_state(value);
+      }
+    }
+#endif
+
+    this->json_callbacks_.call(root, StringRef(data, len));
+    return true;
+  });
+
+  if (!success) {
+    ESP_LOGW(TAG, "Failed to parse JSON");
+  }
+}
+
+/**
+ * @brief Logs the EmonTx component configuration details.
+ */
+void EmonTx::dump_config() {
+  ESP_LOGCONFIG(TAG, "EmonTx:");
+
+#ifdef USE_SENSOR
+  ESP_LOGCONFIG(TAG, "  Registered sensors: %zu", this->sensors_.size());
+  for (const auto &sensor_pair : this->sensors_) {
+    ESP_LOGCONFIG(TAG, "    Sensor: %s", sensor_pair.first);
+  }
+#else
+  ESP_LOGCONFIG(TAG, "  Sensor support: DISABLED");
+#endif
+}
+
+/**
+ * @brief Sends a command string to the emonTx device via UART.
+ *
+ * @param command The command string to send (LF will be appended automatically).
+ */
+void EmonTx::send_command(const std::string &command) {
+  ESP_LOGD(TAG, "Sending command to emonTx: %s", command.c_str());
+  this->write_str(command.c_str());
+  this->write_byte('\n');
+}
+
+#ifdef USE_SENSOR
+/**
+ * @brief Registers a sensor to receive updates for a specific JSON tag.
+ *
+ * @param tag_name The JSON key to monitor for this sensor (must be a string literal).
+ * @param sensor Pointer to the sensor that will receive value updates.
+ */
+void EmonTx::register_sensor(const char *tag_name, sensor::Sensor *sensor) {
+  ESP_LOGCONFIG(TAG, "Registering sensor for tag: %s", tag_name);
+  this->sensors_.emplace_back(tag_name, sensor);
+}
+#endif
+
+}  // namespace esphome::emontx

esphome/components/emontx/emontx.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/string_ref.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/components/json/json_util.h"
+
+#include <array>
+
+#ifdef USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+
+namespace esphome::emontx {
+
+/// Maximum line length in bytes (plus one byte reserved for null terminator)
+static constexpr size_t MAX_LINE_LENGTH = 1024;
+
+/**
+ * @class EmonTx
+ * @brief Main class for the EmonTx component.
+ *
+ * The EmonTx processes incoming data frames via UART,
+ * extracts tags and values, and publishes them to registered sensors.
+ */
+class EmonTx : public Component, public uart::UARTDevice {
+ public:
+  EmonTx() = default;
+
+  void loop() override;
+  void setup() override;
+  void dump_config() override;
+
+  template<typename F> void add_on_json_callback(F &&callback) { this->json_callbacks_.add(std::forward<F>(callback)); }
+
+  template<typename F> void add_on_data_callback(F &&callback) { this->data_callbacks_.add(std::forward<F>(callback)); }
+
+  // Send command to emonTx via UART
+  void send_command(const std::string &command);
+
+#ifdef USE_SENSOR
+  void init_sensors(size_t count) { this->sensors_.init(count); }
+  void register_sensor(const char *tag_name, sensor::Sensor *sensor);
+#endif
+
+ protected:
+  void parse_json_(const char *data, size_t len);
+
+#ifdef USE_SENSOR
+  FixedVector<std::pair<const char *, sensor::Sensor *>> sensors_{};
+#endif
+  LazyCallbackManager<void(JsonObject, StringRef)> json_callbacks_;
+  LazyCallbackManager<void(StringRef)> data_callbacks_;
+  uint16_t buffer_pos_{0};
+  std::array<char, MAX_LINE_LENGTH + 1> buffer_{};
+};
+
+// Action to send command to emonTx
+template<typename... Ts> class EmonTxSendCommandAction : public Action<Ts...>, public Parented<EmonTx> {
+ public:
+  TEMPLATABLE_VALUE(std::string, command)
+
+  void play(const Ts &...x) override { this->parent_->send_command(this->command_.value(x...)); }
+};
+
+}  // namespace esphome::emontx

esphome/components/emontx/sensor/__init__.py

@@ -0,0 +1,133 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ACCURACY_DECIMALS,
+    CONF_DEVICE_CLASS,
+    CONF_ID,
+    CONF_STATE_CLASS,
+    CONF_UNIT_OF_MEASUREMENT,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
+    UNIT_AMPERE,
+    UNIT_CELSIUS,
+    UNIT_EMPTY,
+    UNIT_PULSES,
+    UNIT_VOLT,
+    UNIT_WATT,
+    UNIT_WATT_HOURS,
+)
+from esphome.types import ConfigType
+
+from .. import CONF_EMONTX_ID, CONF_TAG_NAME, EmonTx, emontx_ns
+
+EmonTxSensor = emontx_ns.class_("EmonTxSensor", sensor.Sensor, cg.Component)
+
+# Define sensor type configurations by prefix
+SENSOR_CONFIGS = {
+    "P": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_WATT,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_POWER,
+        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS: 0,
+    },
+    "E": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_WATT_HOURS,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_ENERGY,
+        CONF_STATE_CLASS: STATE_CLASS_TOTAL_INCREASING,
+        CONF_ACCURACY_DECIMALS: 0,
+    },
+    "V": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_VOLT,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_VOLTAGE,
+        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS: 2,
+    },
+    "I": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_AMPERE,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_CURRENT,
+        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS: 2,
+    },
+    "T": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_CELSIUS,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_TEMPERATURE,
+        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS: 2,
+    },
+}
+
+# Pattern-based configurations
+PATTERN_CONFIGS = {
+    "PULSE": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_PULSES,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_ENERGY,
+        CONF_ACCURACY_DECIMALS: 0,
+    },
+    "PF": {
+        CONF_UNIT_OF_MEASUREMENT: UNIT_EMPTY,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_POWER_FACTOR,
+        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS: 2,
+    },
+}
+
+# Create a base schema that's flexible for any tag
+BASE_SCHEMA = sensor.sensor_schema(
+    EmonTxSensor,
+    state_class=STATE_CLASS_MEASUREMENT,
+    accuracy_decimals=0,
+).extend(
+    {
+        cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
+        cv.Required(CONF_TAG_NAME): cv.string,
+    }
+)
+
+
+def apply_tag_defaults(config: ConfigType) -> ConfigType:
+    """Apply defaults based on tag prefix if applicable, but don't restrict any tags."""
+    tag = config[CONF_TAG_NAME]
+
+    # Skip if tag is too short
+    if len(tag) < 2:
+        return config
+
+    # Check if this tag starts with a known prefix
+    tag_upper = tag.upper()
+
+    for pattern, pattern_config in PATTERN_CONFIGS.items():
+        if tag_upper.startswith(pattern):
+            # Apply pattern defaults if not overridden by user
+            for key, value in pattern_config.items():
+                if key not in config:
+                    config[key] = value
+            return config
+
+    # Only apply defaults for known prefixes with numeric indices
+    prefix = tag_upper[0]
+    if prefix in SENSOR_CONFIGS and len(tag) > 1 and tag[1:].isdigit():
+        # Apply defaults for known tag types, but only if not overridden by user
+        defaults = SENSOR_CONFIGS[prefix]
+        for key, value in defaults.items():
+            if key not in config:
+                config[key] = value
+
+    return config
+
+
+CONFIG_SCHEMA = cv.All(BASE_SCHEMA, apply_tag_defaults)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    hub = await cg.get_variable(config[CONF_EMONTX_ID])
+    cg.add(hub.register_sensor(config[CONF_TAG_NAME], var))

esphome/components/emontx/sensor/emontx_sensor.cpp

@@ -0,0 +1,10 @@
+#include "emontx_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::emontx {
+
+static const char *const TAG = "emontx_sensor";
+
+void EmonTxSensor::dump_config() { LOG_SENSOR("  ", "EmonTx Sensor", this); }
+
+}  // namespace esphome::emontx

esphome/components/emontx/sensor/emontx_sensor.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
+
+namespace esphome::emontx {
+
+class EmonTxSensor : public sensor::Sensor, public Component {
+ public:
+  void dump_config() override;
+};
+
+}  // namespace esphome::emontx

esphome/components/ens160_base/__init__.py

@@ -24,7 +24,6 @@ CODEOWNERS = ["@vincentscode", "@latonita"]
 ens160_ns = cg.esphome_ns.namespace("ens160_base")
 
 CONF_AQI = "aqi"
-UNIT_INDEX = "index"
 
 CONFIG_SCHEMA_BASE = cv.Schema(
     {

esphome/components/epaper_spi/display.py

@@ -175,9 +175,7 @@ async def to_code(config):
         *model.get_constructor_args(config),
     )
 
-    # Rotation is handled by setting the transform
-    display_config = {k: v for k, v in config.items() if k != CONF_ROTATION}
-    await display.register_display(var, display_config)
+    await display.register_display(var, config)
     await spi.register_spi_device(var, config, write_only=True)
 
     dc = await cg.gpio_pin_expression(config[CONF_DC_PIN])
@@ -201,16 +199,6 @@ async def to_code(config):
         transform[CONF_SWAP_XY] = False
     else:
         transform = {x: model.get_default(x, False) for x in TRANSFORM_OPTIONS}
-    rotation = config[CONF_ROTATION]
-    if rotation == 180:
-        transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
-        transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
-    elif rotation == 90:
-        transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-        transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
-    elif rotation == 270:
-        transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-        transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
     transform_str = "|".join(
         {
             str(getattr(Transform, x.upper()))

esphome/components/epaper_spi/epaper_spi.cpp

@@ -97,6 +97,23 @@ bool EPaperBase::reset() {
   return true;
 }
 
+void EPaperBase::update_effective_transform_() {
+  switch (this->rotation_) {
+    case DISPLAY_ROTATION_90_DEGREES:
+      this->effective_transform_ = this->transform_ ^ (SWAP_XY | MIRROR_X);
+      break;
+    case DISPLAY_ROTATION_180_DEGREES:
+      this->effective_transform_ = this->transform_ ^ (MIRROR_Y | MIRROR_X);
+      break;
+    case DISPLAY_ROTATION_270_DEGREES:
+      this->effective_transform_ = this->transform_ ^ (SWAP_XY | MIRROR_Y);
+      break;
+    default:
+      this->effective_transform_ = this->transform_;
+      break;
+  }
+}
+
 void EPaperBase::update() {
   if (this->state_ != EPaperState::IDLE) {
     ESP_LOGE(TAG, "Display already in state %s", epaper_state_to_string_());
@@ -280,11 +297,11 @@ bool EPaperBase::initialise(bool partial) {
 bool EPaperBase::rotate_coordinates_(int &x, int &y) {
   if (!this->get_clipping().inside(x, y))
     return false;
-  if (this->transform_ & SWAP_XY)
+  if (this->effective_transform_ & SWAP_XY)
     std::swap(x, y);
-  if (this->transform_ & MIRROR_X)
+  if (this->effective_transform_ & MIRROR_X)
     x = this->width_ - x - 1;
-  if (this->transform_ & MIRROR_Y)
+  if (this->effective_transform_ & MIRROR_Y)
     y = this->height_ - y - 1;
   if (x >= this->width_ || y >= this->height_ || x < 0 || y < 0)
     return false;

esphome/components/epaper_spi/epaper_spi.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/display/display.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/split_buffer/split_buffer.h"
 #include "esphome/core/component.h"
@@ -51,7 +51,14 @@ class EPaperBase : public Display,
   void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
   void set_busy_pin(GPIOPin *busy) { this->busy_pin_ = busy; }
   void set_reset_duration(uint32_t reset_duration) { this->reset_duration_ = reset_duration; }
-  void set_transform(uint8_t transform) { this->transform_ = transform; }
+  void set_transform(uint8_t transform) {
+    this->transform_ = transform;
+    this->update_effective_transform_();
+  }
+  void set_rotation(DisplayRotation rotation) override {
+    Display::set_rotation(rotation);
+    this->update_effective_transform_();
+  }
   void set_full_update_every(uint8_t full_update_every) { this->full_update_every_ = full_update_every; }
   void dump_config() override;
 
@@ -103,12 +110,14 @@ class EPaperBase : public Display,
     this->fill(COLOR_ON);
   }
 
+  int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
+  int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
+  void draw_pixel_at(int x, int y, Color color) override;
+
  protected:
   int get_height_internal() override { return this->height_; };
   int get_width_internal() override { return this->width_; };
-  int get_width() override { return this->transform_ & SWAP_XY ? this->height_ : this->width_; }
-  int get_height() override { return this->transform_ & SWAP_XY ? this->width_ : this->height_; }
-  void draw_pixel_at(int x, int y, Color color) override;
+  bool is_using_partial_update_() const { return this->full_update_every_ > 1; }
   void process_state_();
 
   const char *epaper_state_to_string_();
@@ -119,6 +128,7 @@ class EPaperBase : public Display,
   void send_init_sequence_(const uint8_t *sequence, size_t length);
   void wait_for_idle_(bool should_wait);
   bool init_buffer_(size_t buffer_length);
+  void update_effective_transform_();
   bool rotate_coordinates_(int &x, int &y);
 
   /**
@@ -171,6 +181,7 @@ class EPaperBase : public Display,
   uint32_t delay_until_{};  // timestamp until which to delay processing
   uint16_t next_delay_{};   // milliseconds to delay before next state
   uint8_t transform_{};
+  uint8_t effective_transform_{};
   uint8_t update_count_{};
   // these values represent the bounds of the updated buffer. Note that x_high and y_high
   // point to the pixel past the last one updated, i.e. may range up to width/height.