[const] Move CONF_AUDIO_DAC (#13614)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.clang-tidy.hash

@@ -1 +1 @@
-d565b0589e35e692b5f2fc0c14723a99595b4828a3a3ef96c442e86a23176c00
+cf3d341206b4184ec8b7fe85141aef4fe4696aa720c3f8a06d4e57930574bdab

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

@@ -0,0 +1,38 @@
+// Constants and markers for PR auto-labeling
+module.exports = {
+  BOT_COMMENT_MARKER: '<!-- auto-label-pr-bot -->',
+  CODEOWNERS_MARKER: '<!-- codeowners-request -->',
+  TOO_BIG_MARKER: '<!-- too-big-request -->',
+  DEPRECATED_COMPONENT_MARKER: '<!-- deprecated-component-request -->',
+
+  MANAGED_LABELS: [
+    'new-component',
+    'new-platform',
+    'new-target-platform',
+    'merging-to-release',
+    'merging-to-beta',
+    'chained-pr',
+    'core',
+    'small-pr',
+    'dashboard',
+    'github-actions',
+    'by-code-owner',
+    'has-tests',
+    'needs-tests',
+    'needs-docs',
+    'needs-codeowners',
+    'too-big',
+    'labeller-recheck',
+    'bugfix',
+    'new-feature',
+    'breaking-change',
+    'developer-breaking-change',
+    'code-quality',
+    'deprecated-component'
+  ],
+
+  DOCS_PR_PATTERNS: [
+    /https:\/\/github\.com\/esphome\/esphome-docs\/pull\/\d+/,
+    /esphome\/esphome-docs#\d+/
+  ]
+};

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

@@ -0,0 +1,373 @@
+const fs = require('fs');
+const { DOCS_PR_PATTERNS } = require('./constants');
+
+// Strategy: Merge branch detection
+async function detectMergeBranch(context) {
+  const labels = new Set();
+  const baseRef = context.payload.pull_request.base.ref;
+
+  if (baseRef === 'release') {
+    labels.add('merging-to-release');
+  } else if (baseRef === 'beta') {
+    labels.add('merging-to-beta');
+  } else if (baseRef !== 'dev') {
+    labels.add('chained-pr');
+  }
+
+  return labels;
+}
+
+// Strategy: Component and platform labeling
+async function detectComponentPlatforms(changedFiles, apiData) {
+  const labels = new Set();
+  const componentRegex = /^esphome\/components\/([^\/]+)\//;
+  const targetPlatformRegex = new RegExp(`^esphome\/components\/(${apiData.targetPlatforms.join('|')})/`);
+
+  for (const file of changedFiles) {
+    const componentMatch = file.match(componentRegex);
+    if (componentMatch) {
+      labels.add(`component: ${componentMatch[1]}`);
+    }
+
+    const platformMatch = file.match(targetPlatformRegex);
+    if (platformMatch) {
+      labels.add(`platform: ${platformMatch[1]}`);
+    }
+  }
+
+  return labels;
+}
+
+// Strategy: New component detection
+async function detectNewComponents(prFiles) {
+  const labels = new Set();
+  const addedFiles = prFiles.filter(file => file.status === 'added').map(file => file.filename);
+
+  for (const file of addedFiles) {
+    const componentMatch = file.match(/^esphome\/components\/([^\/]+)\/__init__\.py$/);
+    if (componentMatch) {
+      try {
+        const content = fs.readFileSync(file, 'utf8');
+        if (content.includes('IS_TARGET_PLATFORM = True')) {
+          labels.add('new-target-platform');
+        }
+      } catch (error) {
+        console.log(`Failed to read content of ${file}:`, error.message);
+      }
+      labels.add('new-component');
+    }
+  }
+
+  return labels;
+}
+
+// Strategy: New platform detection
+async function detectNewPlatforms(prFiles, apiData) {
+  const labels = new Set();
+  const addedFiles = prFiles.filter(file => file.status === 'added').map(file => file.filename);
+
+  for (const file of addedFiles) {
+    const platformFileMatch = file.match(/^esphome\/components\/([^\/]+)\/([^\/]+)\.py$/);
+    if (platformFileMatch) {
+      const [, component, platform] = platformFileMatch;
+      if (apiData.platformComponents.includes(platform)) {
+        labels.add('new-platform');
+      }
+    }
+
+    const platformDirMatch = file.match(/^esphome\/components\/([^\/]+)\/([^\/]+)\/__init__\.py$/);
+    if (platformDirMatch) {
+      const [, component, platform] = platformDirMatch;
+      if (apiData.platformComponents.includes(platform)) {
+        labels.add('new-platform');
+      }
+    }
+  }
+
+  return labels;
+}
+
+// Strategy: Core files detection
+async function detectCoreChanges(changedFiles) {
+  const labels = new Set();
+  const coreFiles = changedFiles.filter(file =>
+    file.startsWith('esphome/core/') ||
+    (file.startsWith('esphome/') && file.split('/').length === 2)
+  );
+
+  if (coreFiles.length > 0) {
+    labels.add('core');
+  }
+
+  return labels;
+}
+
+// Strategy: PR size detection
+async function detectPRSize(prFiles, totalAdditions, totalDeletions, totalChanges, isMegaPR, SMALL_PR_THRESHOLD, TOO_BIG_THRESHOLD) {
+  const labels = new Set();
+
+  if (totalChanges <= SMALL_PR_THRESHOLD) {
+    labels.add('small-pr');
+    return labels;
+  }
+
+  const testAdditions = prFiles
+    .filter(file => file.filename.startsWith('tests/'))
+    .reduce((sum, file) => sum + (file.additions || 0), 0);
+  const testDeletions = prFiles
+    .filter(file => file.filename.startsWith('tests/'))
+    .reduce((sum, file) => sum + (file.deletions || 0), 0);
+
+  const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
+
+  // Don't add too-big if mega-pr label is already present
+  if (nonTestChanges > TOO_BIG_THRESHOLD && !isMegaPR) {
+    labels.add('too-big');
+  }
+
+  return labels;
+}
+
+// Strategy: Dashboard changes
+async function detectDashboardChanges(changedFiles) {
+  const labels = new Set();
+  const dashboardFiles = changedFiles.filter(file =>
+    file.startsWith('esphome/dashboard/') ||
+    file.startsWith('esphome/components/dashboard_import/')
+  );
+
+  if (dashboardFiles.length > 0) {
+    labels.add('dashboard');
+  }
+
+  return labels;
+}
+
+// Strategy: GitHub Actions changes
+async function detectGitHubActionsChanges(changedFiles) {
+  const labels = new Set();
+  const githubActionsFiles = changedFiles.filter(file =>
+    file.startsWith('.github/workflows/')
+  );
+
+  if (githubActionsFiles.length > 0) {
+    labels.add('github-actions');
+  }
+
+  return labels;
+}
+
+// Strategy: Code owner detection
+async function detectCodeOwner(github, context, changedFiles) {
+  const labels = new Set();
+  const { owner, repo } = context.repo;
+
+  try {
+    const { data: codeownersFile } = await github.rest.repos.getContent({
+      owner,
+      repo,
+      path: 'CODEOWNERS',
+    });
+
+    const codeownersContent = Buffer.from(codeownersFile.content, 'base64').toString('utf8');
+    const prAuthor = context.payload.pull_request.user.login;
+
+    const codeownersLines = codeownersContent.split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'));
+
+    const codeownersRegexes = codeownersLines.map(line => {
+      const parts = line.split(/\s+/);
+      const pattern = parts[0];
+      const owners = parts.slice(1);
+
+      let regex;
+      if (pattern.endsWith('*')) {
+        const dir = pattern.slice(0, -1);
+        regex = new RegExp(`^${dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`);
+      } else if (pattern.includes('*')) {
+        // First escape all regex special chars except *, then replace * with .*
+        const regexPattern = pattern
+          .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+          .replace(/\*/g, '.*');
+        regex = new RegExp(`^${regexPattern}$`);
+      } else {
+        regex = new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
+      }
+
+      return { regex, owners };
+    });
+
+    for (const file of changedFiles) {
+      for (const { regex, owners } of codeownersRegexes) {
+        if (regex.test(file) && owners.some(owner => owner === `@${prAuthor}`)) {
+          labels.add('by-code-owner');
+          return labels;
+        }
+      }
+    }
+  } catch (error) {
+    console.log('Failed to read or parse CODEOWNERS file:', error.message);
+  }
+
+  return labels;
+}
+
+// Strategy: Test detection
+async function detectTests(changedFiles) {
+  const labels = new Set();
+  const testFiles = changedFiles.filter(file => file.startsWith('tests/'));
+
+  if (testFiles.length > 0) {
+    labels.add('has-tests');
+  }
+
+  return labels;
+}
+
+// Strategy: PR Template Checkbox detection
+async function detectPRTemplateCheckboxes(context) {
+  const labels = new Set();
+  const prBody = context.payload.pull_request.body || '';
+
+  console.log('Checking PR template checkboxes...');
+
+  // Check for checked checkboxes in the "Types of changes" section
+  const checkboxPatterns = [
+    { pattern: /- \[x\] Bugfix \(non-breaking change which fixes an issue\)/i, label: 'bugfix' },
+    { pattern: /- \[x\] New feature \(non-breaking change which adds functionality\)/i, label: 'new-feature' },
+    { pattern: /- \[x\] Breaking change \(fix or feature that would cause existing functionality to not work as expected\)/i, label: 'breaking-change' },
+    { pattern: /- \[x\] Developer breaking change \(an API change that could break external components\)/i, label: 'developer-breaking-change' },
+    { pattern: /- \[x\] Code quality improvements to existing code or addition of tests/i, label: 'code-quality' }
+  ];
+
+  for (const { pattern, label } of checkboxPatterns) {
+    if (pattern.test(prBody)) {
+      console.log(`Found checked checkbox for: ${label}`);
+      labels.add(label);
+    }
+  }
+
+  return labels;
+}
+
+// Strategy: Deprecated component detection
+async function detectDeprecatedComponents(github, context, changedFiles) {
+  const labels = new Set();
+  const deprecatedInfo = [];
+  const { owner, repo } = context.repo;
+
+  // Compile regex once for better performance
+  const componentFileRegex = /^esphome\/components\/([^\/]+)\//;
+
+  // Get files that are modified or added in components directory
+  const componentFiles = changedFiles.filter(file => componentFileRegex.test(file));
+
+  if (componentFiles.length === 0) {
+    return { labels, deprecatedInfo };
+  }
+
+  // Extract unique component names using the same regex
+  const components = new Set();
+  for (const file of componentFiles) {
+    const match = file.match(componentFileRegex);
+    if (match) {
+      components.add(match[1]);
+    }
+  }
+
+  // Get PR head to fetch files from the PR branch
+  const prNumber = context.payload.pull_request.number;
+
+  // 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
+      const { data: fileData } = await github.rest.repos.getContent({
+        owner,
+        repo,
+        path: initFile,
+        ref: `refs/pull/${prNumber}/head`
+      });
+
+      // Decode base64 content
+      const content = Buffer.from(fileData.content, 'base64').toString('utf8');
+
+      // Look for DEPRECATED_COMPONENT = "message" or DEPRECATED_COMPONENT = 'message'
+      // Support single quotes, double quotes, and triple quotes (for multiline)
+      const doubleQuoteMatch = content.match(/DEPRECATED_COMPONENT\s*=\s*"""([\s\S]*?)"""/s) ||
+                              content.match(/DEPRECATED_COMPONENT\s*=\s*"((?:[^"\\]|\\.)*)"/);
+      const singleQuoteMatch = content.match(/DEPRECATED_COMPONENT\s*=\s*'''([\s\S]*?)'''/s) ||
+                              content.match(/DEPRECATED_COMPONENT\s*=\s*'((?:[^'\\]|\\.)*)'/);
+      const deprecatedMatch = doubleQuoteMatch || singleQuoteMatch;
+
+      if (deprecatedMatch) {
+        labels.add('deprecated-component');
+        deprecatedInfo.push({
+          component: component,
+          message: deprecatedMatch[1].trim()
+        });
+        console.log(`Found deprecated component: ${component}`);
+      }
+    } catch (error) {
+      // Only log if it's not a simple "file not found" error (404)
+      if (error.status !== 404) {
+        console.log(`Error reading ${initFile}:`, error.message);
+      }
+    }
+  }
+
+  return { labels, deprecatedInfo };
+}
+
+// Strategy: Requirements detection
+async function detectRequirements(allLabels, prFiles, context) {
+  const labels = new Set();
+
+  // Check for missing tests
+  if ((allLabels.has('new-component') || allLabels.has('new-platform') || allLabels.has('new-feature')) && !allLabels.has('has-tests')) {
+    labels.add('needs-tests');
+  }
+
+  // Check for missing docs
+  if (allLabels.has('new-component') || allLabels.has('new-platform') || allLabels.has('new-feature')) {
+    const prBody = context.payload.pull_request.body || '';
+    const hasDocsLink = DOCS_PR_PATTERNS.some(pattern => pattern.test(prBody));
+
+    if (!hasDocsLink) {
+      labels.add('needs-docs');
+    }
+  }
+
+  // Check for missing CODEOWNERS
+  if (allLabels.has('new-component')) {
+    const codeownersModified = prFiles.some(file =>
+      file.filename === 'CODEOWNERS' &&
+      (file.status === 'modified' || file.status === 'added') &&
+      (file.additions || 0) > 0
+    );
+
+    if (!codeownersModified) {
+      labels.add('needs-codeowners');
+    }
+  }
+
+  return labels;
+}
+
+module.exports = {
+  detectMergeBranch,
+  detectComponentPlatforms,
+  detectNewComponents,
+  detectNewPlatforms,
+  detectCoreChanges,
+  detectPRSize,
+  detectDashboardChanges,
+  detectGitHubActionsChanges,
+  detectCodeOwner,
+  detectTests,
+  detectPRTemplateCheckboxes,
+  detectDeprecatedComponents,
+  detectRequirements
+};

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

@@ -0,0 +1,187 @@
+const { MANAGED_LABELS } = require('./constants');
+const {
+  detectMergeBranch,
+  detectComponentPlatforms,
+  detectNewComponents,
+  detectNewPlatforms,
+  detectCoreChanges,
+  detectPRSize,
+  detectDashboardChanges,
+  detectGitHubActionsChanges,
+  detectCodeOwner,
+  detectTests,
+  detectPRTemplateCheckboxes,
+  detectDeprecatedComponents,
+  detectRequirements
+} = require('./detectors');
+const { handleReviews } = require('./reviews');
+const { applyLabels, removeOldLabels } = require('./labels');
+
+// Fetch API data
+async function fetchApiData() {
+  try {
+    const response = await fetch('https://data.esphome.io/components.json');
+    const componentsData = await response.json();
+    return {
+      targetPlatforms: componentsData.target_platforms || [],
+      platformComponents: componentsData.platform_components || []
+    };
+  } catch (error) {
+    console.log('Failed to fetch components data from API:', error.message);
+    return { targetPlatforms: [], platformComponents: [] };
+  }
+}
+
+module.exports = async ({ github, context }) => {
+  // Environment variables
+  const SMALL_PR_THRESHOLD = parseInt(process.env.SMALL_PR_THRESHOLD);
+  const MAX_LABELS = parseInt(process.env.MAX_LABELS);
+  const TOO_BIG_THRESHOLD = parseInt(process.env.TOO_BIG_THRESHOLD);
+  const COMPONENT_LABEL_THRESHOLD = parseInt(process.env.COMPONENT_LABEL_THRESHOLD);
+
+  // Global state
+  const { owner, repo } = context.repo;
+  const pr_number = context.issue.number;
+
+  // Get current labels and PR data
+  const { data: currentLabelsData } = await github.rest.issues.listLabelsOnIssue({
+    owner,
+    repo,
+    issue_number: pr_number
+  });
+  const currentLabels = currentLabelsData.map(label => label.name);
+  const managedLabels = currentLabels.filter(label =>
+    label.startsWith('component: ') || MANAGED_LABELS.includes(label)
+  );
+
+  // Check for mega-PR early - if present, skip most automatic labeling
+  const isMegaPR = currentLabels.includes('mega-pr');
+
+  // Get all PR files with automatic pagination
+  const prFiles = await github.paginate(
+    github.rest.pulls.listFiles,
+    {
+      owner,
+      repo,
+      pull_number: pr_number
+    }
+  );
+
+  // Calculate data from PR files
+  const changedFiles = prFiles.map(file => file.filename);
+  const totalAdditions = prFiles.reduce((sum, file) => sum + (file.additions || 0), 0);
+  const totalDeletions = prFiles.reduce((sum, file) => sum + (file.deletions || 0), 0);
+  const totalChanges = totalAdditions + totalDeletions;
+
+  console.log('Current labels:', currentLabels.join(', '));
+  console.log('Changed files:', changedFiles.length);
+  console.log('Total changes:', totalChanges);
+  if (isMegaPR) {
+    console.log('Mega-PR detected - applying limited labeling logic');
+  }
+
+  // Fetch API data
+  const apiData = await fetchApiData();
+  const baseRef = context.payload.pull_request.base.ref;
+
+  // Early exit for release and beta branches only
+  if (baseRef === 'release' || baseRef === 'beta') {
+    const branchLabels = await detectMergeBranch(context);
+    const finalLabels = Array.from(branchLabels);
+
+    console.log('Computed labels (merge branch only):', finalLabels.join(', '));
+
+    // Apply labels
+    await applyLabels(github, context, finalLabels);
+
+    // Remove old managed labels
+    await removeOldLabels(github, context, managedLabels, finalLabels);
+
+    return;
+  }
+
+  // Run all strategies
+  const [
+    branchLabels,
+    componentLabels,
+    newComponentLabels,
+    newPlatformLabels,
+    coreLabels,
+    sizeLabels,
+    dashboardLabels,
+    actionsLabels,
+    codeOwnerLabels,
+    testLabels,
+    checkboxLabels,
+    deprecatedResult
+  ] = await Promise.all([
+    detectMergeBranch(context),
+    detectComponentPlatforms(changedFiles, apiData),
+    detectNewComponents(prFiles),
+    detectNewPlatforms(prFiles, apiData),
+    detectCoreChanges(changedFiles),
+    detectPRSize(prFiles, totalAdditions, totalDeletions, totalChanges, isMegaPR, SMALL_PR_THRESHOLD, TOO_BIG_THRESHOLD),
+    detectDashboardChanges(changedFiles),
+    detectGitHubActionsChanges(changedFiles),
+    detectCodeOwner(github, context, changedFiles),
+    detectTests(changedFiles),
+    detectPRTemplateCheckboxes(context),
+    detectDeprecatedComponents(github, context, changedFiles)
+  ]);
+
+  // Extract deprecated component info
+  const deprecatedLabels = deprecatedResult.labels;
+  const deprecatedInfo = deprecatedResult.deprecatedInfo;
+
+  // Combine all labels
+  const allLabels = new Set([
+    ...branchLabels,
+    ...componentLabels,
+    ...newComponentLabels,
+    ...newPlatformLabels,
+    ...coreLabels,
+    ...sizeLabels,
+    ...dashboardLabels,
+    ...actionsLabels,
+    ...codeOwnerLabels,
+    ...testLabels,
+    ...checkboxLabels,
+    ...deprecatedLabels
+  ]);
+
+  // Detect requirements based on all other labels
+  const requirementLabels = await detectRequirements(allLabels, prFiles, context);
+  for (const label of requirementLabels) {
+    allLabels.add(label);
+  }
+
+  let finalLabels = Array.from(allLabels);
+
+  // For mega-PRs, exclude component labels if there are too many
+  if (isMegaPR) {
+    const componentLabels = finalLabels.filter(label => label.startsWith('component: '));
+    if (componentLabels.length > COMPONENT_LABEL_THRESHOLD) {
+      finalLabels = finalLabels.filter(label => !label.startsWith('component: '));
+      console.log(`Mega-PR detected - excluding ${componentLabels.length} component labels (threshold: ${COMPONENT_LABEL_THRESHOLD})`);
+    }
+  }
+
+  // Handle too many labels (only for non-mega PRs)
+  const tooManyLabels = finalLabels.length > MAX_LABELS;
+  const originalLabelCount = finalLabels.length;
+
+  if (tooManyLabels && !isMegaPR && !finalLabels.includes('too-big')) {
+    finalLabels = ['too-big'];
+  }
+
+  console.log('Computed labels:', finalLabels.join(', '));
+
+  // Handle reviews
+  await handleReviews(github, context, finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, MAX_LABELS, TOO_BIG_THRESHOLD);
+
+  // Apply labels
+  await applyLabels(github, context, finalLabels);
+
+  // Remove old managed labels
+  await removeOldLabels(github, context, managedLabels, finalLabels);
+};

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

@@ -0,0 +1,41 @@
+// Apply labels to PR
+async function applyLabels(github, context, finalLabels) {
+  const { owner, repo } = context.repo;
+  const pr_number = context.issue.number;
+
+  if (finalLabels.length > 0) {
+    console.log(`Adding labels: ${finalLabels.join(', ')}`);
+    await github.rest.issues.addLabels({
+      owner,
+      repo,
+      issue_number: pr_number,
+      labels: finalLabels
+    });
+  }
+}
+
+// Remove old managed labels
+async function removeOldLabels(github, context, managedLabels, finalLabels) {
+  const { owner, repo } = context.repo;
+  const pr_number = context.issue.number;
+
+  const labelsToRemove = managedLabels.filter(label => !finalLabels.includes(label));
+  for (const label of labelsToRemove) {
+    console.log(`Removing label: ${label}`);
+    try {
+      await github.rest.issues.removeLabel({
+        owner,
+        repo,
+        issue_number: pr_number,
+        name: label
+      });
+    } catch (error) {
+      console.log(`Failed to remove label ${label}:`, error.message);
+    }
+  }
+}
+
+module.exports = {
+  applyLabels,
+  removeOldLabels
+};

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

@@ -0,0 +1,141 @@
+const {
+  BOT_COMMENT_MARKER,
+  CODEOWNERS_MARKER,
+  TOO_BIG_MARKER,
+  DEPRECATED_COMPONENT_MARKER
+} = require('./constants');
+
+// Generate review messages
+function generateReviewMessages(finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, prAuthor, MAX_LABELS, TOO_BIG_THRESHOLD) {
+  const messages = [];
+
+  // Deprecated component message
+  if (finalLabels.includes('deprecated-component') && deprecatedInfo && deprecatedInfo.length > 0) {
+    let message = `${DEPRECATED_COMPONENT_MARKER}\n### ⚠️ Deprecated Component\n\n`;
+    message += `Hey there @${prAuthor},\n`;
+    message += `This PR modifies one or more deprecated components. Please be aware:\n\n`;
+
+    for (const info of deprecatedInfo) {
+      message += `#### Component: \`${info.component}\`\n`;
+      message += `${info.message}\n\n`;
+    }
+
+    message += `Consider migrating to the recommended alternative if applicable.`;
+
+    messages.push(message);
+  }
+
+  // Too big message
+  if (finalLabels.includes('too-big')) {
+    const testAdditions = prFiles
+      .filter(file => file.filename.startsWith('tests/'))
+      .reduce((sum, file) => sum + (file.additions || 0), 0);
+    const testDeletions = prFiles
+      .filter(file => file.filename.startsWith('tests/'))
+      .reduce((sum, file) => sum + (file.deletions || 0), 0);
+    const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
+
+    const tooManyLabels = originalLabelCount > MAX_LABELS;
+    const tooManyChanges = nonTestChanges > TOO_BIG_THRESHOLD;
+
+    let message = `${TOO_BIG_MARKER}\n### 📦 Pull Request Size\n\n`;
+
+    if (tooManyLabels && tooManyChanges) {
+      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${originalLabelCount} different components/areas.`;
+    } else if (tooManyLabels) {
+      message += `This PR affects ${originalLabelCount} different components/areas.`;
+    } else {
+      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests).`;
+    }
+
+    message += ` Please consider breaking it down into smaller, focused PRs to make review easier and reduce the risk of conflicts.\n\n`;
+    message += `For guidance on breaking down large PRs, see: https://developers.esphome.io/contributing/submitting-your-work/#how-to-approach-large-submissions`;
+
+    messages.push(message);
+  }
+
+  // CODEOWNERS message
+  if (finalLabels.includes('needs-codeowners')) {
+    const message = `${CODEOWNERS_MARKER}\n### 👥 Code Ownership\n\n` +
+      `Hey there @${prAuthor},\n` +
+      `Thanks for submitting this pull request! Can you add yourself as a codeowner for this integration? ` +
+      `This way we can notify you if a bug report for this integration is reported.\n\n` +
+      `In \`__init__.py\` of the integration, please add:\n\n` +
+      `\`\`\`python\nCODEOWNERS = ["@${prAuthor}"]\n\`\`\`\n\n` +
+      `And run \`script/build_codeowners.py\``;
+
+    messages.push(message);
+  }
+
+  return messages;
+}
+
+// Handle reviews
+async function handleReviews(github, context, finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, MAX_LABELS, TOO_BIG_THRESHOLD) {
+  const { owner, repo } = context.repo;
+  const pr_number = context.issue.number;
+  const prAuthor = context.payload.pull_request.user.login;
+
+  const reviewMessages = generateReviewMessages(finalLabels, originalLabelCount, deprecatedInfo, prFiles, totalAdditions, totalDeletions, prAuthor, MAX_LABELS, TOO_BIG_THRESHOLD);
+  const hasReviewableLabels = finalLabels.some(label =>
+    ['too-big', 'needs-codeowners', 'deprecated-component'].includes(label)
+  );
+
+  const { data: reviews } = await github.rest.pulls.listReviews({
+    owner,
+    repo,
+    pull_number: pr_number
+  });
+
+  const botReviews = reviews.filter(review =>
+    review.user.type === 'Bot' &&
+    review.state === 'CHANGES_REQUESTED' &&
+    review.body && review.body.includes(BOT_COMMENT_MARKER)
+  );
+
+  if (hasReviewableLabels) {
+    const reviewBody = `${BOT_COMMENT_MARKER}\n\n${reviewMessages.join('\n\n---\n\n')}`;
+
+    if (botReviews.length > 0) {
+      // Update existing review
+      await github.rest.pulls.updateReview({
+        owner,
+        repo,
+        pull_number: pr_number,
+        review_id: botReviews[0].id,
+        body: reviewBody
+      });
+      console.log('Updated existing bot review');
+    } else {
+      // Create new review
+      await github.rest.pulls.createReview({
+        owner,
+        repo,
+        pull_number: pr_number,
+        body: reviewBody,
+        event: 'REQUEST_CHANGES'
+      });
+      console.log('Created new bot review');
+    }
+  } else if (botReviews.length > 0) {
+    // Dismiss existing reviews
+    for (const review of botReviews) {
+      try {
+        await github.rest.pulls.dismissReview({
+          owner,
+          repo,
+          pull_number: pr_number,
+          review_id: review.id,
+          message: 'Review dismissed: All requirements have been met'
+        });
+        console.log(`Dismissed bot review ${review.id}`);
+      } catch (error) {
+        console.log(`Failed to dismiss review ${review.id}:`, error.message);
+      }
+    }
+  }
+}
+
+module.exports = {
+  handleReviews
+};

.github/workflows/auto-label-pr.yml

@@ -36,633 +36,5 @@ jobs:
         with:
           github-token: ${{ steps.generate-token.outputs.token }}
           script: |
-            const fs = require('fs');
+            const script = require('./.github/scripts/auto-label-pr/index.js');
-
+            await script({ github, context });
-            // Constants
-            const SMALL_PR_THRESHOLD = parseInt('${{ env.SMALL_PR_THRESHOLD }}');
-            const MAX_LABELS = parseInt('${{ env.MAX_LABELS }}');
-            const TOO_BIG_THRESHOLD = parseInt('${{ env.TOO_BIG_THRESHOLD }}');
-            const COMPONENT_LABEL_THRESHOLD = parseInt('${{ env.COMPONENT_LABEL_THRESHOLD }}');
-            const BOT_COMMENT_MARKER = '<!-- auto-label-pr-bot -->';
-            const CODEOWNERS_MARKER = '<!-- codeowners-request -->';
-            const TOO_BIG_MARKER = '<!-- too-big-request -->';
-
-            const MANAGED_LABELS = [
-              'new-component',
-              'new-platform',
-              'new-target-platform',
-              'merging-to-release',
-              'merging-to-beta',
-              'chained-pr',
-              'core',
-              'small-pr',
-              'dashboard',
-              'github-actions',
-              'by-code-owner',
-              'has-tests',
-              'needs-tests',
-              'needs-docs',
-              'needs-codeowners',
-              'too-big',
-              'labeller-recheck',
-              'bugfix',
-              'new-feature',
-              'breaking-change',
-              'developer-breaking-change',
-              'code-quality'
-            ];
-
-            const DOCS_PR_PATTERNS = [
-              /https:\/\/github\.com\/esphome\/esphome-docs\/pull\/\d+/,
-              /esphome\/esphome-docs#\d+/
-            ];
-
-            // Global state
-            const { owner, repo } = context.repo;
-            const pr_number = context.issue.number;
-
-            // Get current labels and PR data
-            const { data: currentLabelsData } = await github.rest.issues.listLabelsOnIssue({
-              owner,
-              repo,
-              issue_number: pr_number
-            });
-            const currentLabels = currentLabelsData.map(label => label.name);
-            const managedLabels = currentLabels.filter(label =>
-              label.startsWith('component: ') || MANAGED_LABELS.includes(label)
-            );
-
-            // Check for mega-PR early - if present, skip most automatic labeling
-            const isMegaPR = currentLabels.includes('mega-pr');
-
-            // Get all PR files with automatic pagination
-            const prFiles = await github.paginate(
-              github.rest.pulls.listFiles,
-              {
-                owner,
-                repo,
-                pull_number: pr_number
-              }
-            );
-
-            // Calculate data from PR files
-            const changedFiles = prFiles.map(file => file.filename);
-            const totalAdditions = prFiles.reduce((sum, file) => sum + (file.additions || 0), 0);
-            const totalDeletions = prFiles.reduce((sum, file) => sum + (file.deletions || 0), 0);
-            const totalChanges = totalAdditions + totalDeletions;
-
-            console.log('Current labels:', currentLabels.join(', '));
-            console.log('Changed files:', changedFiles.length);
-            console.log('Total changes:', totalChanges);
-            if (isMegaPR) {
-              console.log('Mega-PR detected - applying limited labeling logic');
-            }
-
-            // Fetch API data
-            async function fetchApiData() {
-              try {
-                const response = await fetch('https://data.esphome.io/components.json');
-                const componentsData = await response.json();
-                return {
-                  targetPlatforms: componentsData.target_platforms || [],
-                  platformComponents: componentsData.platform_components || []
-                };
-              } catch (error) {
-                console.log('Failed to fetch components data from API:', error.message);
-                return { targetPlatforms: [], platformComponents: [] };
-              }
-            }
-
-            // Strategy: Merge branch detection
-            async function detectMergeBranch() {
-              const labels = new Set();
-              const baseRef = context.payload.pull_request.base.ref;
-
-              if (baseRef === 'release') {
-                labels.add('merging-to-release');
-              } else if (baseRef === 'beta') {
-                labels.add('merging-to-beta');
-              } else if (baseRef !== 'dev') {
-                labels.add('chained-pr');
-              }
-
-              return labels;
-            }
-
-            // Strategy: Component and platform labeling
-            async function detectComponentPlatforms(apiData) {
-              const labels = new Set();
-              const componentRegex = /^esphome\/components\/([^\/]+)\//;
-              const targetPlatformRegex = new RegExp(`^esphome\/components\/(${apiData.targetPlatforms.join('|')})/`);
-
-              for (const file of changedFiles) {
-                const componentMatch = file.match(componentRegex);
-                if (componentMatch) {
-                  labels.add(`component: ${componentMatch[1]}`);
-                }
-
-                const platformMatch = file.match(targetPlatformRegex);
-                if (platformMatch) {
-                  labels.add(`platform: ${platformMatch[1]}`);
-                }
-              }
-
-              return labels;
-            }
-
-            // Strategy: New component detection
-            async function detectNewComponents() {
-              const labels = new Set();
-              const addedFiles = prFiles.filter(file => file.status === 'added').map(file => file.filename);
-
-              for (const file of addedFiles) {
-                const componentMatch = file.match(/^esphome\/components\/([^\/]+)\/__init__\.py$/);
-                if (componentMatch) {
-                  try {
-                    const content = fs.readFileSync(file, 'utf8');
-                    if (content.includes('IS_TARGET_PLATFORM = True')) {
-                      labels.add('new-target-platform');
-                    }
-                  } catch (error) {
-                    console.log(`Failed to read content of ${file}:`, error.message);
-                  }
-                  labels.add('new-component');
-                }
-              }
-
-              return labels;
-            }
-
-            // Strategy: New platform detection
-            async function detectNewPlatforms(apiData) {
-              const labels = new Set();
-              const addedFiles = prFiles.filter(file => file.status === 'added').map(file => file.filename);
-
-              for (const file of addedFiles) {
-                const platformFileMatch = file.match(/^esphome\/components\/([^\/]+)\/([^\/]+)\.py$/);
-                if (platformFileMatch) {
-                  const [, component, platform] = platformFileMatch;
-                  if (apiData.platformComponents.includes(platform)) {
-                    labels.add('new-platform');
-                  }
-                }
-
-                const platformDirMatch = file.match(/^esphome\/components\/([^\/]+)\/([^\/]+)\/__init__\.py$/);
-                if (platformDirMatch) {
-                  const [, component, platform] = platformDirMatch;
-                  if (apiData.platformComponents.includes(platform)) {
-                    labels.add('new-platform');
-                  }
-                }
-              }
-
-              return labels;
-            }
-
-            // Strategy: Core files detection
-            async function detectCoreChanges() {
-              const labels = new Set();
-              const coreFiles = changedFiles.filter(file =>
-                file.startsWith('esphome/core/') ||
-                (file.startsWith('esphome/') && file.split('/').length === 2)
-              );
-
-              if (coreFiles.length > 0) {
-                labels.add('core');
-              }
-
-              return labels;
-            }
-
-            // Strategy: PR size detection
-            async function detectPRSize() {
-              const labels = new Set();
-
-              if (totalChanges <= SMALL_PR_THRESHOLD) {
-                labels.add('small-pr');
-                return labels;
-              }
-
-              const testAdditions = prFiles
-                .filter(file => file.filename.startsWith('tests/'))
-                .reduce((sum, file) => sum + (file.additions || 0), 0);
-              const testDeletions = prFiles
-                .filter(file => file.filename.startsWith('tests/'))
-                .reduce((sum, file) => sum + (file.deletions || 0), 0);
-
-              const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
-
-              // Don't add too-big if mega-pr label is already present
-              if (nonTestChanges > TOO_BIG_THRESHOLD && !isMegaPR) {
-                labels.add('too-big');
-              }
-
-              return labels;
-            }
-
-            // Strategy: Dashboard changes
-            async function detectDashboardChanges() {
-              const labels = new Set();
-              const dashboardFiles = changedFiles.filter(file =>
-                file.startsWith('esphome/dashboard/') ||
-                file.startsWith('esphome/components/dashboard_import/')
-              );
-
-              if (dashboardFiles.length > 0) {
-                labels.add('dashboard');
-              }
-
-              return labels;
-            }
-
-            // Strategy: GitHub Actions changes
-            async function detectGitHubActionsChanges() {
-              const labels = new Set();
-              const githubActionsFiles = changedFiles.filter(file =>
-                file.startsWith('.github/workflows/')
-              );
-
-              if (githubActionsFiles.length > 0) {
-                labels.add('github-actions');
-              }
-
-              return labels;
-            }
-
-            // Strategy: Code owner detection
-            async function detectCodeOwner() {
-              const labels = new Set();
-
-              try {
-                const { data: codeownersFile } = await github.rest.repos.getContent({
-                  owner,
-                  repo,
-                  path: 'CODEOWNERS',
-                });
-
-                const codeownersContent = Buffer.from(codeownersFile.content, 'base64').toString('utf8');
-                const prAuthor = context.payload.pull_request.user.login;
-
-                const codeownersLines = codeownersContent.split('\n')
-                  .map(line => line.trim())
-                  .filter(line => line && !line.startsWith('#'));
-
-                const codeownersRegexes = codeownersLines.map(line => {
-                  const parts = line.split(/\s+/);
-                  const pattern = parts[0];
-                  const owners = parts.slice(1);
-
-                  let regex;
-                  if (pattern.endsWith('*')) {
-                    const dir = pattern.slice(0, -1);
-                    regex = new RegExp(`^${dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`);
-                  } else if (pattern.includes('*')) {
-                    // First escape all regex special chars except *, then replace * with .*
-                    const regexPattern = pattern
-                      .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-                      .replace(/\*/g, '.*');
-                    regex = new RegExp(`^${regexPattern}$`);
-                  } else {
-                    regex = new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
-                  }
-
-                  return { regex, owners };
-                });
-
-                for (const file of changedFiles) {
-                  for (const { regex, owners } of codeownersRegexes) {
-                    if (regex.test(file) && owners.some(owner => owner === `@${prAuthor}`)) {
-                      labels.add('by-code-owner');
-                      return labels;
-                    }
-                  }
-                }
-              } catch (error) {
-                console.log('Failed to read or parse CODEOWNERS file:', error.message);
-              }
-
-              return labels;
-            }
-
-            // Strategy: Test detection
-            async function detectTests() {
-              const labels = new Set();
-              const testFiles = changedFiles.filter(file => file.startsWith('tests/'));
-
-              if (testFiles.length > 0) {
-                labels.add('has-tests');
-              }
-
-              return labels;
-            }
-
-            // Strategy: PR Template Checkbox detection
-            async function detectPRTemplateCheckboxes() {
-              const labels = new Set();
-              const prBody = context.payload.pull_request.body || '';
-
-              console.log('Checking PR template checkboxes...');
-
-              // Check for checked checkboxes in the "Types of changes" section
-              const checkboxPatterns = [
-                { pattern: /- \[x\] Bugfix \(non-breaking change which fixes an issue\)/i, label: 'bugfix' },
-                { pattern: /- \[x\] New feature \(non-breaking change which adds functionality\)/i, label: 'new-feature' },
-                { pattern: /- \[x\] Breaking change \(fix or feature that would cause existing functionality to not work as expected\)/i, label: 'breaking-change' },
-                { pattern: /- \[x\] Developer breaking change \(an API change that could break external components\)/i, label: 'developer-breaking-change' },
-                { pattern: /- \[x\] Code quality improvements to existing code or addition of tests/i, label: 'code-quality' }
-              ];
-
-              for (const { pattern, label } of checkboxPatterns) {
-                if (pattern.test(prBody)) {
-                  console.log(`Found checked checkbox for: ${label}`);
-                  labels.add(label);
-                }
-              }
-
-              return labels;
-            }
-
-            // Strategy: Requirements detection
-            async function detectRequirements(allLabels) {
-              const labels = new Set();
-
-              // Check for missing tests
-              if ((allLabels.has('new-component') || allLabels.has('new-platform') || allLabels.has('new-feature')) && !allLabels.has('has-tests')) {
-                labels.add('needs-tests');
-              }
-
-              // Check for missing docs
-              if (allLabels.has('new-component') || allLabels.has('new-platform') || allLabels.has('new-feature')) {
-                const prBody = context.payload.pull_request.body || '';
-                const hasDocsLink = DOCS_PR_PATTERNS.some(pattern => pattern.test(prBody));
-
-                if (!hasDocsLink) {
-                  labels.add('needs-docs');
-                }
-              }
-
-              // Check for missing CODEOWNERS
-              if (allLabels.has('new-component')) {
-                const codeownersModified = prFiles.some(file =>
-                  file.filename === 'CODEOWNERS' &&
-                  (file.status === 'modified' || file.status === 'added') &&
-                  (file.additions || 0) > 0
-                );
-
-                if (!codeownersModified) {
-                  labels.add('needs-codeowners');
-                }
-              }
-
-              return labels;
-            }
-
-            // Generate review messages
-            function generateReviewMessages(finalLabels, originalLabelCount) {
-              const messages = [];
-              const prAuthor = context.payload.pull_request.user.login;
-
-              // Too big message
-              if (finalLabels.includes('too-big')) {
-                const testAdditions = prFiles
-                  .filter(file => file.filename.startsWith('tests/'))
-                  .reduce((sum, file) => sum + (file.additions || 0), 0);
-                const testDeletions = prFiles
-                  .filter(file => file.filename.startsWith('tests/'))
-                  .reduce((sum, file) => sum + (file.deletions || 0), 0);
-                const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
-
-                const tooManyLabels = originalLabelCount > MAX_LABELS;
-                const tooManyChanges = nonTestChanges > TOO_BIG_THRESHOLD;
-
-                let message = `${TOO_BIG_MARKER}\n### 📦 Pull Request Size\n\n`;
-
-                if (tooManyLabels && tooManyChanges) {
-                  message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${originalLabelCount} different components/areas.`;
-                } else if (tooManyLabels) {
-                  message += `This PR affects ${originalLabelCount} different components/areas.`;
-                } else {
-                  message += `This PR is too large with ${nonTestChanges} line changes (excluding tests).`;
-                }
-
-                message += ` Please consider breaking it down into smaller, focused PRs to make review easier and reduce the risk of conflicts.\n\n`;
-                message += `For guidance on breaking down large PRs, see: https://developers.esphome.io/contributing/submitting-your-work/#how-to-approach-large-submissions`;
-
-                messages.push(message);
-              }
-
-              // CODEOWNERS message
-              if (finalLabels.includes('needs-codeowners')) {
-                const message = `${CODEOWNERS_MARKER}\n### 👥 Code Ownership\n\n` +
-                  `Hey there @${prAuthor},\n` +
-                  `Thanks for submitting this pull request! Can you add yourself as a codeowner for this integration? ` +
-                  `This way we can notify you if a bug report for this integration is reported.\n\n` +
-                  `In \`__init__.py\` of the integration, please add:\n\n` +
-                  `\`\`\`python\nCODEOWNERS = ["@${prAuthor}"]\n\`\`\`\n\n` +
-                  `And run \`script/build_codeowners.py\``;
-
-                messages.push(message);
-              }
-
-              return messages;
-            }
-
-            // Handle reviews
-            async function handleReviews(finalLabels, originalLabelCount) {
-              const reviewMessages = generateReviewMessages(finalLabels, originalLabelCount);
-              const hasReviewableLabels = finalLabels.some(label =>
-                ['too-big', 'needs-codeowners'].includes(label)
-              );
-
-              const { data: reviews } = await github.rest.pulls.listReviews({
-                owner,
-                repo,
-                pull_number: pr_number
-              });
-
-              const botReviews = reviews.filter(review =>
-                review.user.type === 'Bot' &&
-                review.state === 'CHANGES_REQUESTED' &&
-                review.body && review.body.includes(BOT_COMMENT_MARKER)
-              );
-
-              if (hasReviewableLabels) {
-                const reviewBody = `${BOT_COMMENT_MARKER}\n\n${reviewMessages.join('\n\n---\n\n')}`;
-
-                if (botReviews.length > 0) {
-                  // Update existing review
-                  await github.rest.pulls.updateReview({
-                    owner,
-                    repo,
-                    pull_number: pr_number,
-                    review_id: botReviews[0].id,
-                    body: reviewBody
-                  });
-                  console.log('Updated existing bot review');
-                } else {
-                  // Create new review
-                  await github.rest.pulls.createReview({
-                    owner,
-                    repo,
-                    pull_number: pr_number,
-                    body: reviewBody,
-                    event: 'REQUEST_CHANGES'
-                  });
-                  console.log('Created new bot review');
-                }
-              } else if (botReviews.length > 0) {
-                // Dismiss existing reviews
-                for (const review of botReviews) {
-                  try {
-                    await github.rest.pulls.dismissReview({
-                      owner,
-                      repo,
-                      pull_number: pr_number,
-                      review_id: review.id,
-                      message: 'Review dismissed: All requirements have been met'
-                    });
-                    console.log(`Dismissed bot review ${review.id}`);
-                  } catch (error) {
-                    console.log(`Failed to dismiss review ${review.id}:`, error.message);
-                  }
-                }
-              }
-            }
-
-            // Main execution
-            const apiData = await fetchApiData();
-            const baseRef = context.payload.pull_request.base.ref;
-
-            // Early exit for release and beta branches only
-            if (baseRef === 'release' || baseRef === 'beta') {
-              const branchLabels = await detectMergeBranch();
-              const finalLabels = Array.from(branchLabels);
-
-              console.log('Computed labels (merge branch only):', finalLabels.join(', '));
-
-              // Apply labels
-              if (finalLabels.length > 0) {
-                await github.rest.issues.addLabels({
-                  owner,
-                  repo,
-                  issue_number: pr_number,
-                  labels: finalLabels
-                });
-              }
-
-              // Remove old managed labels
-              const labelsToRemove = managedLabels.filter(label => !finalLabels.includes(label));
-              for (const label of labelsToRemove) {
-                try {
-                  await github.rest.issues.removeLabel({
-                    owner,
-                    repo,
-                    issue_number: pr_number,
-                    name: label
-                  });
-                } catch (error) {
-                  console.log(`Failed to remove label ${label}:`, error.message);
-                }
-              }
-
-              return;
-            }
-
-            // Run all strategies
-            const [
-              branchLabels,
-              componentLabels,
-              newComponentLabels,
-              newPlatformLabels,
-              coreLabels,
-              sizeLabels,
-              dashboardLabels,
-              actionsLabels,
-              codeOwnerLabels,
-              testLabels,
-              checkboxLabels
-            ] = await Promise.all([
-              detectMergeBranch(),
-              detectComponentPlatforms(apiData),
-              detectNewComponents(),
-              detectNewPlatforms(apiData),
-              detectCoreChanges(),
-              detectPRSize(),
-              detectDashboardChanges(),
-              detectGitHubActionsChanges(),
-              detectCodeOwner(),
-              detectTests(),
-              detectPRTemplateCheckboxes()
-            ]);
-
-            // Combine all labels
-            const allLabels = new Set([
-              ...branchLabels,
-              ...componentLabels,
-              ...newComponentLabels,
-              ...newPlatformLabels,
-              ...coreLabels,
-              ...sizeLabels,
-              ...dashboardLabels,
-              ...actionsLabels,
-              ...codeOwnerLabels,
-              ...testLabels,
-              ...checkboxLabels
-            ]);
-
-            // Detect requirements based on all other labels
-            const requirementLabels = await detectRequirements(allLabels);
-            for (const label of requirementLabels) {
-              allLabels.add(label);
-            }
-
-            let finalLabels = Array.from(allLabels);
-
-            // For mega-PRs, exclude component labels if there are too many
-            if (isMegaPR) {
-              const componentLabels = finalLabels.filter(label => label.startsWith('component: '));
-              if (componentLabels.length > COMPONENT_LABEL_THRESHOLD) {
-                finalLabels = finalLabels.filter(label => !label.startsWith('component: '));
-                console.log(`Mega-PR detected - excluding ${componentLabels.length} component labels (threshold: ${COMPONENT_LABEL_THRESHOLD})`);
-              }
-            }
-
-            // Handle too many labels (only for non-mega PRs)
-            const tooManyLabels = finalLabels.length > MAX_LABELS;
-            const originalLabelCount = finalLabels.length;
-
-            if (tooManyLabels && !isMegaPR && !finalLabels.includes('too-big')) {
-              finalLabels = ['too-big'];
-            }
-
-            console.log('Computed labels:', finalLabels.join(', '));
-
-            // Handle reviews
-            await handleReviews(finalLabels, originalLabelCount);
-
-            // Apply labels
-            if (finalLabels.length > 0) {
-              console.log(`Adding labels: ${finalLabels.join(', ')}`);
-              await github.rest.issues.addLabels({
-                owner,
-                repo,
-                issue_number: pr_number,
-                labels: finalLabels
-              });
-            }
-
-            // Remove old managed labels
-            const labelsToRemove = managedLabels.filter(label => !finalLabels.includes(label));
-            for (const label of labelsToRemove) {
-              console.log(`Removing label: ${label}`);
-              try {
-                await github.rest.issues.removeLabel({
-                  owner,
-                  repo,
-                  issue_number: pr_number,
-                  name: label
-                });
-              } catch (error) {
-                console.log(`Failed to remove label ${label}:`, error.message);
-              }
-            }

.github/workflows/release.yml

@@ -102,12 +102,12 @@ jobs:
         uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Log in to docker hub
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}

esphome/components/async_tcp/__init__.py

@@ -38,8 +38,10 @@ async def to_code(config):
         # https://github.com/ESP32Async/ESPAsyncTCP
         cg.add_library("ESP32Async/ESPAsyncTCP", "2.0.0")
     elif CORE.is_rp2040:
-        # https://github.com/khoih-prog/AsyncTCP_RP2040W
+        # https://github.com/ayushsharma82/RPAsyncTCP
-        cg.add_library("khoih-prog/AsyncTCP_RP2040W", "1.2.0")
+        # RPAsyncTCP is a drop-in replacement for AsyncTCP_RP2040W with better
+        # ESPAsyncWebServer compatibility
+        cg.add_library("ayushsharma82/RPAsyncTCP", "1.3.2")
     # Other platforms (host, etc) use socket-based implementation
 
 

esphome/components/async_tcp/async_tcp.h

@@ -8,8 +8,8 @@
 // Use ESPAsyncTCP library for ESP8266 (always Arduino)
 #include <ESPAsyncTCP.h>
 #elif defined(USE_RP2040)
-// Use AsyncTCP_RP2040W library for RP2040
+// Use RPAsyncTCP library for RP2040
-#include <AsyncTCP_RP2040W.h>
+#include <RPAsyncTCP.h>
 #else
 // Use socket-based implementation for other platforms
 #include "async_tcp_socket.h"

esphome/components/binary_sensor/binary_sensor.cpp

@@ -14,10 +14,7 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-
+  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-  if (!obj->get_device_class_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
-  }
 }
 
 void BinarySensor::publish_state(bool new_state) {

esphome/components/bl0940/number/calibration_number.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "bl0940.number";
 void CalibrationNumber::setup() {
   float value = 0.0f;
   if (this->restore_value_) {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<float>();
     if (!this->pref_.load(&value)) {
       value = 0.0f;
     }

esphome/components/button/button.cpp

@@ -12,10 +12,7 @@ void log_button(const char *tag, const char *prefix, const char *type, Button *o
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-
+  LOG_ENTITY_ICON(tag, prefix, *obj);
-  if (!obj->get_icon_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
-  }
 }
 
 void Button::press() {

esphome/components/captive_portal/captive_portal.cpp

@@ -96,10 +96,16 @@ void CaptivePortal::start() {
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-  if (req->url() == ESPHOME_F("/config.json")) {
+#ifdef USE_ESP32
+  char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
+  StringRef url = req->url_to(url_buf);
+#else
+  const auto &url = req->url();
+#endif
+  if (url == ESPHOME_F("/config.json")) {
     this->handle_config(req);
     return;
-  } else if (req->url() == ESPHOME_F("/wifisave")) {
+  } else if (url == ESPHOME_F("/wifisave")) {
     this->handle_wifisave(req);
     return;
   }

esphome/components/climate/climate.cpp

@@ -360,8 +360,7 @@ void Climate::add_on_control_callback(std::function<void(ClimateCall &)> &&callb
 static const uint32_t RESTORE_STATE_VERSION = 0x848EA6ADUL;
 
 optional<ClimateDeviceRestoreState> Climate::restore_state_() {
-  this->rtc_ = global_preferences->make_preference<ClimateDeviceRestoreState>(this->get_preference_hash() ^
+  this->rtc_ = this->make_entity_preference<ClimateDeviceRestoreState>(RESTORE_STATE_VERSION);
-                                                                              RESTORE_STATE_VERSION);
   ClimateDeviceRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/cover/cover.cpp

@@ -187,7 +187,7 @@ void Cover::publish_state(bool save) {
   }
 }
 optional<CoverRestoreState> Cover::restore_state_() {
-  this->rtc_ = global_preferences->make_preference<CoverRestoreState>(this->get_preference_hash());
+  this->rtc_ = this->make_entity_preference<CoverRestoreState>();
   CoverRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/cover/cover.h

@@ -20,9 +20,7 @@ const extern float COVER_CLOSED;
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    if (!(obj)->get_device_class_ref().empty()) { \
+    LOG_ENTITY_DEVICE_CLASS(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
-    } \
   }
 
 class Cover;

esphome/components/datetime/date_entity.h

@@ -15,9 +15,7 @@ namespace esphome::datetime {
 #define LOG_DATETIME_DATE(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
   }
 
 class DateCall;

esphome/components/datetime/datetime_entity.h

@@ -15,9 +15,7 @@ namespace esphome::datetime {
 #define LOG_DATETIME_DATETIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
   }
 
 class DateTimeCall;

esphome/components/datetime/time_entity.h

@@ -15,9 +15,7 @@ namespace esphome::datetime {
 #define LOG_DATETIME_TIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
   }
 
 class TimeCall;

esphome/components/duty_time/duty_time_sensor.cpp

@@ -41,7 +41,7 @@ void DutyTimeSensor::setup() {
   uint32_t seconds = 0;
 
   if (this->restore_) {
-    this->pref_ = global_preferences->make_preference<uint32_t>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<uint32_t>();
     this->pref_.load(&seconds);
   }
 

esphome/components/es8156/audio_dac.py

@@ -2,7 +2,8 @@ import esphome.codegen as cg
 from esphome.components import i2c
 from esphome.components.audio_dac import AudioDac
 import esphome.config_validation as cv
-from esphome.const import CONF_ID
+from esphome.const import CONF_AUDIO_DAC, CONF_BITS_PER_SAMPLE, CONF_ID
+import esphome.final_validate as fv
 
 CODEOWNERS = ["@kbx81"]
 DEPENDENCIES = ["i2c"]
@@ -21,6 +22,29 @@ CONFIG_SCHEMA = (
 )
 
 
+def _final_validate(config):
+    full_config = fv.full_config.get()
+
+    # Check all speaker configurations for ones that reference this es8156
+    speaker_configs = full_config.get("speaker", [])
+    for speaker_config in speaker_configs:
+        audio_dac_id = speaker_config.get(CONF_AUDIO_DAC)
+        if (
+            audio_dac_id is not None
+            and audio_dac_id == config[CONF_ID]
+            and (bits_per_sample := speaker_config.get(CONF_BITS_PER_SAMPLE))
+            is not None
+            and bits_per_sample > 24
+        ):
+            raise cv.Invalid(
+                f"ES8156 does not support more than 24 bits per sample. "
+                f"The speaker referencing this audio_dac has bits_per_sample set to {bits_per_sample}."
+            )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/es8156/es8156.cpp

@@ -17,24 +17,61 @@ static const char *const TAG = "es8156";
   }
 
 void ES8156::setup() {
+  // REG02 MODE CONFIG 1: Enable software mode for I2C control of volume/mute
+  // Bit 2: SOFT_MODE_SEL=1 (software mode enabled)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG02_SCLK_MODE, 0x04));
+
+  // Analog system configuration (active-low power down bits, active-high enables)
+  // REG20 ANALOG SYSTEM: Configure analog signal path
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG20_ANALOG_SYS1, 0x2A));
+
+  // REG21 ANALOG SYSTEM: VSEL=0x1C (bias level ~120%), normal VREF ramp speed
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG21_ANALOG_SYS2, 0x3C));
+
+  // REG22 ANALOG SYSTEM: Line out mode (HPSW=0), OUT_MUTE=0 (not muted)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG22_ANALOG_SYS3, 0x00));
+
+  // REG24 ANALOG SYSTEM: Low power mode for VREFBUF, HPCOM, DACVRP; DAC normal power
+  // Bits 2:0 = 0x07: LPVREFBUF=1, LPHPCOM=1, LPDACVRP=1, LPDAC=0
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG24_ANALOG_LP, 0x07));
+
+  // REG23 ANALOG SYSTEM: Lowest bias (IBIAS_SW=0), VMIDLVL=VDDA/2, normal impedance
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG23_ANALOG_SYS4, 0x00));
 
+  // Timing and interface configuration
+  // REG0A/0B TIME CONTROL: Fast state machine transitions
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0A_TIME_CONTROL1, 0x01));
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0B_TIME_CONTROL2, 0x01));
+
+  // REG11 SDP INTERFACE CONFIG: Default I2S format (24-bit, I2S mode)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG11_DAC_SDP, 0x00));
+
+  // REG19 EQ CONTROL 1: EQ disabled (EQ_ON=0), EQ_BAND_NUM=2
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG19_EQ_CONTROL1, 0x20));
 
+  // REG0D P2S CONTROL: Parallel-to-serial converter settings
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0D_P2S_CONTROL, 0x14));
+
+  // REG09 MISC CONTROL 2: Default settings
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG09_MISC_CONTROL2, 0x00));
+
+  // REG18 MISC CONTROL 3: Stereo channel routing, no inversion
+  // Bits 5:4 CHN_CROSS: 0=L→L/R→R, 1=L to both, 2=R to both, 3=swap L/R
+  // Bits 3:2: LCH_INV/RCH_INV channel inversion
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG18_MISC_CONTROL3, 0x00));
+
+  // REG08 CLOCK OFF: Enable all internal clocks (0x3F = all clock gates open)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG08_CLOCK_ON_OFF, 0x3F));
+
+  // REG00 RESET CONTROL: Reset sequence
+  // First: RST_DIG=1 (assert digital reset)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x02));
+  // Then: CSM_ON=1 (enable chip state machine), RST_DIG=1
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x03));
+
+  // REG25 ANALOG SYSTEM: Power up analog blocks
+  // VMIDSEL=2 (normal VMID operation), PDN_ANA=0, ENREFR=0, ENHPCOM=0
+  // PDN_DACVREFGEN=0, PDN_VREFBUF=0, PDN_DAC=0 (all enabled)
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG25_ANALOG_SYS5, 0x20));
 }
 

esphome/components/esp32/__init__.py

@@ -55,6 +55,7 @@ from .const import (  # noqa
     KEY_ESP32,
     KEY_EXTRA_BUILD_FILES,
     KEY_FLASH_SIZE,
+    KEY_FULL_CERT_BUNDLE,
     KEY_PATH,
     KEY_REF,
     KEY_REPO,
@@ -670,11 +671,26 @@ CONF_FREERTOS_IN_IRAM = "freertos_in_iram"
 CONF_RINGBUF_IN_IRAM = "ringbuf_in_iram"
 CONF_HEAP_IN_IRAM = "heap_in_iram"
 CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
+CONF_USE_FULL_CERTIFICATE_BUNDLE = "use_full_certificate_bundle"
+CONF_DISABLE_DEBUG_STUBS = "disable_debug_stubs"
+CONF_DISABLE_OCD_AWARE = "disable_ocd_aware"
+CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY = "disable_usb_serial_jtag_secondary"
+CONF_DISABLE_DEV_NULL_VFS = "disable_dev_null_vfs"
+CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
+CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
+CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
+CONF_DISABLE_FATFS = "disable_fatfs"
 
 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_select() or require_vfs_dir()
 KEY_VFS_SELECT_REQUIRED = "vfs_select_required"
 KEY_VFS_DIR_REQUIRED = "vfs_dir_required"
+# Feature requirement tracking - components can call require_* functions to re-enable
+# These are stored in CORE.data[KEY_ESP32] dict
+KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED = "usb_serial_jtag_secondary_required"
+KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
+KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
+KEY_FATFS_REQUIRED = "fatfs_required"
 
 
 def require_vfs_select() -> None:
@@ -695,6 +711,55 @@ def require_vfs_dir() -> None:
     CORE.data[KEY_VFS_DIR_REQUIRED] = True
 
 
+def require_full_certificate_bundle() -> None:
+    """Request the full certificate bundle instead of the common-CAs-only bundle.
+
+    By default, ESPHome uses CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN which
+    includes only CAs with >1% market share (~51 KB smaller than full bundle).
+    This covers ~99% of websites including Let's Encrypt, DigiCert, Google, Amazon.
+
+    Call this from components that need to connect to services using uncommon CAs.
+    """
+    CORE.data[KEY_ESP32][KEY_FULL_CERT_BUNDLE] = True
+
+
+def require_usb_serial_jtag_secondary() -> None:
+    """Mark that USB Serial/JTAG secondary console is required by a component.
+
+    Call this from components (e.g., logger) that need USB Serial/JTAG console output.
+    This prevents CONFIG_ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG from being disabled.
+    """
+    CORE.data[KEY_ESP32][KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED] = True
+
+
+def require_mbedtls_peer_cert() -> None:
+    """Mark that mbedTLS peer certificate retention is required by a component.
+
+    Call this from components that need access to the peer certificate after
+    the TLS handshake is complete. This prevents CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
+    from being disabled.
+    """
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_PEER_CERT_REQUIRED] = True
+
+
+def require_mbedtls_pkcs7() -> None:
+    """Mark that mbedTLS PKCS#7 support is required by a component.
+
+    Call this from components that need PKCS#7 certificate validation.
+    This prevents CONFIG_MBEDTLS_PKCS7_C from being disabled.
+    """
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_PKCS7_REQUIRED] = True
+
+
+def require_fatfs() -> None:
+    """Mark that FATFS support is required by a component.
+
+    Call this from components that use FATFS (e.g., SD card, storage components).
+    This prevents FATFS from being disabled when disable_fatfs is set.
+    """
+    CORE.data[KEY_ESP32][KEY_FATFS_REQUIRED] = True
+
+
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
     # Match operator followed by version-like string (digit or *)
@@ -776,6 +841,19 @@ FRAMEWORK_SCHEMA = cv.Schema(
                     min=8192, max=32768
                 ),
                 cv.Optional(CONF_ENABLE_OTA_ROLLBACK, default=True): cv.boolean,
+                cv.Optional(
+                    CONF_USE_FULL_CERTIFICATE_BUNDLE, default=False
+                ): cv.boolean,
+                cv.Optional(CONF_DISABLE_DEBUG_STUBS, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_OCD_AWARE, default=True): cv.boolean,
+                cv.Optional(
+                    CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY, default=True
+                ): cv.boolean,
+                cv.Optional(CONF_DISABLE_DEV_NULL_VFS, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
             }
         ),
         cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -1048,6 +1126,19 @@ async def to_code(config):
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
         if use_platformio:
             cg.add_platformio_option("framework", "espidf")
+
+        # Wrap std::__throw_* functions to abort immediately, eliminating ~3KB of
+        # exception class overhead. See throw_stubs.cpp for implementation.
+        # ESP-IDF already compiles with -fno-exceptions, so this code was dead anyway.
+        for mangled in [
+            "_ZSt20__throw_length_errorPKc",
+            "_ZSt19__throw_logic_errorPKc",
+            "_ZSt20__throw_out_of_rangePKc",
+            "_ZSt24__throw_out_of_range_fmtPKcz",
+            "_ZSt17__throw_bad_allocv",
+            "_ZSt25__throw_bad_function_callv",
+        ]:
+            cg.add_build_flag(f"-Wl,--wrap={mangled}")
     else:
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
@@ -1080,6 +1171,18 @@ async def to_code(config):
 
     cg.add_build_flag("-Wno-nonnull-compare")
 
+    # Use CMN (common CAs) bundle by default to save ~51KB flash
+    # CMN covers CAs with >1% market share (~99% of websites)
+    # Components needing uncommon CAs can call require_full_certificate_bundle()
+    use_full_bundle = conf[CONF_ADVANCED].get(
+        CONF_USE_FULL_CERTIFICATE_BUNDLE, False
+    ) or CORE.data[KEY_ESP32].get(KEY_FULL_CERT_BUNDLE, False)
+    add_idf_sdkconfig_option(
+        "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL", use_full_bundle
+    )
+    if not use_full_bundle:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN", True)
+
     add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
     add_idf_sdkconfig_option(
         f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
@@ -1274,6 +1377,61 @@ async def to_code(config):
 
     add_idf_sdkconfig_option(f"CONFIG_LOG_DEFAULT_LEVEL_{conf[CONF_LOG_LEVEL]}", True)
 
+    # Disable OpenOCD debug stubs to save code size
+    # These are used for on-chip debugging with OpenOCD/JTAG, rarely needed for ESPHome
+    if advanced[CONF_DISABLE_DEBUG_STUBS]:
+        add_idf_sdkconfig_option("CONFIG_ESP_DEBUG_STUBS_ENABLE", False)
+
+    # Disable OCD-aware exception handlers
+    # When enabled, the panic handler detects JTAG debugger and halts instead of resetting
+    # Most ESPHome users don't use JTAG debugging
+    if advanced[CONF_DISABLE_OCD_AWARE]:
+        add_idf_sdkconfig_option("CONFIG_ESP_DEBUG_OCDAWARE", False)
+
+    # Disable USB Serial/JTAG secondary console
+    # Components like logger can call require_usb_serial_jtag_secondary() to re-enable
+    if CORE.data[KEY_ESP32].get(KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED, False):
+        add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG", True)
+    elif advanced[CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY]:
+        add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_SECONDARY_NONE", True)
+
+    # Disable /dev/null VFS initialization
+    # ESPHome doesn't typically need /dev/null
+    if advanced[CONF_DISABLE_DEV_NULL_VFS]:
+        add_idf_sdkconfig_option("CONFIG_VFS_INITIALIZE_DEV_NULL", False)
+
+    # Disable keeping peer certificate after TLS handshake
+    # Saves ~4KB heap per connection, but prevents certificate inspection after handshake
+    # Components that need it can call require_mbedtls_peer_cert()
+    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PEER_CERT_REQUIRED, False):
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", True)
+    elif advanced[CONF_DISABLE_MBEDTLS_PEER_CERT]:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", False)
+
+    # Disable PKCS#7 support in mbedTLS
+    # Only needed for specific certificate validation scenarios
+    # Components that need it can call require_mbedtls_pkcs7()
+    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PKCS7_REQUIRED, False):
+        # Component called require_mbedtls_pkcs7() - enable regardless of user setting
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", True)
+    elif advanced[CONF_DISABLE_MBEDTLS_PKCS7]:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", False)
+
+    # Disable regi2c control functions in IRAM
+    # Only needed if using analog peripherals (ADC, DAC, etc.) from ISRs while cache is disabled
+    if advanced[CONF_DISABLE_REGI2C_IN_IRAM]:
+        add_idf_sdkconfig_option("CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM", False)
+
+    # Disable FATFS support
+    # Components that need FATFS (SD card, etc.) can call require_fatfs()
+    if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):
+        # Component called require_fatfs() - enable regardless of user setting
+        add_idf_sdkconfig_option("CONFIG_FATFS_LFN_NONE", False)
+        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 2)
+    elif advanced[CONF_DISABLE_FATFS]:
+        add_idf_sdkconfig_option("CONFIG_FATFS_LFN_NONE", True)
+        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 0)
+
     for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
         add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 

esphome/components/esp32/boards.py

@@ -175,6 +175,32 @@ ESP32_BOARD_PINS = {
         "LED": 13,
         "LED_BUILTIN": 13,
     },
+    "adafruit_feather_esp32s3_reversetft": {
+        "BUTTON": 0,
+        "A0": 18,
+        "A1": 17,
+        "A2": 16,
+        "A3": 15,
+        "A4": 14,
+        "A5": 8,
+        "SCK": 36,
+        "MOSI": 35,
+        "MISO": 37,
+        "RX": 38,
+        "TX": 39,
+        "SCL": 4,
+        "SDA": 3,
+        "NEOPIXEL": 33,
+        "PIN_NEOPIXEL": 33,
+        "NEOPIXEL_POWER": 21,
+        "TFT_I2C_POWER": 7,
+        "TFT_CS": 42,
+        "TFT_DC": 40,
+        "TFT_RESET": 41,
+        "TFT_BACKLIGHT": 45,
+        "LED": 13,
+        "LED_BUILTIN": 13,
+    },
     "adafruit_feather_esp32s3_tft": {
         "BUTTON": 0,
         "A0": 18,

esphome/components/esp32/const.py

@@ -12,6 +12,7 @@ KEY_REFRESH = "refresh"
 KEY_PATH = "path"
 KEY_SUBMODULES = "submodules"
 KEY_EXTRA_BUILD_FILES = "extra_build_files"
+KEY_FULL_CERT_BUNDLE = "full_cert_bundle"
 
 VARIANT_ESP32 = "ESP32"
 VARIANT_ESP32C2 = "ESP32C2"

esphome/components/esp32/throw_stubs.cpp

@@ -0,0 +1,57 @@
+/*
+ * Linker wrap stubs for std::__throw_* functions.
+ *
+ * ESP-IDF compiles with -fno-exceptions, so C++ exceptions always abort.
+ * However, ESP-IDF only wraps low-level functions (__cxa_throw, etc.),
+ * not the std::__throw_* functions that construct exception objects first.
+ * This pulls in ~3KB of dead exception class code that can never run.
+ *
+ * ESP8266 Arduino already solved this: their toolchain rebuilds libstdc++
+ * with throw functions that just call abort(). We achieve the same result
+ * using linker --wrap without requiring toolchain changes.
+ *
+ * These stubs abort immediately with a descriptive message, allowing
+ * the linker to dead-code eliminate the exception class infrastructure.
+ *
+ * Wrapped functions and their callers:
+ * - std::__throw_length_error: std::string::reserve, std::vector::reserve
+ * - std::__throw_logic_error: std::promise, std::packaged_task
+ * - std::__throw_out_of_range: std::string::at, std::vector::at
+ * - std::__throw_out_of_range_fmt: std::bitset::to_ulong
+ * - std::__throw_bad_alloc: operator new
+ * - std::__throw_bad_function_call: std::function::operator()
+ */
+
+#ifdef USE_ESP_IDF
+#include "esp_system.h"
+
+namespace esphome::esp32 {}
+
+// Linker wraps for std::__throw_* - must be extern "C" at global scope.
+// Names must be __wrap_ + mangled name for the linker's --wrap option.
+
+// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+extern "C" {
+
+// std::__throw_length_error(char const*) - called when container size exceeds max_size()
+void __wrap__ZSt20__throw_length_errorPKc(const char *) { esp_system_abort("std::length_error"); }
+
+// std::__throw_logic_error(char const*) - called for logic errors (e.g., promise already satisfied)
+void __wrap__ZSt19__throw_logic_errorPKc(const char *) { esp_system_abort("std::logic_error"); }
+
+// std::__throw_out_of_range(char const*) - called by at() when index is out of bounds
+void __wrap__ZSt20__throw_out_of_rangePKc(const char *) { esp_system_abort("std::out_of_range"); }
+
+// std::__throw_out_of_range_fmt(char const*, ...) - called by bitset::to_ulong when value doesn't fit
+void __wrap__ZSt24__throw_out_of_range_fmtPKcz(const char *, ...) { esp_system_abort("std::out_of_range"); }
+
+// std::__throw_bad_alloc() - called when operator new fails
+void __wrap__ZSt17__throw_bad_allocv() { esp_system_abort("std::bad_alloc"); }
+
+// std::__throw_bad_function_call() - called when invoking empty std::function
+void __wrap__ZSt25__throw_bad_function_callv() { esp_system_abort("std::bad_function_call"); }
+
+}  // extern "C"
+// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+
+#endif  // USE_ESP_IDF

esphome/components/event/event.h

@@ -16,12 +16,8 @@ namespace event {
 #define LOG_EVENT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    LOG_ENTITY_DEVICE_CLASS(TAG, prefix, *(obj)); \
-    } \
-    if (!(obj)->get_device_class_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
-    } \
   }
 
 class Event : public EntityBase, public EntityBase_DeviceClass {

esphome/components/factory_reset/factory_reset.cpp

@@ -3,6 +3,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include <cinttypes>
 
@@ -19,7 +20,8 @@ static bool was_power_cycled() {
 #endif
 #ifdef USE_ESP8266
   auto reset_reason = EspClass::getResetReason();
-  return strcasecmp(reset_reason.c_str(), "power On") == 0 || strcasecmp(reset_reason.c_str(), "external system") == 0;
+  return ESPHOME_strcasecmp_P(reset_reason.c_str(), ESPHOME_PSTR("power On")) == 0 ||
+         ESPHOME_strcasecmp_P(reset_reason.c_str(), ESPHOME_PSTR("external system")) == 0;
 #endif
 #ifdef USE_LIBRETINY
   auto reason = lt_get_reboot_reason();

esphome/components/fan/fan.cpp

@@ -227,8 +227,7 @@ void Fan::publish_state() {
 constexpr uint32_t RESTORE_STATE_VERSION = 0x71700ABA;
 optional<FanRestoreState> Fan::restore_state_() {
   FanRestoreState recovered{};
-  this->rtc_ =
+  this->rtc_ = this->make_entity_preference<FanRestoreState>(RESTORE_STATE_VERSION);
-      global_preferences->make_preference<FanRestoreState>(this->get_preference_hash() ^ RESTORE_STATE_VERSION);
   bool restored = this->rtc_.load(&recovered);
 
   switch (this->restore_mode_) {

esphome/components/globals/__init__.py

@@ -9,30 +9,56 @@ from esphome.const import (
     CONF_VALUE,
 )
 from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.types import ConfigType
 
 CODEOWNERS = ["@esphome/core"]
 globals_ns = cg.esphome_ns.namespace("globals")
 GlobalsComponent = globals_ns.class_("GlobalsComponent", cg.Component)
-RestoringGlobalsComponent = globals_ns.class_("RestoringGlobalsComponent", cg.Component)
+RestoringGlobalsComponent = globals_ns.class_(
+    "RestoringGlobalsComponent", cg.PollingComponent
+)
 RestoringGlobalStringComponent = globals_ns.class_(
-    "RestoringGlobalStringComponent", cg.Component
+    "RestoringGlobalStringComponent", cg.PollingComponent
 )
 GlobalVarSetAction = globals_ns.class_("GlobalVarSetAction", automation.Action)
 
 CONF_MAX_RESTORE_DATA_LENGTH = "max_restore_data_length"
 
+# Base schema fields shared by both variants
+_BASE_SCHEMA = {
+    cv.Required(CONF_ID): cv.declare_id(GlobalsComponent),
+    cv.Required(CONF_TYPE): cv.string_strict,
+    cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
+    cv.Optional(CONF_MAX_RESTORE_DATA_LENGTH): cv.int_range(0, 254),
+}
 
-MULTI_CONF = True
+# Non-restoring globals: regular Component (no polling needed)
-CONFIG_SCHEMA = cv.Schema(
+_NON_RESTORING_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_ID): cv.declare_id(GlobalsComponent),
+        **_BASE_SCHEMA,
-        cv.Required(CONF_TYPE): cv.string_strict,
-        cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
         cv.Optional(CONF_RESTORE_VALUE, default=False): cv.boolean,
-        cv.Optional(CONF_MAX_RESTORE_DATA_LENGTH): cv.int_range(0, 254),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
+# Restoring globals: PollingComponent with configurable update_interval
+_RESTORING_SCHEMA = cv.Schema(
+    {
+        **_BASE_SCHEMA,
+        cv.Optional(CONF_RESTORE_VALUE, default=True): cv.boolean,
+    }
+).extend(cv.polling_component_schema("1s"))
+
+
+def _globals_schema(config: ConfigType) -> ConfigType:
+    """Select schema based on restore_value setting."""
+    if config.get(CONF_RESTORE_VALUE, False):
+        return _RESTORING_SCHEMA(config)
+    return _NON_RESTORING_SCHEMA(config)
+
+
+MULTI_CONF = True
+CONFIG_SCHEMA = _globals_schema
+
 
 # Run with low priority so that namespaces are registered first
 @coroutine_with_priority(CoroPriority.LATE)

esphome/components/globals/globals_component.h

@@ -5,8 +5,7 @@
 #include "esphome/core/helpers.h"
 #include <cstring>
 
-namespace esphome {
+namespace esphome::globals {
-namespace globals {
 
 template<typename T> class GlobalsComponent : public Component {
  public:
@@ -24,13 +23,14 @@ template<typename T> class GlobalsComponent : public Component {
   T value_{};
 };
 
-template<typename T> class RestoringGlobalsComponent : public Component {
+template<typename T> class RestoringGlobalsComponent : public PollingComponent {
  public:
   using value_type = T;
-  explicit RestoringGlobalsComponent() = default;
+  explicit RestoringGlobalsComponent() : PollingComponent(1000) {}
-  explicit RestoringGlobalsComponent(T initial_value) : value_(initial_value) {}
+  explicit RestoringGlobalsComponent(T initial_value) : PollingComponent(1000), value_(initial_value) {}
   explicit RestoringGlobalsComponent(
-      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value) {
+      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value)
+      : PollingComponent(1000) {
     memcpy(this->value_, initial_value.data(), sizeof(T));
   }
 
@@ -44,7 +44,7 @@ template<typename T> class RestoringGlobalsComponent : public Component {
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  void loop() override { store_value_(); }
+  void update() override { store_value_(); }
 
   void on_shutdown() override { store_value_(); }
 
@@ -66,13 +66,14 @@ template<typename T> class RestoringGlobalsComponent : public Component {
 };
 
 // Use with string or subclasses of strings
-template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public Component {
+template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public PollingComponent {
  public:
   using value_type = T;
-  explicit RestoringGlobalStringComponent() = default;
+  explicit RestoringGlobalStringComponent() : PollingComponent(1000) {}
-  explicit RestoringGlobalStringComponent(T initial_value) { this->value_ = initial_value; }
+  explicit RestoringGlobalStringComponent(T initial_value) : PollingComponent(1000) { this->value_ = initial_value; }
   explicit RestoringGlobalStringComponent(
-      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value) {
+      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value)
+      : PollingComponent(1000) {
     memcpy(this->value_, initial_value.data(), sizeof(T));
   }
 
@@ -90,7 +91,7 @@ template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public C
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  void loop() override { store_value_(); }
+  void update() override { store_value_(); }
 
   void on_shutdown() override { store_value_(); }
 
@@ -144,5 +145,4 @@ template<typename T> T &id(GlobalsComponent<T> *value) { return value->value();
 template<typename T> T &id(RestoringGlobalsComponent<T> *value) { return value->value(); }
 template<typename T, uint8_t SZ> T &id(RestoringGlobalStringComponent<T, SZ> *value) { return value->value(); }
 
-}  // namespace globals
+}  // namespace esphome::globals
-}  // namespace esphome

esphome/components/haier/haier_base.cpp

@@ -350,8 +350,7 @@ ClimateTraits HaierClimateBase::traits() { return traits_; }
 
 void HaierClimateBase::initialization() {
   constexpr uint32_t restore_settings_version = 0xA77D21EF;
-  this->base_rtc_ =
+  this->base_rtc_ = this->make_entity_preference<HaierBaseSettings>(restore_settings_version);
-      global_preferences->make_preference<HaierBaseSettings>(this->get_preference_hash() ^ restore_settings_version);
   HaierBaseSettings recovered;
   if (!this->base_rtc_.load(&recovered)) {
     recovered = {false, true};

esphome/components/haier/hon_climate.cpp

@@ -515,8 +515,7 @@ haier_protocol::HaierMessage HonClimate::get_power_message(bool state) {
 void HonClimate::initialization() {
   HaierClimateBase::initialization();
   constexpr uint32_t restore_settings_version = 0x57EB59DDUL;
-  this->hon_rtc_ =
+  this->hon_rtc_ = this->make_entity_preference<HonSettings>(restore_settings_version);
-      global_preferences->make_preference<HonSettings>(this->get_preference_hash() ^ restore_settings_version);
   HonSettings recovered;
   if (this->hon_rtc_.load(&recovered)) {
     this->settings_ = recovered;

esphome/components/http_request/__init__.py

@@ -165,6 +165,16 @@ async def to_code(config):
                     ca_cert_content = f.read()
                 cg.add(var.set_ca_certificate(ca_cert_content))
             else:
+                # Uses the certificate bundle configured in esp32 component.
+                # By default, ESPHome uses the CMN (common CAs) bundle which covers
+                # ~99% of websites including GitHub, Let's Encrypt, DigiCert, etc.
+                # If connecting to services with uncommon CAs, components can call:
+                #   esp32.require_full_certificate_bundle()
+                # Or users can set in their config:
+                #   esp32:
+                #     framework:
+                #       advanced:
+                #         use_full_certificate_bundle: true
                 esp32.add_idf_sdkconfig_option(
                     "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True
                 )

esphome/components/http_request/http_request_arduino.cpp

@@ -131,6 +131,10 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
     }
   }
 
+  // HTTPClient::getSize() returns -1 for chunked transfer encoding (no Content-Length).
+  // When cast to size_t, -1 becomes SIZE_MAX (4294967295 on 32-bit).
+  // The read() method handles this: bytes_read_ can never reach SIZE_MAX, so the
+  // early return check (bytes_read_ >= content_length) will never trigger.
   int content_length = container->client_.getSize();
   ESP_LOGD(TAG, "Content-Length: %d", content_length);
   container->content_length = (size_t) content_length;
@@ -167,17 +171,23 @@ int HttpContainerArduino::read(uint8_t *buf, size_t max_len) {
   }
 
   int available_data = stream_ptr->available();
-  int bufsize = std::min(max_len, std::min(this->content_length - this->bytes_read_, (size_t) available_data));
+  // For chunked transfer encoding, HTTPClient::getSize() returns -1, which becomes SIZE_MAX when
+  // cast to size_t. SIZE_MAX - bytes_read_ is still huge, so it won't limit the read.
+  size_t remaining = (this->content_length > 0) ? (this->content_length - this->bytes_read_) : max_len;
+  int bufsize = std::min(max_len, std::min(remaining, (size_t) available_data));
 
   if (bufsize == 0) {
     this->duration_ms += (millis() - start);
-    // Check if we've read all expected content
+    // Check if we've read all expected content (only valid when content_length is known and not SIZE_MAX)
-    if (this->bytes_read_ >= this->content_length) {
+    // For chunked encoding (content_length == SIZE_MAX), we can't use this check
+    if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
       return 0;  // All content read successfully
     }
     // No data available - check if connection is still open
+    // For chunked encoding, !connected() after reading means EOF (all chunks received)
+    // For known content_length with bytes_read_ < content_length, it means connection dropped
     if (!stream_ptr->connected()) {
-      return HTTP_ERROR_CONNECTION_CLOSED;  // Connection closed prematurely
+      return HTTP_ERROR_CONNECTION_CLOSED;  // Connection closed or EOF for chunked
     }
     return 0;  // No data yet, caller should retry
   }

esphome/components/http_request/http_request_idf.cpp

@@ -157,6 +157,8 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   }
 
   container->feed_wdt();
+  // esp_http_client_fetch_headers() returns 0 for chunked transfer encoding (no Content-Length header).
+  // The read() method handles content_length == 0 specially to support chunked responses.
   container->content_length = esp_http_client_fetch_headers(client);
   container->feed_wdt();
   container->status_code = esp_http_client_get_status_code(client);
@@ -225,14 +227,22 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
 //
 // We normalize to HttpContainer::read() contract:
 //   > 0: bytes read
-//   0: no data yet / all content read (caller should check bytes_read vs content_length)
+//   0: all content read (only returned when content_length is known and fully read)
 //   < 0: error/connection closed
+//
+// Note on chunked transfer encoding:
+//   esp_http_client_fetch_headers() returns 0 for chunked responses (no Content-Length header).
+//   We handle this by skipping the content_length check when content_length is 0,
+//   allowing esp_http_client_read() to handle chunked decoding internally and signal EOF
+//   by returning 0.
 int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
   // Check if we've already read all expected content
-  if (this->bytes_read_ >= this->content_length) {
+  // Skip this check when content_length is 0 (chunked transfer encoding or unknown length)
+  // For chunked responses, esp_http_client_read() will return 0 when all data is received
+  if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
     return 0;  // All content read successfully
   }
 
@@ -247,7 +257,13 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
     return read_len_or_error;
   }
 
-  // Connection closed by server before all content received
+  // esp_http_client_read() returns 0 in two cases:
+  // 1. Known content_length: connection closed before all data received (error)
+  // 2. Chunked encoding (content_length == 0): end of stream reached (EOF)
+  // For case 1, returning HTTP_ERROR_CONNECTION_CLOSED is correct.
+  // For case 2, 0 indicates that all chunked data has already been delivered
+  // in previous successful read() calls, so treating this as a closed
+  // connection does not cause any loss of response data.
   if (read_len_or_error == 0) {
     return HTTP_ERROR_CONNECTION_CLOSED;
   }

esphome/components/hub75/boards/huidu.py

@@ -2,6 +2,25 @@
 
 from . import BoardConfig
 
+# Huidu HD-WF1
+BoardConfig(
+    "huidu-hd-wf1",
+    r1_pin=2,
+    g1_pin=6,
+    b1_pin=3,
+    r2_pin=4,
+    g2_pin=8,
+    b2_pin=5,
+    a_pin=39,
+    b_pin=38,
+    c_pin=37,
+    d_pin=36,
+    e_pin=12,
+    lat_pin=33,
+    oe_pin=35,
+    clk_pin=34,
+)
+
 # Huidu HD-WF2
 BoardConfig(
     "huidu-hd-wf2",

esphome/components/hub75/display.py

@@ -587,7 +587,7 @@ def _build_config_struct(
 async def to_code(config: ConfigType) -> None:
     add_idf_component(
         name="esphome/esp-hub75",
-        ref="0.3.0",
+        ref="0.3.2",
     )
 
     # Set compile-time configuration via build flags (so external library sees them)

esphome/components/integration/integration_sensor.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "integration";
 
 void IntegrationSensor::setup() {
   if (this->restore_) {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<float>();
     float preference_value = 0;
     this->pref_.load(&preference_value);
     this->result_ = preference_value;

esphome/components/ld2450/ld2450.cpp

@@ -184,7 +184,7 @@ static inline bool validate_header_footer(const uint8_t *header_footer, const ui
 void LD2450Component::setup() {
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
-    this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_preference_hash());
+    this->pref_ = this->presence_timeout_number_->make_entity_preference<float>();
     this->set_presence_timeout();
   }
 #endif
@@ -451,7 +451,7 @@ void LD2450Component::handle_periodic_data_() {
   int16_t ty = 0;
   int16_t td = 0;
   int16_t ts = 0;
-  int16_t angle = 0;
+  float angle = 0;
   uint8_t index = 0;
   Direction direction{DIRECTION_UNDEFINED};
   bool is_moving = false;

esphome/components/ld2450/sensor.py

@@ -143,6 +143,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                     ],
                     icon=ICON_FORMAT_TEXT_ROTATION_ANGLE_UP,
                     unit_of_measurement=UNIT_DEGREES,
+                    accuracy_decimals=1,
                 ),
                 cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_DISTANCE,

esphome/components/light/light_state.cpp

@@ -44,7 +44,7 @@ void LightState::setup() {
     case LIGHT_RESTORE_DEFAULT_ON:
     case LIGHT_RESTORE_INVERTED_DEFAULT_OFF:
     case LIGHT_RESTORE_INVERTED_DEFAULT_ON:
-      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
+      this->rtc_ = this->make_entity_preference<LightStateRTCState>();
       // Attempt to load from preferences, else fall back to default values
       if (!this->rtc_.load(&recovered)) {
         recovered.state = (this->restore_mode_ == LIGHT_RESTORE_DEFAULT_ON ||
@@ -57,7 +57,7 @@ void LightState::setup() {
       break;
     case LIGHT_RESTORE_AND_OFF:
     case LIGHT_RESTORE_AND_ON:
-      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
+      this->rtc_ = this->make_entity_preference<LightStateRTCState>();
       this->rtc_.load(&recovered);
       recovered.state = (this->restore_mode_ == LIGHT_RESTORE_AND_ON);
       break;

esphome/components/lock/lock.h

@@ -14,9 +14,7 @@ class Lock;
 #define LOG_LOCK(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
     if ((obj)->traits.get_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \

esphome/components/lvgl/number/lvgl_number.h

@@ -21,7 +21,7 @@ class LVGLNumber : public number::Number, public Component {
   void setup() override {
     float value = this->value_lambda_();
     if (this->restore_) {
-      this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+      this->pref_ = this->make_entity_preference<float>();
       if (this->pref_.load(&value)) {
         this->control_lambda_(value);
       }

esphome/components/lvgl/select/lvgl_select.h

@@ -20,7 +20,7 @@ class LVGLSelect : public select::Select, public Component {
     this->set_options_();
     if (this->restore_) {
       size_t index;
-      this->pref_ = global_preferences->make_preference<size_t>(this->get_preference_hash());
+      this->pref_ = this->make_entity_preference<size_t>();
       if (this->pref_.load(&index))
         this->widget_->set_selected_index(index, LV_ANIM_OFF);
     }

esphome/components/mdns/mdns_esp32.cpp

@@ -12,6 +12,10 @@ namespace esphome::mdns {
 static const char *const TAG = "mdns";
 
 static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services) {
+#ifdef USE_OPENTHREAD
+  // OpenThread handles service registration via SRP client
+  // Services are compiled by MDNSComponent::compile_records_() and consumed by OpenThreadSrpComponent
+#else
   esp_err_t err = mdns_init();
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "Init failed: %s", esp_err_to_name(err));
@@ -41,13 +45,16 @@ static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_S
       ESP_LOGW(TAG, "Failed to register service %s: %s", MDNS_STR_ARG(service.service_type), esp_err_to_name(err));
     }
   }
+#endif
 }
 
 void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }
 
 void MDNSComponent::on_shutdown() {
+#ifndef USE_OPENTHREAD
   mdns_free();
   delay(40);  // Allow the mdns packets announcing service removal to be sent
+#endif
 }
 
 }  // namespace esphome::mdns

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -13,54 +13,27 @@ static const char *const TAG = "mqtt.alarm_control_panel";
 
 using namespace esphome::alarm_control_panel;
 
-static ProgmemStr alarm_state_to_mqtt_str(AlarmControlPanelState state) {
-  switch (state) {
-    case ACP_STATE_DISARMED:
-      return ESPHOME_F("disarmed");
-    case ACP_STATE_ARMED_HOME:
-      return ESPHOME_F("armed_home");
-    case ACP_STATE_ARMED_AWAY:
-      return ESPHOME_F("armed_away");
-    case ACP_STATE_ARMED_NIGHT:
-      return ESPHOME_F("armed_night");
-    case ACP_STATE_ARMED_VACATION:
-      return ESPHOME_F("armed_vacation");
-    case ACP_STATE_ARMED_CUSTOM_BYPASS:
-      return ESPHOME_F("armed_custom_bypass");
-    case ACP_STATE_PENDING:
-      return ESPHOME_F("pending");
-    case ACP_STATE_ARMING:
-      return ESPHOME_F("arming");
-    case ACP_STATE_DISARMING:
-      return ESPHOME_F("disarming");
-    case ACP_STATE_TRIGGERED:
-      return ESPHOME_F("triggered");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
 MQTTAlarmControlPanelComponent::MQTTAlarmControlPanelComponent(AlarmControlPanel *alarm_control_panel)
     : alarm_control_panel_(alarm_control_panel) {}
 void MQTTAlarmControlPanelComponent::setup() {
   this->alarm_control_panel_->add_on_state_callback([this]() { this->publish_state(); });
   this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
     auto call = this->alarm_control_panel_->make_call();
-    if (strcasecmp(payload.c_str(), "ARM_AWAY") == 0) {
+    if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_AWAY")) == 0) {
       call.arm_away();
-    } else if (strcasecmp(payload.c_str(), "ARM_HOME") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_HOME")) == 0) {
       call.arm_home();
-    } else if (strcasecmp(payload.c_str(), "ARM_NIGHT") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_NIGHT")) == 0) {
       call.arm_night();
-    } else if (strcasecmp(payload.c_str(), "ARM_VACATION") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_VACATION")) == 0) {
       call.arm_vacation();
-    } else if (strcasecmp(payload.c_str(), "ARM_CUSTOM_BYPASS") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_CUSTOM_BYPASS")) == 0) {
       call.arm_custom_bypass();
-    } else if (strcasecmp(payload.c_str(), "DISARM") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("DISARM")) == 0) {
       call.disarm();
-    } else if (strcasecmp(payload.c_str(), "PENDING") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("PENDING")) == 0) {
       call.pending();
-    } else if (strcasecmp(payload.c_str(), "TRIGGERED") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("TRIGGERED")) == 0) {
       call.triggered();
     } else {
       ESP_LOGW(TAG, "'%s': Received unknown command payload %s", this->friendly_name_().c_str(), payload.c_str());
@@ -112,9 +85,43 @@ const EntityBase *MQTTAlarmControlPanelComponent::get_entity() const { return th
 
 bool MQTTAlarmControlPanelComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTAlarmControlPanelComponent::publish_state() {
+  const char *state_s;
+  switch (this->alarm_control_panel_->get_state()) {
+    case ACP_STATE_DISARMED:
+      state_s = "disarmed";
+      break;
+    case ACP_STATE_ARMED_HOME:
+      state_s = "armed_home";
+      break;
+    case ACP_STATE_ARMED_AWAY:
+      state_s = "armed_away";
+      break;
+    case ACP_STATE_ARMED_NIGHT:
+      state_s = "armed_night";
+      break;
+    case ACP_STATE_ARMED_VACATION:
+      state_s = "armed_vacation";
+      break;
+    case ACP_STATE_ARMED_CUSTOM_BYPASS:
+      state_s = "armed_custom_bypass";
+      break;
+    case ACP_STATE_PENDING:
+      state_s = "pending";
+      break;
+    case ACP_STATE_ARMING:
+      state_s = "arming";
+      break;
+    case ACP_STATE_DISARMING:
+      state_s = "disarming";
+      break;
+    case ACP_STATE_TRIGGERED:
+      state_s = "triggered";
+      break;
+    default:
+      state_s = "unknown";
+  }
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf),
+  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
-                       alarm_state_to_mqtt_str(this->alarm_control_panel_->get_state()));
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_climate.cpp

@@ -1,6 +1,5 @@
 #include "mqtt_climate.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -13,111 +12,6 @@ static const char *const TAG = "mqtt.climate";
 
 using namespace esphome::climate;
 
-static ProgmemStr climate_mode_to_mqtt_str(ClimateMode mode) {
-  switch (mode) {
-    case CLIMATE_MODE_OFF:
-      return ESPHOME_F("off");
-    case CLIMATE_MODE_HEAT_COOL:
-      return ESPHOME_F("heat_cool");
-    case CLIMATE_MODE_AUTO:
-      return ESPHOME_F("auto");
-    case CLIMATE_MODE_COOL:
-      return ESPHOME_F("cool");
-    case CLIMATE_MODE_HEAT:
-      return ESPHOME_F("heat");
-    case CLIMATE_MODE_FAN_ONLY:
-      return ESPHOME_F("fan_only");
-    case CLIMATE_MODE_DRY:
-      return ESPHOME_F("dry");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
-static ProgmemStr climate_action_to_mqtt_str(ClimateAction action) {
-  switch (action) {
-    case CLIMATE_ACTION_OFF:
-      return ESPHOME_F("off");
-    case CLIMATE_ACTION_COOLING:
-      return ESPHOME_F("cooling");
-    case CLIMATE_ACTION_HEATING:
-      return ESPHOME_F("heating");
-    case CLIMATE_ACTION_IDLE:
-      return ESPHOME_F("idle");
-    case CLIMATE_ACTION_DRYING:
-      return ESPHOME_F("drying");
-    case CLIMATE_ACTION_FAN:
-      return ESPHOME_F("fan");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
-static ProgmemStr climate_fan_mode_to_mqtt_str(ClimateFanMode fan_mode) {
-  switch (fan_mode) {
-    case CLIMATE_FAN_ON:
-      return ESPHOME_F("on");
-    case CLIMATE_FAN_OFF:
-      return ESPHOME_F("off");
-    case CLIMATE_FAN_AUTO:
-      return ESPHOME_F("auto");
-    case CLIMATE_FAN_LOW:
-      return ESPHOME_F("low");
-    case CLIMATE_FAN_MEDIUM:
-      return ESPHOME_F("medium");
-    case CLIMATE_FAN_HIGH:
-      return ESPHOME_F("high");
-    case CLIMATE_FAN_MIDDLE:
-      return ESPHOME_F("middle");
-    case CLIMATE_FAN_FOCUS:
-      return ESPHOME_F("focus");
-    case CLIMATE_FAN_DIFFUSE:
-      return ESPHOME_F("diffuse");
-    case CLIMATE_FAN_QUIET:
-      return ESPHOME_F("quiet");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
-static ProgmemStr climate_swing_mode_to_mqtt_str(ClimateSwingMode swing_mode) {
-  switch (swing_mode) {
-    case CLIMATE_SWING_OFF:
-      return ESPHOME_F("off");
-    case CLIMATE_SWING_BOTH:
-      return ESPHOME_F("both");
-    case CLIMATE_SWING_VERTICAL:
-      return ESPHOME_F("vertical");
-    case CLIMATE_SWING_HORIZONTAL:
-      return ESPHOME_F("horizontal");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
-static ProgmemStr climate_preset_to_mqtt_str(ClimatePreset preset) {
-  switch (preset) {
-    case CLIMATE_PRESET_NONE:
-      return ESPHOME_F("none");
-    case CLIMATE_PRESET_HOME:
-      return ESPHOME_F("home");
-    case CLIMATE_PRESET_ECO:
-      return ESPHOME_F("eco");
-    case CLIMATE_PRESET_AWAY:
-      return ESPHOME_F("away");
-    case CLIMATE_PRESET_BOOST:
-      return ESPHOME_F("boost");
-    case CLIMATE_PRESET_COMFORT:
-      return ESPHOME_F("comfort");
-    case CLIMATE_PRESET_SLEEP:
-      return ESPHOME_F("sleep");
-    case CLIMATE_PRESET_ACTIVITY:
-      return ESPHOME_F("activity");
-    default:
-      return ESPHOME_F("unknown");
-  }
-}
-
 void MQTTClimateComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   auto traits = this->device_->get_traits();
@@ -366,8 +260,34 @@ const EntityBase *MQTTClimateComponent::get_entity() const { return this->device
 bool MQTTClimateComponent::publish_state_() {
   auto traits = this->device_->get_traits();
   // mode
+  const char *mode_s;
+  switch (this->device_->mode) {
+    case CLIMATE_MODE_OFF:
+      mode_s = "off";
+      break;
+    case CLIMATE_MODE_AUTO:
+      mode_s = "auto";
+      break;
+    case CLIMATE_MODE_COOL:
+      mode_s = "cool";
+      break;
+    case CLIMATE_MODE_HEAT:
+      mode_s = "heat";
+      break;
+    case CLIMATE_MODE_FAN_ONLY:
+      mode_s = "fan_only";
+      break;
+    case CLIMATE_MODE_DRY:
+      mode_s = "dry";
+      break;
+    case CLIMATE_MODE_HEAT_COOL:
+      mode_s = "heat_cool";
+      break;
+    default:
+      mode_s = "unknown";
+  }
   bool success = true;
-  if (!this->publish(this->get_mode_state_topic(), climate_mode_to_mqtt_str(this->device_->mode)))
+  if (!this->publish(this->get_mode_state_topic(), mode_s))
     success = false;
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
@@ -407,37 +327,134 @@ bool MQTTClimateComponent::publish_state_() {
   }
 
   if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
-    if (this->device_->has_custom_preset()) {
+    std::string payload;
-      if (!this->publish(this->get_preset_state_topic(), this->device_->get_custom_preset()))
+    if (this->device_->preset.has_value()) {
-        success = false;
+      switch (this->device_->preset.value()) {
-    } else if (this->device_->preset.has_value()) {
+        case CLIMATE_PRESET_NONE:
-      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
+          payload = "none";
-        success = false;
+          break;
-    } else if (!this->publish(this->get_preset_state_topic(), "")) {
+        case CLIMATE_PRESET_HOME:
-      success = false;
+          payload = "home";
+          break;
+        case CLIMATE_PRESET_AWAY:
+          payload = "away";
+          break;
+        case CLIMATE_PRESET_BOOST:
+          payload = "boost";
+          break;
+        case CLIMATE_PRESET_COMFORT:
+          payload = "comfort";
+          break;
+        case CLIMATE_PRESET_ECO:
+          payload = "eco";
+          break;
+        case CLIMATE_PRESET_SLEEP:
+          payload = "sleep";
+          break;
+        case CLIMATE_PRESET_ACTIVITY:
+          payload = "activity";
+          break;
+        default:
+          payload = "unknown";
+      }
     }
+    if (this->device_->has_custom_preset())
+      payload = this->device_->get_custom_preset().c_str();
+    if (!this->publish(this->get_preset_state_topic(), payload))
+      success = false;
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
+    const char *payload;
+    switch (this->device_->action) {
+      case CLIMATE_ACTION_OFF:
+        payload = "off";
+        break;
+      case CLIMATE_ACTION_COOLING:
+        payload = "cooling";
+        break;
+      case CLIMATE_ACTION_HEATING:
+        payload = "heating";
+        break;
+      case CLIMATE_ACTION_IDLE:
+        payload = "idle";
+        break;
+      case CLIMATE_ACTION_DRYING:
+        payload = "drying";
+        break;
+      case CLIMATE_ACTION_FAN:
+        payload = "fan";
+        break;
+      default:
+        payload = "unknown";
+    }
+    if (!this->publish(this->get_action_state_topic(), payload))
       success = false;
   }
 
   if (traits.get_supports_fan_modes()) {
-    if (this->device_->has_custom_fan_mode()) {
+    std::string payload;
-      if (!this->publish(this->get_fan_mode_state_topic(), this->device_->get_custom_fan_mode()))
+    if (this->device_->fan_mode.has_value()) {
-        success = false;
+      switch (this->device_->fan_mode.value()) {
-    } else if (this->device_->fan_mode.has_value()) {
+        case CLIMATE_FAN_ON:
-      if (!this->publish(this->get_fan_mode_state_topic(),
+          payload = "on";
-                         climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
+          break;
-        success = false;
+        case CLIMATE_FAN_OFF:
-    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
+          payload = "off";
-      success = false;
+          break;
+        case CLIMATE_FAN_AUTO:
+          payload = "auto";
+          break;
+        case CLIMATE_FAN_LOW:
+          payload = "low";
+          break;
+        case CLIMATE_FAN_MEDIUM:
+          payload = "medium";
+          break;
+        case CLIMATE_FAN_HIGH:
+          payload = "high";
+          break;
+        case CLIMATE_FAN_MIDDLE:
+          payload = "middle";
+          break;
+        case CLIMATE_FAN_FOCUS:
+          payload = "focus";
+          break;
+        case CLIMATE_FAN_DIFFUSE:
+          payload = "diffuse";
+          break;
+        case CLIMATE_FAN_QUIET:
+          payload = "quiet";
+          break;
+        default:
+          payload = "unknown";
+      }
     }
+    if (this->device_->has_custom_fan_mode())
+      payload = this->device_->get_custom_fan_mode().c_str();
+    if (!this->publish(this->get_fan_mode_state_topic(), payload))
+      success = false;
   }
 
   if (traits.get_supports_swing_modes()) {
-    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
+    const char *payload;
+    switch (this->device_->swing_mode) {
+      case CLIMATE_SWING_OFF:
+        payload = "off";
+        break;
+      case CLIMATE_SWING_BOTH:
+        payload = "both";
+        break;
+      case CLIMATE_SWING_VERTICAL:
+        payload = "vertical";
+        break;
+      case CLIMATE_SWING_HORIZONTAL:
+        payload = "horizontal";
+        break;
+      default:
+        payload = "unknown";
+    }
+    if (!this->publish(this->get_swing_mode_state_topic(), payload))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.cpp

@@ -5,7 +5,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/version.h"
 
 #include "mqtt_const.h"
@@ -150,22 +149,6 @@ bool MQTTComponent::publish(const char *topic, const char *payload) {
   return this->publish(topic, payload, strlen(payload));
 }
 
-#ifdef USE_ESP8266
-bool MQTTComponent::publish(const std::string &topic, ProgmemStr payload) {
-  return this->publish(topic.c_str(), payload);
-}
-
-bool MQTTComponent::publish(const char *topic, ProgmemStr payload) {
-  if (topic[0] == '\0')
-    return false;
-  // On ESP8266, ProgmemStr is __FlashStringHelper* - need to copy from flash
-  char buf[64];
-  strncpy_P(buf, reinterpret_cast<const char *>(payload), sizeof(buf) - 1);
-  buf[sizeof(buf) - 1] = '\0';
-  return global_mqtt_client->publish(topic, buf, strlen(buf), this->qos_, this->retain_);
-}
-#endif
-
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
   return this->publish_json(topic.c_str(), f);
 }

esphome/components/mqtt/mqtt_component.h

@@ -9,7 +9,6 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 #include "mqtt_client.h"
 
@@ -158,15 +157,6 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
-  /** Send a MQTT message.
-   *
-   * @param topic The topic.
-   * @param payload The null-terminated payload.
-   */
-  bool publish(const std::string &topic, const char *payload) {
-    return this->publish(topic.c_str(), payload, strlen(payload));
-  }
-
   /** Send a MQTT message (no heap allocation for topic).
    *
    * @param topic The topic as C string.
@@ -199,29 +189,6 @@ class MQTTComponent : public Component {
    */
   bool publish(StringRef topic, const char *payload) { return this->publish(topic.c_str(), payload); }
 
-#ifdef USE_ESP8266
-  /** Send a MQTT message with a PROGMEM string payload.
-   *
-   * @param topic The topic.
-   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
-   */
-  bool publish(const std::string &topic, ProgmemStr payload);
-
-  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
-   */
-  bool publish(const char *topic, ProgmemStr payload);
-
-  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
-   */
-  bool publish(StringRef topic, ProgmemStr payload) { return this->publish(topic.c_str(), payload); }
-#endif
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.

esphome/components/mqtt/mqtt_cover.cpp

@@ -1,6 +1,5 @@
 #include "mqtt_cover.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -13,20 +12,6 @@ static const char *const TAG = "mqtt.cover";
 
 using namespace esphome::cover;
 
-static ProgmemStr cover_state_to_mqtt_str(CoverOperation operation, float position, bool supports_position) {
-  if (operation == COVER_OPERATION_OPENING)
-    return ESPHOME_F("opening");
-  if (operation == COVER_OPERATION_CLOSING)
-    return ESPHOME_F("closing");
-  if (position == COVER_CLOSED)
-    return ESPHOME_F("closed");
-  if (position == COVER_OPEN)
-    return ESPHOME_F("open");
-  if (supports_position)
-    return ESPHOME_F("open");
-  return ESPHOME_F("unknown");
-}
-
 MQTTCoverComponent::MQTTCoverComponent(Cover *cover) : cover_(cover) {}
 void MQTTCoverComponent::setup() {
   auto traits = this->cover_->get_traits();
@@ -124,10 +109,14 @@ bool MQTTCoverComponent::publish_state() {
     if (!this->publish(this->get_tilt_state_topic(), pos, len))
       success = false;
   }
+  const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"
+                        : this->cover_->current_operation == COVER_OPERATION_CLOSING ? "closing"
+                        : this->cover_->position == COVER_CLOSED                     ? "closed"
+                        : this->cover_->position == COVER_OPEN                       ? "open"
+                        : traits.get_supports_position()                             ? "open"
+                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf),
+  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
-                     cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
-                                             traits.get_supports_position())))
     success = false;
   return success;
 }

esphome/components/mqtt/mqtt_fan.cpp

@@ -1,6 +1,5 @@
 #include "mqtt_fan.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -13,14 +12,6 @@ static const char *const TAG = "mqtt.fan";
 
 using namespace esphome::fan;
 
-static ProgmemStr fan_direction_to_mqtt_str(FanDirection direction) {
-  return direction == FanDirection::FORWARD ? ESPHOME_F("forward") : ESPHOME_F("reverse");
-}
-
-static ProgmemStr fan_oscillation_to_mqtt_str(bool oscillating) {
-  return oscillating ? ESPHOME_F("oscillate_on") : ESPHOME_F("oscillate_off");
-}
-
 MQTTFanComponent::MQTTFanComponent(Fan *state) : state_(state) {}
 
 Fan *MQTTFanComponent::get_state() const { return this->state_; }
@@ -173,12 +164,13 @@ bool MQTTFanComponent::publish_state() {
   this->publish(this->get_state_topic_to_(topic_buf), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
-    bool success = this->publish(this->get_direction_state_topic(), fan_direction_to_mqtt_str(this->state_->direction));
+    bool success = this->publish(this->get_direction_state_topic(),
+                                 this->state_->direction == fan::FanDirection::FORWARD ? "forward" : "reverse");
     failed = failed || !success;
   }
   if (this->state_->get_traits().supports_oscillation()) {
-    bool success =
+    bool success = this->publish(this->get_oscillation_state_topic(),
-        this->publish(this->get_oscillation_state_topic(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
+                                 this->state_->oscillating ? "oscillate_on" : "oscillate_off");
     failed = failed || !success;
   }
   auto traits = this->state_->get_traits();

esphome/components/mqtt/mqtt_lock.cpp

@@ -1,5 +1,6 @@
 #include "mqtt_lock.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -16,11 +17,11 @@ MQTTLockComponent::MQTTLockComponent(lock::Lock *a_lock) : lock_(a_lock) {}
 
 void MQTTLockComponent::setup() {
   this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
-    if (strcasecmp(payload.c_str(), "LOCK") == 0) {
+    if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("LOCK")) == 0) {
       this->lock_->lock();
-    } else if (strcasecmp(payload.c_str(), "UNLOCK") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("UNLOCK")) == 0) {
       this->lock_->unlock();
-    } else if (strcasecmp(payload.c_str(), "OPEN") == 0) {
+    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("OPEN")) == 0) {
       this->lock_->open();
     } else {
       ESP_LOGW(TAG, "'%s': Received unknown status payload: %s", this->friendly_name_().c_str(), payload.c_str());

esphome/components/mqtt/mqtt_valve.cpp

@@ -1,6 +1,5 @@
 #include "mqtt_valve.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -13,20 +12,6 @@ static const char *const TAG = "mqtt.valve";
 
 using namespace esphome::valve;
 
-static ProgmemStr valve_state_to_mqtt_str(ValveOperation operation, float position, bool supports_position) {
-  if (operation == VALVE_OPERATION_OPENING)
-    return ESPHOME_F("opening");
-  if (operation == VALVE_OPERATION_CLOSING)
-    return ESPHOME_F("closing");
-  if (position == VALVE_CLOSED)
-    return ESPHOME_F("closed");
-  if (position == VALVE_OPEN)
-    return ESPHOME_F("open");
-  if (supports_position)
-    return ESPHOME_F("open");
-  return ESPHOME_F("unknown");
-}
-
 MQTTValveComponent::MQTTValveComponent(Valve *valve) : valve_(valve) {}
 void MQTTValveComponent::setup() {
   auto traits = this->valve_->get_traits();
@@ -93,10 +78,14 @@ bool MQTTValveComponent::publish_state() {
     if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
+  const char *state_s = this->valve_->current_operation == VALVE_OPERATION_OPENING   ? "opening"
+                        : this->valve_->current_operation == VALVE_OPERATION_CLOSING ? "closing"
+                        : this->valve_->position == VALVE_CLOSED                     ? "closed"
+                        : this->valve_->position == VALVE_OPEN                       ? "open"
+                        : traits.get_supports_position()                             ? "open"
+                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf),
+  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
-                     valve_state_to_mqtt_str(this->valve_->current_operation, this->valve_->position,
-                                             traits.get_supports_position())))
     success = false;
   return success;
 }

esphome/components/nextion/nextion.cpp

@@ -150,27 +150,24 @@ void Nextion::dump_config() {
 #ifdef USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
   ESP_LOGCONFIG(TAG, "  Skip handshake: YES");
 #else  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
-  ESP_LOGCONFIG(TAG,
 #ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+  ESP_LOGCONFIG(TAG,
                 "  Device Model: %s\n"
                 "  FW Version: %s\n"
                 "  Serial Number: %s\n"
                 "  Flash Size: %s\n"
                 "  Max queue age: %u ms\n"
                 "  Startup override: %u ms\n",
+                this->device_model_.c_str(), this->firmware_version_.c_str(), this->serial_number_.c_str(),
+                this->flash_size_.c_str(), this->max_q_age_ms_, this->startup_override_ms_);
 #endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
 #ifdef USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
-                "  Exit reparse: YES\n"
+  ESP_LOGCONFIG(TAG, "  Exit reparse: YES\n");
 #endif  // USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
+  ESP_LOGCONFIG(TAG,
                 "  Wake On Touch: %s\n"
                 "  Touch Timeout: %" PRIu16,
-#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+                YESNO(this->connection_state_.auto_wake_on_touch_), this->touch_sleep_timeout_);
-                this->device_model_.c_str(), this->firmware_version_.c_str(), this->serial_number_.c_str(),
-                this->flash_size_.c_str(), this->max_q_age_ms_,
-                this->startup_override_ms_
-#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
-                    YESNO(this->connection_state_.auto_wake_on_touch_),
-                this->touch_sleep_timeout_);
 #endif  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
 
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP

esphome/components/nfc/binary_sensor/nfc_binary_sensor.cpp

@@ -40,7 +40,7 @@ void NfcTagBinarySensor::set_tag_name(const std::string &str) {
   this->match_tag_name_ = true;
 }
 
-void NfcTagBinarySensor::set_uid(const std::vector<uint8_t> &uid) { this->uid_ = uid; }
+void NfcTagBinarySensor::set_uid(const NfcTagUid &uid) { this->uid_ = uid; }
 
 bool NfcTagBinarySensor::tag_match_ndef_string(const std::shared_ptr<NdefMessage> &msg) {
   for (const auto &record : msg->get_records()) {
@@ -63,7 +63,7 @@ bool NfcTagBinarySensor::tag_match_tag_name(const std::shared_ptr<NdefMessage> &
   return false;
 }
 
-bool NfcTagBinarySensor::tag_match_uid(const std::vector<uint8_t> &data) {
+bool NfcTagBinarySensor::tag_match_uid(const NfcTagUid &data) {
   if (data.size() != this->uid_.size()) {
     return false;
   }

esphome/components/nfc/binary_sensor/nfc_binary_sensor.h

@@ -19,11 +19,11 @@ class NfcTagBinarySensor : public binary_sensor::BinarySensor,
 
   void set_ndef_match_string(const std::string &str);
   void set_tag_name(const std::string &str);
-  void set_uid(const std::vector<uint8_t> &uid);
+  void set_uid(const NfcTagUid &uid);
 
   bool tag_match_ndef_string(const std::shared_ptr<NdefMessage> &msg);
   bool tag_match_tag_name(const std::shared_ptr<NdefMessage> &msg);
-  bool tag_match_uid(const std::vector<uint8_t> &data);
+  bool tag_match_uid(const NfcTagUid &data);
 
   void tag_off(NfcTag &tag) override;
   void tag_on(NfcTag &tag) override;
@@ -31,7 +31,7 @@ class NfcTagBinarySensor : public binary_sensor::BinarySensor,
  protected:
   bool match_tag_name_{false};
   std::string match_string_;
-  std::vector<uint8_t> uid_;
+  NfcTagUid uid_;
 };
 
 }  // namespace nfc

esphome/components/nfc/nfc.cpp

@@ -8,19 +8,23 @@ namespace nfc {
 
 static const char *const TAG = "nfc";
 
-char *format_uid_to(char *buffer, const std::vector<uint8_t> &uid) {
+char *format_uid_to(char *buffer, std::span<const uint8_t> uid) {
   return format_hex_pretty_to(buffer, FORMAT_UID_BUFFER_SIZE, uid.data(), uid.size(), '-');
 }
 
-char *format_bytes_to(char *buffer, const std::vector<uint8_t> &bytes) {
+char *format_bytes_to(char *buffer, std::span<const uint8_t> bytes) {
   return format_hex_pretty_to(buffer, FORMAT_BYTES_BUFFER_SIZE, bytes.data(), bytes.size(), ' ');
 }
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 // Deprecated wrappers intentionally use heap-allocating version for backward compatibility
-std::string format_uid(const std::vector<uint8_t> &uid) { return format_hex_pretty(uid, '-', false); }        // NOLINT
+std::string format_uid(std::span<const uint8_t> uid) {
-std::string format_bytes(const std::vector<uint8_t> &bytes) { return format_hex_pretty(bytes, ' ', false); }  // NOLINT
+  return format_hex_pretty(uid.data(), uid.size(), '-', false);  // NOLINT
+}
+std::string format_bytes(std::span<const uint8_t> bytes) {
+  return format_hex_pretty(bytes.data(), bytes.size(), ' ', false);  // NOLINT
+}
 #pragma GCC diagnostic pop
 
 uint8_t guess_tag_type(uint8_t uid_length) {

esphome/components/nfc/nfc.h

@@ -6,6 +6,7 @@
 #include "ndef_record.h"
 #include "nfc_tag.h"
 
+#include <span>
 #include <vector>
 
 namespace esphome {
@@ -56,19 +57,19 @@ static const uint8_t MAD_KEY[6] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5};
 /// Max UID size is 10 bytes, formatted as "XX-XX-XX-XX-XX-XX-XX-XX-XX-XX\0" = 30 chars
 static constexpr size_t FORMAT_UID_BUFFER_SIZE = 30;
 /// Format UID to buffer with '-' separator (e.g., "04-11-22-33"). Returns buffer for inline use.
-char *format_uid_to(char *buffer, const std::vector<uint8_t> &uid);
+char *format_uid_to(char *buffer, std::span<const uint8_t> uid);
 
 /// Buffer size for format_bytes_to (64 bytes max = 192 chars with space separator)
 static constexpr size_t FORMAT_BYTES_BUFFER_SIZE = 192;
 /// Format bytes to buffer with ' ' separator (e.g., "04 11 22 33"). Returns buffer for inline use.
-char *format_bytes_to(char *buffer, const std::vector<uint8_t> &bytes);
+char *format_bytes_to(char *buffer, std::span<const uint8_t> bytes);
 
 // Remove before 2026.6.0
 ESPDEPRECATED("Use format_uid_to() with stack buffer instead. Removed in 2026.6.0", "2025.12.0")
-std::string format_uid(const std::vector<uint8_t> &uid);
+std::string format_uid(std::span<const uint8_t> uid);
 // Remove before 2026.6.0
 ESPDEPRECATED("Use format_bytes_to() with stack buffer instead. Removed in 2026.6.0", "2025.12.0")
-std::string format_bytes(const std::vector<uint8_t> &bytes);
+std::string format_bytes(std::span<const uint8_t> bytes);
 
 uint8_t guess_tag_type(uint8_t uid_length);
 uint8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data);

esphome/components/nfc/nfc_tag.h

@@ -10,26 +10,27 @@
 namespace esphome {
 namespace nfc {
 
+// NFC UIDs are 4, 7, or 10 bytes depending on tag type
+static constexpr size_t NFC_UID_MAX_LENGTH = 10;
+using NfcTagUid = StaticVector<uint8_t, NFC_UID_MAX_LENGTH>;
+
 class NfcTag {
  public:
-  NfcTag() {
+  NfcTag() { this->tag_type_ = "Unknown"; };
-    this->uid_ = {};
+  NfcTag(const NfcTagUid &uid) {
-    this->tag_type_ = "Unknown";
-  };
-  NfcTag(std::vector<uint8_t> &uid) {
     this->uid_ = uid;
     this->tag_type_ = "Unknown";
   };
-  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type) {
+  NfcTag(const NfcTagUid &uid, const std::string &tag_type) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
   };
-  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type, std::unique_ptr<nfc::NdefMessage> ndef_message) {
+  NfcTag(const NfcTagUid &uid, const std::string &tag_type, std::unique_ptr<nfc::NdefMessage> ndef_message) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
     this->ndef_message_ = std::move(ndef_message);
   };
-  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type, std::vector<uint8_t> &ndef_data) {
+  NfcTag(const NfcTagUid &uid, const std::string &tag_type, std::vector<uint8_t> &ndef_data) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
     this->ndef_message_ = make_unique<NdefMessage>(ndef_data);
@@ -41,14 +42,14 @@ class NfcTag {
       ndef_message_ = make_unique<NdefMessage>(*rhs.ndef_message_);
   }
 
-  std::vector<uint8_t> &get_uid() { return this->uid_; };
+  NfcTagUid &get_uid() { return this->uid_; };
   const std::string &get_tag_type() { return this->tag_type_; };
   bool has_ndef_message() { return this->ndef_message_ != nullptr; };
   const std::shared_ptr<NdefMessage> &get_ndef_message() { return this->ndef_message_; };
   void set_ndef_message(std::unique_ptr<NdefMessage> ndef_message) { this->ndef_message_ = std::move(ndef_message); };
 
  protected:
-  std::vector<uint8_t> uid_;
+  NfcTagUid uid_;
   std::string tag_type_;
   std::shared_ptr<NdefMessage> ndef_message_;
 };

esphome/components/nrf52/__init__.py

@@ -69,9 +69,21 @@ def set_core_data(config: ConfigType) -> ConfigType:
 
 
 def set_framework(config: ConfigType) -> ConfigType:
-    version = cv.Version.parse(cv.version_number(config[CONF_FRAMEWORK][CONF_VERSION]))
+    framework_ver = cv.Version.parse(
-    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = version
+        cv.version_number(config[CONF_FRAMEWORK][CONF_VERSION])
-    return config
+    )
+    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = framework_ver
+    if framework_ver < cv.Version(2, 9, 2):
+        return cv.require_framework_version(
+            nrf52_zephyr=cv.Version(2, 6, 1, "a"),
+        )(config)
+    if framework_ver < cv.Version(3, 2, 0):
+        return cv.require_framework_version(
+            nrf52_zephyr=cv.Version(2, 9, 2, "2"),
+        )(config)
+    return cv.require_framework_version(
+        nrf52_zephyr=cv.Version(3, 2, 0, "1"),
+    )(config)
 
 
 BOOTLOADERS = [
@@ -140,7 +152,7 @@ CONFIG_SCHEMA = cv.All(
                     cv.Optional(CONF_UICR_ERASE, default=False): cv.boolean,
                 }
             ),
-            cv.Optional(CONF_FRAMEWORK, default={CONF_VERSION: "2.6.1-7"}): cv.Schema(
+            cv.Optional(CONF_FRAMEWORK, default={CONF_VERSION: "2.6.1-a"}): cv.Schema(
                 {
                     cv.Required(CONF_VERSION): cv.string_strict,
                 }
@@ -181,13 +193,12 @@ async def to_code(config: ConfigType) -> None:
     cg.add_platformio_option(CONF_FRAMEWORK, CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK])
     cg.add_platformio_option(
         "platform",
-        "https://github.com/tomaszduda23/platform-nordicnrf52/archive/refs/tags/v10.3.0-1.zip",
+        "https://github.com/tomaszduda23/platform-nordicnrf52/archive/refs/tags/v10.3.0-5.zip",
     )
     cg.add_platformio_option(
         "platform_packages",
         [
             f"platformio/framework-zephyr@https://github.com/tomaszduda23/framework-sdk-nrf/archive/refs/tags/v{CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]}.zip",
-            "platformio/toolchain-gccarmnoneeabi@https://github.com/tomaszduda23/toolchain-sdk-ng/archive/refs/tags/v0.17.4-0.zip",
         ],
     )
 

esphome/components/number/automation.cpp

@@ -14,8 +14,7 @@ void ValueRangeTrigger::setup() {
   float local_min = this->min_.value(0.0);
   float local_max = this->max_.value(0.0);
   convert hash = {.from = (local_max - local_min)};
-  uint32_t myhash = hash.to ^ this->parent_->get_preference_hash();
+  this->rtc_ = this->parent_->make_entity_preference<bool>(hash.to);
-  this->rtc_ = global_preferences->make_preference<bool>(myhash);
   bool initial_state;
   if (this->rtc_.load(&initial_state)) {
     this->previous_in_range_ = initial_state;

esphome/components/number/number.cpp

@@ -14,18 +14,9 @@ void log_number(const char *tag, const char *prefix, const char *type, Number *o
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-
+  LOG_ENTITY_ICON(tag, prefix, *obj);
-  if (!obj->get_icon_ref().empty()) {
+  LOG_ENTITY_UNIT_OF_MEASUREMENT(tag, prefix, obj->traits);
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  LOG_ENTITY_DEVICE_CLASS(tag, prefix, obj->traits);
-  }
-
-  if (!obj->traits.get_unit_of_measurement_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Unit of Measurement: '%s'", prefix, obj->traits.get_unit_of_measurement_ref().c_str());
-  }
-
-  if (!obj->traits.get_device_class_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->traits.get_device_class_ref().c_str());
-  }
 }
 
 void Number::publish_state(float state) {

esphome/components/opentherm/number/opentherm_number.cpp

@@ -17,7 +17,7 @@ void OpenthermNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<float>();
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/pn532/pn532.cpp

@@ -168,11 +168,11 @@ void PN532::loop() {
   }
 
   uint8_t nfcid_length = read[5];
-  std::vector<uint8_t> nfcid(read.begin() + 6, read.begin() + 6 + nfcid_length);
+  if (nfcid_length > nfc::NFC_UID_MAX_LENGTH || read.size() < 6U + nfcid_length) {
-  if (read.size() < 6U + nfcid_length) {
     // oops, pn532 returned invalid data
     return;
   }
+  nfc::NfcTagUid nfcid(read.begin() + 6, read.begin() + 6 + nfcid_length);
 
   bool report = true;
   for (auto *bin_sens : this->binary_sensors_) {
@@ -358,7 +358,7 @@ void PN532::turn_off_rf_() {
   });
 }
 
-std::unique_ptr<nfc::NfcTag> PN532::read_tag_(std::vector<uint8_t> &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_tag_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
 
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
@@ -393,7 +393,7 @@ void PN532::write_mode(nfc::NdefMessage *message) {
   ESP_LOGD(TAG, "Waiting to write next tag");
 }
 
-bool PN532::clean_tag_(std::vector<uint8_t> &uid) {
+bool PN532::clean_tag_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->format_mifare_classic_mifare_(uid);
@@ -404,7 +404,7 @@ bool PN532::clean_tag_(std::vector<uint8_t> &uid) {
   return false;
 }
 
-bool PN532::format_tag_(std::vector<uint8_t> &uid) {
+bool PN532::format_tag_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->format_mifare_classic_ndef_(uid);
@@ -415,7 +415,7 @@ bool PN532::format_tag_(std::vector<uint8_t> &uid) {
   return false;
 }
 
-bool PN532::write_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
+bool PN532::write_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->write_mifare_classic_tag_(uid, message);
@@ -448,7 +448,7 @@ void PN532::dump_config() {
   }
 }
 
-bool PN532BinarySensor::process(std::vector<uint8_t> &data) {
+bool PN532BinarySensor::process(const nfc::NfcTagUid &data) {
   if (data.size() != this->uid_.size())
     return false;
 

esphome/components/pn532/pn532.h

@@ -69,28 +69,28 @@ class PN532 : public PollingComponent {
   virtual bool read_data(std::vector<uint8_t> &data, uint8_t len) = 0;
   virtual bool read_response(uint8_t command, std::vector<uint8_t> &data) = 0;
 
-  std::unique_ptr<nfc::NfcTag> read_tag_(std::vector<uint8_t> &uid);
+  std::unique_ptr<nfc::NfcTag> read_tag_(nfc::NfcTagUid &uid);
 
-  bool format_tag_(std::vector<uint8_t> &uid);
+  bool format_tag_(nfc::NfcTagUid &uid);
-  bool clean_tag_(std::vector<uint8_t> &uid);
+  bool clean_tag_(nfc::NfcTagUid &uid);
-  bool write_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
+  bool write_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
 
-  std::unique_ptr<nfc::NfcTag> read_mifare_classic_tag_(std::vector<uint8_t> &uid);
+  std::unique_ptr<nfc::NfcTag> read_mifare_classic_tag_(nfc::NfcTagUid &uid);
   bool read_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &data);
   bool write_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &data);
-  bool auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key);
+  bool auth_mifare_classic_block_(nfc::NfcTagUid &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key);
-  bool format_mifare_classic_mifare_(std::vector<uint8_t> &uid);
+  bool format_mifare_classic_mifare_(nfc::NfcTagUid &uid);
-  bool format_mifare_classic_ndef_(std::vector<uint8_t> &uid);
+  bool format_mifare_classic_ndef_(nfc::NfcTagUid &uid);
-  bool write_mifare_classic_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
+  bool write_mifare_classic_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
 
-  std::unique_ptr<nfc::NfcTag> read_mifare_ultralight_tag_(std::vector<uint8_t> &uid);
+  std::unique_ptr<nfc::NfcTag> read_mifare_ultralight_tag_(nfc::NfcTagUid &uid);
   bool read_mifare_ultralight_bytes_(uint8_t start_page, uint16_t num_bytes, std::vector<uint8_t> &data);
   bool is_mifare_ultralight_formatted_(const std::vector<uint8_t> &page_3_to_6);
   uint16_t read_mifare_ultralight_capacity_();
   bool find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                     uint8_t &message_start_index);
   bool write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  bool write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
+  bool write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
   bool clean_mifare_ultralight_();
 
   bool updates_enabled_{true};
@@ -98,7 +98,7 @@ class PN532 : public PollingComponent {
   std::vector<PN532BinarySensor *> binary_sensors_;
   std::vector<nfc::NfcOnTagTrigger *> triggers_ontag_;
   std::vector<nfc::NfcOnTagTrigger *> triggers_ontagremoved_;
-  std::vector<uint8_t> current_uid_;
+  nfc::NfcTagUid current_uid_;
   nfc::NdefMessage *next_task_message_to_write_;
   uint32_t rd_start_time_{0};
   enum PN532ReadReady rd_ready_ { WOULDBLOCK };
@@ -118,9 +118,9 @@ class PN532 : public PollingComponent {
 
 class PN532BinarySensor : public binary_sensor::BinarySensor {
  public:
-  void set_uid(const std::vector<uint8_t> &uid) { uid_ = uid; }
+  void set_uid(const nfc::NfcTagUid &uid) { uid_ = uid; }
 
-  bool process(std::vector<uint8_t> &data);
+  bool process(const nfc::NfcTagUid &data);
 
   void on_scan_end() {
     if (!this->found_) {
@@ -130,7 +130,7 @@ class PN532BinarySensor : public binary_sensor::BinarySensor {
   }
 
  protected:
-  std::vector<uint8_t> uid_;
+  nfc::NfcTagUid uid_;
   bool found_{false};
 };
 

esphome/components/pn532/pn532_mifare_classic.cpp

@@ -8,7 +8,7 @@ namespace pn532 {
 
 static const char *const TAG = "pn532.mifare_classic";
 
-std::unique_ptr<nfc::NfcTag> PN532::read_mifare_classic_tag_(std::vector<uint8_t> &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_mifare_classic_tag_(nfc::NfcTagUid &uid) {
   uint8_t current_block = 4;
   uint8_t message_start_index = 0;
   uint32_t message_length = 0;
@@ -82,8 +82,7 @@ bool PN532::read_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &
   return true;
 }
 
-bool PN532::auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_num, uint8_t key_num,
+bool PN532::auth_mifare_classic_block_(nfc::NfcTagUid &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key) {
-                                       const uint8_t *key) {
   std::vector<uint8_t> data({
       PN532_COMMAND_INDATAEXCHANGE,
       0x01,       // One card
@@ -106,7 +105,7 @@ bool PN532::auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_
   return true;
 }
 
-bool PN532::format_mifare_classic_mifare_(std::vector<uint8_t> &uid) {
+bool PN532::format_mifare_classic_mifare_(nfc::NfcTagUid &uid) {
   std::vector<uint8_t> blank_buffer(
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
   std::vector<uint8_t> trailer_buffer(
@@ -141,7 +140,7 @@ bool PN532::format_mifare_classic_mifare_(std::vector<uint8_t> &uid) {
   return !error;
 }
 
-bool PN532::format_mifare_classic_ndef_(std::vector<uint8_t> &uid) {
+bool PN532::format_mifare_classic_ndef_(nfc::NfcTagUid &uid) {
   std::vector<uint8_t> empty_ndef_message(
       {0x03, 0x03, 0xD0, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
   std::vector<uint8_t> blank_block(
@@ -216,7 +215,7 @@ bool PN532::write_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t>
   return true;
 }
 
-bool PN532::write_mifare_classic_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
+bool PN532::write_mifare_classic_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
   auto encoded = message->encode();
 
   uint32_t message_length = encoded.size();

esphome/components/pn532/pn532_mifare_ultralight.cpp

@@ -8,7 +8,7 @@ namespace pn532 {
 
 static const char *const TAG = "pn532.mifare_ultralight";
 
-std::unique_ptr<nfc::NfcTag> PN532::read_mifare_ultralight_tag_(std::vector<uint8_t> &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_mifare_ultralight_tag_(nfc::NfcTagUid &uid) {
   std::vector<uint8_t> data;
   // pages 3 to 6 contain various info we are interested in -- do one read to grab it all
   if (!this->read_mifare_ultralight_bytes_(3, nfc::MIFARE_ULTRALIGHT_PAGE_SIZE * nfc::MIFARE_ULTRALIGHT_READ_SIZE,
@@ -114,7 +114,7 @@ bool PN532::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6
   return false;
 }
 
-bool PN532::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
+bool PN532::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/pn7150/pn7150.cpp

@@ -478,7 +478,7 @@ uint8_t PN7150::read_endpoint_data_(nfc::NfcTag &tag) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::clean_endpoint_(std::vector<uint8_t> &uid) {
+uint8_t PN7150::clean_endpoint_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -494,7 +494,7 @@ uint8_t PN7150::clean_endpoint_(std::vector<uint8_t> &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::format_endpoint_(std::vector<uint8_t> &uid) {
+uint8_t PN7150::format_endpoint_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -510,7 +510,7 @@ uint8_t PN7150::format_endpoint_(std::vector<uint8_t> &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7150::write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -534,7 +534,7 @@ std::unique_ptr<nfc::NfcTag> PN7150::build_tag_(const uint8_t mode_tech, const s
         ESP_LOGE(TAG, "UID length cannot be zero");
         return nullptr;
       }
-      std::vector<uint8_t> uid(data.begin() + 3, data.begin() + 3 + uid_length);
+      nfc::NfcTagUid uid(data.begin() + 3, data.begin() + 3 + uid_length);
       const auto *tag_type_str =
           nfc::guess_tag_type(uid_length) == nfc::TAG_TYPE_MIFARE_CLASSIC ? nfc::MIFARE_CLASSIC : nfc::NFC_FORUM_TYPE_2;
       return make_unique<nfc::NfcTag>(uid, tag_type_str);
@@ -543,7 +543,7 @@ std::unique_ptr<nfc::NfcTag> PN7150::build_tag_(const uint8_t mode_tech, const s
   return nullptr;
 }
 
-optional<size_t> PN7150::find_tag_uid_(const std::vector<uint8_t> &uid) {
+optional<size_t> PN7150::find_tag_uid_(const nfc::NfcTagUid &uid) {
   if (!this->discovered_endpoint_.empty()) {
     for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
       auto existing_tag_uid = this->discovered_endpoint_[i].tag->get_uid();

esphome/components/pn7150/pn7150.h

@@ -203,12 +203,12 @@ class PN7150 : public nfc::Nfcc, public Component {
   void select_endpoint_();
 
   uint8_t read_endpoint_data_(nfc::NfcTag &tag);
-  uint8_t clean_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t clean_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t format_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t format_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message);
 
   std::unique_ptr<nfc::NfcTag> build_tag_(uint8_t mode_tech, const std::vector<uint8_t> &data);
-  optional<size_t> find_tag_uid_(const std::vector<uint8_t> &uid);
+  optional<size_t> find_tag_uid_(const nfc::NfcTagUid &uid);
   void purge_old_tags_();
   void erase_tag_(uint8_t tag_index);
 
@@ -251,7 +251,7 @@ class PN7150 : public nfc::Nfcc, public Component {
   uint8_t find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                        uint8_t &message_start_index);
   uint8_t write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  uint8_t write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, const std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message);
   uint8_t clean_mifare_ultralight_();
 
   enum NfcTask : uint8_t {

esphome/components/pn7150/pn7150_mifare_ultralight.cpp

@@ -115,8 +115,7 @@ uint8_t PN7150::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid,
+uint8_t PN7150::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message) {
-                                             const std::shared_ptr<nfc::NdefMessage> &message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/pn7160/pn7160.cpp

@@ -506,7 +506,7 @@ uint8_t PN7160::read_endpoint_data_(nfc::NfcTag &tag) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::clean_endpoint_(std::vector<uint8_t> &uid) {
+uint8_t PN7160::clean_endpoint_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -522,7 +522,7 @@ uint8_t PN7160::clean_endpoint_(std::vector<uint8_t> &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::format_endpoint_(std::vector<uint8_t> &uid) {
+uint8_t PN7160::format_endpoint_(nfc::NfcTagUid &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -538,7 +538,7 @@ uint8_t PN7160::format_endpoint_(std::vector<uint8_t> &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7160::write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -562,7 +562,7 @@ std::unique_ptr<nfc::NfcTag> PN7160::build_tag_(const uint8_t mode_tech, const s
         ESP_LOGE(TAG, "UID length cannot be zero");
         return nullptr;
       }
-      std::vector<uint8_t> uid(data.begin() + 3, data.begin() + 3 + uid_length);
+      nfc::NfcTagUid uid(data.begin() + 3, data.begin() + 3 + uid_length);
       const auto *tag_type_str =
           nfc::guess_tag_type(uid_length) == nfc::TAG_TYPE_MIFARE_CLASSIC ? nfc::MIFARE_CLASSIC : nfc::NFC_FORUM_TYPE_2;
       return make_unique<nfc::NfcTag>(uid, tag_type_str);
@@ -571,7 +571,7 @@ std::unique_ptr<nfc::NfcTag> PN7160::build_tag_(const uint8_t mode_tech, const s
   return nullptr;
 }
 
-optional<size_t> PN7160::find_tag_uid_(const std::vector<uint8_t> &uid) {
+optional<size_t> PN7160::find_tag_uid_(const nfc::NfcTagUid &uid) {
   if (!this->discovered_endpoint_.empty()) {
     for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
       auto existing_tag_uid = this->discovered_endpoint_[i].tag->get_uid();

esphome/components/pn7160/pn7160.h

@@ -220,12 +220,12 @@ class PN7160 : public nfc::Nfcc, public Component {
   void select_endpoint_();
 
   uint8_t read_endpoint_data_(nfc::NfcTag &tag);
-  uint8_t clean_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t clean_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t format_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t format_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message);
 
   std::unique_ptr<nfc::NfcTag> build_tag_(uint8_t mode_tech, const std::vector<uint8_t> &data);
-  optional<size_t> find_tag_uid_(const std::vector<uint8_t> &uid);
+  optional<size_t> find_tag_uid_(const nfc::NfcTagUid &uid);
   void purge_old_tags_();
   void erase_tag_(uint8_t tag_index);
 
@@ -268,7 +268,7 @@ class PN7160 : public nfc::Nfcc, public Component {
   uint8_t find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                        uint8_t &message_start_index);
   uint8_t write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  uint8_t write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, const std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message);
   uint8_t clean_mifare_ultralight_();
 
   enum NfcTask : uint8_t {

esphome/components/pn7160/pn7160_mifare_ultralight.cpp

@@ -115,8 +115,7 @@ uint8_t PN7160::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid,
+uint8_t PN7160::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message) {
-                                             const std::shared_ptr<nfc::NdefMessage> &message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/prometheus/prometheus_handler.h

@@ -41,12 +41,14 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
   void add_label_name(EntityBase *obj, const std::string &value) { relabel_map_name_.insert({obj, value}); }
 
   bool canHandle(AsyncWebServerRequest *request) const override {
-    if (request->method() == HTTP_GET) {
+    if (request->method() != HTTP_GET)
-      if (request->url() == "/metrics")
+      return false;
-        return true;
+#ifdef USE_ESP32
-    }
+    char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-
+    return request->url_to(url_buf) == "/metrics";
-    return false;
+#else
+    return request->url() == ESPHOME_F("/metrics");
+#endif
   }
 
   void handleRequest(AsyncWebServerRequest *req) override;

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -132,7 +132,7 @@ void RotaryEncoderSensor::setup() {
   int32_t initial_value = 0;
   switch (this->restore_mode_) {
     case ROTARY_ENCODER_RESTORE_DEFAULT_ZERO:
-      this->rtc_ = global_preferences->make_preference<int32_t>(this->get_preference_hash());
+      this->rtc_ = this->make_entity_preference<int32_t>();
       if (!this->rtc_.load(&initial_value)) {
         initial_value = 0;
       }

esphome/components/rp2040/preferences.cpp

@@ -8,7 +8,6 @@
 #include "preferences.h"
 
 #include <cstring>
-#include <vector>
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -25,6 +24,9 @@ static bool s_flash_dirty = false;          // NOLINT(cppcoreguidelines-avoid-no
 
 static const uint32_t RP2040_FLASH_STORAGE_SIZE = 512;
 
+// Stack buffer size for preferences - covers virtually all real-world preferences without heap allocation
+static constexpr size_t PREF_BUFFER_SIZE = 64;
+
 extern "C" uint8_t _EEPROM_start;
 
 template<class It> uint8_t calculate_crc(It first, It last, uint32_t type) {
@@ -42,12 +44,14 @@ class RP2040PreferenceBackend : public ESPPreferenceBackend {
   uint32_t type = 0;
 
   bool save(const uint8_t *data, size_t len) override {
-    std::vector<uint8_t> buffer;
+    const size_t buffer_size = len + 1;
-    buffer.resize(len + 1);
+    SmallBufferWithHeapFallback<PREF_BUFFER_SIZE> buffer_alloc(buffer_size);
-    memcpy(buffer.data(), data, len);
+    uint8_t *buffer = buffer_alloc.get();
-    buffer[buffer.size() - 1] = calculate_crc(buffer.begin(), buffer.end() - 1, type);
 
-    for (uint32_t i = 0; i < len + 1; i++) {
+    memcpy(buffer, data, len);
+    buffer[len] = calculate_crc(buffer, buffer + len, type);
+
+    for (size_t i = 0; i < buffer_size; i++) {
       uint32_t j = offset + i;
       if (j >= RP2040_FLASH_STORAGE_SIZE)
         return false;
@@ -60,22 +64,23 @@ class RP2040PreferenceBackend : public ESPPreferenceBackend {
     return true;
   }
   bool load(uint8_t *data, size_t len) override {
-    std::vector<uint8_t> buffer;
+    const size_t buffer_size = len + 1;
-    buffer.resize(len + 1);
+    SmallBufferWithHeapFallback<PREF_BUFFER_SIZE> buffer_alloc(buffer_size);
+    uint8_t *buffer = buffer_alloc.get();
 
-    for (size_t i = 0; i < len + 1; i++) {
+    for (size_t i = 0; i < buffer_size; i++) {
       uint32_t j = offset + i;
       if (j >= RP2040_FLASH_STORAGE_SIZE)
         return false;
       buffer[i] = s_flash_storage[j];
     }
 
-    uint8_t crc = calculate_crc(buffer.begin(), buffer.end() - 1, type);
+    uint8_t crc = calculate_crc(buffer, buffer + len, type);
-    if (buffer[buffer.size() - 1] != crc) {
+    if (buffer[len] != crc) {
       return false;
     }
 
-    memcpy(data, buffer.data(), len);
+    memcpy(data, buffer, len);
     return true;
   }
 };

esphome/components/rtl87xx/boards.py

@@ -23,6 +23,10 @@ RTL87XX_BOARDS = {
         "name": "WR2 Wi-Fi Module",
         "family": FAMILY_RTL8710B,
     },
+    "wbr3": {
+        "name": "WBR3 Wi-Fi Module",
+        "family": FAMILY_RTL8720C,
+    },
     "generic-rtl8710bn-2mb-468k": {
         "name": "Generic - RTL8710BN (2M/468k)",
         "family": FAMILY_RTL8710B,
@@ -79,6 +83,10 @@ RTL87XX_BOARDS = {
         "name": "T103_V1.0",
         "family": FAMILY_RTL8710B,
     },
+    "generic-rtl8720cf-2mb-896k": {
+        "name": "Generic - RTL8720CF (2M/896k)",
+        "family": FAMILY_RTL8720C,
+    },
     "generic-rtl8720cf-2mb-992k": {
         "name": "Generic - RTL8720CF (2M/992k)",
         "family": FAMILY_RTL8720C,
@@ -221,6 +229,71 @@ RTL87XX_BOARD_PINS = {
         "D9": 29,
         "A1": 41,
     },
+    "wbr3": {
+        "WIRE0_SCL_0": 11,
+        "WIRE0_SCL_1": 2,
+        "WIRE0_SCL_2": 19,
+        "WIRE0_SCL_3": 15,
+        "WIRE0_SDA_0": 3,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 16,
+        "SERIAL0_RX_0": 12,
+        "SERIAL0_RX_1": 13,
+        "SERIAL0_TX_0": 11,
+        "SERIAL0_TX_1": 14,
+        "SERIAL1_CTS": 4,
+        "SERIAL1_RX_0": 2,
+        "SERIAL1_RX_1": 0,
+        "SERIAL1_TX_0": 3,
+        "SERIAL1_TX_1": 1,
+        "SERIAL2_CTS": 19,
+        "SERIAL2_RX": 15,
+        "SERIAL2_TX": 16,
+        "CS0": 15,
+        "CTS1": 4,
+        "CTS2": 19,
+        "PA00": 0,
+        "PA0": 0,
+        "PA01": 1,
+        "PA1": 1,
+        "PA02": 2,
+        "PA2": 2,
+        "PA03": 3,
+        "PA3": 3,
+        "PA04": 4,
+        "PA4": 4,
+        "PA07": 7,
+        "PA7": 7,
+        "PA11": 11,
+        "PA12": 12,
+        "PA13": 13,
+        "PA14": 14,
+        "PA15": 15,
+        "PA16": 16,
+        "PA17": 17,
+        "PA18": 18,
+        "PA19": 19,
+        "PWM5": 17,
+        "PWM6": 18,
+        "RX2": 15,
+        "SDA0": 16,
+        "TX2": 16,
+        "D0": 7,
+        "D1": 11,
+        "D2": 2,
+        "D3": 3,
+        "D4": 4,
+        "D5": 12,
+        "D6": 16,
+        "D7": 17,
+        "D8": 18,
+        "D9": 19,
+        "D10": 13,
+        "D11": 14,
+        "D12": 15,
+        "D13": 0,
+        "D14": 1,
+    },
     "generic-rtl8710bn-2mb-468k": {
         "SPI0_CS": 19,
         "SPI0_MISO": 22,
@@ -1178,6 +1251,104 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
+    "generic-rtl8720cf-2mb-896k": {
+        "SPI0_CS_0": 2,
+        "SPI0_CS_1": 7,
+        "SPI0_CS_2": 15,
+        "SPI0_MISO_0": 10,
+        "SPI0_MISO_1": 20,
+        "SPI0_MOSI_0": 4,
+        "SPI0_MOSI_1": 9,
+        "SPI0_MOSI_2": 19,
+        "SPI0_SCK_0": 3,
+        "SPI0_SCK_1": 8,
+        "SPI0_SCK_2": 16,
+        "WIRE0_SCL_0": 2,
+        "WIRE0_SCL_1": 11,
+        "WIRE0_SCL_2": 15,
+        "WIRE0_SCL_3": 19,
+        "WIRE0_SDA_0": 3,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 16,
+        "WIRE0_SDA_3": 20,
+        "SERIAL0_CTS": 10,
+        "SERIAL0_RTS": 9,
+        "SERIAL0_RX_0": 12,
+        "SERIAL0_RX_1": 13,
+        "SERIAL0_TX_0": 11,
+        "SERIAL0_TX_1": 14,
+        "SERIAL1_CTS": 4,
+        "SERIAL1_RX_0": 0,
+        "SERIAL1_RX_1": 2,
+        "SERIAL1_TX_0": 1,
+        "SERIAL1_TX_1": 3,
+        "SERIAL2_CTS": 19,
+        "SERIAL2_RTS": 20,
+        "SERIAL2_RX": 15,
+        "SERIAL2_TX": 16,
+        "CS0": 15,
+        "CTS0": 10,
+        "CTS1": 4,
+        "CTS2": 19,
+        "MOSI0": 19,
+        "PA00": 0,
+        "PA0": 0,
+        "PA01": 1,
+        "PA1": 1,
+        "PA02": 2,
+        "PA2": 2,
+        "PA03": 3,
+        "PA3": 3,
+        "PA04": 4,
+        "PA4": 4,
+        "PA07": 7,
+        "PA7": 7,
+        "PA08": 8,
+        "PA8": 8,
+        "PA09": 9,
+        "PA9": 9,
+        "PA10": 10,
+        "PA11": 11,
+        "PA12": 12,
+        "PA13": 13,
+        "PA14": 14,
+        "PA15": 15,
+        "PA16": 16,
+        "PA17": 17,
+        "PA18": 18,
+        "PA19": 19,
+        "PA20": 20,
+        "PA23": 23,
+        "PWM0": 20,
+        "PWM5": 17,
+        "PWM6": 18,
+        "PWM7": 23,
+        "RTS0": 9,
+        "RTS2": 20,
+        "RX2": 15,
+        "SCK0": 16,
+        "TX2": 16,
+        "D0": 0,
+        "D1": 1,
+        "D2": 2,
+        "D3": 3,
+        "D4": 4,
+        "D5": 7,
+        "D6": 8,
+        "D7": 9,
+        "D8": 10,
+        "D9": 11,
+        "D10": 12,
+        "D11": 13,
+        "D12": 14,
+        "D13": 15,
+        "D14": 16,
+        "D15": 17,
+        "D16": 18,
+        "D17": 19,
+        "D18": 20,
+        "D19": 23,
+    },
     "generic-rtl8720cf-2mb-992k": {
         "SPI0_CS_0": 2,
         "SPI0_CS_1": 7,

esphome/components/runtime_stats/runtime_stats.cpp

@@ -27,46 +27,61 @@ void RuntimeStatsCollector::record_component_time(Component *component, uint32_t
 }
 
 void RuntimeStatsCollector::log_stats_() {
+  // First pass: count active components
+  size_t count = 0;
+  for (const auto &it : this->component_stats_) {
+    if (it.second.get_period_count() > 0) {
+      count++;
+    }
+  }
+
   ESP_LOGI(TAG,
            "Component Runtime Statistics\n"
-           " Period stats (last %" PRIu32 "ms):",
+           " Period stats (last %" PRIu32 "ms): %zu active components",
-           this->log_interval_);
+           this->log_interval_, count);
 
-  // First collect stats we want to display
+  if (count == 0) {
-  std::vector<ComponentStatPair> stats_to_display;
+    return;
+  }
 
+  // Stack buffer sized to actual active count (up to 256 components), heap fallback for larger
+  SmallBufferWithHeapFallback<256, Component *> buffer(count);
+  Component **sorted = buffer.get();
+
+  // Second pass: fill buffer with active components
+  size_t idx = 0;
   for (const auto &it : this->component_stats_) {
-    Component *component = it.first;
+    if (it.second.get_period_count() > 0) {
-    const ComponentRuntimeStats &stats = it.second;
+      sorted[idx++] = it.first;
-    if (stats.get_period_count() > 0) {
-      ComponentStatPair pair = {component, &stats};
-      stats_to_display.push_back(pair);
     }
   }
 
   // Sort by period runtime (descending)
-  std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
+  std::sort(sorted, sorted + count, [this](Component *a, Component *b) {
+    return this->component_stats_[a].get_period_time_ms() > this->component_stats_[b].get_period_time_ms();
+  });
 
   // Log top components by period runtime
-  for (const auto &it : stats_to_display) {
+  for (size_t i = 0; i < count; i++) {
+    const auto &stats = this->component_stats_[sorted[i]];
     ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-             LOG_STR_ARG(it.component->get_component_log_str()), it.stats->get_period_count(),
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_period_count(), stats.get_period_avg_time_ms(),
-             it.stats->get_period_avg_time_ms(), it.stats->get_period_max_time_ms(), it.stats->get_period_time_ms());
+             stats.get_period_max_time_ms(), stats.get_period_time_ms());
   }
 
-  // Log total stats since boot
+  // Log total stats since boot (only for active components - idle ones haven't changed)
-  ESP_LOGI(TAG, " Total stats (since boot):");
+  ESP_LOGI(TAG, " Total stats (since boot): %zu active components", count);
 
   // Re-sort by total runtime for all-time stats
-  std::sort(stats_to_display.begin(), stats_to_display.end(),
+  std::sort(sorted, sorted + count, [this](Component *a, Component *b) {
-            [](const ComponentStatPair &a, const ComponentStatPair &b) {
+    return this->component_stats_[a].get_total_time_ms() > this->component_stats_[b].get_total_time_ms();
-              return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
+  });
-            });
 
-  for (const auto &it : stats_to_display) {
+  for (size_t i = 0; i < count; i++) {
+    const auto &stats = this->component_stats_[sorted[i]];
     ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-             LOG_STR_ARG(it.component->get_component_log_str()), it.stats->get_total_count(),
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_total_count(), stats.get_total_avg_time_ms(),
-             it.stats->get_total_avg_time_ms(), it.stats->get_total_max_time_ms(), it.stats->get_total_time_ms());
+             stats.get_total_max_time_ms(), stats.get_total_time_ms());
   }
 }
 

esphome/components/runtime_stats/runtime_stats.h

@@ -5,7 +5,6 @@
 #ifdef USE_RUNTIME_STATS
 
 #include <map>
-#include <vector>
 #include <cstdint>
 #include <cstring>
 #include "esphome/core/helpers.h"
@@ -77,17 +76,6 @@ class ComponentRuntimeStats {
   uint32_t total_max_time_ms_;
 };
 
-// For sorting components by run time
-struct ComponentStatPair {
-  Component *component;
-  const ComponentRuntimeStats *stats;
-
-  bool operator>(const ComponentStatPair &other) const {
-    // Sort by period time as that's what we're displaying in the logs
-    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
-  }
-};
-
 class RuntimeStatsCollector {
  public:
   RuntimeStatsCollector();

esphome/components/select/select.h

@@ -12,9 +12,7 @@ namespace esphome::select {
 #define LOG_SELECT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
   }
 
 #define SUB_SELECT(name) \

esphome/components/sensor/automation.h

@@ -39,7 +39,7 @@ class ValueRangeTrigger : public Trigger<float>, public Component {
   template<typename V> void set_max(V max) { this->max_ = max; }
 
   void setup() override {
-    this->rtc_ = global_preferences->make_preference<bool>(this->parent_->get_preference_hash());
+    this->rtc_ = this->parent_->make_entity_preference<bool>();
     bool initial_state;
     if (this->rtc_.load(&initial_state)) {
       this->previous_in_range_ = initial_state;

esphome/components/sensor/sensor.cpp

@@ -22,13 +22,8 @@ void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *o
                 LOG_STR_ARG(state_class_to_string(obj->get_state_class())), prefix,
                 obj->get_unit_of_measurement_ref().c_str(), prefix, obj->get_accuracy_decimals());
 
-  if (!obj->get_device_class_ref().empty()) {
+  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  LOG_ENTITY_ICON(tag, prefix, *obj);
-  }
-
-  if (!obj->get_icon_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
-  }
 
   if (obj->get_force_update()) {
     ESP_LOGV(tag, "%s  Force Update: YES", prefix);

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -29,6 +29,14 @@ void socket_delay(uint32_t ms) {
   // Use esp_delay with a callback that checks if socket data arrived.
   // This allows the delay to exit early when socket_wake() is called by
   // lwip recv_fn/accept_fn callbacks, reducing socket latency.
+  //
+  // When ms is 0, we must use delay(0) because esp_delay(0, callback)
+  // exits immediately without yielding, which can cause watchdog timeouts
+  // when the main loop runs in high-frequency mode (e.g., during light effects).
+  if (ms == 0) {
+    delay(0);
+    return;
+  }
   s_socket_woke = false;
   esp_delay(ms, []() { return !s_socket_woke; });
 }

esphome/components/speaker/__init__.py

@@ -2,7 +2,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import audio, audio_dac
 import esphome.config_validation as cv
-from esphome.const import CONF_DATA, CONF_ID, CONF_VOLUME
+from esphome.const import CONF_AUDIO_DAC, CONF_DATA, CONF_ID, CONF_VOLUME
 from esphome.core import CORE, ID
 from esphome.coroutine import CoroPriority, coroutine_with_priority
 
@@ -11,8 +11,6 @@ CODEOWNERS = ["@jesserockz", "@kahrendt"]
 
 IS_PLATFORM_COMPONENT = True
 
-CONF_AUDIO_DAC = "audio_dac"
-
 speaker_ns = cg.esphome_ns.namespace("speaker")
 
 Speaker = speaker_ns.class_("Speaker")

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -55,7 +55,7 @@ void SpeakerMediaPlayer::setup() {
 
   this->media_control_command_queue_ = xQueueCreate(MEDIA_CONTROLS_QUEUE_LENGTH, sizeof(MediaCallCommand));
 
-  this->pref_ = global_preferences->make_preference<VolumeRestoreState>(this->get_preference_hash());
+  this->pref_ = this->make_entity_preference<VolumeRestoreState>();
 
   VolumeRestoreState volume_restore_state;
   if (this->pref_.load(&volume_restore_state)) {

esphome/components/sprinkler/sprinkler.cpp

@@ -16,7 +16,7 @@ void SprinklerControllerNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<float>();
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/switch/switch.cpp

@@ -34,7 +34,7 @@ optional<bool> Switch::get_initial_state() {
   if (!(restore_mode & RESTORE_MODE_PERSISTENT_MASK))
     return {};
 
-  this->rtc_ = global_preferences->make_preference<bool>(this->get_preference_hash());
+  this->rtc_ = this->make_entity_preference<bool>();
   bool initial_state;
   if (!this->rtc_.load(&initial_state))
     return {};
@@ -96,18 +96,14 @@ void log_switch(const char *tag, const char *prefix, const char *type, Switch *o
                   LOG_STR_ARG(onoff));
 
     // Add optional fields separately
-    if (!obj->get_icon_ref().empty()) {
+    LOG_ENTITY_ICON(tag, prefix, *obj);
-      ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
-    }
     if (obj->assumed_state()) {
       ESP_LOGCONFIG(tag, "%s  Assumed State: YES", prefix);
     }
     if (obj->is_inverted()) {
       ESP_LOGCONFIG(tag, "%s  Inverted: YES", prefix);
     }
-    if (!obj->get_device_class_ref().empty()) {
+    LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-      ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
-    }
   }
 }
 

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -82,7 +82,7 @@ void TemplateAlarmControlPanel::setup() {
   this->current_state_ = ACP_STATE_DISARMED;
   if (this->restore_mode_ == ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED) {
     uint8_t value;
-    this->pref_ = global_preferences->make_preference<uint8_t>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<uint8_t>();
     if (this->pref_.load(&value)) {
       this->current_state_ = static_cast<alarm_control_panel::AlarmControlPanelState>(value);
     }

esphome/components/template/datetime/template_date.cpp

@@ -18,8 +18,7 @@ void TemplateDate::setup() {
     state = this->initial_value_;
   } else {
     datetime::DateEntityRestoreState temp;
-    this->pref_ =
+    this->pref_ = this->make_entity_preference<datetime::DateEntityRestoreState>(194434030U);
-        global_preferences->make_preference<datetime::DateEntityRestoreState>(194434030U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/datetime/template_datetime.cpp

@@ -18,8 +18,7 @@ void TemplateDateTime::setup() {
     state = this->initial_value_;
   } else {
     datetime::DateTimeEntityRestoreState temp;
-    this->pref_ = global_preferences->make_preference<datetime::DateTimeEntityRestoreState>(
+    this->pref_ = this->make_entity_preference<datetime::DateTimeEntityRestoreState>(194434090U);
-        194434090U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/datetime/template_time.cpp

@@ -18,8 +18,7 @@ void TemplateTime::setup() {
     state = this->initial_value_;
   } else {
     datetime::TimeEntityRestoreState temp;
-    this->pref_ =
+    this->pref_ = this->make_entity_preference<datetime::TimeEntityRestoreState>(194434060U);
-        global_preferences->make_preference<datetime::TimeEntityRestoreState>(194434060U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/number/template_number.cpp

@@ -13,7 +13,7 @@ void TemplateNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<float>();
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/template/select/template_select.cpp

@@ -11,7 +11,7 @@ void TemplateSelect::setup() {
 
   size_t index = this->initial_option_index_;
   if (this->restore_value_) {
-    this->pref_ = global_preferences->make_preference<size_t>(this->get_preference_hash());
+    this->pref_ = this->make_entity_preference<size_t>();
     size_t restored_index;
     if (this->pref_.load(&restored_index) && this->has_index(restored_index)) {
       index = restored_index;

esphome/components/template/text/template_text.cpp

@@ -20,7 +20,14 @@ void TemplateText::setup() {
 
   // Need std::string for pref_->setup() to fill from flash
   std::string value{this->initial_value_ != nullptr ? this->initial_value_ : ""};
+  // For future hash migration: use migrate_entity_preference_() with:
+  //   old_key = get_preference_hash() + extra
+  //   new_key = get_preference_hash_v2() + extra
+  // See: https://github.com/esphome/backlog/issues/85
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   uint32_t key = this->get_preference_hash();
+#pragma GCC diagnostic pop
   key += this->traits.get_min_length() << 2;
   key += this->traits.get_max_length() << 4;
   key += fnv1_hash(this->traits.get_pattern_c_str()) << 6;

esphome/components/text/text.h

@@ -12,9 +12,7 @@ namespace text {
 #define LOG_TEXT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
+    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
   }
 
 /** Base-class for all text inputs.

esphome/components/text_sensor/filter.cpp

@@ -9,19 +9,18 @@ namespace text_sensor {
 static const char *const TAG = "text_sensor.filter";
 
 // Filter
-void Filter::input(const std::string &value) {
+void Filter::input(std::string value) {
   ESP_LOGVV(TAG, "Filter(%p)::input(%s)", this, value.c_str());
-  optional<std::string> out = this->new_value(value);
+  if (this->new_value(value))
-  if (out.has_value())
+    this->output(value);
-    this->output(*out);
 }
-void Filter::output(const std::string &value) {
+void Filter::output(std::string &value) {
   if (this->next_ == nullptr) {
     ESP_LOGVV(TAG, "Filter(%p)::output(%s) -> SENSOR", this, value.c_str());
     this->parent_->internal_send_state_to_frontend(value);
   } else {
     ESP_LOGVV(TAG, "Filter(%p)::output(%s) -> %p", this, value.c_str(), this->next_);
-    this->next_->input(value);
+    this->next_->input(std::move(value));
   }
 }
 void Filter::initialize(TextSensor *parent, Filter *next) {
@@ -35,43 +34,48 @@ LambdaFilter::LambdaFilter(lambda_filter_t lambda_filter) : lambda_filter_(std::
 const lambda_filter_t &LambdaFilter::get_lambda_filter() const { return this->lambda_filter_; }
 void LambdaFilter::set_lambda_filter(const lambda_filter_t &lambda_filter) { this->lambda_filter_ = lambda_filter; }
 
-optional<std::string> LambdaFilter::new_value(std::string value) {
+bool LambdaFilter::new_value(std::string &value) {
-  auto it = this->lambda_filter_(value);
+  auto result = this->lambda_filter_(value);
-  ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> %s", this, value.c_str(), it.value_or("").c_str());
+  if (result.has_value()) {
-  return it;
+    ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> %s (continue)", this, value.c_str(), result->c_str());
+    value = std::move(*result);
+    return true;
+  }
+  ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> (stop)", this, value.c_str());
+  return false;
 }
 
 // ToUpperFilter
-optional<std::string> ToUpperFilter::new_value(std::string value) {
+bool ToUpperFilter::new_value(std::string &value) {
   for (char &c : value)
     c = ::toupper(c);
-  return value;
+  return true;
 }
 
 // ToLowerFilter
-optional<std::string> ToLowerFilter::new_value(std::string value) {
+bool ToLowerFilter::new_value(std::string &value) {
   for (char &c : value)
     c = ::tolower(c);
-  return value;
+  return true;
 }
 
 // Append
-optional<std::string> AppendFilter::new_value(std::string value) {
+bool AppendFilter::new_value(std::string &value) {
   value.append(this->suffix_);
-  return value;
+  return true;
 }
 
 // Prepend
-optional<std::string> PrependFilter::new_value(std::string value) {
+bool PrependFilter::new_value(std::string &value) {
   value.insert(0, this->prefix_);
-  return value;
+  return true;
 }
 
 // Substitute
 SubstituteFilter::SubstituteFilter(const std::initializer_list<Substitution> &substitutions)
     : substitutions_(substitutions) {}
 
-optional<std::string> SubstituteFilter::new_value(std::string value) {
+bool SubstituteFilter::new_value(std::string &value) {
   for (const auto &sub : this->substitutions_) {
     // Compute lengths once per substitution (strlen is fast, called infrequently)
     const size_t from_len = strlen(sub.from);
@@ -84,20 +88,20 @@ optional<std::string> SubstituteFilter::new_value(std::string value) {
       pos += to_len;
     }
   }
-  return value;
+  return true;
 }
 
 // Map
 MapFilter::MapFilter(const std::initializer_list<Substitution> &mappings) : mappings_(mappings) {}
 
-optional<std::string> MapFilter::new_value(std::string value) {
+bool MapFilter::new_value(std::string &value) {
   for (const auto &mapping : this->mappings_) {
     if (value == mapping.from) {
       value.assign(mapping.to);
-      return value;
+      return true;
     }
   }
-  return value;  // Pass through if no match
+  return true;  // Pass through if no match
 }
 
 }  // namespace text_sensor

esphome/components/text_sensor/filter.h

@@ -17,21 +17,20 @@ class Filter {
  public:
   /** This will be called every time the filter receives a new value.
    *
-   * It can return an empty optional to indicate that the filter chain
+   * Modify the value in place. Return false to stop the filter chain
-   * should stop, otherwise the value in the filter will be passed down
+   * (value will not be published), or true to continue.
-   * the chain.
    *
-   * @param value The new value.
+   * @param value The value to filter (modified in place).
-   * @return An optional string, the new value that should be pushed out.
+   * @return True to continue the filter chain, false to stop.
    */
-  virtual optional<std::string> new_value(std::string value) = 0;
+  virtual bool new_value(std::string &value) = 0;
 
   /// Initialize this filter, please note this can be called more than once.
   virtual void initialize(TextSensor *parent, Filter *next);
 
-  void input(const std::string &value);
+  void input(std::string value);
 
-  void output(const std::string &value);
+  void output(std::string &value);
 
  protected:
   friend TextSensor;
@@ -45,15 +44,14 @@ using lambda_filter_t = std::function<optional<std::string>(std::string)>;
 /** This class allows for creation of simple template filters.
  *
  * The constructor accepts a lambda of the form std::string -> optional<std::string>.
- * It will be called with each new value in the filter chain and returns the modified
+ * Return a modified string to continue the chain, or return {} to stop
- * value that shall be passed down the filter chain. Returning an empty Optional
+ * (value will not be published).
- * means that the value shall be discarded.
  */
 class LambdaFilter : public Filter {
  public:
   explicit LambdaFilter(lambda_filter_t lambda_filter);
 
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 
   const lambda_filter_t &get_lambda_filter() const;
   void set_lambda_filter(const lambda_filter_t &lambda_filter);
@@ -71,7 +69,14 @@ class StatelessLambdaFilter : public Filter {
  public:
   explicit StatelessLambdaFilter(optional<std::string> (*lambda_filter)(std::string)) : lambda_filter_(lambda_filter) {}
 
-  optional<std::string> new_value(std::string value) override { return this->lambda_filter_(value); }
+  bool new_value(std::string &value) override {
+    auto result = this->lambda_filter_(value);
+    if (result.has_value()) {
+      value = std::move(*result);
+      return true;
+    }
+    return false;
+  }
 
  protected:
   optional<std::string> (*lambda_filter_)(std::string);
@@ -80,20 +85,20 @@ class StatelessLambdaFilter : public Filter {
 /// A simple filter that converts all text to uppercase
 class ToUpperFilter : public Filter {
  public:
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 };
 
 /// A simple filter that converts all text to lowercase
 class ToLowerFilter : public Filter {
  public:
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 };
 
 /// A simple filter that adds a string to the end of another string
 class AppendFilter : public Filter {
  public:
   explicit AppendFilter(const char *suffix) : suffix_(suffix) {}
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 
  protected:
   const char *suffix_;
@@ -103,7 +108,7 @@ class AppendFilter : public Filter {
 class PrependFilter : public Filter {
  public:
   explicit PrependFilter(const char *prefix) : prefix_(prefix) {}
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 
  protected:
   const char *prefix_;
@@ -118,7 +123,7 @@ struct Substitution {
 class SubstituteFilter : public Filter {
  public:
   explicit SubstituteFilter(const std::initializer_list<Substitution> &substitutions);
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 
  protected:
   FixedVector<Substitution> substitutions_;
@@ -151,7 +156,7 @@ class SubstituteFilter : public Filter {
 class MapFilter : public Filter {
  public:
   explicit MapFilter(const std::initializer_list<Substitution> &mappings);
-  optional<std::string> new_value(std::string value) override;
+  bool new_value(std::string &value) override;
 
  protected:
   FixedVector<Substitution> mappings_;

esphome/components/text_sensor/text_sensor.cpp

@@ -15,14 +15,8 @@ void log_text_sensor(const char *tag, const char *prefix, const char *type, Text
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-
+  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-  if (!obj->get_device_class_ref().empty()) {
+  LOG_ENTITY_ICON(tag, prefix, *obj);
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
-  }
-
-  if (!obj->get_icon_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
-  }
 }
 
 void TextSensor::publish_state(const std::string &state) { this->publish_state(state.data(), state.size()); }