diff --git a/.ai/instructions.md b/.ai/instructions.md
index 3c24177827f..240a47a52fd 100644
--- a/.ai/instructions.md
+++ b/.ai/instructions.md
@@ -286,6 +286,7 @@ This document provides essential context for AI models interacting with this pro
 *   **Documentation Contributions:**
     *   Documentation is hosted in the separate `esphome/esphome-docs` repository.
     *   The contribution workflow is the same as for the codebase.
+    *   When editing a component's documentation page, also update the corresponding component index page to ensure both pages remain in sync.
 
 *   **Best Practices:**
     *   **Component Development:** Keep dependencies minimal, provide clear error messages, and write comprehensive docstrings and tests.
diff --git a/.github/scripts/codeowners.js b/.github/scripts/codeowners.js
index 9a10391699e..5d69c11b1a2 100644
--- a/.github/scripts/codeowners.js
+++ b/.github/scripts/codeowners.js
@@ -2,7 +2,7 @@
 //
 // Used by:
 //   - codeowner-review-request.yml
-//   - codeowner-approved-label.yml
+//   - codeowner-approved-label.yml + codeowner-approved-label-update.yml
 //   - auto-label-pr/detectors.js (detectCodeOwner)
 
 /**
@@ -133,11 +133,95 @@ function loadCodeowners(repoRoot = '.') {
   return parseCodeowners(content);
 }
 
+/** Possible label actions returned by determineLabelAction. */
+const LabelAction = Object.freeze({
+  ADD: 'add',
+  REMOVE: 'remove',
+  NONE: 'none',
+});
+
+/**
+ * Determine what label action is needed for a PR based on codeowner approvals.
+ *
+ * Checks changed files against CODEOWNERS patterns, reviews, and current labels
+ * to decide if the label should be added, removed, or left unchanged.
+ *
+ * @param {object} github              - octokit instance from actions/github-script
+ * @param {string} owner               - repo owner
+ * @param {string} repo                - repo name
+ * @param {number} pr_number           - pull request number
+ * @param {Array}  codeownersPatterns   - from loadCodeowners / fetchCodeowners
+ * @param {string} labelName           - label to manage
+ * @returns {Promise<LabelAction>}
+ */
+async function determineLabelAction(github, owner, repo, pr_number, codeownersPatterns, labelName) {
+  // Get the list of changed files in this PR
+  const prFiles = await github.paginate(
+    github.rest.pulls.listFiles,
+    { owner, repo, pull_number: pr_number }
+  );
+
+  const changedFiles = prFiles.map(file => file.filename);
+  console.log(`Found ${changedFiles.length} changed files`);
+
+  if (changedFiles.length === 0) {
+    console.log('No changed files found');
+    return LabelAction.NONE;
+  }
+
+  // Get effective owners using last-match-wins semantics
+  const effective = getEffectiveOwners(changedFiles, codeownersPatterns);
+  const componentCodeowners = effective.users;
+
+  console.log(`Component-specific codeowners: ${Array.from(componentCodeowners).join(', ') || '(none)'}`);
+
+  // Get current labels
+  const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
+    owner, repo, issue_number: pr_number
+  });
+  const hasLabel = currentLabels.some(label => label.name === labelName);
+
+  if (componentCodeowners.size === 0) {
+    console.log('No component-specific codeowners found');
+    return hasLabel ? LabelAction.REMOVE : LabelAction.NONE;
+  }
+
+  // Get all reviews and find latest per user
+  const reviews = await github.paginate(
+    github.rest.pulls.listReviews,
+    { owner, repo, pull_number: pr_number }
+  );
+
+  const latestReviewByUser = new Map();
+  for (const review of reviews) {
+    if (!review.user || review.user.type === 'Bot' || review.state === 'COMMENTED') continue;
+    latestReviewByUser.set(review.user.login, review);
+  }
+
+  // Check if any component-specific codeowner has an active approval
+  let hasCodeownerApproval = false;
+  for (const [login, review] of latestReviewByUser) {
+    if (review.state === 'APPROVED' && componentCodeowners.has(login)) {
+      console.log(`Codeowner '${login}' has approved`);
+      hasCodeownerApproval = true;
+      break;
+    }
+  }
+
+  if (hasCodeownerApproval && !hasLabel) return LabelAction.ADD;
+  if (!hasCodeownerApproval && hasLabel) return LabelAction.REMOVE;
+
+  console.log(`Label already ${hasLabel ? 'present' : 'absent'}, no change needed`);
+  return LabelAction.NONE;
+}
+
 module.exports = {
   globToRegex,
   parseCodeowners,
   fetchCodeowners,
   loadCodeowners,
   classifyOwners,
-  getEffectiveOwners
+  getEffectiveOwners,
+  LabelAction,
+  determineLabelAction
 };
diff --git a/.github/workflows/ci-docker.yml b/.github/workflows/ci-docker.yml
index a83bcae0b06..4009ac1e174 100644
--- a/.github/workflows/ci-docker.yml
+++ b/.github/workflows/ci-docker.yml
@@ -49,7 +49,7 @@ jobs:
         with:
           python-version: "3.11"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Set TAG
         run: |
diff --git a/.github/workflows/codeowner-approved-label-update.yml b/.github/workflows/codeowner-approved-label-update.yml
new file mode 100644
index 00000000000..9168cce1d6b
--- /dev/null
+++ b/.github/workflows/codeowner-approved-label-update.yml
@@ -0,0 +1,95 @@
+# Fallback for fork PRs: phase 1 (codeowner-approved-label.yml) handles
+# non-fork PRs directly but can't write labels on fork PRs (read-only token).
+# This workflow re-determines the action and applies it if needed.
+
+name: Codeowner Approved Label Update
+
+on:
+  workflow_run:
+    workflows: ["Codeowner Approved Label"]
+    types: [completed]
+
+permissions:
+  issues: write
+  pull-requests: read
+  contents: read
+
+jobs:
+  update-label:
+    name: Run
+    if: >
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'pull_request_review'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get PR details
+        id: pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+          HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
+          REPO: ${{ github.repository }}
+        run: |
+          pr_data=$(gh pr list --repo "$REPO" --state open --search "$HEAD_SHA" \
+            --json number,baseRefName --jq '.[0] // empty')
+
+          if [ -z "$pr_data" ]; then
+            echo "No open PR found for SHA $HEAD_SHA, skipping"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          pr_number=$(echo "$pr_data" | jq -r '.number')
+          base_ref=$(echo "$pr_data" | jq -r '.baseRefName')
+
+          echo "pr_number=$pr_number" >> "$GITHUB_OUTPUT"
+          echo "base_ref=$base_ref" >> "$GITHUB_OUTPUT"
+          echo "Found PR #$pr_number targeting $base_ref"
+
+      - name: Checkout base repository
+        if: steps.pr.outputs.skip != 'true'
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          repository: ${{ github.repository }}
+          ref: ${{ steps.pr.outputs.base_ref }}
+          sparse-checkout: |
+            .github/scripts/codeowners.js
+            CODEOWNERS
+
+      - name: Update label
+        if: steps.pr.outputs.skip != 'true'
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.pr_number }}
+        with:
+          script: |
+            const { loadCodeowners, determineLabelAction, LabelAction } = require('./.github/scripts/codeowners.js');
+
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const pr_number = parseInt(process.env.PR_NUMBER, 10);
+            const LABEL_NAME = 'code-owner-approved';
+
+            console.log(`Processing PR #${pr_number} for codeowner approval label`);
+
+            const codeownersPatterns = loadCodeowners();
+            const action = await determineLabelAction(
+              github, owner, repo, pr_number, codeownersPatterns, LABEL_NAME
+            );
+
+            if (action === LabelAction.ADD) {
+              await github.rest.issues.addLabels({
+                owner, repo, issue_number: pr_number, labels: [LABEL_NAME]
+              });
+              console.log(`Added '${LABEL_NAME}' label`);
+            } else if (action === LabelAction.REMOVE) {
+              try {
+                await github.rest.issues.removeLabel({
+                  owner, repo, issue_number: pr_number, name: LABEL_NAME
+                });
+                console.log(`Removed '${LABEL_NAME}' label`);
+              } catch (error) {
+                if (error.status !== 404) throw error;
+              }
+            } else {
+              console.log('No label change needed');
+            }
diff --git a/.github/workflows/codeowner-approved-label.yml b/.github/workflows/codeowner-approved-label.yml
index 217ae06419b..12199bd0b04 100644
--- a/.github/workflows/codeowner-approved-label.yml
+++ b/.github/workflows/codeowner-approved-label.yml
@@ -1,9 +1,9 @@
-# This workflow adds/removes a 'code-owner-approved' label when a
-# component-specific codeowner approves (or dismisses) a PR.
-# This helps maintainers prioritize PRs that have codeowner sign-off.
+# Adds/removes a 'code-owner-approved' label when a component-specific
+# codeowner approves (or dismisses) a PR.
 #
-# Only component-specific codeowners count — the catch-all @esphome/core
-# team is excluded so the label reflects domain-expert approval.
+# Handles non-fork PRs directly. For fork PRs the GITHUB_TOKEN is read-only,
+# so label writes are deferred to codeowner-approved-label-update.yml which
+# triggers via workflow_run with write permissions.
 
 name: Codeowner Approved Label
 
@@ -12,7 +12,8 @@ on:
     types: [submitted, dismissed]
 
 permissions:
-  pull-requests: write
+  issues: write
+  pull-requests: read
   contents: read
 
 jobs:
@@ -25,134 +26,53 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ github.event.pull_request.base.sha }}
+          sparse-checkout: |
+            .github/scripts/codeowners.js
+            CODEOWNERS
 
       - name: Check codeowner approval and update label
         uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number }}
         with:
           script: |
-            const { loadCodeowners, getEffectiveOwners } = require('./.github/scripts/codeowners.js');
+            const { loadCodeowners, determineLabelAction, LabelAction } = require('./.github/scripts/codeowners.js');
 
             const owner = context.repo.owner;
             const repo = context.repo.repo;
-            const pr_number = context.payload.pull_request.number;
+            const pr_number = parseInt(process.env.PR_NUMBER, 10);
             const LABEL_NAME = 'code-owner-approved';
 
             console.log(`Processing PR #${pr_number} for codeowner approval label`);
 
+            const codeownersPatterns = loadCodeowners();
+            const action = await determineLabelAction(
+              github, owner, repo, pr_number, codeownersPatterns, LABEL_NAME
+            );
+
+            if (action === LabelAction.NONE) {
+              console.log('No label change needed');
+              return;
+            }
+
             try {
-              // Get the list of changed files in this PR (with pagination)
-              const prFiles = await github.paginate(
-                github.rest.pulls.listFiles,
-                {
-                  owner,
-                  repo,
-                  pull_number: pr_number
-                }
-              );
-
-              const changedFiles = prFiles.map(file => file.filename);
-              console.log(`Found ${changedFiles.length} changed files`);
-
-              if (changedFiles.length === 0) {
-                console.log('No changed files found, skipping');
-                return;
-              }
-
-              // Parse CODEOWNERS from the checked-out base branch
-              const codeownersPatterns = loadCodeowners();
-
-              // Get effective owners using last-match-wins semantics
-              const effective = getEffectiveOwners(changedFiles, codeownersPatterns);
-
-              // Only keep individual component-specific codeowners (exclude teams)
-              const componentCodeowners = effective.users;
-
-              console.log(`Component-specific codeowners for changed files: ${Array.from(componentCodeowners).join(', ') || '(none)'}`);
-
-              if (componentCodeowners.size === 0) {
-                console.log('No component-specific codeowners found for changed files');
-                // Remove label if present since there are no component codeowners
-                try {
-                  await github.rest.issues.removeLabel({
-                    owner,
-                    repo,
-                    issue_number: pr_number,
-                    name: LABEL_NAME
-                  });
-                  console.log(`Removed '${LABEL_NAME}' label (no component codeowners)`);
-                } catch (error) {
-                  if (error.status !== 404) {
-                    console.log(`Failed to remove label: ${error.message}`);
-                  }
-                }
-                return;
-              }
-
-              // Get all reviews on the PR
-              const reviews = await github.paginate(
-                github.rest.pulls.listReviews,
-                {
-                  owner,
-                  repo,
-                  pull_number: pr_number
-                }
-              );
-
-              // Get the latest review per user (reviews are returned chronologically)
-              const latestReviewByUser = new Map();
-              for (const review of reviews) {
-                // Skip bot reviews and comment-only reviews
-                if (!review.user || review.user.type === 'Bot' || review.state === 'COMMENTED') continue;
-                latestReviewByUser.set(review.user.login, review);
-              }
-
-              // Check if any component-specific codeowner has an active approval
-              let hasCodeownerApproval = false;
-              for (const [login, review] of latestReviewByUser) {
-                if (review.state === 'APPROVED' && componentCodeowners.has(login)) {
-                  console.log(`Codeowner '${login}' has approved`);
-                  hasCodeownerApproval = true;
-                  break;
-                }
-              }
-
-              // Get current labels to check if label is already present
-              const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
-                owner,
-                repo,
-                issue_number: pr_number
-              });
-              const hasLabel = currentLabels.some(label => label.name === LABEL_NAME);
-
-              if (hasCodeownerApproval && !hasLabel) {
-                // Add the label
+              if (action === LabelAction.ADD) {
                 await github.rest.issues.addLabels({
-                  owner,
-                  repo,
-                  issue_number: pr_number,
-                  labels: [LABEL_NAME]
+                  owner, repo, issue_number: pr_number, labels: [LABEL_NAME]
                 });
                 console.log(`Added '${LABEL_NAME}' label`);
-              } else if (!hasCodeownerApproval && hasLabel) {
-                // Remove the label
-                try {
-                  await github.rest.issues.removeLabel({
-                    owner,
-                    repo,
-                    issue_number: pr_number,
-                    name: LABEL_NAME
-                  });
-                  console.log(`Removed '${LABEL_NAME}' label`);
-                } catch (error) {
-                  if (error.status !== 404) {
-                    console.log(`Failed to remove label: ${error.message}`);
-                  }
-                }
-              } else {
-                console.log(`Label already ${hasLabel ? 'present' : 'absent'}, no change needed`);
+              } else if (action === LabelAction.REMOVE) {
+                await github.rest.issues.removeLabel({
+                  owner, repo, issue_number: pr_number, name: LABEL_NAME
+                });
+                console.log(`Removed '${LABEL_NAME}' label`);
               }
-
             } catch (error) {
-              console.error(error);
-              core.setFailed(`Failed to process codeowner approval label: ${error.message}`);
+              if (error.status === 403) {
+                console.log('Fork PR: deferring label write to phase 2 workflow');
+              } else if (error.status === 404) {
+                console.log('Label already removed');
+              } else {
+                throw error;
+              }
             }
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 17a2616dffc..8f68e9c873f 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -99,15 +99,15 @@ jobs:
           python-version: "3.11"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Log in to docker hub
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -178,17 +178,17 @@ jobs:
           merge-multiple: true
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.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@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
diff --git a/CODEOWNERS b/CODEOWNERS
index b22f85b71d7..7c37b20e099 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -54,6 +54,7 @@ esphome/components/atm90e32/* @circuitsetup @descipher
 esphome/components/audio/* @kahrendt
 esphome/components/audio_adc/* @kbx81
 esphome/components/audio_dac/* @kbx81
+esphome/components/audio_file/* @kahrendt
 esphome/components/axs15231/* @clydebarrow
 esphome/components/b_parasite/* @rbaron
 esphome/components/ballu/* @bazuchan
diff --git a/esphome/__main__.py b/esphome/__main__.py
index ffedb90bde4..0164e2eeb33 100644
--- a/esphome/__main__.py
+++ b/esphome/__main__.py
@@ -23,6 +23,7 @@ import esphome.codegen as cg
 from esphome.config import iter_component_configs, read_config, strip_default_ids
 from esphome.const import (
     ALLOWED_NAME_CHARS,
+    ARGUMENT_HELP_DEVICE,
     CONF_API,
     CONF_BAUD_RATE,
     CONF_BROKER,
@@ -1367,7 +1368,7 @@ def parse_args(argv):
     parser_upload.add_argument(
         "--device",
         action="append",
-        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0. Can be specified multiple times for fallback addresses.",
+        help=ARGUMENT_HELP_DEVICE,
     )
     parser_upload.add_argument(
         "--upload_speed",
@@ -1390,7 +1391,7 @@ def parse_args(argv):
     parser_logs.add_argument(
         "--device",
         action="append",
-        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0. Can be specified multiple times for fallback addresses.",
+        help=ARGUMENT_HELP_DEVICE,
     )
     parser_logs.add_argument(
         "--reset",
@@ -1420,7 +1421,7 @@ def parse_args(argv):
     parser_run.add_argument(
         "--device",
         action="append",
-        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0. Can be specified multiple times for fallback addresses.",
+        help=ARGUMENT_HELP_DEVICE,
     )
     parser_run.add_argument(
         "--upload_speed",
diff --git a/esphome/components/alpha3/alpha3.cpp b/esphome/components/alpha3/alpha3.cpp
index f22a8e24446..6e82ec047db 100644
--- a/esphome/components/alpha3/alpha3.cpp
+++ b/esphome/components/alpha3/alpha3.cpp
@@ -125,7 +125,7 @@ void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
         this->current_sensor_->publish_state(NAN);
       if (this->speed_sensor_ != nullptr)
         this->speed_sensor_->publish_state(NAN);
-      if (this->speed_sensor_ != nullptr)
+      if (this->voltage_sensor_ != nullptr)
         this->voltage_sensor_->publish_state(NAN);
       break;
     }
diff --git a/esphome/components/am43/cover/am43_cover.cpp b/esphome/components/am43/cover/am43_cover.cpp
index 0d49439095e..2fa26d266a2 100644
--- a/esphome/components/am43/cover/am43_cover.cpp
+++ b/esphome/components/am43/cover/am43_cover.cpp
@@ -63,8 +63,9 @@ void Am43Component::control(const CoverCall &call) {
       ESP_LOGW(TAG, "[%s] Error writing stop command to device, error = %d", this->get_name().c_str(), status);
     }
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto opt_pos = call.get_position();
+  if (opt_pos.has_value()) {
+    auto pos = *opt_pos;
 
     if (this->invert_position_)
       pos = 1 - pos;
diff --git a/esphome/components/anova/anova.cpp b/esphome/components/anova/anova.cpp
index 2693224a97b..b625f92115d 100644
--- a/esphome/components/anova/anova.cpp
+++ b/esphome/components/anova/anova.cpp
@@ -24,8 +24,9 @@ void Anova::loop() {
 }
 
 void Anova::control(const ClimateCall &call) {
-  if (call.get_mode().has_value()) {
-    ClimateMode mode = *call.get_mode();
+  auto mode_val = call.get_mode();
+  if (mode_val.has_value()) {
+    ClimateMode mode = *mode_val;
     AnovaPacket *pkt;
     switch (mode) {
       case climate::CLIMATE_MODE_OFF:
@@ -45,8 +46,9 @@ void Anova::control(const ClimateCall &call) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
   }
-  if (call.get_target_temperature().has_value()) {
-    auto *pkt = this->codec_->get_set_target_temp_request(*call.get_target_temperature());
+  auto target_temp = call.get_target_temperature();
+  if (target_temp.has_value()) {
+    auto *pkt = this->codec_->get_set_target_temp_request(*target_temp);
     auto status =
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 59476fac253..98ba1abe0b5 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -114,9 +114,10 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
     this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
   }
 #elif defined(USE_API_PLAINTEXT)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
+  this->helper_ = std::unique_ptr<APIPlaintextFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
 #elif defined(USE_API_NOISE)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
+  this->helper_ =
+      std::unique_ptr<APINoiseFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
 #else
 #error "No frame helper defined"
 #endif
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 37855b2482a..aae8db3c688 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -3,6 +3,12 @@
 #include "esphome/core/defines.h"
 #ifdef USE_API
 #include "api_frame_helper.h"
+#ifdef USE_API_NOISE
+#include "api_frame_helper_noise.h"
+#endif
+#ifdef USE_API_PLAINTEXT
+#include "api_frame_helper_plaintext.h"
+#endif
 #include "api_pb2.h"
 #include "api_pb2_service.h"
 #include "api_server.h"
@@ -489,7 +495,13 @@ class APIConnection final : public APIServerConnectionBase {
   // === Optimal member ordering for 32-bit systems ===
 
   // Group 1: Pointers (4 bytes each on 32-bit)
+#if defined(USE_API_NOISE) && defined(USE_API_PLAINTEXT)
   std::unique_ptr<APIFrameHelper> helper_;
+#elif defined(USE_API_NOISE)
+  std::unique_ptr<APINoiseFrameHelper> helper_;
+#elif defined(USE_API_PLAINTEXT)
+  std::unique_ptr<APIPlaintextFrameHelper> helper_;
+#endif
   APIServer *parent_;
 
   // Group 2: Iterator union (saves ~16 bytes vs separate iterators)
diff --git a/esphome/components/atc_mithermometer/atc_mithermometer.cpp b/esphome/components/atc_mithermometer/atc_mithermometer.cpp
index b4d2929742a..9afd6334f5b 100644
--- a/esphome/components/atc_mithermometer/atc_mithermometer.cpp
+++ b/esphome/components/atc_mithermometer/atc_mithermometer.cpp
@@ -61,6 +61,10 @@ optional<ParseResult> ATCMiThermometer::parse_header_(const esp32_ble_tracker::S
   }
 
   auto raw = service_data.data;
+  if (raw.size() < 13) {
+    ESP_LOGVV(TAG, "parse_header_(): service data too short (%zu).", raw.size());
+    return {};
+  }
 
   static uint8_t last_frame_count = 0;
   if (last_frame_count == raw[12]) {
diff --git a/esphome/components/atm90e26/atm90e26.cpp b/esphome/components/atm90e26/atm90e26.cpp
index 2203dd0d713..e6602411bb8 100644
--- a/esphome/components/atm90e26/atm90e26.cpp
+++ b/esphome/components/atm90e26/atm90e26.cpp
@@ -197,7 +197,7 @@ float ATM90E26Component::get_reactive_power_() {
 float ATM90E26Component::get_power_factor_() {
   const uint16_t val = this->read16_(ATM90E26_REGISTER_POWERF);  // signed
   if (val & 0x8000) {
-    return -(val & 0x7FF) / 1000.0f;
+    return -(val & 0x7FFF) / 1000.0f;
   } else {
     return val / 1000.0f;
   }
diff --git a/esphome/components/audio_file/__init__.py b/esphome/components/audio_file/__init__.py
new file mode 100644
index 00000000000..3ed6c1cd928
--- /dev/null
+++ b/esphome/components/audio_file/__init__.py
@@ -0,0 +1,255 @@
+from dataclasses import dataclass, field
+import hashlib
+import logging
+from pathlib import Path
+
+import puremagic
+
+from esphome import external_files
+import esphome.codegen as cg
+from esphome.components import audio
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_FILE,
+    CONF_ID,
+    CONF_PATH,
+    CONF_RAW_DATA_ID,
+    CONF_TYPE,
+    CONF_URL,
+)
+from esphome.core import CORE, ID, HexInt
+from esphome.cpp_generator import MockObj
+from esphome.external_files import download_content
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
+
+CODEOWNERS = ["@kahrendt"]
+
+AUTO_LOAD = ["audio"]
+
+DOMAIN = "audio_file"
+
+audio_file_ns = cg.esphome_ns.namespace("audio_file")
+
+TYPE_LOCAL = "local"
+TYPE_WEB = "web"
+
+
+@dataclass
+class AudioFileData:
+    file_ids: dict[str, ID] = field(default_factory=dict)
+    file_cache: dict[str, tuple[bytes, MockObj]] = field(default_factory=dict)
+
+
+def _get_data() -> AudioFileData:
+    if DOMAIN not in CORE.data:
+        CORE.data[DOMAIN] = AudioFileData()
+    return CORE.data[DOMAIN]
+
+
+def get_audio_file_ids() -> dict[str, ID]:
+    """Get all registered audio file IDs for cross-component access."""
+    return _get_data().file_ids
+
+
+def _compute_local_file_path(value: ConfigType) -> Path:
+    url = value[CONF_URL]
+    h = hashlib.new("sha256")
+    h.update(url.encode())
+    key = h.hexdigest()[:8]
+    base_dir = external_files.compute_local_file_dir(DOMAIN)
+    _LOGGER.debug("_compute_local_file_path: base_dir=%s", base_dir / key)
+    return base_dir / key
+
+
+def _download_web_file(value: ConfigType) -> ConfigType:
+    url = value[CONF_URL]
+    path = _compute_local_file_path(value)
+
+    download_content(url, path)
+    _LOGGER.debug("download_web_file: path=%s", path)
+    return value
+
+
+def _file_schema(value: ConfigType | str) -> ConfigType:
+    if isinstance(value, str):
+        return _validate_file_shorthand(value)
+    return TYPED_FILE_SCHEMA(value)
+
+
+def _validate_file_shorthand(value: str) -> ConfigType:
+    value = cv.string_strict(value)
+    if value.startswith("http://") or value.startswith("https://"):
+        return _file_schema(
+            {
+                CONF_TYPE: TYPE_WEB,
+                CONF_URL: value,
+            }
+        )
+    return _file_schema(
+        {
+            CONF_TYPE: TYPE_LOCAL,
+            CONF_PATH: value,
+        }
+    )
+
+
+def read_audio_file_and_type(file_config: ConfigType) -> tuple[bytes, MockObj]:
+    """Read an audio file and determine its type. Used by this component and media_source platform."""
+    conf_file = file_config[CONF_FILE]
+    file_source = conf_file[CONF_TYPE]
+    if file_source == TYPE_LOCAL:
+        path = CORE.relative_config_path(conf_file[CONF_PATH])
+    elif file_source == TYPE_WEB:
+        path = _compute_local_file_path(conf_file)
+    else:
+        raise cv.Invalid("Unsupported file source")
+
+    with open(path, "rb") as f:
+        data = f.read()
+
+    try:
+        file_type: str = puremagic.from_string(data)
+        file_type = file_type.removeprefix(".")
+    except puremagic.PureError as e:
+        raise cv.Invalid(
+            f"Unable to determine audio file type of '{path}'. "
+            f"Try re-encoding the file into a supported format. Details: {e}"
+        )
+
+    media_file_type = audio.AUDIO_FILE_TYPE_ENUM["NONE"]
+    if file_type == "wav":
+        media_file_type = audio.AUDIO_FILE_TYPE_ENUM["WAV"]
+    elif file_type in ("mp3", "mpeg", "mpga"):
+        media_file_type = audio.AUDIO_FILE_TYPE_ENUM["MP3"]
+    elif file_type == "flac":
+        media_file_type = audio.AUDIO_FILE_TYPE_ENUM["FLAC"]
+    elif (
+        file_type == "ogg"
+        and len(data) >= 36
+        and data.startswith(b"OggS")
+        and data[28:36] == b"OpusHead"
+    ):
+        media_file_type = audio.AUDIO_FILE_TYPE_ENUM["OPUS"]
+
+    return data, media_file_type
+
+
+LOCAL_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_PATH): cv.file_,
+    }
+)
+
+WEB_SCHEMA = cv.All(
+    {
+        cv.Required(CONF_URL): cv.url,
+    },
+    _download_web_file,
+)
+
+
+TYPED_FILE_SCHEMA = cv.typed_schema(
+    {
+        TYPE_LOCAL: LOCAL_SCHEMA,
+        TYPE_WEB: WEB_SCHEMA,
+    },
+)
+
+
+MEDIA_FILE_TYPE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(audio.AudioFile),
+        cv.Required(CONF_FILE): _file_schema,
+        cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
+    }
+)
+
+
+MAX_FILE_SIZE = 5 * 1024 * 1024  # 5 MB
+
+
+def _validate_supported_local_file(config: list[ConfigType]) -> list[ConfigType]:
+    for file_config in config:
+        data, media_file_type = read_audio_file_and_type(file_config)
+
+        if len(data) > MAX_FILE_SIZE:
+            file_info = file_config.get(CONF_FILE, {})
+            source = (
+                file_info.get(CONF_PATH) or file_info.get(CONF_URL) or "unknown source"
+            )
+            raise cv.Invalid(
+                f"Audio file {source!r} is too large ({len(data)} bytes, max {MAX_FILE_SIZE} bytes)"
+            )
+
+        if str(media_file_type) == str(audio.AUDIO_FILE_TYPE_ENUM["NONE"]):
+            file_info = file_config.get(CONF_FILE, {})
+            source = (
+                file_info.get(CONF_PATH) or file_info.get(CONF_URL) or "unknown source"
+            )
+            raise cv.Invalid(
+                f"Unsupported media file from {source!r} (detected type: {media_file_type})"
+            )
+
+        # Cache the file data so to_code() doesn't need to re-read it
+        _get_data().file_cache[str(file_config[CONF_ID])] = (data, media_file_type)
+
+        media_file_type_str = str(media_file_type)
+        if media_file_type_str == str(audio.AUDIO_FILE_TYPE_ENUM["FLAC"]):
+            audio.request_flac_support()
+        elif media_file_type_str == str(audio.AUDIO_FILE_TYPE_ENUM["MP3"]):
+            audio.request_mp3_support()
+        elif media_file_type_str == str(audio.AUDIO_FILE_TYPE_ENUM["OPUS"]):
+            audio.request_opus_support()
+
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.only_on_esp32,
+    cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
+    _validate_supported_local_file,
+)
+
+
+async def to_code(config: list[ConfigType]) -> None:
+    cache = _get_data().file_cache
+
+    for file_config in config:
+        file_id = str(file_config[CONF_ID])
+        data, media_file_type = cache[file_id]
+
+        rhs = [HexInt(x) for x in data]
+        prog_arr = cg.progmem_array(file_config[CONF_RAW_DATA_ID], rhs)
+
+        media_files_struct = cg.StructInitializer(
+            audio.AudioFile,
+            (
+                "data",
+                prog_arr,
+            ),
+            (
+                "length",
+                len(rhs),
+            ),
+            (
+                "file_type",
+                media_file_type,
+            ),
+        )
+
+        cg.new_Pvariable(
+            file_config[CONF_ID],
+            media_files_struct,
+        )
+
+        # Store file ID for cross-component access
+        _get_data().file_ids[file_id] = file_config[CONF_ID]
+
+    # Register all files in the shared C++ registry
+    cg.add_define("AUDIO_FILE_MAX_FILES", len(config))
+    for file_config in config:
+        file_id = str(file_config[CONF_ID])
+        file_var = await cg.get_variable(file_config[CONF_ID])
+        cg.add(audio_file_ns.add_named_audio_file(file_var, file_id))
diff --git a/esphome/components/audio_file/audio_file.h b/esphome/components/audio_file/audio_file.h
new file mode 100644
index 00000000000..537e19fb3ca
--- /dev/null
+++ b/esphome/components/audio_file/audio_file.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef AUDIO_FILE_MAX_FILES
+
+#include "esphome/components/audio/audio.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome::audio_file {
+
+struct NamedAudioFile {
+  audio::AudioFile *file;
+  const char *file_id;
+};
+
+inline StaticVector<NamedAudioFile, AUDIO_FILE_MAX_FILES>
+    named_audio_files;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+inline void add_named_audio_file(audio::AudioFile *file, const char *file_id) {
+  named_audio_files.push_back({file, file_id});
+}
+
+inline const StaticVector<NamedAudioFile, AUDIO_FILE_MAX_FILES> &get_named_audio_files() { return named_audio_files; }
+
+}  // namespace esphome::audio_file
+
+#endif  // AUDIO_FILE_MAX_FILES
diff --git a/esphome/components/ballu/ballu.cpp b/esphome/components/ballu/ballu.cpp
index b33ad11c1fb..deb742f8c67 100644
--- a/esphome/components/ballu/ballu.cpp
+++ b/esphome/components/ballu/ballu.cpp
@@ -47,7 +47,7 @@ void BalluClimate::transmit_state() {
   remote_state[11] = 0x1e;
 
   // Fan speed
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_HIGH:
       remote_state[4] |= BALLU_FAN_HIGH;
       break;
diff --git a/esphome/components/bang_bang/bang_bang_climate.cpp b/esphome/components/bang_bang/bang_bang_climate.cpp
index 6871e9df5dc..1058bce6a45 100644
--- a/esphome/components/bang_bang/bang_bang_climate.cpp
+++ b/esphome/components/bang_bang/bang_bang_climate.cpp
@@ -45,17 +45,21 @@ void BangBangClimate::setup() {
 }
 
 void BangBangClimate::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value()) {
-    this->mode = *call.get_mode();
+  auto mode = call.get_mode();
+  if (mode.has_value()) {
+    this->mode = *mode;
   }
-  if (call.get_target_temperature_low().has_value()) {
-    this->target_temperature_low = *call.get_target_temperature_low();
+  auto target_temperature_low = call.get_target_temperature_low();
+  if (target_temperature_low.has_value()) {
+    this->target_temperature_low = *target_temperature_low;
   }
-  if (call.get_target_temperature_high().has_value()) {
-    this->target_temperature_high = *call.get_target_temperature_high();
+  auto target_temperature_high = call.get_target_temperature_high();
+  if (target_temperature_high.has_value()) {
+    this->target_temperature_high = *target_temperature_high;
   }
-  if (call.get_preset().has_value()) {
-    this->change_away_(*call.get_preset() == climate::CLIMATE_PRESET_AWAY);
+  auto preset = call.get_preset();
+  if (preset.has_value()) {
+    this->change_away_(*preset == climate::CLIMATE_PRESET_AWAY);
   }
 
   this->compute_state_();
diff --git a/esphome/components/bedjet/bedjet_codec.cpp b/esphome/components/bedjet/bedjet_codec.cpp
index 9a312e226c1..7a959390f31 100644
--- a/esphome/components/bedjet/bedjet_codec.cpp
+++ b/esphome/components/bedjet/bedjet_codec.cpp
@@ -1,4 +1,5 @@
 #include "bedjet_codec.h"
+#include <algorithm>
 #include <cstdio>
 #include <cstring>
 
@@ -68,6 +69,10 @@ BedjetPacket *BedjetCodec::get_set_runtime_remaining_request(const uint8_t hour,
 
 /** Decodes the extra bytes that were received after being notified with a partial packet. */
 void BedjetCodec::decode_extra(const uint8_t *data, uint16_t length) {
+  if (length < 5) {
+    ESP_LOGVV(TAG, "Received extra: %d bytes (too short)", length);
+    return;
+  }
   ESP_LOGVV(TAG, "Received extra: %d bytes: %d %d %d %d", length, data[1], data[2], data[3], data[4]);
   uint8_t offset = this->last_buffer_size_;
   if (offset > 0 && length + offset <= sizeof(BedjetStatusPacket)) {
@@ -90,14 +95,19 @@ void BedjetCodec::decode_extra(const uint8_t *data, uint16_t length) {
  * @return `true` if the packet was decoded and represents a "partial" packet; `false` otherwise.
  */
 bool BedjetCodec::decode_notify(const uint8_t *data, uint16_t length) {
+  if (length < 5) {
+    ESP_LOGW(TAG, "Received short packet: %d bytes", length);
+    return false;
+  }
   ESP_LOGV(TAG, "Received: %d bytes: %d %d %d %d", length, data[1], data[2], data[3], data[4]);
 
   if (data[1] == PACKET_FORMAT_V3_HOME && data[3] == PACKET_TYPE_STATUS) {
     // Clear old buffer
     memset(&this->buf_, 0, sizeof(BedjetStatusPacket));
     // Copy new data into buffer
-    memcpy(&this->buf_, data, length);
-    this->last_buffer_size_ = length;
+    size_t copy_len = std::min(static_cast<size_t>(length), sizeof(BedjetStatusPacket));
+    memcpy(&this->buf_, data, copy_len);
+    this->last_buffer_size_ = copy_len;
 
     // TODO: validate the packet checksum?
     if (this->buf_.mode < 7 && this->buf_.target_temp_step >= 38 && this->buf_.target_temp_step <= 86 &&
@@ -113,13 +123,15 @@ bool BedjetCodec::decode_notify(const uint8_t *data, uint16_t length) {
     }
   } else if (data[1] == PACKET_FORMAT_DEBUG || data[3] == PACKET_TYPE_DEBUG) {
     // We don't actually know the packet format for this. Dump packets to log, in case a pattern presents itself.
-    ESP_LOGVV(TAG,
-              "received DEBUG packet: set1=%01fF, set2=%01fF, air=%01fF;  [7]=%d, [8]=%d, [9]=%d, [10]=%d, [11]=%d, "
-              "[12]=%d, [-1]=%d",
-              bedjet_temp_to_f(data[4]), bedjet_temp_to_f(data[5]), bedjet_temp_to_f(data[6]), data[7], data[8],
-              data[9], data[10], data[11], data[12], data[length - 1]);
+    if (length >= 13) {
+      ESP_LOGVV(TAG,
+                "received DEBUG packet: set1=%01fF, set2=%01fF, air=%01fF;  [7]=%d, [8]=%d, [9]=%d, [10]=%d, [11]=%d, "
+                "[12]=%d, [-1]=%d",
+                bedjet_temp_to_f(data[4]), bedjet_temp_to_f(data[5]), bedjet_temp_to_f(data[6]), data[7], data[8],
+                data[9], data[10], data[11], data[12], data[length - 1]);
+    }
 
-    if (this->has_status()) {
+    if (this->has_status() && length >= 7) {
       this->status_packet_->ambient_temp_step = data[6];
     }
   } else {
diff --git a/esphome/components/bedjet/climate/bedjet_climate.cpp b/esphome/components/bedjet/climate/bedjet_climate.cpp
index 68a0342873b..a17407f08ff 100644
--- a/esphome/components/bedjet/climate/bedjet_climate.cpp
+++ b/esphome/components/bedjet/climate/bedjet_climate.cpp
@@ -96,8 +96,9 @@ void BedJetClimate::control(const ClimateCall &call) {
     return;
   }
 
-  if (call.get_mode().has_value()) {
-    ClimateMode mode = *call.get_mode();
+  auto mode_opt = call.get_mode();
+  if (mode_opt.has_value()) {
+    ClimateMode mode = *mode_opt;
     bool button_result;
     switch (mode) {
       case CLIMATE_MODE_OFF:
@@ -125,8 +126,9 @@ void BedJetClimate::control(const ClimateCall &call) {
     }
   }
 
-  if (call.get_target_temperature().has_value()) {
-    auto target_temp = *call.get_target_temperature();
+  auto target_temp_opt = call.get_target_temperature();
+  if (target_temp_opt.has_value()) {
+    auto target_temp = *target_temp_opt;
     auto result = this->parent_->set_target_temp(target_temp);
 
     if (result) {
@@ -134,8 +136,9 @@ void BedJetClimate::control(const ClimateCall &call) {
     }
   }
 
-  if (call.get_preset().has_value()) {
-    ClimatePreset preset = *call.get_preset();
+  auto preset_opt = call.get_preset();
+  if (preset_opt.has_value()) {
+    ClimatePreset preset = *preset_opt;
     bool result;
 
     if (preset == CLIMATE_PRESET_BOOST) {
@@ -187,10 +190,11 @@ void BedJetClimate::control(const ClimateCall &call) {
     }
   }
 
-  if (call.get_fan_mode().has_value()) {
+  auto fan_mode_opt = call.get_fan_mode();
+  if (fan_mode_opt.has_value()) {
     // Climate fan mode only supports low/med/high, but the BedJet supports 5-100% increments.
     // We can still support a ClimateCall that requests low/med/high, and just translate it to a step increment here.
-    auto fan_mode = *call.get_fan_mode();
+    auto fan_mode = *fan_mode_opt;
     bool result;
     if (fan_mode == CLIMATE_FAN_LOW) {
       result = this->parent_->set_fan_speed(20);
diff --git a/esphome/components/bedjet/fan/bedjet_fan.cpp b/esphome/components/bedjet/fan/bedjet_fan.cpp
index e2722410404..9539e169a45 100644
--- a/esphome/components/bedjet/fan/bedjet_fan.cpp
+++ b/esphome/components/bedjet/fan/bedjet_fan.cpp
@@ -19,7 +19,8 @@ void BedJetFan::control(const fan::FanCall &call) {
   }
   bool did_change = false;
 
-  if (call.get_state().has_value() && this->state != *call.get_state()) {
+  auto state_opt = call.get_state();
+  if (state_opt.has_value() && this->state != *state_opt) {
     // Turning off is easy:
     if (this->state && this->parent_->button_off()) {
       this->state = false;
@@ -36,8 +37,9 @@ void BedJetFan::control(const fan::FanCall &call) {
   }
 
   // ignore speed changes if not on or turning on
-  if (this->state && call.get_speed().has_value()) {
-    auto speed = *call.get_speed();
+  auto speed_opt = call.get_speed();
+  if (this->state && speed_opt.has_value()) {
+    auto speed = *speed_opt;
     if (speed >= 1) {
       this->speed = speed;
       // Fan.speed is 1-20, but Bedjet expects 0-19, so subtract 1
diff --git a/esphome/components/binary/fan/binary_fan.cpp b/esphome/components/binary/fan/binary_fan.cpp
index a2f75242de1..17d4df095a0 100644
--- a/esphome/components/binary/fan/binary_fan.cpp
+++ b/esphome/components/binary/fan/binary_fan.cpp
@@ -18,12 +18,15 @@ fan::FanTraits BinaryFan::get_traits() {
   return fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr, 0);
 }
 void BinaryFan::control(const fan::FanCall &call) {
-  if (call.get_state().has_value())
-    this->state = *call.get_state();
-  if (call.get_oscillating().has_value())
-    this->oscillating = *call.get_oscillating();
-  if (call.get_direction().has_value())
-    this->direction = *call.get_direction();
+  auto state = call.get_state();
+  if (state.has_value())
+    this->state = *state;
+  auto oscillating = call.get_oscillating();
+  if (oscillating.has_value())
+    this->oscillating = *oscillating;
+  auto direction = call.get_direction();
+  if (direction.has_value())
+    this->direction = *direction;
 
   this->write_state_();
   this->publish_state();
diff --git a/esphome/components/ble_presence/ble_presence_device.h b/esphome/components/ble_presence/ble_presence_device.h
index f2f0a3ed191..8ae5edab3ad 100644
--- a/esphome/components/ble_presence/ble_presence_device.h
+++ b/esphome/components/ble_presence/ble_presence_device.h
@@ -76,11 +76,12 @@ class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
         }
         break;
       case MATCH_BY_IBEACON_UUID:
-        if (!device.get_ibeacon().has_value()) {
+        auto maybe_ibeacon = device.get_ibeacon();
+        if (!maybe_ibeacon.has_value()) {
           return false;
         }
 
-        auto ibeacon = device.get_ibeacon().value();
+        auto ibeacon = *maybe_ibeacon;
 
         if (this->ibeacon_uuid_ != ibeacon.get_uuid()) {
           return false;
diff --git a/esphome/components/ble_rssi/ble_rssi_sensor.h b/esphome/components/ble_rssi/ble_rssi_sensor.h
index 80245a1fe10..81f21c94ddb 100644
--- a/esphome/components/ble_rssi/ble_rssi_sensor.h
+++ b/esphome/components/ble_rssi/ble_rssi_sensor.h
@@ -74,11 +74,12 @@ class BLERSSISensor : public sensor::Sensor, public esp32_ble_tracker::ESPBTDevi
         }
         break;
       case MATCH_BY_IBEACON_UUID:
-        if (!device.get_ibeacon().has_value()) {
+        auto maybe_ibeacon = device.get_ibeacon();
+        if (!maybe_ibeacon.has_value()) {
           return false;
         }
 
-        auto ibeacon = device.get_ibeacon().value();
+        auto ibeacon = *maybe_ibeacon;
 
         if (this->ibeacon_uuid_ != ibeacon.get_uuid()) {
           return false;
diff --git a/esphome/components/climate_ir/climate_ir.cpp b/esphome/components/climate_ir/climate_ir.cpp
index 50c8d459b01..cc291ff17cf 100644
--- a/esphome/components/climate_ir/climate_ir.cpp
+++ b/esphome/components/climate_ir/climate_ir.cpp
@@ -71,16 +71,21 @@ void ClimateIR::setup() {
 }
 
 void ClimateIR::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value())
-    this->mode = *call.get_mode();
-  if (call.get_target_temperature().has_value())
-    this->target_temperature = *call.get_target_temperature();
-  if (call.get_fan_mode().has_value())
-    this->fan_mode = *call.get_fan_mode();
-  if (call.get_swing_mode().has_value())
-    this->swing_mode = *call.get_swing_mode();
-  if (call.get_preset().has_value())
-    this->preset = *call.get_preset();
+  auto mode = call.get_mode();
+  if (mode.has_value())
+    this->mode = *mode;
+  auto target_temperature = call.get_target_temperature();
+  if (target_temperature.has_value())
+    this->target_temperature = *target_temperature;
+  auto fan_mode = call.get_fan_mode();
+  if (fan_mode.has_value())
+    this->fan_mode = fan_mode;
+  auto swing_mode = call.get_swing_mode();
+  if (swing_mode.has_value())
+    this->swing_mode = *swing_mode;
+  auto preset = call.get_preset();
+  if (preset.has_value())
+    this->preset = preset;
   this->transmit_state();
   this->publish_state();
 }
diff --git a/esphome/components/climate_ir_lg/climate_ir_lg.cpp b/esphome/components/climate_ir_lg/climate_ir_lg.cpp
index 7fe06462302..90e3d006a85 100644
--- a/esphome/components/climate_ir_lg/climate_ir_lg.cpp
+++ b/esphome/components/climate_ir_lg/climate_ir_lg.cpp
@@ -79,7 +79,7 @@ void LgIrClimate::transmit_state() {
   if (this->mode == climate::CLIMATE_MODE_OFF) {
     remote_state |= FAN_AUTO;
   } else {
-    switch (this->fan_mode.value()) {
+    switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
       case climate::CLIMATE_FAN_HIGH:
         remote_state |= FAN_MAX;
         break;
diff --git a/esphome/components/climate_ir_lg/climate_ir_lg.h b/esphome/components/climate_ir_lg/climate_ir_lg.h
index 00fc99ae735..958245279f2 100644
--- a/esphome/components/climate_ir_lg/climate_ir_lg.h
+++ b/esphome/components/climate_ir_lg/climate_ir_lg.h
@@ -23,7 +23,8 @@ class LgIrClimate : public climate_ir::ClimateIR {
   void control(const climate::ClimateCall &call) override {
     this->send_swing_cmd_ = call.get_swing_mode().has_value();
     // swing resets after unit powered off
-    if (call.get_mode().has_value() && *call.get_mode() == climate::CLIMATE_MODE_OFF)
+    auto mode = call.get_mode();
+    if (mode.has_value() && *mode == climate::CLIMATE_MODE_OFF)
       this->swing_mode = climate::CLIMATE_SWING_OFF;
     climate_ir::ClimateIR::control(call);
   }
diff --git a/esphome/components/coolix/coolix.cpp b/esphome/components/coolix/coolix.cpp
index 5c6bfd7740a..d8ea6764781 100644
--- a/esphome/components/coolix/coolix.cpp
+++ b/esphome/components/coolix/coolix.cpp
@@ -83,7 +83,7 @@ void CoolixClimate::transmit_state() {
         this->fan_mode = climate::CLIMATE_FAN_AUTO;
         remote_state |= COOLIX_FAN_MODE_AUTO_DRY;
       } else {
-        switch (this->fan_mode.value()) {
+        switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
           case climate::CLIMATE_FAN_HIGH:
             remote_state |= COOLIX_FAN_MAX;
             break;
diff --git a/esphome/components/coolix/coolix.h b/esphome/components/coolix/coolix.h
index f4b4ff8e0e8..51ddcdf8f2f 100644
--- a/esphome/components/coolix/coolix.h
+++ b/esphome/components/coolix/coolix.h
@@ -23,7 +23,8 @@ class CoolixClimate : public climate_ir::ClimateIR {
   void control(const climate::ClimateCall &call) override {
     send_swing_cmd_ = call.get_swing_mode().has_value();
     // swing resets after unit powered off
-    if (call.get_mode().has_value() && *call.get_mode() == climate::CLIMATE_MODE_OFF)
+    auto mode = call.get_mode();
+    if (mode.has_value() && *mode == climate::CLIMATE_MODE_OFF)
       this->swing_mode = climate::CLIMATE_SWING_OFF;
     climate_ir::ClimateIR::control(call);
   }
diff --git a/esphome/components/copy/cover/copy_cover.cpp b/esphome/components/copy/cover/copy_cover.cpp
index 28f8c9877c9..c139869d8f5 100644
--- a/esphome/components/copy/cover/copy_cover.cpp
+++ b/esphome/components/copy/cover/copy_cover.cpp
@@ -38,12 +38,15 @@ cover::CoverTraits CopyCover::get_traits() {
 void CopyCover::control(const cover::CoverCall &call) {
   auto call2 = source_->make_call();
   call2.set_stop(call.get_stop());
-  if (call.get_tilt().has_value())
-    call2.set_tilt(*call.get_tilt());
-  if (call.get_position().has_value())
-    call2.set_position(*call.get_position());
-  if (call.get_tilt().has_value())
-    call2.set_tilt(*call.get_tilt());
+  auto tilt = call.get_tilt();
+  if (tilt.has_value())
+    call2.set_tilt(*tilt);
+  auto position = call.get_position();
+  if (position.has_value())
+    call2.set_position(*position);
+  auto tilt2 = call.get_tilt();
+  if (tilt2.has_value())
+    call2.set_tilt(*tilt2);
   call2.perform();
 }
 
diff --git a/esphome/components/copy/fan/copy_fan.cpp b/esphome/components/copy/fan/copy_fan.cpp
index b4a43cf2f18..14c600d71f4 100644
--- a/esphome/components/copy/fan/copy_fan.cpp
+++ b/esphome/components/copy/fan/copy_fan.cpp
@@ -45,14 +45,18 @@ fan::FanTraits CopyFan::get_traits() {
 
 void CopyFan::control(const fan::FanCall &call) {
   auto call2 = source_->make_call();
-  if (call.get_state().has_value())
-    call2.set_state(*call.get_state());
-  if (call.get_oscillating().has_value())
-    call2.set_oscillating(*call.get_oscillating());
-  if (call.get_speed().has_value())
-    call2.set_speed(*call.get_speed());
-  if (call.get_direction().has_value())
-    call2.set_direction(*call.get_direction());
+  auto state = call.get_state();
+  if (state.has_value())
+    call2.set_state(*state);
+  auto oscillating = call.get_oscillating();
+  if (oscillating.has_value())
+    call2.set_oscillating(*oscillating);
+  auto speed = call.get_speed();
+  if (speed.has_value())
+    call2.set_speed(*speed);
+  auto direction = call.get_direction();
+  if (direction.has_value())
+    call2.set_direction(*direction);
   if (call.has_preset_mode())
     call2.set_preset_mode(call.get_preset_mode());
   call2.perform();
diff --git a/esphome/components/copy/select/copy_select.cpp b/esphome/components/copy/select/copy_select.cpp
index e85e08e3536..227fe33182b 100644
--- a/esphome/components/copy/select/copy_select.cpp
+++ b/esphome/components/copy/select/copy_select.cpp
@@ -11,8 +11,9 @@ void CopySelect::setup() {
 
   traits.set_options(source_->traits.get_options());
 
-  if (source_->has_state())
-    this->publish_state(source_->active_index().value());
+  auto idx = this->source_->active_index();
+  if (idx.has_value())
+    this->publish_state(*idx);
 }
 
 void CopySelect::dump_config() { LOG_SELECT("", "Copy Select", this); }
diff --git a/esphome/components/current_based/current_based_cover.cpp b/esphome/components/current_based/current_based_cover.cpp
index 58ae7cbc34a..13bf11b9912 100644
--- a/esphome/components/current_based/current_based_cover.cpp
+++ b/esphome/components/current_based/current_based_cover.cpp
@@ -37,8 +37,9 @@ void CurrentBasedCover::control(const CoverCall &call) {
       }
     }
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto opt_pos = call.get_position();
+  if (opt_pos.has_value()) {
+    auto pos = *opt_pos;
     if (fabsf(this->position - pos) < 0.01) {
       // already at target
     } else {
diff --git a/esphome/components/daikin/daikin.cpp b/esphome/components/daikin/daikin.cpp
index 359c63aecac..a285f3613db 100644
--- a/esphome/components/daikin/daikin.cpp
+++ b/esphome/components/daikin/daikin.cpp
@@ -94,7 +94,7 @@ uint8_t DaikinClimate::operation_mode_() const {
 
 uint16_t DaikinClimate::fan_speed_() const {
   uint16_t fan_speed;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_QUIET:
       fan_speed = DAIKIN_FAN_SILENT << 8;
       break;
diff --git a/esphome/components/daikin_arc/daikin_arc.cpp b/esphome/components/daikin_arc/daikin_arc.cpp
index 47263108065..c45fa307a7c 100644
--- a/esphome/components/daikin_arc/daikin_arc.cpp
+++ b/esphome/components/daikin_arc/daikin_arc.cpp
@@ -176,7 +176,7 @@ uint8_t DaikinArcClimate::operation_mode_() {
 
 uint16_t DaikinArcClimate::fan_speed_() {
   uint16_t fan_speed;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       fan_speed = DAIKIN_FAN_1 << 8;
       break;
@@ -485,8 +485,9 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
 }
 
 void DaikinArcClimate::control(const climate::ClimateCall &call) {
-  if (call.get_target_humidity().has_value()) {
-    this->target_humidity = *call.get_target_humidity();
+  auto target_humidity = call.get_target_humidity();
+  if (target_humidity.has_value()) {
+    this->target_humidity = *target_humidity;
   }
   climate_ir::ClimateIR::control(call);
 }
diff --git a/esphome/components/daikin_brc/daikin_brc.cpp b/esphome/components/daikin_brc/daikin_brc.cpp
index 6683d70f807..1179cb07d70 100644
--- a/esphome/components/daikin_brc/daikin_brc.cpp
+++ b/esphome/components/daikin_brc/daikin_brc.cpp
@@ -111,7 +111,7 @@ uint8_t DaikinBrcClimate::operation_mode_() {
 
 uint8_t DaikinBrcClimate::fan_speed_swing_() {
   uint16_t fan_speed;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       fan_speed = DAIKIN_BRC_FAN_1;
       break;
diff --git a/esphome/components/deep_sleep/deep_sleep_esp8266.cpp b/esphome/components/deep_sleep/deep_sleep_esp8266.cpp
index 54d2aa993de..efbd45c34e7 100644
--- a/esphome/components/deep_sleep/deep_sleep_esp8266.cpp
+++ b/esphome/components/deep_sleep/deep_sleep_esp8266.cpp
@@ -15,7 +15,7 @@ void DeepSleepComponent::dump_config_platform_() {}
 bool DeepSleepComponent::prepare_to_sleep_() { return true; }
 
 void DeepSleepComponent::deep_sleep_() {
-  ESP.deepSleep(*this->sleep_duration_);  // NOLINT(readability-static-accessed-through-instance)
+  ESP.deepSleep(this->sleep_duration_.value_or(0));  // NOLINT(readability-static-accessed-through-instance)
 }
 
 }  // namespace deep_sleep
diff --git a/esphome/components/delonghi/delonghi.cpp b/esphome/components/delonghi/delonghi.cpp
index 9bc0b5753d8..19af703ab26 100644
--- a/esphome/components/delonghi/delonghi.cpp
+++ b/esphome/components/delonghi/delonghi.cpp
@@ -64,7 +64,7 @@ uint8_t DelonghiClimate::operation_mode_() {
 
 uint16_t DelonghiClimate::fan_speed_() {
   uint16_t fan_speed;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       fan_speed = DELONGHI_FAN_LOW;
       break;
diff --git a/esphome/components/demo/demo_alarm_control_panel.h b/esphome/components/demo/demo_alarm_control_panel.h
index f59434830b1..76cb24c2f4a 100644
--- a/esphome/components/demo/demo_alarm_control_panel.h
+++ b/esphome/components/demo/demo_alarm_control_panel.h
@@ -29,10 +29,11 @@ class DemoAlarmControlPanel : public AlarmControlPanel, public Component {
  protected:
   void control(const AlarmControlPanelCall &call) override {
     auto state = call.get_state().value_or(ACP_STATE_DISARMED);
+    auto code = call.get_code();
     switch (state) {
       case ACP_STATE_ARMED_AWAY:
-        if (this->get_requires_code_to_arm() && call.get_code().has_value()) {
-          if (call.get_code().value() != "1234") {
+        if (this->get_requires_code_to_arm() && code.has_value()) {
+          if (*code != "1234") {
             this->status_momentary_error("invalid_code", 5000);
             return;
           }
@@ -40,8 +41,8 @@ class DemoAlarmControlPanel : public AlarmControlPanel, public Component {
         this->publish_state(ACP_STATE_ARMED_AWAY);
         break;
       case ACP_STATE_DISARMED:
-        if (this->get_requires_code() && call.get_code().has_value()) {
-          if (call.get_code().value() != "1234") {
+        if (this->get_requires_code() && code.has_value()) {
+          if (*code != "1234") {
             this->status_momentary_error("invalid_code", 5000);
             return;
           }
diff --git a/esphome/components/demo/demo_climate.h b/esphome/components/demo/demo_climate.h
index e2dfb0142be..c5f07ac1145 100644
--- a/esphome/components/demo/demo_climate.h
+++ b/esphome/components/demo/demo_climate.h
@@ -45,33 +45,31 @@ class DemoClimate : public climate::Climate, public Component {
 
  protected:
   void control(const climate::ClimateCall &call) override {
-    if (call.get_mode().has_value()) {
-      this->mode = *call.get_mode();
-    }
-    if (call.get_target_temperature().has_value()) {
-      this->target_temperature = *call.get_target_temperature();
-    }
-    if (call.get_target_temperature_low().has_value()) {
-      this->target_temperature_low = *call.get_target_temperature_low();
-    }
-    if (call.get_target_temperature_high().has_value()) {
-      this->target_temperature_high = *call.get_target_temperature_high();
-    }
-    if (call.get_fan_mode().has_value()) {
-      this->set_fan_mode_(*call.get_fan_mode());
-    }
-    if (call.get_swing_mode().has_value()) {
-      this->swing_mode = *call.get_swing_mode();
-    }
-    if (call.has_custom_fan_mode()) {
+    auto mode = call.get_mode();
+    if (mode.has_value())
+      this->mode = *mode;
+    auto target_temperature = call.get_target_temperature();
+    if (target_temperature.has_value())
+      this->target_temperature = *target_temperature;
+    auto target_temperature_low = call.get_target_temperature_low();
+    if (target_temperature_low.has_value())
+      this->target_temperature_low = *target_temperature_low;
+    auto target_temperature_high = call.get_target_temperature_high();
+    if (target_temperature_high.has_value())
+      this->target_temperature_high = *target_temperature_high;
+    auto fan_mode = call.get_fan_mode();
+    if (fan_mode.has_value())
+      this->set_fan_mode_(*fan_mode);
+    auto swing_mode = call.get_swing_mode();
+    if (swing_mode.has_value())
+      this->swing_mode = *swing_mode;
+    if (call.has_custom_fan_mode())
       this->set_custom_fan_mode_(call.get_custom_fan_mode());
-    }
-    if (call.get_preset().has_value()) {
-      this->set_preset_(*call.get_preset());
-    }
-    if (call.has_custom_preset()) {
+    auto preset = call.get_preset();
+    if (preset.has_value())
+      this->set_preset_(*preset);
+    if (call.has_custom_preset())
       this->set_custom_preset_(call.get_custom_preset());
-    }
     this->publish_state();
   }
   climate::ClimateTraits traits() override {
diff --git a/esphome/components/demo/demo_cover.h b/esphome/components/demo/demo_cover.h
index ec266d46ab0..69dd5a4d2d1 100644
--- a/esphome/components/demo/demo_cover.h
+++ b/esphome/components/demo/demo_cover.h
@@ -38,8 +38,9 @@ class DemoCover : public cover::Cover, public Component {
 
  protected:
   void control(const cover::CoverCall &call) override {
-    if (call.get_position().has_value()) {
-      float target = *call.get_position();
+    auto pos = call.get_position();
+    if (pos.has_value()) {
+      float target = *pos;
       this->current_operation =
           target > this->position ? cover::COVER_OPERATION_OPENING : cover::COVER_OPERATION_CLOSING;
 
@@ -49,8 +50,9 @@ class DemoCover : public cover::Cover, public Component {
         this->publish_state();
       });
     }
-    if (call.get_tilt().has_value()) {
-      this->tilt = *call.get_tilt();
+    auto tilt = call.get_tilt();
+    if (tilt.has_value()) {
+      this->tilt = *tilt;
     }
     if (call.get_stop()) {
       this->cancel_timeout("move");
diff --git a/esphome/components/demo/demo_fan.h b/esphome/components/demo/demo_fan.h
index 09edc4e0b7f..a8b397f19ac 100644
--- a/esphome/components/demo/demo_fan.h
+++ b/esphome/components/demo/demo_fan.h
@@ -47,14 +47,18 @@ class DemoFan : public fan::Fan, public Component {
 
  protected:
   void control(const fan::FanCall &call) override {
-    if (call.get_state().has_value())
-      this->state = *call.get_state();
-    if (call.get_oscillating().has_value())
-      this->oscillating = *call.get_oscillating();
-    if (call.get_speed().has_value())
-      this->speed = *call.get_speed();
-    if (call.get_direction().has_value())
-      this->direction = *call.get_direction();
+    auto state = call.get_state();
+    if (state.has_value())
+      this->state = *state;
+    auto oscillating = call.get_oscillating();
+    if (oscillating.has_value())
+      this->oscillating = *oscillating;
+    auto speed = call.get_speed();
+    if (speed.has_value())
+      this->speed = *speed;
+    auto direction = call.get_direction();
+    if (direction.has_value())
+      this->direction = *direction;
 
     this->publish_state();
   }
diff --git a/esphome/components/demo/demo_lock.h b/esphome/components/demo/demo_lock.h
index 94d0f70a143..1e3fd51db4c 100644
--- a/esphome/components/demo/demo_lock.h
+++ b/esphome/components/demo/demo_lock.h
@@ -8,8 +8,9 @@ namespace demo {
 class DemoLock : public lock::Lock {
  protected:
   void control(const lock::LockCall &call) override {
-    auto state = *call.get_state();
-    this->publish_state(state);
+    auto state = call.get_state();
+    if (state.has_value())
+      this->publish_state(*state);
   }
 };
 
diff --git a/esphome/components/demo/demo_valve.h b/esphome/components/demo/demo_valve.h
index 55d457f1768..9a3122aca5c 100644
--- a/esphome/components/demo/demo_valve.h
+++ b/esphome/components/demo/demo_valve.h
@@ -26,12 +26,15 @@ class DemoValve : public valve::Valve {
 
  protected:
   void control(const valve::ValveCall &call) override {
-    if (call.get_position().has_value()) {
-      this->position = *call.get_position();
+    auto pos = call.get_position();
+    if (pos.has_value()) {
+      this->position = *pos;
       this->publish_state();
       return;
-    } else if (call.get_toggle().has_value()) {
-      if (call.get_toggle().value()) {
+    }
+    auto toggle = call.get_toggle();
+    if (toggle.has_value()) {
+      if (*toggle) {
         if (this->position == valve::VALVE_OPEN) {
           this->position = valve::VALVE_CLOSED;
           this->publish_state();
diff --git a/esphome/components/dfplayer/dfplayer.cpp b/esphome/components/dfplayer/dfplayer.cpp
index 79f8fd03c3e..1e1c33adaf3 100644
--- a/esphome/components/dfplayer/dfplayer.cpp
+++ b/esphome/components/dfplayer/dfplayer.cpp
@@ -260,6 +260,7 @@ void DFPlayer::loop() {
               ESP_LOGV(TAG, "Playback finished (USB drive)");
               this->is_playing_ = false;
               this->on_finished_playback_callback_.call();
+              break;
             case 0x3D:
               ESP_LOGV(TAG, "Playback finished (SD card)");
               this->is_playing_ = false;
diff --git a/esphome/components/dfrobot_sen0395/commands.h b/esphome/components/dfrobot_sen0395/commands.h
index 3b0551b1843..95167efb4db 100644
--- a/esphome/components/dfrobot_sen0395/commands.h
+++ b/esphome/components/dfrobot_sen0395/commands.h
@@ -30,11 +30,9 @@ class Command {
 
 class ReadStateCommand : public Command {
  public:
+  ReadStateCommand() { timeout_ms_ = 500; }
   uint8_t execute(DfrobotSen0395Component *parent) override;
   uint8_t on_message(std::string &message) override;
-
- protected:
-  uint32_t timeout_ms_{500};
 };
 
 class PowerCommand : public Command {
@@ -99,12 +97,12 @@ class ResetSystemCommand : public Command {
 
 class SaveCfgCommand : public Command {
  public:
-  SaveCfgCommand() { cmd_ = "saveCfg 0x45670123 0xCDEF89AB 0x956128C6 0xDF54AC89"; }
+  SaveCfgCommand() {
+    cmd_ = "saveCfg 0x45670123 0xCDEF89AB 0x956128C6 0xDF54AC89";
+    cmd_duration_ms_ = 3000;
+    timeout_ms_ = 3500;
+  }
   uint8_t on_message(std::string &message) override;
-
- protected:
-  uint32_t cmd_duration_ms_{3000};
-  uint32_t timeout_ms_{3500};
 };
 
 class LedModeCommand : public Command {
diff --git a/esphome/components/display/display.cpp b/esphome/components/display/display.cpp
index 2bd7d036006..f8569b6e7c9 100644
--- a/esphome/components/display/display.cpp
+++ b/esphome/components/display/display.cpp
@@ -661,6 +661,9 @@ void Display::printf(int x, int y, BaseFont *font, const char *format, ...) {
 void Display::set_writer(display_writer_t &&writer) { this->writer_ = writer; }
 
 void Display::set_pages(std::vector<DisplayPage *> pages) {
+  if (pages.empty())
+    return;
+
   for (auto *page : pages)
     page->set_parent(this);
 
diff --git a/esphome/components/ds2484/ds2484.cpp b/esphome/components/ds2484/ds2484.cpp
index 7c890ff4339..0b36f868749 100644
--- a/esphome/components/ds2484/ds2484.cpp
+++ b/esphome/components/ds2484/ds2484.cpp
@@ -110,9 +110,9 @@ uint8_t DS2484OneWireBus::read8() {
 }
 
 uint64_t DS2484OneWireBus::read64() {
-  uint8_t response = 0;
+  uint64_t response = 0;
   for (uint8_t i = 0; i < 8; i++) {
-    response |= (this->read8() << (i * 8));
+    response |= (static_cast<uint64_t>(this->read8()) << (i * 8));
   }
   return response;
 }
diff --git a/esphome/components/ee895/ee895.h b/esphome/components/ee895/ee895.h
index 259b7c524b5..ff1085e05d8 100644
--- a/esphome/components/ee895/ee895.h
+++ b/esphome/components/ee895/ee895.h
@@ -22,9 +22,9 @@ class EE895Component : public PollingComponent, public i2c::I2CDevice {
   void write_command_(uint16_t addr, uint16_t reg_cnt);
   float read_float_();
   uint16_t calc_crc16_(const uint8_t buf[], uint8_t len);
-  sensor::Sensor *co2_sensor_;
-  sensor::Sensor *temperature_sensor_;
-  sensor::Sensor *pressure_sensor_;
+  sensor::Sensor *co2_sensor_{nullptr};
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *pressure_sensor_{nullptr};
 
   enum ErrorCode { NONE = 0, COMMUNICATION_FAILED, CRC_CHECK_FAILED } error_code_{NONE};
 };
diff --git a/esphome/components/emc2101/emc2101.cpp b/esphome/components/emc2101/emc2101.cpp
index 7d85cd31cfd..068e25568f1 100644
--- a/esphome/components/emc2101/emc2101.cpp
+++ b/esphome/components/emc2101/emc2101.cpp
@@ -72,7 +72,7 @@ void Emc2101Component::setup() {
     config |= EMC2101_DAC_BIT;
   }
   if (this->inverted_) {
-    config |= EMC2101_POLARITY_BIT;
+    reg(EMC2101_REGISTER_FAN_CONFIG) |= EMC2101_POLARITY_BIT;
   }
 
   if (this->dac_mode_) {  // DAC mode configurations
diff --git a/esphome/components/emmeti/emmeti.cpp b/esphome/components/emmeti/emmeti.cpp
index d3e923cbefc..04976d95d70 100644
--- a/esphome/components/emmeti/emmeti.cpp
+++ b/esphome/components/emmeti/emmeti.cpp
@@ -28,7 +28,7 @@ uint8_t EmmetiClimate::set_mode_() {
 }
 
 uint8_t EmmetiClimate::set_fan_speed_() {
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       return EMMETI_FAN_1;
     case climate::CLIMATE_FAN_MEDIUM:
diff --git a/esphome/components/endstop/endstop_cover.cpp b/esphome/components/endstop/endstop_cover.cpp
index ea8a5ec1869..5e0b9c72d3c 100644
--- a/esphome/components/endstop/endstop_cover.cpp
+++ b/esphome/components/endstop/endstop_cover.cpp
@@ -37,8 +37,9 @@ void EndstopCover::control(const CoverCall &call) {
       }
     }
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto opt_pos = call.get_position();
+  if (opt_pos.has_value()) {
+    auto pos = *opt_pos;
     if (pos == this->position) {
       // already at target
     } else {
diff --git a/esphome/components/esp32_ble_server/ble_characteristic.cpp b/esphome/components/esp32_ble_server/ble_characteristic.cpp
index a1b1ff94bb3..d4ccefd9b29 100644
--- a/esphome/components/esp32_ble_server/ble_characteristic.cpp
+++ b/esphome/components/esp32_ble_server/ble_characteristic.cpp
@@ -209,7 +209,11 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
 
       esp_gatt_rsp_t response;
       if (param->read.is_long) {
-        if (this->value_.size() - this->value_read_offset_ < max_offset) {
+        if (this->value_read_offset_ >= this->value_.size()) {
+          response.attr_value.len = 0;
+          response.attr_value.offset = this->value_read_offset_;
+          this->value_read_offset_ = 0;
+        } else if (this->value_.size() - this->value_read_offset_ < max_offset) {
           //  Last message in the chain
           response.attr_value.len = this->value_.size() - this->value_read_offset_;
           response.attr_value.offset = this->value_read_offset_;
diff --git a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
index fa0cdb6f452..7f1c2b0f7c8 100644
--- a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
+++ b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
@@ -107,7 +107,7 @@ class ESPBTDevice {
     for (auto &it : this->manufacturer_datas_) {
       auto res = ESPBLEiBeacon::from_manufacturer_data(it);
       if (res.has_value())
-        return *res;
+        return res;
     }
     return {};
   }
diff --git a/esphome/components/esp32_improv/esp32_improv_component.cpp b/esphome/components/esp32_improv/esp32_improv_component.cpp
index 83bc842a3d3..e4ae49f2356 100644
--- a/esphome/components/esp32_improv/esp32_improv_component.cpp
+++ b/esphome/components/esp32_improv/esp32_improv_component.cpp
@@ -314,6 +314,8 @@ void ESP32ImprovComponent::dump_config() {
 }
 
 void ESP32ImprovComponent::process_incoming_data_() {
+  if (this->incoming_data_.size() < 3)
+    return;
   uint8_t length = this->incoming_data_[1];
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
diff --git a/esphome/components/esp32_rmt_led_strip/led_strip.cpp b/esphome/components/esp32_rmt_led_strip/led_strip.cpp
index 8bb5cbb62ed..66b41931aac 100644
--- a/esphome/components/esp32_rmt_led_strip/led_strip.cpp
+++ b/esphome/components/esp32_rmt_led_strip/led_strip.cpp
@@ -162,7 +162,8 @@ void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bi
 void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
   // protect from refreshing too often
   uint32_t now = micros();
-  if (*this->max_refresh_rate_ != 0 && (now - this->last_refresh_) < *this->max_refresh_rate_) {
+  auto rate = this->max_refresh_rate_.value_or(0);
+  if (rate != 0 && (now - this->last_refresh_) < rate) {
     // try again next loop iteration, so that this change won't get lost
     this->schedule_show();
     return;
@@ -301,7 +302,7 @@ void ESP32RMTLEDStripLightOutput::dump_config() {
                 "  RGB Order: %s\n"
                 "  Max refresh rate: %" PRIu32 "\n"
                 "  Number of LEDs: %u",
-                rgb_order, *this->max_refresh_rate_, this->num_leds_);
+                rgb_order, this->max_refresh_rate_.value_or(0), this->num_leds_);
 }
 
 float ESP32RMTLEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }
diff --git a/esphome/components/esphome/ota/ota_esphome.h b/esphome/components/esphome/ota/ota_esphome.h
index 08edacad92f..f3a5952398f 100644
--- a/esphome/components/esphome/ota/ota_esphome.h
+++ b/esphome/components/esphome/ota/ota_esphome.h
@@ -2,7 +2,7 @@
 
 #include "esphome/core/defines.h"
 #ifdef USE_OTA
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota/ota_backend_factory.h"
 #include "esphome/components/socket/socket.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -86,7 +86,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
 
   socket::ListenSocket *server_{nullptr};
   std::unique_ptr<socket::Socket> client_;
-  std::unique_ptr<ota::OTABackend> backend_;
+  ota::OTABackendPtr backend_;
 
   uint32_t client_connect_time_{0};
   uint16_t port_;
diff --git a/esphome/components/ethernet/ethernet_component.cpp b/esphome/components/ethernet/ethernet_component.cpp
index f855bc89cc7..098f7be972f 100644
--- a/esphome/components/ethernet/ethernet_component.cpp
+++ b/esphome/components/ethernet/ethernet_component.cpp
@@ -687,8 +687,6 @@ void EthernetComponent::start_connect_() {
   this->status_set_warning();
 }
 
-bool EthernetComponent::is_connected() { return this->state_ == EthernetComponentState::CONNECTED; }
-
 void EthernetComponent::dump_connect_params_() {
   esp_netif_ip_info_t ip;
   esp_netif_get_ip_info(this->eth_netif_, &ip);
diff --git a/esphome/components/ethernet/ethernet_component.h b/esphome/components/ethernet/ethernet_component.h
index 1cd44d2b2cf..f5a31d78ebf 100644
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -76,7 +76,7 @@ class EthernetComponent : public Component {
   void dump_config() override;
   float get_setup_priority() const override;
   void on_powerdown() override { powerdown(); }
-  bool is_connected();
+  bool is_connected() { return this->state_ == EthernetComponentState::CONNECTED; }
 
 #ifdef USE_ETHERNET_SPI
   void set_clk_pin(uint8_t clk_pin);
diff --git a/esphome/components/ezo/ezo.cpp b/esphome/components/ezo/ezo.cpp
index e4036021df7..2dc65b7d14c 100644
--- a/esphome/components/ezo/ezo.cpp
+++ b/esphome/components/ezo/ezo.cpp
@@ -66,8 +66,9 @@ void EZOSensor::loop() {
 
     if (to_run->command_type == EzoCommandType::EZO_SLEEP ||
         to_run->command_type == EzoCommandType::EZO_I2C) {  // Commands with no return data
+      bool update_address = to_run->command_type == EzoCommandType::EZO_I2C;
       this->commands_.pop_front();
-      if (to_run->command_type == EzoCommandType::EZO_I2C)
+      if (update_address)
         this->address_ = this->new_address_;
       return;
     }
diff --git a/esphome/components/ezo_pmp/ezo_pmp.cpp b/esphome/components/ezo_pmp/ezo_pmp.cpp
index bf6e3926b87..4ce4da57ffc 100644
--- a/esphome/components/ezo_pmp/ezo_pmp.cpp
+++ b/esphome/components/ezo_pmp/ezo_pmp.cpp
@@ -165,22 +165,23 @@ void EzoPMP::read_command_result_() {
       continue;
     }
 
-    switch (current_parameter) {
-      case 1:
-        first_parameter_buffer[position_in_parameter_buffer] = current_char;
-        first_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
-        break;
-      case 2:
-        second_parameter_buffer[position_in_parameter_buffer] = current_char;
-        second_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
-        break;
-      case 3:
-        third_parameter_buffer[position_in_parameter_buffer] = current_char;
-        third_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
-        break;
+    if (position_in_parameter_buffer < sizeof(first_parameter_buffer) - 1) {
+      switch (current_parameter) {
+        case 1:
+          first_parameter_buffer[position_in_parameter_buffer] = current_char;
+          first_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
+          break;
+        case 2:
+          second_parameter_buffer[position_in_parameter_buffer] = current_char;
+          second_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
+          break;
+        case 3:
+          third_parameter_buffer[position_in_parameter_buffer] = current_char;
+          third_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
+          break;
+      }
+      position_in_parameter_buffer++;
     }
-
-    position_in_parameter_buffer++;
   }
 
   auto parsed_first_parameter = parse_number<float>(first_parameter_buffer);
@@ -404,7 +405,8 @@ void EzoPMP::send_next_command_() {
       break;
 
     case EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS:  // Run an arbitrary command
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "%s", this->arbitrary_command_);
+      command_buffer_length =
+          snprintf((char *) command_buffer, sizeof(command_buffer), "%s", this->arbitrary_command_.c_str());
       ESP_LOGI(TAG, "Sending arbitrary command: %s", (char *) command_buffer);
       break;
 
@@ -541,7 +543,7 @@ void EzoPMP::change_i2c_address(int address) {
 }
 
 void EzoPMP::exec_arbitrary_command(const std::basic_string<char> &command) {
-  this->arbitrary_command_ = command.c_str();
+  this->arbitrary_command_ = command;
   this->queue_command_(EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS, 0, 0, true);
 }
 
diff --git a/esphome/components/ezo_pmp/ezo_pmp.h b/esphome/components/ezo_pmp/ezo_pmp.h
index d4917e7f4b4..bbfd8991707 100644
--- a/esphome/components/ezo_pmp/ezo_pmp.h
+++ b/esphome/components/ezo_pmp/ezo_pmp.h
@@ -85,7 +85,7 @@ class EzoPMP : public PollingComponent, public i2c::I2CDevice {
   bool is_paused_flag_ = false;
   bool is_dosing_flag_ = false;
 
-  const char *arbitrary_command_{nullptr};
+  std::string arbitrary_command_{};
 
   void send_next_command_();
   void read_command_result_();
diff --git a/esphome/components/fastled_base/fastled_light.cpp b/esphome/components/fastled_base/fastled_light.cpp
index b3946a34b5f..504b8d473e4 100644
--- a/esphome/components/fastled_base/fastled_light.cpp
+++ b/esphome/components/fastled_base/fastled_light.cpp
@@ -21,12 +21,13 @@ void FastLEDLightOutput::dump_config() {
                 "FastLED light:\n"
                 "  Num LEDs: %u\n"
                 "  Max refresh rate: %u",
-                this->num_leds_, *this->max_refresh_rate_);
+                this->num_leds_, this->max_refresh_rate_.value_or(0));
 }
 void FastLEDLightOutput::write_state(light::LightState *state) {
   // protect from refreshing too often
   uint32_t now = micros();
-  if (*this->max_refresh_rate_ != 0 && (now - this->last_refresh_) < *this->max_refresh_rate_) {
+  uint32_t max_rate = this->max_refresh_rate_.value_or(0);
+  if (max_rate != 0 && (now - this->last_refresh_) < max_rate) {
     // try again next loop iteration, so that this change won't get lost
     this->schedule_show();
     return;
diff --git a/esphome/components/feedback/feedback_cover.cpp b/esphome/components/feedback/feedback_cover.cpp
index ffb19fa091b..d247bada33f 100644
--- a/esphome/components/feedback/feedback_cover.cpp
+++ b/esphome/components/feedback/feedback_cover.cpp
@@ -269,9 +269,12 @@ void FeedbackCover::control(const CoverCall &call) {
         this->start_direction_(COVER_OPERATION_CLOSING);
       }
     }
-  } else if (call.get_position().has_value()) {
+  } else {
+    auto pos_opt = call.get_position();
+    if (!pos_opt.has_value())
+      return;
     // go to position action
-    auto pos = *call.get_position();
+    auto pos = *pos_opt;
     if (pos == this->position) {
       // already at target,
 
diff --git a/esphome/components/fingerprint_grow/fingerprint_grow.cpp b/esphome/components/fingerprint_grow/fingerprint_grow.cpp
index da4535fc828..a633fbca282 100644
--- a/esphome/components/fingerprint_grow/fingerprint_grow.cpp
+++ b/esphome/components/fingerprint_grow/fingerprint_grow.cpp
@@ -361,7 +361,7 @@ void FingerprintGrowComponent::aura_led_control(uint8_t state, uint8_t speed, ui
   }
 }
 
-uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> *p_data_buffer) {
+uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> &data_buffer) {
   while (this->available())
     this->read();
   this->write((uint8_t) (START_CODE >> 8));
@@ -372,12 +372,12 @@ uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> *p_data_buffer)
   this->write(this->address_[3]);
   this->write(COMMAND);
 
-  uint16_t wire_length = p_data_buffer->size() + 2;
+  uint16_t wire_length = data_buffer.size() + 2;
   this->write((uint8_t) (wire_length >> 8));
   this->write((uint8_t) (wire_length & 0xFF));
 
   uint16_t sum = (wire_length >> 8) + (wire_length & 0xFF) + COMMAND;
-  for (auto data : *p_data_buffer) {
+  for (auto data : data_buffer) {
     this->write(data);
     sum += data;
   }
@@ -385,7 +385,7 @@ uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> *p_data_buffer)
   this->write((uint8_t) (sum >> 8));
   this->write((uint8_t) (sum & 0xFF));
 
-  p_data_buffer->clear();
+  data_buffer.clear();
 
   uint8_t byte;
   uint16_t idx = 0, length = 0;
@@ -431,9 +431,9 @@ uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> *p_data_buffer)
         length |= byte;
         break;
       default:
-        p_data_buffer->push_back(byte);
+        data_buffer.push_back(byte);
         if ((idx - 8) == length) {
-          switch ((*p_data_buffer)[0]) {
+          switch (data_buffer[0]) {
             case OK:
             case NO_FINGER:
             case IMAGE_FAIL:
@@ -453,25 +453,26 @@ uint8_t FingerprintGrowComponent::transfer_(std::vector<uint8_t> *p_data_buffer)
               ESP_LOGE(TAG, "Reader failed to process request");
               break;
             default:
-              ESP_LOGE(TAG, "Unknown response received from reader: 0x%.2X", (*p_data_buffer)[0]);
+              ESP_LOGE(TAG, "Unknown response received from reader: 0x%.2X", data_buffer[0]);
               break;
           }
           this->last_transfer_ms_ = millis();
-          return (*p_data_buffer)[0];
+          return data_buffer[0];
         }
         break;
     }
     idx++;
   }
   ESP_LOGE(TAG, "No response received from reader");
-  (*p_data_buffer)[0] = TIMEOUT;
+  data_buffer.clear();
+  data_buffer.push_back(TIMEOUT);
   this->last_transfer_ms_ = millis();
   return TIMEOUT;
 }
 
 uint8_t FingerprintGrowComponent::send_command_() {
   this->sensor_wakeup_();
-  return this->transfer_(&this->data_);
+  return this->transfer_(this->data_);
 }
 
 void FingerprintGrowComponent::sensor_wakeup_() {
@@ -517,7 +518,7 @@ void FingerprintGrowComponent::sensor_wakeup_() {
   std::vector<uint8_t> buffer = {VERIFY_PASSWORD, (uint8_t) (this->password_ >> 24), (uint8_t) (this->password_ >> 16),
                                  (uint8_t) (this->password_ >> 8), (uint8_t) (this->password_ & 0xFF)};
 
-  if (this->transfer_(&buffer) != OK) {
+  if (this->transfer_(buffer) != OK) {
     ESP_LOGE(TAG, "Wrong password");
   }
 }
diff --git a/esphome/components/fingerprint_grow/fingerprint_grow.h b/esphome/components/fingerprint_grow/fingerprint_grow.h
index 370b26f56a3..db9d5ce564f 100644
--- a/esphome/components/fingerprint_grow/fingerprint_grow.h
+++ b/esphome/components/fingerprint_grow/fingerprint_grow.h
@@ -169,7 +169,7 @@ class FingerprintGrowComponent : public PollingComponent, public uart::UARTDevic
   bool set_password_();
   bool get_parameters_();
   void get_fingerprint_count_();
-  uint8_t transfer_(std::vector<uint8_t> *p_data_buffer);
+  uint8_t transfer_(std::vector<uint8_t> &data_buffer);
   uint8_t send_command_();
   void sensor_wakeup_();
   void sensor_sleep_();
@@ -190,7 +190,7 @@ class FingerprintGrowComponent : public PollingComponent, public uart::UARTDevic
   bool is_sensor_awake_ = false;
   uint32_t last_transfer_ms_ = 0;
   uint32_t last_aura_led_control_ = 0;
-  uint16_t last_aura_led_duration_ = 0;
+  uint32_t last_aura_led_duration_ = 0;
   uint16_t system_identifier_code_ = 0;
   uint32_t idle_period_to_sleep_ms_ = UINT32_MAX;
   sensor::Sensor *fingerprint_count_sensor_{nullptr};
diff --git a/esphome/components/fujitsu_general/fujitsu_general.cpp b/esphome/components/fujitsu_general/fujitsu_general.cpp
index 6c7adebfeaf..8aa0f517287 100644
--- a/esphome/components/fujitsu_general/fujitsu_general.cpp
+++ b/esphome/components/fujitsu_general/fujitsu_general.cpp
@@ -141,7 +141,7 @@ void FujitsuGeneralClimate::transmit_state() {
   }
 
   // Set fan
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_HIGH:
       SET_NIBBLE(remote_state, FUJITSU_GENERAL_FAN_NIBBLE, FUJITSU_GENERAL_FAN_HIGH);
       break;
diff --git a/esphome/components/globals/__init__.py b/esphome/components/globals/__init__.py
index fe11a93a4bb..fe83b1ea7c3 100644
--- a/esphome/components/globals/__init__.py
+++ b/esphome/components/globals/__init__.py
@@ -51,7 +51,7 @@ _RESTORING_SCHEMA = cv.Schema(
 
 def _globals_schema(config: ConfigType) -> ConfigType:
     """Select schema based on restore_value setting."""
-    if config.get(CONF_RESTORE_VALUE, False):
+    if cv.boolean(config.get(CONF_RESTORE_VALUE, False)):
         return _RESTORING_SCHEMA(config)
     return _NON_RESTORING_SCHEMA(config)
 
diff --git a/esphome/components/gps/__init__.py b/esphome/components/gps/__init__.py
index 045a5a6c847..ab48417a4e7 100644
--- a/esphome/components/gps/__init__.py
+++ b/esphome/components/gps/__init__.py
@@ -34,7 +34,7 @@ AUTO_LOAD = ["sensor"]
 CODEOWNERS = ["@coogle", "@ximex"]
 
 gps_ns = cg.esphome_ns.namespace("gps")
-GPS = gps_ns.class_("GPS", cg.Component, uart.UARTDevice)
+GPS = gps_ns.class_("GPS", cg.PollingComponent, uart.UARTDevice)
 GPSListener = gps_ns.class_("GPSListener")
 
 MULTI_CONF = True
diff --git a/esphome/components/gree/gree.cpp b/esphome/components/gree/gree.cpp
index b8cf8a39a85..8a9f264932c 100644
--- a/esphome/components/gree/gree.cpp
+++ b/esphome/components/gree/gree.cpp
@@ -180,7 +180,7 @@ uint8_t GreeClimate::operation_mode_() {
 uint8_t GreeClimate::fan_speed_() {
   // YX1FF has 4 fan speeds -- we treat low as quiet and turbo as high
   if (this->model_ == GREE_YX1FF) {
-    switch (this->fan_mode.value()) {
+    switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
       case climate::CLIMATE_FAN_QUIET:
         return GREE_FAN_1;
       case climate::CLIMATE_FAN_LOW:
@@ -195,7 +195,7 @@ uint8_t GreeClimate::fan_speed_() {
     }
   }
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       return GREE_FAN_1;
     case climate::CLIMATE_FAN_MEDIUM:
@@ -235,7 +235,7 @@ uint8_t GreeClimate::temperature_() {
 uint8_t GreeClimate::preset_() {
   // YX1FF has sleep preset
   if (this->model_ == GREE_YX1FF) {
-    switch (this->preset.value()) {
+    switch (this->preset.value_or(climate::CLIMATE_PRESET_NONE)) {
       case climate::CLIMATE_PRESET_NONE:
         return GREE_PRESET_NONE;
       case climate::CLIMATE_PRESET_SLEEP:
diff --git a/esphome/components/grove_tb6612fng/grove_tb6612fng.cpp b/esphome/components/grove_tb6612fng/grove_tb6612fng.cpp
index a2499846473..428c8ec4a8c 100644
--- a/esphome/components/grove_tb6612fng/grove_tb6612fng.cpp
+++ b/esphome/components/grove_tb6612fng/grove_tb6612fng.cpp
@@ -131,7 +131,7 @@ void GroveMotorDriveTB6612FNG::stepper_run(StepperModeTypeT mode, int16_t steps,
   buffer_[4] = ms_per_step;
   buffer_[5] = (ms_per_step >> 8);
 
-  if (this->write_register(GROVE_MOTOR_DRIVER_I2C_CMD_STEPPER_RUN, buffer_, 1) != i2c::ERROR_OK) {
+  if (this->write_register(GROVE_MOTOR_DRIVER_I2C_CMD_STEPPER_RUN, buffer_, 6) != i2c::ERROR_OK) {
     ESP_LOGW(TAG, "Run stepper failed!");
     this->status_set_warning();
     return;
diff --git a/esphome/components/haier/hon_climate.cpp b/esphome/components/haier/hon_climate.cpp
index d98d273957a..be5035caa17 100644
--- a/esphome/components/haier/hon_climate.cpp
+++ b/esphome/components/haier/hon_climate.cpp
@@ -893,7 +893,8 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
     } else {
       this->preset = CLIMATE_PRESET_NONE;
     }
-    should_publish = should_publish || (!old_preset.has_value()) || (old_preset.value() != this->preset.value());
+    should_publish = should_publish || (!old_preset.has_value()) ||
+                     (old_preset.value_or(CLIMATE_PRESET_NONE) != this->preset.value_or(CLIMATE_PRESET_NONE));
   }
   {
     // Target temperature
@@ -936,7 +937,8 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
         this->fan_mode = CLIMATE_FAN_HIGH;
         break;
     }
-    should_publish = should_publish || (!old_fan_mode.has_value()) || (old_fan_mode.value() != fan_mode.value());
+    should_publish = should_publish || (!old_fan_mode.has_value()) ||
+                     (old_fan_mode.value_or(CLIMATE_FAN_ON) != this->fan_mode.value_or(CLIMATE_FAN_ON));
   }
   // Display status
   // should be before "Climate mode" because it is changing this->mode
@@ -1301,7 +1303,8 @@ void HonClimate::clear_control_messages_queue_() {
 }
 
 bool HonClimate::prepare_pending_action() {
-  switch (this->action_request_.value().action) {
+  auto &action_request = this->action_request_.value();  // NOLINT(bugprone-unchecked-optional-access)
+  switch (action_request.action) {
     case ActionRequest::START_SELF_CLEAN:
       if (this->control_method_ == HonControlMethod::SET_GROUP_PARAMETERS) {
         uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
@@ -1315,12 +1318,12 @@ bool HonClimate::prepare_pending_action() {
         out_data->ac_power = 1;
         out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
         out_data->light_status = 0;
-        this->action_request_.value().message = haier_protocol::HaierMessage(
+        action_request.message = haier_protocol::HaierMessage(
             haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
             control_out_buffer, this->real_control_packet_size_);
         return true;
       } else if (this->control_method_ == HonControlMethod::SET_SINGLE_PARAMETER) {
-        this->action_request_.value().message =
+        action_request.message =
             haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::SELF_CLEANING,
@@ -1343,7 +1346,7 @@ bool HonClimate::prepare_pending_action() {
         out_data->ac_power = 1;
         out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
         out_data->light_status = 0;
-        this->action_request_.value().message = haier_protocol::HaierMessage(
+        action_request.message = haier_protocol::HaierMessage(
             haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
             control_out_buffer, this->real_control_packet_size_);
         return true;
diff --git a/esphome/components/haier/smartair2_climate.cpp b/esphome/components/haier/smartair2_climate.cpp
index 63c22821b3e..e91224e2d8e 100644
--- a/esphome/components/haier/smartair2_climate.cpp
+++ b/esphome/components/haier/smartair2_climate.cpp
@@ -385,7 +385,7 @@ haier_protocol::HaierMessage Smartair2Climate::get_control_message() {
 }
 
 haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
-  if (size < sizeof(smartair2_protocol::HaierStatus))
+  if (size != sizeof(smartair2_protocol::HaierStatus))
     return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
   smartair2_protocol::HaierStatus packet;
   memcpy(&packet, packet_buffer, size);
@@ -402,7 +402,8 @@ haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uin
     } else {
       this->preset = CLIMATE_PRESET_NONE;
     }
-    should_publish = should_publish || (!old_preset.has_value()) || (old_preset.value() != this->preset.value());
+    should_publish = should_publish || (!old_preset.has_value()) ||
+                     (old_preset.value_or(CLIMATE_PRESET_NONE) != this->preset.value_or(CLIMATE_PRESET_NONE));
   }
   {
     // Target temperature
@@ -446,7 +447,8 @@ haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uin
         this->fan_mode = CLIMATE_FAN_HIGH;
         break;
     }
-    should_publish = should_publish || (!old_fan_mode.has_value()) || (old_fan_mode.value() != fan_mode.value());
+    should_publish = should_publish || (!old_fan_mode.has_value()) ||
+                     (old_fan_mode.value_or(CLIMATE_FAN_ON) != this->fan_mode.value_or(CLIMATE_FAN_ON));
   }
   // Display status
   // should be before "Climate mode" because it is changing this->mode
diff --git a/esphome/components/hbridge/fan/hbridge_fan.cpp b/esphome/components/hbridge/fan/hbridge_fan.cpp
index 38e4129e66f..89c162eebfc 100644
--- a/esphome/components/hbridge/fan/hbridge_fan.cpp
+++ b/esphome/components/hbridge/fan/hbridge_fan.cpp
@@ -49,14 +49,18 @@ void HBridgeFan::dump_config() {
 }
 
 void HBridgeFan::control(const fan::FanCall &call) {
-  if (call.get_state().has_value())
-    this->state = *call.get_state();
-  if (call.get_speed().has_value())
-    this->speed = *call.get_speed();
-  if (call.get_oscillating().has_value())
-    this->oscillating = *call.get_oscillating();
-  if (call.get_direction().has_value())
-    this->direction = *call.get_direction();
+  auto call_state = call.get_state();
+  if (call_state.has_value())
+    this->state = *call_state;
+  auto call_speed = call.get_speed();
+  if (call_speed.has_value())
+    this->speed = *call_speed;
+  auto call_oscillating = call.get_oscillating();
+  if (call_oscillating.has_value())
+    this->oscillating = *call_oscillating;
+  auto call_direction = call.get_direction();
+  if (call_direction.has_value())
+    this->direction = *call_direction;
   this->apply_preset_mode_(call);
 
   this->write_state_();
diff --git a/esphome/components/he60r/he60r.cpp b/esphome/components/he60r/he60r.cpp
index ca179302726..fdcd1a29c05 100644
--- a/esphome/components/he60r/he60r.cpp
+++ b/esphome/components/he60r/he60r.cpp
@@ -171,9 +171,12 @@ void HE60rCover::control(const CoverCall &call) {
     } else {
       this->toggles_needed_++;
     }
-  } else if (call.get_position().has_value()) {
+  } else {
+    auto pos_opt = call.get_position();
+    if (!pos_opt.has_value())
+      return;
     // go to position action
-    auto pos = *call.get_position();
+    auto pos = *pos_opt;
     // are we at the target?
     if (pos == this->position) {
       this->start_direction_(COVER_OPERATION_IDLE);
diff --git a/esphome/components/hitachi_ac344/hitachi_ac344.cpp b/esphome/components/hitachi_ac344/hitachi_ac344.cpp
index 2bcb205644c..69469cab2ea 100644
--- a/esphome/components/hitachi_ac344/hitachi_ac344.cpp
+++ b/esphome/components/hitachi_ac344/hitachi_ac344.cpp
@@ -175,7 +175,7 @@ void HitachiClimate::transmit_state() {
 
   set_temp_(static_cast<uint8_t>(this->target_temperature));
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       set_fan_(HITACHI_AC344_FAN_LOW);
       break;
diff --git a/esphome/components/hitachi_ac424/hitachi_ac424.cpp b/esphome/components/hitachi_ac424/hitachi_ac424.cpp
index 64f23dfc174..0b3cc99a82b 100644
--- a/esphome/components/hitachi_ac424/hitachi_ac424.cpp
+++ b/esphome/components/hitachi_ac424/hitachi_ac424.cpp
@@ -176,7 +176,7 @@ void HitachiClimate::transmit_state() {
 
   set_temp_(static_cast<uint8_t>(this->target_temperature));
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       set_fan_(HITACHI_AC424_FAN_LOW);
       break;
diff --git a/esphome/components/http_request/ota/ota_http_request.cpp b/esphome/components/http_request/ota/ota_http_request.cpp
index 0db3a50b47d..5dd21c314c6 100644
--- a/esphome/components/http_request/ota/ota_http_request.cpp
+++ b/esphome/components/http_request/ota/ota_http_request.cpp
@@ -8,10 +8,6 @@
 
 #include "esphome/components/md5/md5.h"
 #include "esphome/components/watchdog/watchdog.h"
-#include "esphome/components/ota/ota_backend.h"
-#include "esphome/components/ota/ota_backend_esp8266.h"
-#include "esphome/components/ota/ota_backend_arduino_rp2040.h"
-#include "esphome/components/ota/ota_backend_esp_idf.h"
 
 namespace esphome {
 namespace http_request {
@@ -69,8 +65,7 @@ void OtaHttpRequestComponent::flash() {
   }
 }
 
-void OtaHttpRequestComponent::cleanup_(std::unique_ptr<ota::OTABackend> backend,
-                                       const std::shared_ptr<HttpContainer> &container) {
+void OtaHttpRequestComponent::cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container) {
   if (this->update_started_) {
     ESP_LOGV(TAG, "Aborting OTA backend");
     backend->abort();
diff --git a/esphome/components/http_request/ota/ota_http_request.h b/esphome/components/http_request/ota/ota_http_request.h
index 6d39b0d466c..70e4559fa7c 100644
--- a/esphome/components/http_request/ota/ota_http_request.h
+++ b/esphome/components/http_request/ota/ota_http_request.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota/ota_backend_factory.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
@@ -39,7 +39,7 @@ class OtaHttpRequestComponent final : public ota::OTAComponent, public Parented<
   void flash();
 
  protected:
-  void cleanup_(std::unique_ptr<ota::OTABackend> backend, const std::shared_ptr<HttpContainer> &container);
+  void cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container);
   uint8_t do_ota_();
   std::string get_url_with_auth_(const std::string &url);
   bool http_get_md5_();
diff --git a/esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp b/esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp
index 39301220d5a..369c964a859 100644
--- a/esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp
+++ b/esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp
@@ -11,17 +11,18 @@ static const char *const TAG = "audio";
 
 void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
   media_player::MediaPlayerState play_state = media_player::MEDIA_PLAYER_STATE_PLAYING;
-  if (call.get_announcement().has_value()) {
-    play_state = call.get_announcement().value() ? media_player::MEDIA_PLAYER_STATE_ANNOUNCING
-                                                 : media_player::MEDIA_PLAYER_STATE_PLAYING;
+  auto announcement = call.get_announcement();
+  if (announcement.has_value()) {
+    play_state = *announcement ? media_player::MEDIA_PLAYER_STATE_ANNOUNCING : media_player::MEDIA_PLAYER_STATE_PLAYING;
   }
-  if (call.get_media_url().has_value()) {
-    this->current_url_ = call.get_media_url();
+  auto media_url = call.get_media_url();
+  if (media_url.has_value()) {
+    this->current_url_ = media_url;
     if (this->i2s_state_ != I2S_STATE_STOPPED && this->audio_ != nullptr) {
       if (this->audio_->isRunning()) {
         this->audio_->stopSong();
       }
-      this->audio_->connecttohost(this->current_url_.value().c_str());
+      this->audio_->connecttohost(media_url->c_str());
       this->state = play_state;
     } else {
       this->start();
@@ -32,13 +33,15 @@ void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
     this->is_announcement_ = true;
   }
 
-  if (call.get_volume().has_value()) {
-    this->volume = call.get_volume().value();
+  auto vol = call.get_volume();
+  if (vol.has_value()) {
+    this->volume = *vol;
     this->set_volume_(volume);
     this->unmute_();
   }
-  if (call.get_command().has_value()) {
-    switch (call.get_command().value()) {
+  auto cmd = call.get_command();
+  if (cmd.has_value()) {
+    switch (*cmd) {
       case media_player::MEDIA_PLAYER_COMMAND_MUTE:
         this->mute_();
         break;
@@ -67,7 +70,7 @@ void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
     if (this->i2s_state_ != I2S_STATE_RUNNING) {
       return;
     }
-    switch (call.get_command().value()) {
+    switch (*cmd) {
       case media_player::MEDIA_PLAYER_COMMAND_PLAY:
         if (!this->audio_->isRunning())
           this->audio_->pauseResume();
diff --git a/esphome/components/infrared/infrared.cpp b/esphome/components/infrared/infrared.cpp
index 44318699511..658c9fd0df5 100644
--- a/esphome/components/infrared/infrared.cpp
+++ b/esphome/components/infrared/infrared.cpp
@@ -90,8 +90,9 @@ void Infrared::control(const InfraredCall &call) {
   auto *transmit_data = transmit_call.get_data();
 
   // Set carrier frequency
-  if (call.get_carrier_frequency().has_value()) {
-    transmit_data->set_carrier_frequency(call.get_carrier_frequency().value());
+  auto freq = call.get_carrier_frequency();
+  if (freq.has_value()) {
+    transmit_data->set_carrier_frequency(*freq);
   }
 
   // Set timings based on format
diff --git a/esphome/components/inkplate/inkplate.cpp b/esphome/components/inkplate/inkplate.cpp
index c921c643fa3..df9c2b29c78 100644
--- a/esphome/components/inkplate/inkplate.cpp
+++ b/esphome/components/inkplate/inkplate.cpp
@@ -63,16 +63,26 @@ void Inkplate::initialize_() {
   if (buffer_size == 0)
     return;
 
-  if (this->partial_buffer_ != nullptr)
+  if (this->partial_buffer_ != nullptr) {
     allocator.deallocate(this->partial_buffer_, buffer_size);
-  if (this->partial_buffer_2_ != nullptr)
+    this->partial_buffer_ = nullptr;
+  }
+  if (this->partial_buffer_2_ != nullptr) {
     allocator.deallocate(this->partial_buffer_2_, buffer_size * 2);
-  if (this->buffer_ != nullptr)
+    this->partial_buffer_2_ = nullptr;
+  }
+  if (this->buffer_ != nullptr) {
     allocator.deallocate(this->buffer_, buffer_size);
-  if (this->glut_ != nullptr)
+    this->buffer_ = nullptr;
+  }
+  if (this->glut_ != nullptr) {
     allocator32.deallocate(this->glut_, 256 * 9);
-  if (this->glut2_ != nullptr)
+    this->glut_ = nullptr;
+  }
+  if (this->glut2_ != nullptr) {
     allocator32.deallocate(this->glut2_, 256 * 9);
+    this->glut2_ = nullptr;
+  }
 
   this->buffer_ = allocator.allocate(buffer_size);
   if (this->buffer_ == nullptr) {
diff --git a/esphome/components/integration/integration_sensor.h b/esphome/components/integration/integration_sensor.h
index f075d163fec..6c4ef7049bb 100644
--- a/esphome/components/integration/integration_sensor.h
+++ b/esphome/components/integration/integration_sensor.h
@@ -32,6 +32,7 @@ class IntegrationSensor : public sensor::Sensor, public Component {
   void set_method(IntegrationMethod method) { method_ = method; }
   void set_restore(bool restore) { restore_ = restore; }
   void reset() { this->publish_and_save_(0.0f); }
+  void set_value(float value) { this->publish_and_save_(value); }
 
  protected:
   void process_sensor_value_(float value);
@@ -71,14 +72,16 @@ class IntegrationSensor : public sensor::Sensor, public Component {
   float last_value_{0.0f};
 };
 
-template<typename... Ts> class ResetAction : public Action<Ts...> {
+template<typename... Ts> class ResetAction : public Action<Ts...>, public Parented<IntegrationSensor> {
  public:
-  explicit ResetAction(IntegrationSensor *parent) : parent_(parent) {}
-
   void play(const Ts &...x) override { this->parent_->reset(); }
+};
 
- protected:
-  IntegrationSensor *parent_;
+template<typename... Ts> class SetValueAction : public Action<Ts...>, public Parented<IntegrationSensor> {
+ public:
+  TEMPLATABLE_VALUE(float, value)
+
+  void play(const Ts &...x) override { this->parent_->set_value(this->value_.value(x...)); }
 };
 
 }  // namespace integration
diff --git a/esphome/components/integration/sensor.py b/esphome/components/integration/sensor.py
index 3c04a338dde..26766385565 100644
--- a/esphome/components/integration/sensor.py
+++ b/esphome/components/integration/sensor.py
@@ -9,6 +9,7 @@ from esphome.const import (
     CONF_RESTORE,
     CONF_SENSOR,
     CONF_UNIT_OF_MEASUREMENT,
+    CONF_VALUE,
 )
 from esphome.core.entity_helpers import inherit_property_from
 
@@ -17,6 +18,7 @@ IntegrationSensor = integration_ns.class_(
     "IntegrationSensor", sensor.Sensor, cg.Component
 )
 ResetAction = integration_ns.class_("ResetAction", automation.Action)
+SetValueAction = integration_ns.class_("SetValueAction", automation.Action)
 
 IntegrationSensorTime = integration_ns.enum("IntegrationSensorTime")
 INTEGRATION_TIMES = {
@@ -111,5 +113,24 @@ async def to_code(config):
     ),
 )
 async def sensor_integration_reset_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "sensor.integration.set_value",
+    SetValueAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
+            cv.Required(CONF_VALUE): cv.templatable(cv.float_),
+        }
+    ),
+)
+async def sensor_integration_set_value_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_VALUE], args, float)
+    cg.add(var.set_value(template_))
+    return var
diff --git a/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp b/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
index 00c65a19379..29de6512559 100644
--- a/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
+++ b/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
@@ -136,7 +136,7 @@ void KamstrupKMPComponent::read_command_(uint16_t command) {
   int timeout = 250;  // ms
 
   // Read the data from the UART
-  while (timeout > 0) {
+  while (timeout > 0 && buffer_len < static_cast<int>(sizeof(buffer))) {
     if (this->available()) {
       data = this->read();
       if (data > -1) {
@@ -246,7 +246,7 @@ void KamstrupKMPComponent::parse_command_message_(uint16_t command, const uint8_
 }
 
 void KamstrupKMPComponent::set_sensor_value_(uint16_t command, float value, uint8_t unit_idx) {
-  const char *unit = UNITS[unit_idx];
+  const char *unit = unit_idx < sizeof(UNITS) / sizeof(UNITS[0]) ? UNITS[unit_idx] : "";
 
   // Standard sensors
   if (command == CMD_HEAT_ENERGY && this->heat_energy_sensor_ != nullptr) {
diff --git a/esphome/components/lcd_base/lcd_display.cpp b/esphome/components/lcd_base/lcd_display.cpp
index cd08a739eb6..1f0ba482d74 100644
--- a/esphome/components/lcd_base/lcd_display.cpp
+++ b/esphome/components/lcd_base/lcd_display.cpp
@@ -99,7 +99,7 @@ void HOT LCDDisplay::display() {
       this->send(this->buffer_[this->columns_ * 2 + i], true);
   }
 
-  if (this->rows_ >= 1) {
+  if (this->rows_ >= 2) {
     this->command_(LCD_DISPLAY_COMMAND_SET_DDRAM_ADDR | 0x40);
 
     for (uint8_t i = 0; i < this->columns_; i++)
diff --git a/esphome/components/ld2420/ld2420.cpp b/esphome/components/ld2420/ld2420.cpp
index f14400d15a4..1e671363c9d 100644
--- a/esphome/components/ld2420/ld2420.cpp
+++ b/esphome/components/ld2420/ld2420.cpp
@@ -460,6 +460,10 @@ void LD2420Component::handle_energy_mode_(uint8_t *buffer, int len) {
   uint8_t index = 6;  // Start at presence byte position
   uint16_t range;
   const uint8_t elements = sizeof(this->gate_energy_) / sizeof(this->gate_energy_[0]);
+  if (len < static_cast<int>(index + 1 + sizeof(range) + elements * sizeof(this->gate_energy_[0]))) {
+    ESP_LOGW(TAG, "Energy frame too short: %d bytes", len);
+    return;
+  }
   this->set_presence_(buffer[index]);
   index++;
   memcpy(&range, &buffer[index], sizeof(range));
@@ -471,8 +475,11 @@ void LD2420Component::handle_energy_mode_(uint8_t *buffer, int len) {
   }
 
   if (this->current_operating_mode == OP_CALIBRATE_MODE) {
-    this->update_radar_data(gate_energy_, sample_number_counter);
-    this->sample_number_counter > CALIBRATE_SAMPLES ? this->sample_number_counter = 0 : this->sample_number_counter++;
+    this->update_radar_data(gate_energy_, this->sample_number_counter);
+    this->sample_number_counter++;
+    if (this->sample_number_counter >= CALIBRATE_SAMPLES) {
+      this->sample_number_counter = 0;
+    }
   }
 
   // Resonable refresh rate for home assistant database size health
@@ -503,22 +510,20 @@ void LD2420Component::handle_simple_mode_(const uint8_t *inbuf, int len) {
   char *endptr{nullptr};
   char outbuf[bufsize]{0};
   while (true) {
-    if (inbuf[pos - 2] == 'O' && inbuf[pos - 1] == 'F' && inbuf[pos] == 'F') {
+    if (pos >= 2 && inbuf[pos - 2] == 'O' && inbuf[pos - 1] == 'F' && inbuf[pos] == 'F') {
       this->set_presence_(false);
-    } else if (inbuf[pos - 1] == 'O' && inbuf[pos] == 'N') {
+    } else if (pos >= 1 && inbuf[pos - 1] == 'O' && inbuf[pos] == 'N') {
       this->set_presence_(true);
     }
     if (inbuf[pos] >= '0' && inbuf[pos] <= '9') {
       if (index < bufsize - 1) {
         outbuf[index++] = inbuf[pos];
-        pos++;
       }
+    }
+    if (pos < len - 1) {
+      pos++;
     } else {
-      if (pos < len - 1) {
-        pos++;
-      } else {
-        break;
-      }
+      break;
     }
   }
   outbuf[index] = '\0';
diff --git a/esphome/components/ledc/ledc_output.cpp b/esphome/components/ledc/ledc_output.cpp
index a01d42ac8b2..21e06822575 100644
--- a/esphome/components/ledc/ledc_output.cpp
+++ b/esphome/components/ledc/ledc_output.cpp
@@ -56,7 +56,8 @@ optional<uint8_t> ledc_bit_depth_for_frequency(float frequency) {
 
 esp_err_t configure_timer_frequency(ledc_mode_t speed_mode, ledc_timer_t timer_num, ledc_channel_t chan_num,
                                     uint8_t channel, uint8_t &bit_depth, float frequency) {
-  bit_depth = *ledc_bit_depth_for_frequency(frequency);
+  auto bit_depth_opt = ledc_bit_depth_for_frequency(frequency);
+  bit_depth = bit_depth_opt.value_or(0);
   if (bit_depth < 1) {
     ESP_LOGE(TAG, "Frequency %f can't be achieved with any bit depth", frequency);
   }
diff --git a/esphome/components/lightwaverf/LwTx.cpp b/esphome/components/lightwaverf/LwTx.cpp
index f5ef6ddb2c0..b69b93b978d 100644
--- a/esphome/components/lightwaverf/LwTx.cpp
+++ b/esphome/components/lightwaverf/LwTx.cpp
@@ -108,6 +108,10 @@ bool LwTx::lwtx_free() { return !this->tx_msg_active; }
   Send a LightwaveRF message (10 nibbles in bytes)
 **/
 void LwTx::lwtx_send(const std::vector<uint8_t> &msg) {
+  if (msg.size() < TX_MSGLEN) {
+    ESP_LOGW("lightwaverf.sensor", "Message too short: %zu < %u", msg.size(), static_cast<unsigned>(TX_MSGLEN));
+    return;
+  }
   if (this->tx_translate) {
     for (uint8_t i = 0; i < TX_MSGLEN; i++) {
       this->tx_buf[i] = TX_NIBBLE[msg[i] & 0xF];
diff --git a/esphome/components/lvgl/lvgl_esphome.cpp b/esphome/components/lvgl/lvgl_esphome.cpp
index bb373abb88b..3e447e9169d 100644
--- a/esphome/components/lvgl/lvgl_esphome.cpp
+++ b/esphome/components/lvgl/lvgl_esphome.cpp
@@ -421,7 +421,7 @@ void LvglComponent::write_random_() {
     col = col / this->draw_rounding * this->draw_rounding;
     auto row = random_uint32() % this->disp_drv_.ver_res;
     row = row / this->draw_rounding * this->draw_rounding;
-    auto size = (random_uint32() % 32) / this->draw_rounding * this->draw_rounding - 1;
+    auto size = ((random_uint32() % 32) / this->draw_rounding + 2) * this->draw_rounding - 1;
     lv_area_t area;
     area.x1 = col;
     area.y1 = row;
diff --git a/esphome/components/mcp4461/mcp4461.cpp b/esphome/components/mcp4461/mcp4461.cpp
index 2f2c75e05ad..dc7e7019aa0 100644
--- a/esphome/components/mcp4461/mcp4461.cpp
+++ b/esphome/components/mcp4461/mcp4461.cpp
@@ -19,8 +19,9 @@ void Mcp4461Component::setup() {
   // save WP/WL status
   this->update_write_protection_status_();
   for (uint8_t i = 0; i < 8; i++) {
-    if (this->reg_[i].initial_value.has_value()) {
-      uint16_t initial_state = static_cast<uint16_t>(*this->reg_[i].initial_value * 256.0f);
+    auto init_val = this->reg_[i].initial_value;
+    if (init_val.has_value()) {
+      uint16_t initial_state = static_cast<uint16_t>(*init_val * 256.0f);
       this->write_wiper_level_(i, initial_state);
     }
     if (this->reg_[i].enabled) {
diff --git a/esphome/components/media_source/media_source.h b/esphome/components/media_source/media_source.h
index 688c27134f2..f21ba486b87 100644
--- a/esphome/components/media_source/media_source.h
+++ b/esphome/components/media_source/media_source.h
@@ -67,11 +67,13 @@ class MediaSource {
   /// @brief Start playing the given URI
   /// Sources should validate the URI and state, returning false if the source is busy.
   /// The orchestrator is responsible for stopping active sources before starting a new one.
+  /// @note Must only be called from the main loop.
   /// @param uri URI to play; e.g., "http://stream_url"
   /// @return true if playback started successfully, false otherwise
   virtual bool play_uri(const std::string &uri) = 0;
 
-  /// @brief Handle playback commands (pause, stop, next, etc.)
+  /// @brief Handle playback commands; e.g., pause, stop, next, etc.
+  /// @note Must only be called from the main loop.
   /// @param command Command to execute
   virtual void handle_command(MediaSourceCommand command) = 0;
 
@@ -81,7 +83,8 @@ class MediaSource {
 
   // === State Access ===
 
-  /// @brief Get current playback state (must only be called from the main loop)
+  /// @brief Get current playback state
+  /// @note Must only be called from the main loop.
   /// @return Current state of this source
   MediaSourceState get_state() const { return this->state_; }
 
@@ -136,9 +139,10 @@ class MediaSource {
   virtual void notify_audio_played(uint32_t frames, int64_t timestamp) {}
 
  protected:
-  /// @brief Update state and notify listener (must only be called from the main loop)
+  /// @brief Update state and notify listener
   /// This is the only way to change state_, ensuring listener notifications always fire.
   /// Sources running FreeRTOS tasks should signal via event groups and call this from loop().
+  /// @note Must only be called from the main loop.
   /// @param state New state to set
   void set_state_(MediaSourceState state) {
     if (this->state_ != state) {
diff --git a/esphome/components/midea/air_conditioner.cpp b/esphome/components/midea/air_conditioner.cpp
index bc750e37135..4d59a4fbbca 100644
--- a/esphome/components/midea/air_conditioner.cpp
+++ b/esphome/components/midea/air_conditioner.cpp
@@ -56,20 +56,25 @@ void AirConditioner::on_status_change() {
 
 void AirConditioner::control(const ClimateCall &call) {
   dudanov::midea::ac::Control ctrl{};
-  if (call.get_target_temperature().has_value())
-    ctrl.targetTemp = call.get_target_temperature().value();
-  if (call.get_swing_mode().has_value())
-    ctrl.swingMode = Converters::to_midea_swing_mode(call.get_swing_mode().value());
-  if (call.get_mode().has_value())
-    ctrl.mode = Converters::to_midea_mode(call.get_mode().value());
-  if (call.get_preset().has_value()) {
-    ctrl.preset = Converters::to_midea_preset(call.get_preset().value());
+  auto target_temp_val = call.get_target_temperature();
+  if (target_temp_val.has_value())
+    ctrl.targetTemp = *target_temp_val;
+  auto swing_mode_val = call.get_swing_mode();
+  if (swing_mode_val.has_value())
+    ctrl.swingMode = Converters::to_midea_swing_mode(*swing_mode_val);
+  auto mode_val = call.get_mode();
+  if (mode_val.has_value())
+    ctrl.mode = Converters::to_midea_mode(*mode_val);
+  auto preset_val = call.get_preset();
+  if (preset_val.has_value()) {
+    ctrl.preset = Converters::to_midea_preset(*preset_val);
   } else if (call.has_custom_preset()) {
     // get_custom_preset() returns StringRef pointing to null-terminated string literals from codegen
     ctrl.preset = Converters::to_midea_preset(call.get_custom_preset().c_str());
   }
-  if (call.get_fan_mode().has_value()) {
-    ctrl.fanMode = Converters::to_midea_fan_mode(call.get_fan_mode().value());
+  auto fan_mode_val = call.get_fan_mode();
+  if (fan_mode_val.has_value()) {
+    ctrl.fanMode = Converters::to_midea_fan_mode(*fan_mode_val);
   } else if (call.has_custom_fan_mode()) {
     // get_custom_fan_mode() returns StringRef pointing to null-terminated string literals from codegen
     ctrl.fanMode = Converters::to_midea_fan_mode(call.get_custom_fan_mode().c_str());
diff --git a/esphome/components/midea_ir/midea_ir.cpp b/esphome/components/midea_ir/midea_ir.cpp
index eaee1c731cb..220bb3f414d 100644
--- a/esphome/components/midea_ir/midea_ir.cpp
+++ b/esphome/components/midea_ir/midea_ir.cpp
@@ -114,15 +114,20 @@ void MideaIR::control(const climate::ClimateCall &call) {
   if (call.get_mode() == climate::CLIMATE_MODE_OFF) {
     this->swing_mode = climate::CLIMATE_SWING_OFF;
     this->preset = climate::CLIMATE_PRESET_NONE;
-  } else if (call.get_swing_mode().has_value() && ((*call.get_swing_mode() == climate::CLIMATE_SWING_OFF &&
-                                                    this->swing_mode == climate::CLIMATE_SWING_VERTICAL) ||
-                                                   (*call.get_swing_mode() == climate::CLIMATE_SWING_VERTICAL &&
-                                                    this->swing_mode == climate::CLIMATE_SWING_OFF))) {
-    this->swing_ = true;
-  } else if (call.get_preset().has_value() &&
-             ((*call.get_preset() == climate::CLIMATE_PRESET_NONE && this->preset == climate::CLIMATE_PRESET_BOOST) ||
-              (*call.get_preset() == climate::CLIMATE_PRESET_BOOST && this->preset == climate::CLIMATE_PRESET_NONE))) {
-    this->boost_ = true;
+  } else {
+    auto swing = call.get_swing_mode();
+    if (swing.has_value() &&
+        ((*swing == climate::CLIMATE_SWING_OFF && this->swing_mode == climate::CLIMATE_SWING_VERTICAL) ||
+         (*swing == climate::CLIMATE_SWING_VERTICAL && this->swing_mode == climate::CLIMATE_SWING_OFF))) {
+      this->swing_ = true;
+    } else {
+      auto preset = call.get_preset();
+      if (preset.has_value() &&
+          ((*preset == climate::CLIMATE_PRESET_NONE && this->preset == climate::CLIMATE_PRESET_BOOST) ||
+           (*preset == climate::CLIMATE_PRESET_BOOST && this->preset == climate::CLIMATE_PRESET_NONE))) {
+        this->boost_ = true;
+      }
+    }
   }
   climate_ir::ClimateIR::control(call);
 }
diff --git a/esphome/components/mitsubishi/mitsubishi.cpp b/esphome/components/mitsubishi/mitsubishi.cpp
index d80b7aeff56..882163ff5db 100644
--- a/esphome/components/mitsubishi/mitsubishi.cpp
+++ b/esphome/components/mitsubishi/mitsubishi.cpp
@@ -180,7 +180,7 @@ void MitsubishiClimate::transmit_state() {
   // For 5Level: Low = 1, Middle = 2, Medium = 3, High = 4
   // For 4Level + Quiet: Low = 1, Middle = 2, Medium = 3, High = 4, Quiet = 5
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       remote_state[9] = 1;
       break;
@@ -209,7 +209,8 @@ void MitsubishiClimate::transmit_state() {
       break;
   }
 
-  ESP_LOGD(TAG, "fan: %02x state: %02x", this->fan_mode.value(), remote_state[9]);
+  ESP_LOGD(TAG, "fan: %02x state: %02x", static_cast<uint8_t>(this->fan_mode.value_or(climate::CLIMATE_FAN_ON)),
+           remote_state[9]);
 
   // Vertical Vane
   switch (this->swing_mode) {
@@ -227,7 +228,7 @@ void MitsubishiClimate::transmit_state() {
   ESP_LOGD(TAG, "default_vertical_direction_: %02X", this->default_vertical_direction_);
 
   // Special modes
-  switch (this->preset.value()) {
+  switch (this->preset.value_or(climate::CLIMATE_PRESET_NONE)) {
     case climate::CLIMATE_PRESET_ECO:
       remote_state[6] = MITSUBISHI_MODE_COOL | MITSUBISHI_OTHERWISE;
       remote_state[8] = (remote_state[8] & ~7) | MITSUBISHI_MODE_A_COOL;
diff --git a/esphome/components/mixer/speaker/mixer_speaker.cpp b/esphome/components/mixer/speaker/mixer_speaker.cpp
index 100acbebc33..8e1278206f4 100644
--- a/esphome/components/mixer/speaker/mixer_speaker.cpp
+++ b/esphome/components/mixer/speaker/mixer_speaker.cpp
@@ -438,24 +438,14 @@ void MixerSpeaker::loop() {
   // Handle pending start request
   if (event_group_bits & MIXER_TASK_COMMAND_START) {
     // Only start the task if it's fully stopped and cleaned up
-    if (!this->status_has_error() && (this->task_handle_ == nullptr) && (this->task_stack_buffer_ == nullptr)) {
-      esp_err_t err = this->start_task_();
-      switch (err) {
-        case ESP_OK:
-          xEventGroupClearBits(this->event_group_, MIXER_TASK_COMMAND_START);
-          break;
-        case ESP_ERR_NO_MEM:
-          ESP_LOGE(TAG, "Failed to start; retrying in 1 second");
-          this->status_momentary_error("memory-failure", 1000);
-          return;
-        case ESP_ERR_INVALID_STATE:
-          ESP_LOGE(TAG, "Failed to start; retrying in 1 second");
-          this->status_momentary_error("task-failure", 1000);
-          return;
-        default:
-          ESP_LOGE(TAG, "Failed to start; retrying in 1 second");
-          this->status_momentary_error("failure", 1000);
-          return;
+    if (!this->status_has_error() && !this->task_.is_created()) {
+      if (this->task_.create(audio_mixer_task, "mixer", TASK_STACK_SIZE, (void *) this, MIXER_TASK_PRIORITY,
+                             this->task_stack_in_psram_)) {
+        xEventGroupClearBits(this->event_group_, MIXER_TASK_COMMAND_START);
+      } else {
+        ESP_LOGE(TAG, "Failed to start; retrying in 1 second");
+        this->status_momentary_error("failure", 1000);
+        return;
       }
     }
   }
@@ -478,13 +468,12 @@ void MixerSpeaker::loop() {
     xEventGroupClearBits(this->event_group_, MIXER_TASK_STATE_STOPPING);
   }
   if (event_group_bits & MIXER_TASK_STATE_STOPPED) {
-    if (this->delete_task_() == ESP_OK) {
-      ESP_LOGD(TAG, "Stopped");
-      xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
-    }
+    this->task_.deallocate();
+    ESP_LOGD(TAG, "Stopped");
+    xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
   }
 
-  if (this->task_handle_ != nullptr) {
+  if (this->task_.is_created()) {
     // If the mixer task is running, check if all source speakers are stopped
 
     bool all_stopped = true;
@@ -497,7 +486,7 @@ void MixerSpeaker::loop() {
       // Send stop command signal to the mixer task since no source speakers are active
       xEventGroupSetBits(this->event_group_, MIXER_TASK_COMMAND_STOP);
     }
-  } else if (this->task_stack_buffer_ == nullptr) {
+  } else {
     // Task is fully stopped and cleaned up, check if we can disable loop
     event_group_bits = xEventGroupGetBits(this->event_group_);
     if (event_group_bits == 0) {
@@ -538,60 +527,6 @@ esp_err_t MixerSpeaker::start(audio::AudioStreamInfo &stream_info) {
   return ESP_OK;
 }
 
-esp_err_t MixerSpeaker::start_task_() {
-  if (this->task_stack_buffer_ == nullptr) {
-    if (this->task_stack_in_psram_) {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-      this->task_stack_buffer_ = stack_allocator.allocate(TASK_STACK_SIZE);
-    } else {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-      this->task_stack_buffer_ = stack_allocator.allocate(TASK_STACK_SIZE);
-    }
-  }
-
-  if (this->task_stack_buffer_ == nullptr) {
-    return ESP_ERR_NO_MEM;
-  }
-
-  if (this->task_handle_ == nullptr) {
-    this->task_handle_ = xTaskCreateStatic(audio_mixer_task, "mixer", TASK_STACK_SIZE, (void *) this,
-                                           MIXER_TASK_PRIORITY, this->task_stack_buffer_, &this->task_stack_);
-  }
-
-  if (this->task_handle_ == nullptr) {
-    return ESP_ERR_INVALID_STATE;
-  }
-
-  return ESP_OK;
-}
-
-esp_err_t MixerSpeaker::delete_task_() {
-  if (this->task_handle_ != nullptr) {
-    // Delete the task
-    vTaskDelete(this->task_handle_);
-    this->task_handle_ = nullptr;
-  }
-
-  if ((this->task_handle_ == nullptr) && (this->task_stack_buffer_ != nullptr)) {
-    // Deallocate the task stack buffer
-    if (this->task_stack_in_psram_) {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-    } else {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-    }
-
-    this->task_stack_buffer_ = nullptr;
-  }
-
-  if ((this->task_handle_ != nullptr) || (this->task_stack_buffer_ != nullptr)) {
-    return ESP_ERR_INVALID_STATE;
-  }
-
-  return ESP_OK;
-}
-
 void MixerSpeaker::copy_frames(const int16_t *input_buffer, audio::AudioStreamInfo input_stream_info,
                                int16_t *output_buffer, audio::AudioStreamInfo output_stream_info,
                                uint32_t frames_to_transfer) {
diff --git a/esphome/components/mixer/speaker/mixer_speaker.h b/esphome/components/mixer/speaker/mixer_speaker.h
index e920f9895a0..0e0b33c39bc 100644
--- a/esphome/components/mixer/speaker/mixer_speaker.h
+++ b/esphome/components/mixer/speaker/mixer_speaker.h
@@ -8,8 +8,8 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/static_task.h"
 
-#include <freertos/FreeRTOS.h>
 #include <freertos/event_groups.h>
 
 #include <atomic>
@@ -143,8 +143,6 @@ class MixerSpeaker : public Component {
   /// @param stream_info The calling source speaker's audio stream information
   /// @return ESP_ERR_NOT_SUPPORTED if the incoming stream is incompatible due to unsupported bits per sample
   ///         ESP_ERR_INVALID_ARG if the incoming stream is incompatible to be mixed with the other input audio stream
-  ///         ESP_ERR_NO_MEM if there isn't enough memory for the task's stack
-  ///         ESP_ERR_INVALID_STATE if the task fails to start
   ///         ESP_OK if the incoming stream is compatible and the mixer task starts
   esp_err_t start(audio::AudioStreamInfo &stream_info);
 
@@ -188,16 +186,6 @@ class MixerSpeaker : public Component {
 
   static void audio_mixer_task(void *params);
 
-  /// @brief Starts the mixer task after allocating memory for the task stack.
-  /// @return ESP_ERR_NO_MEM if there isn't enough memory for the task's stack
-  ///         ESP_ERR_INVALID_STATE if the task didn't start
-  ///         ESP_OK if successful
-  esp_err_t start_task_();
-
-  /// @brief If the task is stopped, it sets the task handle to the nullptr and deallocates its stack
-  /// @return ESP_OK if the task was stopped, ESP_ERR_INVALID_STATE otherwise.
-  esp_err_t delete_task_();
-
   EventGroupHandle_t event_group_{nullptr};
 
   FixedVector<SourceSpeaker *> source_speakers_;
@@ -207,9 +195,7 @@ class MixerSpeaker : public Component {
   bool queue_mode_;
   bool task_stack_in_psram_{false};
 
-  TaskHandle_t task_handle_{nullptr};
-  StaticTask_t task_stack_;
-  StackType_t *task_stack_buffer_{nullptr};
+  StaticTask task_;
 
   optional<audio::AudioStreamInfo> audio_stream_info_;
 
diff --git a/esphome/components/modbus_controller/select/modbus_select.cpp b/esphome/components/modbus_controller/select/modbus_select.cpp
index 853f4215c35..e2a54d3f602 100644
--- a/esphome/components/modbus_controller/select/modbus_select.cpp
+++ b/esphome/components/modbus_controller/select/modbus_select.cpp
@@ -52,7 +52,7 @@ void ModbusSelect::control(size_t index) {
     // Transform func requires string parameter for backward compatibility
     auto val = (*this->write_transform_func_)(this, std::string(option), *mapval, data);
     if (val.has_value()) {
-      mapval = *val;
+      mapval = val;
       ESP_LOGV(TAG, "write_lambda returned mapping value %lld", *mapval);
     } else {
       ESP_LOGD(TAG, "Communication handled by write_lambda - exiting control");
diff --git a/esphome/components/mopeka_std_check/mopeka_std_check.cpp b/esphome/components/mopeka_std_check/mopeka_std_check.cpp
index 6322b550c94..88bd7b02fdb 100644
--- a/esphome/components/mopeka_std_check/mopeka_std_check.cpp
+++ b/esphome/components/mopeka_std_check/mopeka_std_check.cpp
@@ -108,7 +108,7 @@ bool MopekaStdCheck::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
   }
 
   // Get temperature of sensor
-  uint8_t temp_in_c = this->parse_temperature_(mopeka_data);
+  int8_t temp_in_c = this->parse_temperature_(mopeka_data);
   if (this->temperature_ != nullptr) {
     this->temperature_->publish_state(temp_in_c);
   }
@@ -223,12 +223,12 @@ uint8_t MopekaStdCheck::parse_battery_level_(const mopeka_std_package *message)
   return (uint8_t) percent;
 }
 
-uint8_t MopekaStdCheck::parse_temperature_(const mopeka_std_package *message) {
+int8_t MopekaStdCheck::parse_temperature_(const mopeka_std_package *message) {
   uint8_t tmp = message->raw_temp;
   if (tmp == 0x0) {
     return -40;
   } else {
-    return (uint8_t) ((tmp - 25.0f) * 1.776964f);
+    return static_cast<int8_t>((tmp - 25.0f) * 1.776964f);
   }
 }
 
diff --git a/esphome/components/mopeka_std_check/mopeka_std_check.h b/esphome/components/mopeka_std_check/mopeka_std_check.h
index 897b5414ed0..45588988c53 100644
--- a/esphome/components/mopeka_std_check/mopeka_std_check.h
+++ b/esphome/components/mopeka_std_check/mopeka_std_check.h
@@ -71,7 +71,7 @@ class MopekaStdCheck : public Component, public esp32_ble_tracker::ESPBTDeviceLi
 
   float get_lpg_speed_of_sound_(float temperature);
   uint8_t parse_battery_level_(const mopeka_std_package *message);
-  uint8_t parse_temperature_(const mopeka_std_package *message);
+  int8_t parse_temperature_(const mopeka_std_package *message);
 };
 
 }  // namespace mopeka_std_check
diff --git a/esphome/components/mpu6886/mpu6886.cpp b/esphome/components/mpu6886/mpu6886.cpp
index 68b77b59c99..02747da3064 100644
--- a/esphome/components/mpu6886/mpu6886.cpp
+++ b/esphome/components/mpu6886/mpu6886.cpp
@@ -80,7 +80,7 @@ void MPU6886Component::setup() {
   accel_config &= 0b11100111;
   accel_config |= (MPU6886_RANGE_2G << 3);
   ESP_LOGV(TAG, "    Output accel_config: 0b" BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(accel_config));
-  if (!this->write_byte(MPU6886_REGISTER_GYRO_CONFIG, gyro_config)) {
+  if (!this->write_byte(MPU6886_REGISTER_ACCEL_CONFIG, accel_config)) {
     this->mark_failed();
     return;
   }
diff --git a/esphome/components/network/util.cpp b/esphome/components/network/util.cpp
index e397d770775..226b11b8cd3 100644
--- a/esphome/components/network/util.cpp
+++ b/esphome/components/network/util.cpp
@@ -1,53 +1,11 @@
 #include "util.h"
 #include "esphome/core/defines.h"
 #ifdef USE_NETWORK
-#ifdef USE_WIFI
-#include "esphome/components/wifi/wifi_component.h"
-#endif
-
-#ifdef USE_ETHERNET
-#include "esphome/components/ethernet/ethernet_component.h"
-#endif
-
-#ifdef USE_OPENTHREAD
-#include "esphome/components/openthread/openthread.h"
-#endif
-
-#ifdef USE_MODEM
-#include "esphome/components/modem/modem_component.h"
-#endif
 
 namespace esphome::network {
 
 // The order of the components is important: WiFi should come after any possible main interfaces (it may be used as
-// an AP that use a previous interface for NAT).
-
-bool is_connected() {
-#ifdef USE_ETHERNET
-  if (ethernet::global_eth_component != nullptr && ethernet::global_eth_component->is_connected())
-    return true;
-#endif
-
-#ifdef USE_MODEM
-  if (modem::global_modem_component != nullptr)
-    return modem::global_modem_component->is_connected();
-#endif
-
-#ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr)
-    return wifi::global_wifi_component->is_connected();
-#endif
-
-#ifdef USE_OPENTHREAD
-  if (openthread::global_openthread_component != nullptr)
-    return openthread::global_openthread_component->is_connected();
-#endif
-
-#ifdef USE_HOST
-  return true;  // Assume its connected
-#endif
-  return false;
-}
+// an AP that uses a previous interface for NAT).
 
 bool is_disabled() {
 #ifdef USE_MODEM
diff --git a/esphome/components/network/util.h b/esphome/components/network/util.h
index ae949ab0a85..4b700fe74c0 100644
--- a/esphome/components/network/util.h
+++ b/esphome/components/network/util.h
@@ -2,12 +2,55 @@
 #include "esphome/core/defines.h"
 #ifdef USE_NETWORK
 #include <string>
+#include "esphome/core/helpers.h"
 #include "ip_address.h"
 
+#ifdef USE_ETHERNET
+#include "esphome/components/ethernet/ethernet_component.h"
+#endif
+#ifdef USE_MODEM
+#include "esphome/components/modem/modem_component.h"
+#endif
+#ifdef USE_WIFI
+#include "esphome/components/wifi/wifi_component.h"
+#endif
+#ifdef USE_OPENTHREAD
+#include "esphome/components/openthread/openthread.h"
+#endif
+
 namespace esphome::network {
 
+// The order of the components is important: WiFi should come after any possible main interfaces (it may be used as
+// an AP that uses a previous interface for NAT).
+
 /// Return whether the node is connected to the network (through wifi, eth, ...)
-bool is_connected();
+ESPHOME_ALWAYS_INLINE inline bool is_connected() {
+#ifdef USE_ETHERNET
+  if (ethernet::global_eth_component != nullptr && ethernet::global_eth_component->is_connected())
+    return true;
+#endif
+
+#ifdef USE_MODEM
+  if (modem::global_modem_component != nullptr)
+    return modem::global_modem_component->is_connected();
+#endif
+
+#ifdef USE_WIFI
+  if (wifi::global_wifi_component != nullptr)
+    return wifi::global_wifi_component->is_connected();
+#endif
+
+#ifdef USE_OPENTHREAD
+  if (openthread::global_openthread_component != nullptr)
+    return openthread::global_openthread_component->is_connected();
+#endif
+
+#ifdef USE_HOST
+  return true;  // Assume it's connected
+#endif
+  return false;
+}
+
 /// Return whether the network is disabled (only wifi for now)
 bool is_disabled();
 /// Get the active network hostname
diff --git a/esphome/components/nfc/ndef_message.cpp b/esphome/components/nfc/ndef_message.cpp
index e7304445c55..35028555c55 100644
--- a/esphome/components/nfc/ndef_message.cpp
+++ b/esphome/components/nfc/ndef_message.cpp
@@ -8,8 +8,14 @@ static const char *const TAG = "nfc.ndef_message";
 
 NdefMessage::NdefMessage(std::vector<uint8_t> &data) {
   ESP_LOGV(TAG, "Building NdefMessage with %zu bytes", data.size());
-  uint8_t index = 0;
-  while (index <= data.size()) {
+  size_t index = 0;
+  while (index < data.size()) {
+    // Minimum record: TNF byte + type length byte + payload length (1 or 4 bytes)
+    if (index + 2 >= data.size()) {
+      ESP_LOGE(TAG, "Truncated record header; aborting");
+      break;
+    }
+
     uint8_t tnf_byte = data[index++];
     bool me = tnf_byte & 0x40;      // Message End bit (is set if this is the last record of the message)
     bool sr = tnf_byte & 0x10;      // Short record bit (is set if payload size is less or equal to 255 bytes)
@@ -23,6 +29,10 @@ NdefMessage::NdefMessage(std::vector<uint8_t> &data) {
     if (sr) {
       payload_length = data[index++];
     } else {
+      if (index + 4 > data.size()) {
+        ESP_LOGE(TAG, "Truncated payload length; aborting");
+        break;
+      }
       payload_length = (static_cast<uint32_t>(data[index]) << 24) | (static_cast<uint32_t>(data[index + 1]) << 16) |
                        (static_cast<uint32_t>(data[index + 2]) << 8) | static_cast<uint32_t>(data[index + 3]);
       index += 4;
@@ -30,6 +40,10 @@ NdefMessage::NdefMessage(std::vector<uint8_t> &data) {
 
     uint8_t id_length = 0;
     if (il) {
+      if (index >= data.size()) {
+        ESP_LOGE(TAG, "Truncated ID length; aborting");
+        break;
+      }
       id_length = data[index++];
     }
 
diff --git a/esphome/components/noblex/noblex.cpp b/esphome/components/noblex/noblex.cpp
index 53f807809eb..f1e76eabf2b 100644
--- a/esphome/components/noblex/noblex.cpp
+++ b/esphome/components/noblex/noblex.cpp
@@ -71,7 +71,7 @@ void NoblexClimate::transmit_state() {
       break;
   }
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       remote_state[0] |= (IRNoblexFan::IR_NOBLEX_FAN_LOW << 2);
       break;
diff --git a/esphome/components/noblex/noblex.h b/esphome/components/noblex/noblex.h
index a8e5f41547c..57990db0053 100644
--- a/esphome/components/noblex/noblex.h
+++ b/esphome/components/noblex/noblex.h
@@ -26,7 +26,8 @@ class NoblexClimate : public climate_ir::ClimateIR {
   void control(const climate::ClimateCall &call) override {
     send_swing_cmd_ = call.get_swing_mode().has_value();
     // swing resets after unit powered off
-    if (call.get_mode().has_value() && *call.get_mode() == climate::CLIMATE_MODE_OFF)
+    auto mode = call.get_mode();
+    if (mode.has_value() && *mode == climate::CLIMATE_MODE_OFF)
       this->swing_mode = climate::CLIMATE_SWING_OFF;
     climate_ir::ClimateIR::control(call);
   }
diff --git a/esphome/components/openthread/__init__.py b/esphome/components/openthread/__init__.py
index 5c64cf31dce..21373b77dfb 100644
--- a/esphome/components/openthread/__init__.py
+++ b/esphome/components/openthread/__init__.py
@@ -14,9 +14,12 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHANNEL,
     CONF_ENABLE_IPV6,
+    CONF_FRAMEWORK,
     CONF_ID,
+    CONF_LOG_LEVEL,
     CONF_OUTPUT_POWER,
     CONF_USE_ADDRESS,
+    PLATFORM_ESP32,
 )
 from esphome.core import CORE, TimePeriodMilliseconds
 import esphome.final_validate as fv
@@ -46,6 +49,15 @@ AUTO_LOAD = ["network"]
 CONFLICTS_WITH = ["wifi"]
 DEPENDENCIES = ["esp32"]
 
+IDF_TO_OT_LOG_LEVEL = {
+    "NONE": "NONE",
+    "ERROR": "CRIT",
+    "WARN": "WARN",
+    "INFO": "NOTE",
+    "DEBUG": "INFO",
+    "VERBOSE": "DEBG",
+}
+
 CONF_DEVICE_TYPES = [
     "FTD",
     "MTD",
@@ -198,6 +210,15 @@ def _final_validate(_):
             "Please set `enable_ipv6: true` in the `network` configuration."
         )
 
+    if (
+        (esp32_config := full_config.get(PLATFORM_ESP32)) is not None
+        and (fw_config := esp32_config.get(CONF_FRAMEWORK)) is not None
+        and (log_level := fw_config.get(CONF_LOG_LEVEL)) is not None
+    ):
+        add_idf_sdkconfig_option("CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC", False)
+        ot_log_level = IDF_TO_OT_LOG_LEVEL.get(log_level, log_level)
+        add_idf_sdkconfig_option(f"CONFIG_OPENTHREAD_LOG_LEVEL_{ot_log_level}", True)
+
 
 FINAL_VALIDATE_SCHEMA = _final_validate
 
diff --git a/esphome/components/openthread/openthread.cpp b/esphome/components/openthread/openthread.cpp
index 92897a7e96e..9452f5a41eb 100644
--- a/esphome/components/openthread/openthread.cpp
+++ b/esphome/components/openthread/openthread.cpp
@@ -1,9 +1,7 @@
 #include "esphome/core/defines.h"
 #ifdef USE_OPENTHREAD
 #include "openthread.h"
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
 #include "esp_openthread.h"
-#endif
 
 #include <freertos/portmacro.h>
 
@@ -48,22 +46,15 @@ void OpenThreadComponent::dump_config() {
   }
 }
 
-bool OpenThreadComponent::is_connected() {
-  auto lock = InstanceLock::try_acquire(100);
-  if (!lock) {
-    ESP_LOGW(TAG, "Failed to acquire OpenThread lock in is_connected");
-    return false;
+void OpenThreadComponent::on_state_changed_(otChangedFlags flags, void *context) {
+  if (flags & OT_CHANGED_THREAD_ROLE) {
+    auto *self = static_cast<OpenThreadComponent *>(context);
+    // This runs on the OpenThread task thread with the OT lock held,
+    // so we can safely call otThreadGetDeviceRole directly.
+    otInstance *instance = esp_openthread_get_instance();
+    otDeviceRole role = otThreadGetDeviceRole(instance);
+    self->connected_ = role >= OT_DEVICE_ROLE_CHILD;
   }
-
-  otInstance *instance = lock->get_instance();
-  if (instance == nullptr) {
-    return false;
-  }
-
-  otDeviceRole role = otThreadGetDeviceRole(instance);
-
-  // TODO: If we're a leader, check that there is at least 1 known peer
-  return role >= OT_DEVICE_ROLE_CHILD;
 }
 
 // Gets the off-mesh routable address
diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h
index 728847afa54..d853c58f958 100644
--- a/esphome/components/openthread/openthread.h
+++ b/esphome/components/openthread/openthread.h
@@ -8,6 +8,7 @@
 
 #include <openthread/srp_client.h>
 #include <openthread/srp_client_buffers.h>
+#include <openthread/instance.h>
 #include <openthread/thread.h>
 
 #include <optional>
@@ -26,7 +27,7 @@ class OpenThreadComponent : public Component {
   bool teardown() override;
   float get_setup_priority() const override { return setup_priority::WIFI; }
 
-  bool is_connected();
+  bool is_connected() const { return this->connected_; }
   network::IPAddresses get_ip_addresses();
   std::optional<otIp6Address> get_omr_address();
   void ot_main();
@@ -42,6 +43,7 @@ class OpenThreadComponent : public Component {
 
  protected:
   std::optional<otIp6Address> get_omr_address_(InstanceLock &lock);
+  static void on_state_changed_(otChangedFlags flags, void *context);
   std::function<void()> factory_reset_external_callback_;
 #if CONFIG_OPENTHREAD_MTD
   uint32_t poll_period_{0};
@@ -49,6 +51,7 @@ class OpenThreadComponent : public Component {
   std::optional<int8_t> output_power_{};
   bool teardown_started_{false};
   bool teardown_complete_{false};
+  bool connected_{false};
 
  private:
   // Stores a pointer to a string literal (static storage duration).
diff --git a/esphome/components/openthread/openthread_esp.cpp b/esphome/components/openthread/openthread_esp.cpp
index 2af78b729f3..2296e32b7f7 100644
--- a/esphome/components/openthread/openthread_esp.cpp
+++ b/esphome/components/openthread/openthread_esp.cpp
@@ -175,6 +175,9 @@ void OpenThreadComponent::ot_main() {
   // Pass the existing dataset, or NULL which will use the preprocessor definitions
   ESP_ERROR_CHECK(esp_openthread_auto_start(dataset.mLength > 0 ? &dataset : nullptr));
 
+  // Register state change callback to update connected_ reactively instead of polling
+  otSetStateChangedCallback(instance, OpenThreadComponent::on_state_changed_, this);
+
   esp_openthread_launch_mainloop();
 
   // Clean up
diff --git a/esphome/components/ota/ota_backend.h b/esphome/components/ota/ota_backend.h
index e03afd4fc6f..bc603a6e9e2 100644
--- a/esphome/components/ota/ota_backend.h
+++ b/esphome/components/ota/ota_backend.h
@@ -49,17 +49,6 @@ enum OTAState {
   OTA_ERROR,
 };
 
-class OTABackend {
- public:
-  virtual ~OTABackend() = default;
-  virtual OTAResponseTypes begin(size_t image_size) = 0;
-  virtual void set_update_md5(const char *md5) = 0;
-  virtual OTAResponseTypes write(uint8_t *data, size_t len) = 0;
-  virtual OTAResponseTypes end() = 0;
-  virtual void abort() = 0;
-  virtual bool supports_compression() = 0;
-};
-
 /** Listener interface for OTA state changes.
  *
  * Components can implement this interface to receive OTA state updates
@@ -130,7 +119,5 @@ OTAGlobalCallback *get_global_ota_callback();
 // - notify_state_deferred_() when in separate task (e.g., web_server OTA)
 // This ensures proper listener execution in all contexts.
 #endif
-std::unique_ptr<ota::OTABackend> make_ota_backend();
-
 }  // namespace ota
 }  // namespace esphome
diff --git a/esphome/components/ota/ota_backend_arduino_libretiny.cpp b/esphome/components/ota/ota_backend_arduino_libretiny.cpp
index b4ecad1227e..d364f750074 100644
--- a/esphome/components/ota/ota_backend_arduino_libretiny.cpp
+++ b/esphome/components/ota/ota_backend_arduino_libretiny.cpp
@@ -12,7 +12,7 @@ namespace ota {
 
 static const char *const TAG = "ota.arduino_libretiny";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoLibreTinyOTABackend>(); }
+std::unique_ptr<ArduinoLibreTinyOTABackend> make_ota_backend() { return make_unique<ArduinoLibreTinyOTABackend>(); }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
   // Handle UPDATE_SIZE_UNKNOWN (0) which is used by web server OTA
diff --git a/esphome/components/ota/ota_backend_arduino_libretiny.h b/esphome/components/ota/ota_backend_arduino_libretiny.h
index 8f9d268eec6..4514bf84bda 100644
--- a/esphome/components/ota/ota_backend_arduino_libretiny.h
+++ b/esphome/components/ota/ota_backend_arduino_libretiny.h
@@ -7,19 +7,21 @@
 namespace esphome {
 namespace ota {
 
-class ArduinoLibreTinyOTABackend final : public OTABackend {
+class ArduinoLibreTinyOTABackend final {
  public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
-  bool supports_compression() override { return false; }
+  OTAResponseTypes begin(size_t image_size);
+  void set_update_md5(const char *md5);
+  OTAResponseTypes write(uint8_t *data, size_t len);
+  OTAResponseTypes end();
+  void abort();
+  bool supports_compression() { return false; }
 
  private:
   bool md5_set_{false};
 };
 
+std::unique_ptr<ArduinoLibreTinyOTABackend> make_ota_backend();
+
 }  // namespace ota
 }  // namespace esphome
 
diff --git a/esphome/components/ota/ota_backend_arduino_rp2040.cpp b/esphome/components/ota/ota_backend_arduino_rp2040.cpp
index ee1ba48d504..e2a57ec665b 100644
--- a/esphome/components/ota/ota_backend_arduino_rp2040.cpp
+++ b/esphome/components/ota/ota_backend_arduino_rp2040.cpp
@@ -14,7 +14,7 @@ namespace ota {
 
 static const char *const TAG = "ota.arduino_rp2040";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoRP2040OTABackend>(); }
+std::unique_ptr<ArduinoRP2040OTABackend> make_ota_backend() { return make_unique<ArduinoRP2040OTABackend>(); }
 
 OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
   // OTA size of 0 is not currently handled, but
diff --git a/esphome/components/ota/ota_backend_arduino_rp2040.h b/esphome/components/ota/ota_backend_arduino_rp2040.h
index 6a708f9c574..0956cb4b4b9 100644
--- a/esphome/components/ota/ota_backend_arduino_rp2040.h
+++ b/esphome/components/ota/ota_backend_arduino_rp2040.h
@@ -9,19 +9,21 @@
 namespace esphome {
 namespace ota {
 
-class ArduinoRP2040OTABackend final : public OTABackend {
+class ArduinoRP2040OTABackend final {
  public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
-  bool supports_compression() override { return false; }
+  OTAResponseTypes begin(size_t image_size);
+  void set_update_md5(const char *md5);
+  OTAResponseTypes write(uint8_t *data, size_t len);
+  OTAResponseTypes end();
+  void abort();
+  bool supports_compression() { return false; }
 
  private:
   bool md5_set_{false};
 };
 
+std::unique_ptr<ArduinoRP2040OTABackend> make_ota_backend();
+
 }  // namespace ota
 }  // namespace esphome
 
diff --git a/esphome/components/ota/ota_backend_esp8266.cpp b/esphome/components/ota/ota_backend_esp8266.cpp
index 4b84708cd91..1f9a77e4261 100644
--- a/esphome/components/ota/ota_backend_esp8266.cpp
+++ b/esphome/components/ota/ota_backend_esp8266.cpp
@@ -48,7 +48,7 @@ namespace esphome::ota {
 
 static const char *const TAG = "ota.esp8266";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ESP8266OTABackend>(); }
+std::unique_ptr<ESP8266OTABackend> make_ota_backend() { return make_unique<ESP8266OTABackend>(); }
 
 OTAResponseTypes ESP8266OTABackend::begin(size_t image_size) {
   // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
diff --git a/esphome/components/ota/ota_backend_esp8266.h b/esphome/components/ota/ota_backend_esp8266.h
index 52f657f0065..6213289accb 100644
--- a/esphome/components/ota/ota_backend_esp8266.h
+++ b/esphome/components/ota/ota_backend_esp8266.h
@@ -12,15 +12,15 @@ namespace esphome::ota {
 /// OTA backend for ESP8266 using native SDK functions.
 /// This implementation bypasses the Arduino Updater library to save ~228 bytes of RAM
 /// by not having a global Update object in .bss.
-class ESP8266OTABackend final : public OTABackend {
+class ESP8266OTABackend final {
  public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
+  OTAResponseTypes begin(size_t image_size);
+  void set_update_md5(const char *md5);
+  OTAResponseTypes write(uint8_t *data, size_t len);
+  OTAResponseTypes end();
+  void abort();
   // Compression supported in all ESP8266 Arduino versions ESPHome supports (>= 2.7.0)
-  bool supports_compression() override { return true; }
+  bool supports_compression() { return true; }
 
  protected:
   /// Erase flash sector if current address is at sector boundary
@@ -54,5 +54,7 @@ class ESP8266OTABackend final : public OTABackend {
   bool md5_set_{false};
 };
 
+std::unique_ptr<ESP8266OTABackend> make_ota_backend();
+
 }  // namespace esphome::ota
 #endif  // USE_ESP8266
diff --git a/esphome/components/ota/ota_backend_esp_idf.cpp b/esphome/components/ota/ota_backend_esp_idf.cpp
index 93c65a9624e..925bb396454 100644
--- a/esphome/components/ota/ota_backend_esp_idf.cpp
+++ b/esphome/components/ota/ota_backend_esp_idf.cpp
@@ -11,7 +11,7 @@
 namespace esphome {
 namespace ota {
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::IDFOTABackend>(); }
+std::unique_ptr<IDFOTABackend> make_ota_backend() { return make_unique<IDFOTABackend>(); }
 
 OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
 #ifdef USE_OTA_ROLLBACK
diff --git a/esphome/components/ota/ota_backend_esp_idf.h b/esphome/components/ota/ota_backend_esp_idf.h
index 7f7f6115c50..a0f538afc02 100644
--- a/esphome/components/ota/ota_backend_esp_idf.h
+++ b/esphome/components/ota/ota_backend_esp_idf.h
@@ -10,14 +10,14 @@
 namespace esphome {
 namespace ota {
 
-class IDFOTABackend final : public OTABackend {
+class IDFOTABackend final {
  public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
-  bool supports_compression() override { return false; }
+  OTAResponseTypes begin(size_t image_size);
+  void set_update_md5(const char *md5);
+  OTAResponseTypes write(uint8_t *data, size_t len);
+  OTAResponseTypes end();
+  void abort();
+  bool supports_compression() { return false; }
 
  private:
   esp_ota_handle_t update_handle_{0};
@@ -27,6 +27,8 @@ class IDFOTABackend final : public OTABackend {
   bool md5_set_{false};
 };
 
+std::unique_ptr<IDFOTABackend> make_ota_backend();
+
 }  // namespace ota
 }  // namespace esphome
 #endif  // USE_ESP32
diff --git a/esphome/components/ota/ota_backend_factory.h b/esphome/components/ota/ota_backend_factory.h
new file mode 100644
index 00000000000..7c79f027027
--- /dev/null
+++ b/esphome/components/ota/ota_backend_factory.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "ota_backend.h"
+
+#include <memory>
+
+#ifdef USE_ESP8266
+#include "ota_backend_esp8266.h"
+#elif defined(USE_ESP32)
+#include "ota_backend_esp_idf.h"
+#elif defined(USE_RP2040)
+#include "ota_backend_arduino_rp2040.h"
+#elif defined(USE_LIBRETINY)
+#include "ota_backend_arduino_libretiny.h"
+#elif defined(USE_HOST)
+#include "ota_backend_host.h"
+#else
+// Stub for static analysis when no platform is defined
+namespace esphome::ota {
+struct StubOTABackend {};
+std::unique_ptr<StubOTABackend> make_ota_backend();
+}  // namespace esphome::ota
+#endif
+
+namespace esphome::ota {
+using OTABackendPtr = decltype(make_ota_backend());
+}  // namespace esphome::ota
diff --git a/esphome/components/ota/ota_backend_host.cpp b/esphome/components/ota/ota_backend_host.cpp
index ddab174bed7..2e2132418d8 100644
--- a/esphome/components/ota/ota_backend_host.cpp
+++ b/esphome/components/ota/ota_backend_host.cpp
@@ -8,7 +8,7 @@ namespace esphome::ota {
 // Stub implementation - OTA is not supported on host platform.
 // All methods return error codes to allow compilation of configs with OTA triggers.
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::HostOTABackend>(); }
+std::unique_ptr<HostOTABackend> make_ota_backend() { return make_unique<HostOTABackend>(); }
 
 OTAResponseTypes HostOTABackend::begin(size_t image_size) { return OTA_RESPONSE_ERROR_UPDATE_PREPARE; }
 
diff --git a/esphome/components/ota/ota_backend_host.h b/esphome/components/ota/ota_backend_host.h
index 5a2dcfcf39b..300facf72f9 100644
--- a/esphome/components/ota/ota_backend_host.h
+++ b/esphome/components/ota/ota_backend_host.h
@@ -7,15 +7,17 @@ namespace esphome::ota {
 /// Stub OTA backend for host platform - allows compilation but does not implement OTA.
 /// All operations return error codes immediately. This enables configurations with
 /// OTA triggers to compile for host platform during development.
-class HostOTABackend final : public OTABackend {
+class HostOTABackend final {
  public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
-  bool supports_compression() override { return false; }
+  OTAResponseTypes begin(size_t image_size);
+  void set_update_md5(const char *md5);
+  OTAResponseTypes write(uint8_t *data, size_t len);
+  OTAResponseTypes end();
+  void abort();
+  bool supports_compression() { return false; }
 };
 
+std::unique_ptr<HostOTABackend> make_ota_backend();
+
 }  // namespace esphome::ota
 #endif
diff --git a/esphome/components/output/lock/output_lock.cpp b/esphome/components/output/lock/output_lock.cpp
index 2545f624811..c373cd7b7c9 100644
--- a/esphome/components/output/lock/output_lock.cpp
+++ b/esphome/components/output/lock/output_lock.cpp
@@ -9,7 +9,10 @@ static const char *const TAG = "output.lock";
 void OutputLock::dump_config() { LOG_LOCK("", "Output Lock", this); }
 
 void OutputLock::control(const lock::LockCall &call) {
-  auto state = *call.get_state();
+  auto state_val = call.get_state();
+  if (!state_val.has_value())
+    return;
+  auto state = *state_val;
   if (state == lock::LOCK_STATE_LOCKED) {
     this->output_->turn_on();
   } else if (state == lock::LOCK_STATE_UNLOCKED) {
diff --git a/esphome/components/packet_transport/packet_transport.cpp b/esphome/components/packet_transport/packet_transport.cpp
index 7b7a8523986..f241cc61142 100644
--- a/esphome/components/packet_transport/packet_transport.cpp
+++ b/esphome/components/packet_transport/packet_transport.cpp
@@ -3,6 +3,8 @@
 #include "esphome/core/helpers.h"
 #include "packet_transport.h"
 
+#include <ranges>
+
 #include "esphome/components/xxtea/xxtea.h"
 
 namespace esphome {
@@ -77,7 +79,7 @@ enum DecodeResult {
   DECODE_EMPTY,
 };
 
-static const size_t MAX_PING_KEYS = 4;
+static constexpr size_t MAX_PING_KEYS = 4;
 
 static inline void add(std::vector<uint8_t> &vec, uint32_t data) {
   vec.push_back(data & 0xFF);
@@ -168,7 +170,7 @@ class PacketDecoder {
     return true;
   }
 
-  bool decrypt(const uint32_t *key) {
+  bool decrypt(const uint32_t *key) const {
     if (this->get_remaining_size() % 4 != 0) {
       return false;
     }
@@ -249,9 +251,9 @@ void PacketTransport::init_data_() {
   } else {
     add(this->data_, DATA_KEY);
   }
-  for (auto pkey : this->ping_keys_) {
+  for (auto &value : this->ping_keys_ | std::views::values) {
     add(this->data_, PING_KEY);
-    add(this->data_, pkey.second);
+    add(this->data_, value);
   }
 }
 
@@ -331,7 +333,7 @@ void PacketTransport::update() {
   auto now = millis() / 1000;
   if (this->last_key_time_ + this->ping_pong_recyle_time_ < now) {
     this->resend_ping_key_ = this->ping_pong_enable_;
-    ESP_LOGV(TAG, "Ping request, age %u", now - this->last_key_time_);
+    ESP_LOGV(TAG, "Ping request, age %" PRIu32, now - this->last_key_time_);
     this->last_key_time_ = now;
   }
   for (const auto &provider : this->providers_) {
@@ -339,24 +341,32 @@ void PacketTransport::update() {
     if (key_response_age > (this->ping_pong_recyle_time_ * 2u)) {
 #ifdef USE_STATUS_SENSOR
       if (provider.second.status_sensor != nullptr && provider.second.status_sensor->state) {
-        ESP_LOGI(TAG, "Ping status for %s timeout at %u with age %u", provider.first.c_str(), now, key_response_age);
+        ESP_LOGI(TAG, "Ping status for %s timeout at %" PRIu32 " with age %" PRIu32, provider.first.c_str(), now,
+                 key_response_age);
         provider.second.status_sensor->publish_state(false);
       }
 #endif
 #ifdef USE_SENSOR
-      for (auto &sensor : this->remote_sensors_[provider.first]) {
-        sensor.second->publish_state(NAN);
+      auto it = this->remote_sensors_.find(provider.first);
+      if (it != this->remote_sensors_.end()) {
+        for (auto &val : it->second | std::views::values) {
+          val->publish_state(NAN);
+        }
       }
 #endif
 #ifdef USE_BINARY_SENSOR
-      for (auto &sensor : this->remote_binary_sensors_[provider.first]) {
-        sensor.second->invalidate_state();
+      auto bs_it = this->remote_binary_sensors_.find(provider.first);
+      if (bs_it != this->remote_binary_sensors_.end()) {
+        for (auto &val : bs_it->second | std::views::values) {
+          val->invalidate_state();
+        }
       }
 #endif
     } else {
 #ifdef USE_STATUS_SENSOR
       if (provider.second.status_sensor != nullptr && !provider.second.status_sensor->state) {
-        ESP_LOGI(TAG, "Ping status for %s restored at %u with age %u", provider.first.c_str(), now, key_response_age);
+        ESP_LOGI(TAG, "Ping status for %s restored at %" PRIu32 " with age %" PRIu32, provider.first.c_str(), now,
+                 key_response_age);
         provider.second.status_sensor->publish_state(true);
       }
 #endif
@@ -367,11 +377,16 @@ void PacketTransport::update() {
 void PacketTransport::add_key_(const char *name, uint32_t key) {
   if (!this->is_encrypted_())
     return;
-  if (this->ping_keys_.count(name) == 0 && this->ping_keys_.size() == MAX_PING_KEYS) {
-    ESP_LOGW(TAG, "Ping key from %s discarded", name);
-    return;
+  auto it = this->ping_keys_.find(name);
+  if (it == this->ping_keys_.end()) {
+    if (this->ping_keys_.size() == MAX_PING_KEYS) {
+      ESP_LOGW(TAG, "Ping key from %s discarded", name);
+      return;
+    }
+    this->ping_keys_.emplace(name, key);  // allocates string key once only
+  } else {
+    it->second = key;  // key string already exists in map, no allocation
   }
-  this->ping_keys_[name] = key;
   this->updated_ = true;
   ESP_LOGV(TAG, "Ping key from %s now %X", name, (unsigned) key);
 }
@@ -431,17 +446,19 @@ void PacketTransport::process_(std::span<const uint8_t> data) {
     return;
   }
 
-  if (this->providers_.count(namebuf) == 0) {
+  auto it = this->providers_.find(namebuf);
+  if (it == this->providers_.end()) {
     ESP_LOGVV(TAG, "Unknown hostname %s", namebuf);
     return;
   }
+  auto &provider = it->second;
   ESP_LOGV(TAG, "Found hostname %s", namebuf);
 
 #ifdef USE_SENSOR
-  auto &sensors = this->remote_sensors_[namebuf];
+  auto &sensors = this->remote_sensors_.try_emplace(namebuf).first->second;
 #endif
 #ifdef USE_BINARY_SENSOR
-  auto &binary_sensors = this->remote_binary_sensors_[namebuf];
+  auto &binary_sensors = this->remote_binary_sensors_.try_emplace(namebuf).first->second;
 #endif
 
   if (!decoder.bump_to(4)) {
@@ -453,7 +470,6 @@ void PacketTransport::process_(std::span<const uint8_t> data) {
     return;
   }
 
-  auto &provider = this->providers_[namebuf];
   // if encryption not used with this host, ping check is pointless since it would be easily spoofed.
   if (provider.encryption_key.empty())
     ping_key_seen = true;
@@ -495,16 +511,19 @@ void PacketTransport::process_(std::span<const uint8_t> data) {
     if (decoder.decode(BINARY_SENSOR_KEY, namebuf, sizeof(namebuf), byte) == DECODE_OK) {
       ESP_LOGV(TAG, "Got binary sensor %s %d", namebuf, byte);
 #ifdef USE_BINARY_SENSOR
-      if (binary_sensors.count(namebuf) != 0)
-        binary_sensors[namebuf]->publish_state(byte != 0);
+      auto bs = binary_sensors.find(namebuf);
+      if (bs != binary_sensors.end()) {
+        bs->second->publish_state(byte != 0);
+      }
 #endif
       continue;
     }
     if (decoder.decode(SENSOR_KEY, namebuf, sizeof(namebuf), rdata.u32) == DECODE_OK) {
       ESP_LOGV(TAG, "Got sensor %s %f", namebuf, rdata.f32);
 #ifdef USE_SENSOR
-      if (sensors.count(namebuf) != 0)
-        sensors[namebuf]->publish_state(rdata.f32);
+      auto sensor_it = sensors.find(namebuf);
+      if (sensor_it != sensors.end())
+        sensor_it->second->publish_state(rdata.f32);
 #endif
       continue;
     }
@@ -537,12 +556,18 @@ void PacketTransport::dump_config() {
     ESP_LOGCONFIG(TAG, "  Remote host: %s", host.first.c_str());
     ESP_LOGCONFIG(TAG, "    Encrypted: %s", YESNO(!host.second.encryption_key.empty()));
 #ifdef USE_SENSOR
-    for (const auto &sensor : this->remote_sensors_[host.first.c_str()])
-      ESP_LOGCONFIG(TAG, "    Sensor: %s", sensor.first.c_str());
+    auto rs = this->remote_sensors_.find(host.first.c_str());
+    if (rs != this->remote_sensors_.end()) {
+      for (const auto &key : rs->second | std::views::keys)
+        ESP_LOGCONFIG(TAG, "    Sensor: %s", key.c_str());
+    }
 #endif
 #ifdef USE_BINARY_SENSOR
-    for (const auto &sensor : this->remote_binary_sensors_[host.first.c_str()])
-      ESP_LOGCONFIG(TAG, "    Binary Sensor: %s", sensor.first.c_str());
+    auto rbs = this->remote_binary_sensors_.find(host.first.c_str());
+    if (rbs != this->remote_binary_sensors_.end()) {
+      for (const auto &key : rbs->second | std::views::keys)
+        ESP_LOGCONFIG(TAG, "    Binary Sensor: %s", key.c_str());
+    }
 #endif
   }
 }
diff --git a/esphome/components/packet_transport/packet_transport.h b/esphome/components/packet_transport/packet_transport.h
index 57f40874b53..b3798738e2c 100644
--- a/esphome/components/packet_transport/packet_transport.h
+++ b/esphome/components/packet_transport/packet_transport.h
@@ -24,6 +24,9 @@
 namespace esphome {
 namespace packet_transport {
 
+// std::less provides allocation-free comparison with const char *
+template<typename T> using string_map_t = std::map<std::string, T, std::less<>>;
+
 struct Provider {
   std::vector<uint8_t> encryption_key;
   const char *name;
@@ -79,15 +82,15 @@ class PacketTransport : public PollingComponent {
 #endif
 
   void add_provider(const char *hostname) {
-    if (this->providers_.count(hostname) == 0) {
+    if (!this->providers_.contains(hostname)) {
       Provider provider{};
       provider.name = hostname;
       this->providers_[hostname] = provider;
 #ifdef USE_SENSOR
-      this->remote_sensors_[hostname] = std::map<std::string, sensor::Sensor *>();
+      this->remote_sensors_[hostname] = string_map_t<sensor::Sensor *>();
 #endif
 #ifdef USE_BINARY_SENSOR
-      this->remote_binary_sensors_[hostname] = std::map<std::string, binary_sensor::BinarySensor *>();
+      this->remote_binary_sensors_[hostname] = string_map_t<binary_sensor::BinarySensor *>();
 #endif
     }
   }
@@ -139,23 +142,23 @@ class PacketTransport : public PollingComponent {
 
 #ifdef USE_SENSOR
   std::vector<Sensor> sensors_{};
-  std::map<std::string, std::map<std::string, sensor::Sensor *>> remote_sensors_{};
+  string_map_t<string_map_t<sensor::Sensor *>> remote_sensors_{};
 #endif
 #ifdef USE_BINARY_SENSOR
   std::vector<BinarySensor> binary_sensors_{};
-  std::map<std::string, std::map<std::string, binary_sensor::BinarySensor *>> remote_binary_sensors_{};
+  string_map_t<string_map_t<binary_sensor::BinarySensor *>> remote_binary_sensors_{};
 #endif
 
-  std::map<std::string, Provider> providers_{};
+  string_map_t<Provider> providers_{};
   std::vector<uint8_t> ping_header_{};
   std::vector<uint8_t> header_{};
   std::vector<uint8_t> data_{};
-  std::map<const char *, uint32_t> ping_keys_{};
+  string_map_t<uint32_t> ping_keys_{};
   const char *platform_name_{""};
   void add_key_(const char *name, uint32_t key);
   void send_ping_pong_request_();
 
-  inline bool is_encrypted_() { return !this->encryption_key_.empty(); }
+  bool is_encrypted_() const { return !this->encryption_key_.empty(); }
 };
 
 }  // namespace packet_transport
diff --git a/esphome/components/pid/pid_climate.cpp b/esphome/components/pid/pid_climate.cpp
index 2094c0e942f..54b7a688b41 100644
--- a/esphome/components/pid/pid_climate.cpp
+++ b/esphome/components/pid/pid_climate.cpp
@@ -41,10 +41,12 @@ void PIDClimate::setup() {
   }
 }
 void PIDClimate::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value())
-    this->mode = *call.get_mode();
-  if (call.get_target_temperature().has_value())
-    this->target_temperature = *call.get_target_temperature();
+  auto call_mode = call.get_mode();
+  if (call_mode.has_value())
+    this->mode = *call_mode;
+  auto call_target = call.get_target_temperature();
+  if (call_target.has_value())
+    this->target_temperature = *call_target;
 
   // If switching to off mode, set output immediately
   if (this->mode == climate::CLIMATE_MODE_OFF)
diff --git a/esphome/components/pipsolar/pipsolar.cpp b/esphome/components/pipsolar/pipsolar.cpp
index f95bf4aedb9..9c5caec7758 100644
--- a/esphome/components/pipsolar/pipsolar.cpp
+++ b/esphome/components/pipsolar/pipsolar.cpp
@@ -162,13 +162,15 @@ void Pipsolar::loop() {
 }
 
 uint8_t Pipsolar::check_incoming_length_(uint8_t length) {
-  if (this->read_pos_ - 3 == length) {
+  if (this->read_pos_ >= 3 && this->read_pos_ - 3 == length) {
     return 1;
   }
   return 0;
 }
 
 uint8_t Pipsolar::check_incoming_crc_() {
+  if (this->read_pos_ < 3)
+    return 0;
   uint16_t crc16;
   crc16 = this->pipsolar_crc_(read_buffer_, read_pos_ - 3);
   if (((uint8_t) ((crc16) >> 8)) == read_buffer_[read_pos_ - 3] &&
diff --git a/esphome/components/pn532/pn532_mifare_ultralight.cpp b/esphome/components/pn532/pn532_mifare_ultralight.cpp
index a8a8e2d5735..0e0dc1542f4 100644
--- a/esphome/components/pn532/pn532_mifare_ultralight.cpp
+++ b/esphome/components/pn532/pn532_mifare_ultralight.cpp
@@ -99,7 +99,7 @@ bool PN532::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6
                                          uint8_t &message_start_index) {
   const uint8_t p4_offset = nfc::MIFARE_ULTRALIGHT_PAGE_SIZE;  // page 4 will begin 4 bytes into the vector
 
-  if (!(page_3_to_6.size() > p4_offset + 5)) {
+  if (!(page_3_to_6.size() > p4_offset + 6)) {
     return false;
   }
 
@@ -134,7 +134,7 @@ bool PN532::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *
   } else {
     encoded.insert(encoded.begin() + 1, 0xFF);
     encoded.insert(encoded.begin() + 2, (message_length >> 8) & 0xFF);
-    encoded.insert(encoded.begin() + 2, message_length & 0xFF);
+    encoded.insert(encoded.begin() + 3, message_length & 0xFF);
   }
   encoded.push_back(0xFE);
 
diff --git a/esphome/components/pn532_spi/pn532_spi.cpp b/esphome/components/pn532_spi/pn532_spi.cpp
index 118421c47f3..553c6d26a6a 100644
--- a/esphome/components/pn532_spi/pn532_spi.cpp
+++ b/esphome/components/pn532_spi/pn532_spi.cpp
@@ -88,9 +88,10 @@ bool PN532Spi::read_response(uint8_t command, std::vector<uint8_t> &data) {
 #endif
   ESP_LOGV(TAG, "Header data: %s", format_hex_pretty_to(hex_buf, sizeof(hex_buf), header.data(), header.size()));
 
-  if (header[0] != 0x00 && header[1] != 0x00 && header[2] != 0xFF) {
+  if (header[0] != 0x00 || header[1] != 0x00 || header[2] != 0xFF) {
     // invalid packet
     ESP_LOGV(TAG, "read data invalid preamble!");
+    this->disable();
     return false;
   }
 
@@ -100,15 +101,20 @@ bool PN532Spi::read_response(uint8_t command, std::vector<uint8_t> &data) {
 
   if (!valid_header) {
     ESP_LOGV(TAG, "read data invalid header!");
+    this->disable();
     return false;
   }
 
-  // full length of message, including command response
+  // full length of message, including command response (minimum 2: TFI + command response)
   uint8_t full_len = header[3];
+  if (full_len < 2) {
+    ESP_LOGV(TAG, "read data has no payload");
+    this->disable();
+    return false;
+  }
+
   // length of data, excluding command response
   uint8_t len = full_len - 1;
-  if (full_len == 0)
-    len = 0;
 
   ESP_LOGV(TAG, "Reading response of length %d", len);
 
diff --git a/esphome/components/pn7150/pn7150.cpp b/esphome/components/pn7150/pn7150.cpp
index 8c76c8b88c9..d68bea41b3d 100644
--- a/esphome/components/pn7150/pn7150.cpp
+++ b/esphome/components/pn7150/pn7150.cpp
@@ -562,9 +562,9 @@ optional<size_t> PN7150::find_tag_uid_(const nfc::NfcTagUid &uid) {
 }
 
 void PN7150::purge_old_tags_() {
-  for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
-    if (millis() - this->discovered_endpoint_[i].last_seen > this->tag_ttl_) {
-      this->erase_tag_(i);
+  for (size_t i = this->discovered_endpoint_.size(); i > 0; i--) {
+    if (millis() - this->discovered_endpoint_[i - 1].last_seen > this->tag_ttl_) {
+      this->erase_tag_(i - 1);
     }
   }
 }
diff --git a/esphome/components/pn7150/pn7150_mifare_ultralight.cpp b/esphome/components/pn7150/pn7150_mifare_ultralight.cpp
index 46f5dba2b76..854ddd1be18 100644
--- a/esphome/components/pn7150/pn7150_mifare_ultralight.cpp
+++ b/esphome/components/pn7150/pn7150_mifare_ultralight.cpp
@@ -100,7 +100,7 @@ uint8_t PN7150::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
                                              uint8_t &message_start_index) {
   const uint8_t p4_offset = nfc::MIFARE_ULTRALIGHT_PAGE_SIZE;  // page 4 will begin 4 bytes into the vector
 
-  if (!(page_3_to_6.size() > p4_offset + 5)) {
+  if (!(page_3_to_6.size() > p4_offset + 6)) {
     return nfc::STATUS_FAILED;
   }
 
@@ -135,7 +135,7 @@ uint8_t PN7150::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::sha
   } else {
     encoded.insert(encoded.begin() + 1, 0xFF);
     encoded.insert(encoded.begin() + 2, (message_length >> 8) & 0xFF);
-    encoded.insert(encoded.begin() + 2, message_length & 0xFF);
+    encoded.insert(encoded.begin() + 3, message_length & 0xFF);
   }
   encoded.push_back(0xFE);
 
diff --git a/esphome/components/pn7160/pn7160.cpp b/esphome/components/pn7160/pn7160.cpp
index 3fcd1221a72..5f0f8d0629c 100644
--- a/esphome/components/pn7160/pn7160.cpp
+++ b/esphome/components/pn7160/pn7160.cpp
@@ -589,9 +589,9 @@ optional<size_t> PN7160::find_tag_uid_(const nfc::NfcTagUid &uid) {
 }
 
 void PN7160::purge_old_tags_() {
-  for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
-    if (millis() - this->discovered_endpoint_[i].last_seen > this->tag_ttl_) {
-      this->erase_tag_(i);
+  for (size_t i = this->discovered_endpoint_.size(); i > 0; i--) {
+    if (millis() - this->discovered_endpoint_[i - 1].last_seen > this->tag_ttl_) {
+      this->erase_tag_(i - 1);
     }
   }
 }
diff --git a/esphome/components/pn7160/pn7160_mifare_ultralight.cpp b/esphome/components/pn7160/pn7160_mifare_ultralight.cpp
index 9dc8d3dd2d5..8ca0fa2c11b 100644
--- a/esphome/components/pn7160/pn7160_mifare_ultralight.cpp
+++ b/esphome/components/pn7160/pn7160_mifare_ultralight.cpp
@@ -100,7 +100,7 @@ uint8_t PN7160::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
                                              uint8_t &message_start_index) {
   const uint8_t p4_offset = nfc::MIFARE_ULTRALIGHT_PAGE_SIZE;  // page 4 will begin 4 bytes into the vector
 
-  if (!(page_3_to_6.size() > p4_offset + 5)) {
+  if (!(page_3_to_6.size() > p4_offset + 6)) {
     return nfc::STATUS_FAILED;
   }
 
@@ -135,7 +135,7 @@ uint8_t PN7160::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::sha
   } else {
     encoded.insert(encoded.begin() + 1, 0xFF);
     encoded.insert(encoded.begin() + 2, (message_length >> 8) & 0xFF);
-    encoded.insert(encoded.begin() + 2, message_length & 0xFF);
+    encoded.insert(encoded.begin() + 3, message_length & 0xFF);
   }
   encoded.push_back(0xFE);
 
diff --git a/esphome/components/pulse_counter/pulse_counter_sensor.cpp b/esphome/components/pulse_counter/pulse_counter_sensor.cpp
index 5e62c0a4107..ec00bd024e0 100644
--- a/esphome/components/pulse_counter/pulse_counter_sensor.cpp
+++ b/esphome/components/pulse_counter/pulse_counter_sensor.cpp
@@ -175,7 +175,8 @@ void PulseCounterSensor::setup() {
 
 void PulseCounterSensor::set_total_pulses(uint32_t pulses) {
   this->current_total_ = pulses;
-  this->total_sensor_->publish_state(pulses);
+  if (this->total_sensor_ != nullptr)
+    this->total_sensor_->publish_state(pulses);
 }
 
 void PulseCounterSensor::dump_config() {
diff --git a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
index 57124479090..239a1e74fe6 100644
--- a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
+++ b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
@@ -61,6 +61,10 @@ optional<ParseResult> PVVXMiThermometer::parse_header_(const esp32_ble_tracker::
   }
 
   auto raw = service_data.data;
+  if (raw.size() < 14) {
+    ESP_LOGVV(TAG, "parse_header_(): service data too short (%zu).", raw.size());
+    return {};
+  }
 
   static uint8_t last_frame_count = 0;
   if (last_frame_count == raw[13]) {
diff --git a/esphome/components/pzem004t/pzem004t.cpp b/esphome/components/pzem004t/pzem004t.cpp
index 356847825e6..d0f96d6d1e5 100644
--- a/esphome/components/pzem004t/pzem004t.cpp
+++ b/esphome/components/pzem004t/pzem004t.cpp
@@ -26,7 +26,10 @@ void PZEM004T::loop() {
 
   // PZEM004T packet size is 7 byte
   while (this->available() >= 7) {
-    auto resp = *this->read_array<7>();
+    auto resp_opt = this->read_array<7>();
+    if (!resp_opt.has_value())
+      break;
+    auto resp = *resp_opt;
     // packet format:
     // 0: packet type
     // 1-5: data
diff --git a/esphome/components/qmp6988/qmp6988.cpp b/esphome/components/qmp6988/qmp6988.cpp
index 24fe34e7852..17d91c36330 100644
--- a/esphome/components/qmp6988/qmp6988.cpp
+++ b/esphome/components/qmp6988/qmp6988.cpp
@@ -251,7 +251,7 @@ void QMP6988Component::set_power_mode_(uint8_t power_mode) {
 void QMP6988Component::write_filter_(QMP6988IIRFilter filter) {
   uint8_t data;
 
-  data = (filter & 0x03);
+  data = (filter & QMP6988_CONFIG_REG_FILTER_MSK);
   this->write_byte(QMP6988_CONFIG_REG, data);
   delay(10);
 }
diff --git a/esphome/components/rc522/rc522.cpp b/esphome/components/rc522/rc522.cpp
index 91fae7fa345..c5f7ec2cd41 100644
--- a/esphome/components/rc522/rc522.cpp
+++ b/esphome/components/rc522/rc522.cpp
@@ -169,6 +169,7 @@ void RC522::loop() {
         default:
           ESP_LOGE(TAG, "uid_idx_ invalid, uid_idx_ = %d", uid_idx_);
           state_ = STATE_DONE;
+          return;
       }
       buffer_[1] = 32;
       pcd_transceive_data_(2);
diff --git a/esphome/components/remote_base/pronto_protocol.cpp b/esphome/components/remote_base/pronto_protocol.cpp
index 43029cbc2fc..6903cd46058 100644
--- a/esphome/components/remote_base/pronto_protocol.cpp
+++ b/esphome/components/remote_base/pronto_protocol.cpp
@@ -44,9 +44,13 @@ bool ProntoData::operator==(const ProntoData &rhs) const {
   std::vector<uint16_t> data1 = encode_pronto(data);
   std::vector<uint16_t> data2 = encode_pronto(rhs.data);
 
+  if (data1.size() != data2.size() || data1.empty()) {
+    return false;
+  }
+
   uint32_t total_diff = 0;
   // Don't need to check the last one, it's the large gap at the end.
-  for (std::vector<uint16_t>::size_type i = 0; i < data1.size() - 1; ++i) {
+  for (size_t i = 0; i < data1.size() - 1; ++i) {
     int diff = data2[i] - data1[i];
     diff *= diff;
     if (rhs.delta == -1 && diff > 9)
diff --git a/esphome/components/remote_receiver/remote_receiver_rmt.cpp b/esphome/components/remote_receiver/remote_receiver_rmt.cpp
index 357a36d052f..96b23bd0f52 100644
--- a/esphome/components/remote_receiver/remote_receiver_rmt.cpp
+++ b/esphome/components/remote_receiver/remote_receiver_rmt.cpp
@@ -106,7 +106,7 @@ void RemoteReceiverComponent::setup() {
   this->store_.filter_symbols = this->filter_symbols_;
   this->store_.receive_size = this->receive_symbols_ * sizeof(rmt_symbol_word_t);
   this->store_.buffer_size = std::max((event_size + this->store_.receive_size) * 2, this->buffer_size_);
-  this->store_.buffer = new uint8_t[this->buffer_size_];
+  this->store_.buffer = new uint8_t[this->store_.buffer_size];
   error = rmt_receive(this->channel_, (uint8_t *) this->store_.buffer + event_size, this->store_.receive_size,
                       &this->store_.config);
   if (error != ESP_OK) {
diff --git a/esphome/components/resampler/speaker/resampler_speaker.cpp b/esphome/components/resampler/speaker/resampler_speaker.cpp
index 74420f906a1..1303bc459e5 100644
--- a/esphome/components/resampler/speaker/resampler_speaker.cpp
+++ b/esphome/components/resampler/speaker/resampler_speaker.cpp
@@ -147,7 +147,7 @@ void ResamplerSpeaker::loop() {
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   }
   if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
-    this->delete_task_();
+    this->task_.deallocate();
     ESP_LOGD(TAG, "Stopped");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
   }
@@ -190,7 +190,7 @@ void ResamplerSpeaker::loop() {
         this->output_speaker_->stop();
       }
 
-      if (this->output_speaker_->is_stopped() && (this->task_handle_ == nullptr)) {
+      if (this->output_speaker_->is_stopped() && !this->task_.is_created()) {
         // Only transition to stopped state once the output speaker and resampler task are fully stopped
         this->waiting_for_output_ = false;
         this->state_ = speaker::STATE_STOPPED;
@@ -209,9 +209,6 @@ void ResamplerSpeaker::loop() {
 
 void ResamplerSpeaker::set_start_error_(esp_err_t err) {
   switch (err) {
-    case ESP_ERR_INVALID_STATE:
-      this->status_set_error(LOG_STR("Task failed to start"));
-      break;
     case ESP_ERR_NO_MEM:
       this->status_set_error(LOG_STR("Not enough memory"));
       break;
@@ -267,36 +264,12 @@ esp_err_t ResamplerSpeaker::start_() {
 
   if (this->requires_resampling_()) {
     // Start the resampler task to handle converting sample rates
-    return this->start_task_();
-  }
-
-  return ESP_OK;
-}
-
-esp_err_t ResamplerSpeaker::start_task_() {
-  if (this->task_stack_buffer_ == nullptr) {
-    if (this->task_stack_in_psram_) {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-      this->task_stack_buffer_ = stack_allocator.allocate(TASK_STACK_SIZE);
-    } else {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-      this->task_stack_buffer_ = stack_allocator.allocate(TASK_STACK_SIZE);
+    if (!this->task_.create(resample_task, "resampler", TASK_STACK_SIZE, (void *) this, RESAMPLER_TASK_PRIORITY,
+                            this->task_stack_in_psram_)) {
+      return ESP_ERR_NO_MEM;
     }
   }
 
-  if (this->task_stack_buffer_ == nullptr) {
-    return ESP_ERR_NO_MEM;
-  }
-
-  if (this->task_handle_ == nullptr) {
-    this->task_handle_ = xTaskCreateStatic(resample_task, "resampler", TASK_STACK_SIZE, (void *) this,
-                                           RESAMPLER_TASK_PRIORITY, this->task_stack_buffer_, &this->task_stack_);
-  }
-
-  if (this->task_handle_ == nullptr) {
-    return ESP_ERR_INVALID_STATE;
-  }
-
   return ESP_OK;
 }
 
@@ -305,33 +278,12 @@ void ResamplerSpeaker::stop() { this->send_command_(ResamplingEventGroupBits::CO
 void ResamplerSpeaker::enter_stopping_state_() {
   this->state_ = speaker::STATE_STOPPING;
   this->state_start_ms_ = App.get_loop_component_start_time();
-  if (this->task_handle_ != nullptr) {
+  if (this->task_.is_created()) {
     xEventGroupSetBits(this->event_group_, ResamplingEventGroupBits::TASK_COMMAND_STOP);
   }
   this->output_speaker_->stop();
 }
 
-void ResamplerSpeaker::delete_task_() {
-  if (this->task_handle_ != nullptr) {
-    // Delete the suspended task
-    vTaskDelete(this->task_handle_);
-    this->task_handle_ = nullptr;
-  }
-
-  if (this->task_stack_buffer_ != nullptr) {
-    // Deallocate the task stack buffer
-    if (this->task_stack_in_psram_) {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-    } else {
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-    }
-
-    this->task_stack_buffer_ = nullptr;
-  }
-}
-
 void ResamplerSpeaker::finish() { this->send_command_(ResamplingEventGroupBits::COMMAND_FINISH); }
 
 bool ResamplerSpeaker::has_buffered_data() const {
diff --git a/esphome/components/resampler/speaker/resampler_speaker.h b/esphome/components/resampler/speaker/resampler_speaker.h
index c1ebd7e7b5b..cdbc1c22db4 100644
--- a/esphome/components/resampler/speaker/resampler_speaker.h
+++ b/esphome/components/resampler/speaker/resampler_speaker.h
@@ -7,8 +7,8 @@
 #include "esphome/components/speaker/speaker.h"
 
 #include "esphome/core/component.h"
+#include "esphome/core/static_task.h"
 
-#include <freertos/FreeRTOS.h>
 #include <freertos/event_groups.h>
 
 namespace esphome {
@@ -57,15 +57,9 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
  protected:
   /// @brief Starts the output speaker after setting the resampled stream info. If resampling is required, it starts the
   /// task.
-  /// @return ESP_OK if resampling is required
-  ///         return value of start_task_() if resampling is required
-  esp_err_t start_();
-
-  /// @brief Starts the resampler task after allocating the task stack
   /// @return ESP_OK if successful,
-  ///         ESP_ERR_NO_MEM if the task stack couldn't be allocated
-  ///         ESP_ERR_INVALID_STATE if the task wasn't created
-  esp_err_t start_task_();
+  ///         ESP_ERR_NO_MEM if the resampler task couldn't be created
+  esp_err_t start_();
 
   /// @brief Transitions to STATE_STOPPING, records the stopping timestamp, sends the task stop command if the task is
   /// running, and stops the output speaker.
@@ -74,9 +68,6 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   /// @brief Sets the appropriate status error based on the start failure reason.
   void set_start_error_(esp_err_t err);
 
-  /// @brief Deletes the resampler task if suspended, deallocates the task stack, and resets the related pointers.
-  void delete_task_();
-
   /// @brief Sends a command via event group bits, enables the loop, and optionally wakes the main loop.
   void send_command_(uint32_t command_bit, bool wake_loop = false);
 
@@ -92,9 +83,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   bool task_stack_in_psram_{false};
   bool waiting_for_output_{false};
 
-  TaskHandle_t task_handle_{nullptr};
-  StaticTask_t task_stack_;
-  StackType_t *task_stack_buffer_{nullptr};
+  StaticTask task_;
 
   audio::AudioStreamInfo target_stream_info_;
 
diff --git a/esphome/components/rf_bridge/rf_bridge.cpp b/esphome/components/rf_bridge/rf_bridge.cpp
index d8c148145ce..700e2ba1623 100644
--- a/esphome/components/rf_bridge/rf_bridge.cpp
+++ b/esphome/components/rf_bridge/rf_bridge.cpp
@@ -74,7 +74,7 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
       data.length = raw[2];
       data.protocol = raw[3];
       char next_byte[3];  // 2 hex chars + null
-      for (uint8_t i = 0; i < data.length - 1; i++) {
+      for (uint8_t i = 0; i + 1 < data.length; i++) {
         buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[4 + i]);
         data.code += next_byte;
       }
diff --git a/esphome/components/runtime_stats/runtime_stats.cpp b/esphome/components/runtime_stats/runtime_stats.cpp
index 410695da040..d9fa22d9495 100644
--- a/esphome/components/runtime_stats/runtime_stats.cpp
+++ b/esphome/components/runtime_stats/runtime_stats.cpp
@@ -13,12 +13,12 @@ RuntimeStatsCollector::RuntimeStatsCollector() : log_interval_(60000), next_log_
   global_runtime_stats = this;
 }
 
-void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
+void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_us, uint32_t current_time) {
   if (component == nullptr)
     return;
 
   // Record stats using component pointer as key
-  this->component_stats_[component].record_time(duration_ms);
+  this->component_stats_[component].record_time(duration_us);
 
   if (this->next_log_time_ == 0) {
     this->next_log_time_ = current_time + this->log_interval_;
@@ -58,15 +58,16 @@ void RuntimeStatsCollector::log_stats_() {
 
   // Sort by period runtime (descending)
   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();
+    return this->component_stats_[a].get_period_time_us() > this->component_stats_[b].get_period_time_us();
   });
 
   // Log top components by period runtime
   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(sorted[i]->get_component_log_str()), stats.get_period_count(), stats.get_period_avg_time_ms(),
-             stats.get_period_max_time_ms(), stats.get_period_time_ms());
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_period_count(),
+             stats.get_period_avg_time_us() / 1000.0f, stats.get_period_max_time_us() / 1000.0f,
+             stats.get_period_time_us() / 1000.0f);
   }
 
   // Log total stats since boot (only for active components - idle ones haven't changed)
@@ -74,14 +75,15 @@ void RuntimeStatsCollector::log_stats_() {
 
   // Re-sort by total runtime for all-time stats
   std::sort(sorted, sorted + count, [this](Component *a, Component *b) {
-    return this->component_stats_[a].get_total_time_ms() > this->component_stats_[b].get_total_time_ms();
+    return this->component_stats_[a].get_total_time_us() > this->component_stats_[b].get_total_time_us();
   });
 
   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(sorted[i]->get_component_log_str()), stats.get_total_count(), stats.get_total_avg_time_ms(),
-             stats.get_total_max_time_ms(), stats.get_total_time_ms());
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.3fms, max=%.2fms, total=%.1fms",
+             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_total_count(),
+             stats.get_total_avg_time_us() / 1000.0f, stats.get_total_max_time_us() / 1000.0f,
+             stats.get_total_time_us() / 1000.0);
   }
 }
 
diff --git a/esphome/components/runtime_stats/runtime_stats.h b/esphome/components/runtime_stats/runtime_stats.h
index c7fea7474b5..08475297208 100644
--- a/esphome/components/runtime_stats/runtime_stats.h
+++ b/esphome/components/runtime_stats/runtime_stats.h
@@ -22,58 +22,58 @@ class ComponentRuntimeStats {
  public:
   ComponentRuntimeStats()
       : period_count_(0),
-        period_time_ms_(0),
-        period_max_time_ms_(0),
+        period_time_us_(0),
+        period_max_time_us_(0),
         total_count_(0),
-        total_time_ms_(0),
-        total_max_time_ms_(0) {}
+        total_time_us_(0),
+        total_max_time_us_(0) {}
 
-  void record_time(uint32_t duration_ms) {
+  void record_time(uint32_t duration_us) {
     // Update period counters
     this->period_count_++;
-    this->period_time_ms_ += duration_ms;
-    if (duration_ms > this->period_max_time_ms_)
-      this->period_max_time_ms_ = duration_ms;
+    this->period_time_us_ += duration_us;
+    if (duration_us > this->period_max_time_us_)
+      this->period_max_time_us_ = duration_us;
 
-    // Update total counters
+    // Update total counters (uint64_t to avoid overflow — uint32_t would overflow after ~10 hours)
     this->total_count_++;
-    this->total_time_ms_ += duration_ms;
-    if (duration_ms > this->total_max_time_ms_)
-      this->total_max_time_ms_ = duration_ms;
+    this->total_time_us_ += duration_us;
+    if (duration_us > this->total_max_time_us_)
+      this->total_max_time_us_ = duration_us;
   }
 
   void reset_period_stats() {
     this->period_count_ = 0;
-    this->period_time_ms_ = 0;
-    this->period_max_time_ms_ = 0;
+    this->period_time_us_ = 0;
+    this->period_max_time_us_ = 0;
   }
 
   // Period stats (reset each logging interval)
   uint32_t get_period_count() const { return this->period_count_; }
-  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
-  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
-  float get_period_avg_time_ms() const {
-    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
+  uint32_t get_period_time_us() const { return this->period_time_us_; }
+  uint32_t get_period_max_time_us() const { return this->period_max_time_us_; }
+  float get_period_avg_time_us() const {
+    return this->period_count_ > 0 ? this->period_time_us_ / static_cast<float>(this->period_count_) : 0.0f;
   }
 
-  // Total stats (persistent until reboot)
+  // Total stats (persistent until reboot, uint64_t to avoid overflow)
   uint32_t get_total_count() const { return this->total_count_; }
-  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
-  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
-  float get_total_avg_time_ms() const {
-    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
+  uint64_t get_total_time_us() const { return this->total_time_us_; }
+  uint32_t get_total_max_time_us() const { return this->total_max_time_us_; }
+  float get_total_avg_time_us() const {
+    return this->total_count_ > 0 ? this->total_time_us_ / static_cast<float>(this->total_count_) : 0.0f;
   }
 
  protected:
   // Period stats (reset each logging interval)
   uint32_t period_count_;
-  uint32_t period_time_ms_;
-  uint32_t period_max_time_ms_;
+  uint32_t period_time_us_;
+  uint32_t period_max_time_us_;
 
   // Total stats (persistent until reboot)
   uint32_t total_count_;
-  uint32_t total_time_ms_;
-  uint32_t total_max_time_ms_;
+  uint64_t total_time_us_;
+  uint32_t total_max_time_us_;
 };
 
 class RuntimeStatsCollector {
@@ -83,7 +83,7 @@ class RuntimeStatsCollector {
   void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
   uint32_t get_log_interval() const { return this->log_interval_; }
 
-  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
+  void record_component_time(Component *component, uint32_t duration_us, uint32_t current_time);
 
   // Process any pending stats printing (should be called after component loop)
   void process_pending_stats(uint32_t current_time);
diff --git a/esphome/components/ruuvi_ble/ruuvi_ble.cpp b/esphome/components/ruuvi_ble/ruuvi_ble.cpp
index 1b126bdef0e..bf088873ce0 100644
--- a/esphome/components/ruuvi_ble/ruuvi_ble.cpp
+++ b/esphome/components/ruuvi_ble/ruuvi_ble.cpp
@@ -63,10 +63,13 @@ bool parse_ruuvi_data_byte(const esp32_ble_tracker::adv_data_t &adv_data, RuuviP
       result.acceleration_x = data[6] == 0xFF && data[7] == 0xFF ? NAN : acceleration_x;
       result.acceleration_y = data[8] == 0xFF && data[9] == 0xFF ? NAN : acceleration_y;
       result.acceleration_z = data[10] == 0xFF && data[11] == 0xFF ? NAN : acceleration_z;
-      result.acceleration = result.acceleration_x == NAN || result.acceleration_y == NAN || result.acceleration_z == NAN
-                                ? NAN
-                                : sqrtf(acceleration_x * acceleration_x + acceleration_y * acceleration_y +
-                                        acceleration_z * acceleration_z);
+      if ((data[6] != 0xFF || data[7] != 0xFF) && (data[8] != 0xFF || data[9] != 0xFF) &&
+          (data[10] != 0xFF || data[11] != 0xFF)) {
+        result.acceleration =
+            sqrtf(acceleration_x * acceleration_x + acceleration_y * acceleration_y + acceleration_z * acceleration_z);
+      } else {
+        result.acceleration = NAN;
+      }
       result.battery_voltage = (power_info >> 5) == 0x7FF ? NAN : battery_voltage;
       result.tx_power = (power_info & 0x1F) == 0x1F ? NAN : tx_power;
       result.movement_counter = movement_counter;
diff --git a/esphome/components/scd4x/scd4x.cpp b/esphome/components/scd4x/scd4x.cpp
index a265386cc2f..0c108fba9d6 100644
--- a/esphome/components/scd4x/scd4x.cpp
+++ b/esphome/components/scd4x/scd4x.cpp
@@ -307,7 +307,7 @@ bool SCD4XComponent::start_measurement_() {
       break;
   }
 
-  static uint8_t remaining_retries = 3;
+  uint8_t remaining_retries = 3;
   while (remaining_retries) {
     if (!this->write_command(measurement_command)) {
       ESP_LOGE(TAG, "Error starting measurements");
@@ -316,6 +316,7 @@ bool SCD4XComponent::start_measurement_() {
       if (--remaining_retries == 0)
         return false;
       delay(50);  // NOLINT wait 50 ms and try again
+      continue;
     }
     this->status_clear_warning();
     return true;
diff --git a/esphome/components/select/select_call.cpp b/esphome/components/select/select_call.cpp
index 2ff99c961d6..45fb42c1160 100644
--- a/esphome/components/select/select_call.cpp
+++ b/esphome/components/select/select_call.cpp
@@ -69,7 +69,7 @@ optional<size_t> SelectCall::calculate_target_index_(const char *name) {
       ESP_LOGW(TAG, "'%s' - No option set", name);
       return {};
     }
-    return this->index_.value();
+    return this->index_;
   }
 
   // SELECT_OP_NEXT or SELECT_OP_PREVIOUS
diff --git a/esphome/components/sgp30/sgp30.cpp b/esphome/components/sgp30/sgp30.cpp
index 18814405d48..35e5b3dd42b 100644
--- a/esphome/components/sgp30/sgp30.cpp
+++ b/esphome/components/sgp30/sgp30.cpp
@@ -41,7 +41,9 @@ void SGP30Component::setup() {
     this->mark_failed();
     return;
   }
-  this->serial_number_ = encode_uint24(raw_serial_number[0], raw_serial_number[1], raw_serial_number[2]);
+  this->serial_number_ = (static_cast<uint64_t>(raw_serial_number[0]) << 32) |
+                         (static_cast<uint64_t>(raw_serial_number[1]) << 16) |
+                         static_cast<uint64_t>(raw_serial_number[2]);
   ESP_LOGD(TAG, "Serial number: %" PRIu64, this->serial_number_);
 
   // Featureset identification for future use
diff --git a/esphome/components/sgp4x/sgp4x.h b/esphome/components/sgp4x/sgp4x.h
index 8b31bca28cf..89fa627c61c 100644
--- a/esphome/components/sgp4x/sgp4x.h
+++ b/esphome/components/sgp4x/sgp4x.h
@@ -81,22 +81,16 @@ class SGP4xComponent : public PollingComponent, public sensor::Sensor, public se
   void set_voc_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
                                 uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
                                 uint16_t std_initial, uint16_t gain_factor) {
-    voc_tuning_params_.value().index_offset = index_offset;
-    voc_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
-    voc_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
-    voc_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
-    voc_tuning_params_.value().std_initial = std_initial;
-    voc_tuning_params_.value().gain_factor = gain_factor;
+    this->voc_tuning_params_ = GasTuning{
+        index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial,
+        gain_factor};
   }
   void set_nox_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
                                 uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
                                 uint16_t gain_factor) {
-    nox_tuning_params_.value().index_offset = index_offset;
-    nox_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
-    nox_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
-    nox_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
-    nox_tuning_params_.value().std_initial = 50;
-    nox_tuning_params_.value().gain_factor = gain_factor;
+    this->nox_tuning_params_ =
+        GasTuning{index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, 50,
+                  gain_factor};
   }
 
  protected:
diff --git a/esphome/components/sht4x/sht4x.cpp b/esphome/components/sht4x/sht4x.cpp
index 9d29746f0bf..42be3262029 100644
--- a/esphome/components/sht4x/sht4x.cpp
+++ b/esphome/components/sht4x/sht4x.cpp
@@ -10,7 +10,7 @@ static const uint8_t MEASURECOMMANDS[] = {0xFD, 0xF6, 0xE0};
 static const uint8_t SERIAL_NUMBER_COMMAND = 0x89;
 
 void SHT4XComponent::start_heater_() {
-  uint8_t cmd[] = {MEASURECOMMANDS[this->heater_command_]};
+  uint8_t cmd[] = {this->heater_command_};
 
   ESP_LOGD(TAG, "Heater turning on");
   if (this->write(cmd, 1) != i2c::ERROR_OK) {
diff --git a/esphome/components/sim800l/sim800l.cpp b/esphome/components/sim800l/sim800l.cpp
index 2115c72cefa..913d920c94e 100644
--- a/esphome/components/sim800l/sim800l.cpp
+++ b/esphome/components/sim800l/sim800l.cpp
@@ -196,7 +196,8 @@ void Sim800LComponent::parse_cmd_(std::string message) {
     case STATE_CREG_WAIT: {
       // Response: "+CREG: 0,1" -- the one there means registered ok
       //           "+CREG: -,-" means not registered ok
-      bool registered = message.compare(0, 6, "+CREG:") == 0 && (message[9] == '1' || message[9] == '5');
+      bool registered =
+          message.size() > 9 && message.compare(0, 6, "+CREG:") == 0 && (message[9] == '1' || message[9] == '5');
       if (registered) {
         if (!this->registered_) {
           ESP_LOGD(TAG, "Registered OK");
@@ -205,7 +206,7 @@ void Sim800LComponent::parse_cmd_(std::string message) {
         this->expect_ack_ = true;
       } else {
         ESP_LOGW(TAG, "Registration Fail");
-        if (message[7] == '0') {  // Network registration is disable, enable it
+        if (message.size() > 7 && message[7] == '0') {  // Network registration is disabled, enable it
           send_cmd_("AT+CREG=1");
           this->expect_ack_ = true;
           this->state_ = STATE_SETUP_CMGF;
diff --git a/esphome/components/sml/sml_parser.cpp b/esphome/components/sml/sml_parser.cpp
index 16e37949dc7..ed086e385d2 100644
--- a/esphome/components/sml/sml_parser.cpp
+++ b/esphome/components/sml/sml_parser.cpp
@@ -35,6 +35,8 @@ bool SmlFile::setup_node(SmlNode *node) {
 
   // Check if we need additional length bytes
   if (overlength) {
+    if (this->pos_ + 1 >= this->buffer_.size())
+      return false;
     // Shift the current length to the higher nibble
     // and add the lower nibble of the next byte to the length
     length = (length << 4) + (this->buffer_[this->pos_ + 1] & 0x0f);
diff --git a/esphome/components/speaker/media_player/audio_pipeline.cpp b/esphome/components/speaker/media_player/audio_pipeline.cpp
index 177743feb1d..8cea3abcfc9 100644
--- a/esphome/components/speaker/media_player/audio_pipeline.cpp
+++ b/esphome/components/speaker/media_player/audio_pipeline.cpp
@@ -87,20 +87,20 @@ void AudioPipeline::set_pause_state(bool pause_state) {
 }
 
 void AudioPipeline::suspend_tasks() {
-  if (this->read_task_handle_ != nullptr) {
-    vTaskSuspend(this->read_task_handle_);
+  if (this->read_task_.is_created()) {
+    vTaskSuspend(this->read_task_.get_handle());
   }
-  if (this->decode_task_handle_ != nullptr) {
-    vTaskSuspend(this->decode_task_handle_);
+  if (this->decode_task_.is_created()) {
+    vTaskSuspend(this->decode_task_.get_handle());
   }
 }
 
 void AudioPipeline::resume_tasks() {
-  if (this->read_task_handle_ != nullptr) {
-    vTaskResume(this->read_task_handle_);
+  if (this->read_task_.is_created()) {
+    vTaskResume(this->read_task_.get_handle());
   }
-  if (this->decode_task_handle_ != nullptr) {
-    vTaskResume(this->decode_task_handle_);
+  if (this->decode_task_.is_created()) {
+    vTaskResume(this->decode_task_.get_handle());
   }
 }
 
@@ -159,7 +159,7 @@ AudioPipelineState AudioPipeline::process_state() {
     // Init command pending
     if (!(event_bits & EventGroupBits::PIPELINE_COMMAND_STOP)) {
       // Only start if there is no pending stop command
-      if ((this->read_task_handle_ == nullptr) || (this->decode_task_handle_ == nullptr)) {
+      if (!this->read_task_.is_created() || !this->decode_task_.is_created()) {
         // At least one task isn't running
         this->start_tasks_();
       }
@@ -202,8 +202,9 @@ AudioPipelineState AudioPipeline::process_state() {
 
     if (!this->is_playing_) {
       // The tasks have been stopped for two ``process_state`` calls in a row, so delete the tasks
-      if ((this->read_task_handle_ != nullptr) || (this->decode_task_handle_ != nullptr)) {
-        this->delete_tasks_();
+      if (this->read_task_.is_created() || this->decode_task_.is_created()) {
+        this->read_task_.deallocate();
+        this->decode_task_.deallocate();
         if (this->hard_stop_) {
           // Stop command was sent, so immediately end the playback
           this->speaker_->stop();
@@ -234,7 +235,7 @@ AudioPipelineState AudioPipeline::process_state() {
     }
   }
 
-  if ((this->read_task_handle_ == nullptr) && (this->decode_task_handle_ == nullptr)) {
+  if (!this->read_task_.is_created() && !this->decode_task_.is_created()) {
     // No tasks are running, so the pipeline is stopped.
     xEventGroupClearBits(this->event_group_, EventGroupBits::PIPELINE_COMMAND_STOP);
     return AudioPipelineState::STOPPED;
@@ -262,94 +263,25 @@ esp_err_t AudioPipeline::allocate_communications_() {
 }
 
 esp_err_t AudioPipeline::start_tasks_() {
-  if (this->read_task_handle_ == nullptr) {
-    if (this->read_task_stack_buffer_ == nullptr) {
-      // Reader task uses the AudioReader class which uses esp_http_client. This crashes on IDF 5.4 if the task stack is
-      // in PSRAM. As a workaround, always allocate the read task in internal memory.
-      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-      this->read_task_stack_buffer_ = stack_allocator.allocate(READ_TASK_STACK_SIZE);
-    }
-
-    if (this->read_task_stack_buffer_ == nullptr) {
+  if (!this->read_task_.is_created()) {
+    // Reader task uses the AudioReader class which uses esp_http_client. This crashes on IDF 5.4 if the task stack is
+    // in PSRAM. As a workaround, always allocate the read task in internal memory.
+    if (!this->read_task_.create(read_task, (this->base_name_ + "_read").c_str(), READ_TASK_STACK_SIZE, (void *) this,
+                                 this->priority_, false)) {
       return ESP_ERR_NO_MEM;
     }
-
-    if (this->read_task_handle_ == nullptr) {
-      this->read_task_handle_ =
-          xTaskCreateStatic(read_task, (this->base_name_ + "_read").c_str(), READ_TASK_STACK_SIZE, (void *) this,
-                            this->priority_, this->read_task_stack_buffer_, &this->read_task_stack_);
-    }
-
-    if (this->read_task_handle_ == nullptr) {
-      return ESP_ERR_INVALID_STATE;
-    }
   }
 
-  if (this->decode_task_handle_ == nullptr) {
-    if (this->decode_task_stack_buffer_ == nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        this->decode_task_stack_buffer_ = stack_allocator.allocate(DECODE_TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        this->decode_task_stack_buffer_ = stack_allocator.allocate(DECODE_TASK_STACK_SIZE);
-      }
-    }
-
-    if (this->decode_task_stack_buffer_ == nullptr) {
+  if (!this->decode_task_.is_created()) {
+    if (!this->decode_task_.create(decode_task, (this->base_name_ + "_decode").c_str(), DECODE_TASK_STACK_SIZE,
+                                   (void *) this, this->priority_, this->task_stack_in_psram_)) {
       return ESP_ERR_NO_MEM;
     }
-
-    if (this->decode_task_handle_ == nullptr) {
-      this->decode_task_handle_ =
-          xTaskCreateStatic(decode_task, (this->base_name_ + "_decode").c_str(), DECODE_TASK_STACK_SIZE, (void *) this,
-                            this->priority_, this->decode_task_stack_buffer_, &this->decode_task_stack_);
-    }
-
-    if (this->decode_task_handle_ == nullptr) {
-      return ESP_ERR_INVALID_STATE;
-    }
   }
 
   return ESP_OK;
 }
 
-void AudioPipeline::delete_tasks_() {
-  if (this->read_task_handle_ != nullptr) {
-    vTaskDelete(this->read_task_handle_);
-
-    if (this->read_task_stack_buffer_ != nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        stack_allocator.deallocate(this->read_task_stack_buffer_, READ_TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        stack_allocator.deallocate(this->read_task_stack_buffer_, READ_TASK_STACK_SIZE);
-      }
-
-      this->read_task_stack_buffer_ = nullptr;
-      this->read_task_handle_ = nullptr;
-    }
-  }
-
-  if (this->decode_task_handle_ != nullptr) {
-    vTaskDelete(this->decode_task_handle_);
-
-    if (this->decode_task_stack_buffer_ != nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        stack_allocator.deallocate(this->decode_task_stack_buffer_, DECODE_TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        stack_allocator.deallocate(this->decode_task_stack_buffer_, DECODE_TASK_STACK_SIZE);
-      }
-
-      this->decode_task_stack_buffer_ = nullptr;
-      this->decode_task_handle_ = nullptr;
-    }
-  }
-}
-
 void AudioPipeline::read_task(void *params) {
   AudioPipeline *this_pipeline = (AudioPipeline *) params;
 
diff --git a/esphome/components/speaker/media_player/audio_pipeline.h b/esphome/components/speaker/media_player/audio_pipeline.h
index 6fffde6c206..2c785728359 100644
--- a/esphome/components/speaker/media_player/audio_pipeline.h
+++ b/esphome/components/speaker/media_player/audio_pipeline.h
@@ -8,10 +8,10 @@
 #include "esphome/components/speaker/speaker.h"
 
 #include "esphome/core/ring_buffer.h"
+#include "esphome/core/static_task.h"
 
 #include "esp_err.h"
 
-#include <freertos/FreeRTOS.h>
 #include <freertos/event_groups.h>
 #include <freertos/queue.h>
 
@@ -104,9 +104,6 @@ class AudioPipeline {
   /// @return ESP_OK if successful or an appropriate error if not
   esp_err_t start_tasks_();
 
-  /// @brief Resets the task related pointers and deallocates their stacks.
-  void delete_tasks_();
-
   std::string base_name_;
   UBaseType_t priority_;
 
@@ -143,15 +140,11 @@ class AudioPipeline {
 
   // Handles reading the media file from flash or a url
   static void read_task(void *params);
-  TaskHandle_t read_task_handle_{nullptr};
-  StaticTask_t read_task_stack_;
-  StackType_t *read_task_stack_buffer_{nullptr};
+  StaticTask read_task_;
 
   // Decodes the media file into PCM audio
   static void decode_task(void *params);
-  TaskHandle_t decode_task_handle_{nullptr};
-  StaticTask_t decode_task_stack_;
-  StackType_t *decode_task_stack_buffer_{nullptr};
+  StaticTask decode_task_;
 };
 
 }  // namespace speaker
diff --git a/esphome/components/speaker/media_player/speaker_media_player.cpp b/esphome/components/speaker/media_player/speaker_media_player.cpp
index 3f5cb2fda62..9f168f854d8 100644
--- a/esphome/components/speaker/media_player/speaker_media_player.cpp
+++ b/esphome/components/speaker/media_player/speaker_media_player.cpp
@@ -144,7 +144,7 @@ void SpeakerMediaPlayer::watch_media_commands_() {
         delete media_command.url.value();
       }
       if (media_command.file.has_value()) {
-        playlist_item.file = media_command.file.value();
+        playlist_item.file = media_command.file;
       }
 
       if (this->single_pipeline_() || (media_command.announce.has_value() && media_command.announce.value())) {
@@ -495,18 +495,21 @@ void SpeakerMediaPlayer::control(const media_player::MediaPlayerCall &call) {
 
   MediaCallCommand media_command;
 
-  if (this->single_pipeline_() || (call.get_announcement().has_value() && call.get_announcement().value())) {
+  auto ann = call.get_announcement();
+  if (this->single_pipeline_() || (ann.has_value() && *ann)) {
     media_command.announce = true;
   } else {
     media_command.announce = false;
   }
 
-  if (call.get_media_url().has_value()) {
-    media_command.url = new std::string(
-        call.get_media_url().value());  // Must be manually deleted after receiving media_command from a queue
+  auto media_url = call.get_media_url();
+  if (media_url.has_value()) {
+    media_command.url =
+        new std::string(*media_url);  // Must be manually deleted after receiving media_command from a queue
 
-    if (call.get_command().has_value()) {
-      if (call.get_command().value() == media_player::MEDIA_PLAYER_COMMAND_ENQUEUE) {
+    auto cmd = call.get_command();
+    if (cmd.has_value()) {
+      if (*cmd == media_player::MEDIA_PLAYER_COMMAND_ENQUEUE) {
         media_command.enqueue = true;
       }
     }
@@ -515,18 +518,20 @@ void SpeakerMediaPlayer::control(const media_player::MediaPlayerCall &call) {
     return;
   }
 
-  if (call.get_volume().has_value()) {
-    media_command.volume = call.get_volume().value();
+  auto vol = call.get_volume();
+  if (vol.has_value()) {
+    media_command.volume = vol;
     // Wait 0 ticks for queue to be free, volume sets aren't that important!
     xQueueSend(this->media_control_command_queue_, &media_command, 0);
     return;
   }
 
-  if (call.get_command().has_value()) {
-    media_command.command = call.get_command().value();
+  auto cmd = call.get_command();
+  if (cmd.has_value()) {
+    media_command.command = cmd;
     TickType_t ticks_to_wait = portMAX_DELAY;
-    if ((call.get_command().value() == media_player::MEDIA_PLAYER_COMMAND_VOLUME_UP) ||
-        (call.get_command().value() == media_player::MEDIA_PLAYER_COMMAND_VOLUME_DOWN)) {
+    if ((*cmd == media_player::MEDIA_PLAYER_COMMAND_VOLUME_UP) ||
+        (*cmd == media_player::MEDIA_PLAYER_COMMAND_VOLUME_DOWN)) {
       ticks_to_wait = 0;  // Wait 0 ticks for queue to be free, volume sets aren't that important!
     }
     xQueueSend(this->media_control_command_queue_, &media_command, ticks_to_wait);
diff --git a/esphome/components/speed/fan/speed_fan.cpp b/esphome/components/speed/fan/speed_fan.cpp
index 55f7fd162c2..d45237c4677 100644
--- a/esphome/components/speed/fan/speed_fan.cpp
+++ b/esphome/components/speed/fan/speed_fan.cpp
@@ -21,14 +21,18 @@ void SpeedFan::setup() {
 void SpeedFan::dump_config() { LOG_FAN("", "Speed Fan", this); }
 
 void SpeedFan::control(const fan::FanCall &call) {
-  if (call.get_state().has_value())
-    this->state = *call.get_state();
-  if (call.get_speed().has_value())
-    this->speed = *call.get_speed();
-  if (call.get_oscillating().has_value())
-    this->oscillating = *call.get_oscillating();
-  if (call.get_direction().has_value())
-    this->direction = *call.get_direction();
+  auto call_state = call.get_state();
+  if (call_state.has_value())
+    this->state = *call_state;
+  auto call_speed = call.get_speed();
+  if (call_speed.has_value())
+    this->speed = *call_speed;
+  auto call_oscillating = call.get_oscillating();
+  if (call_oscillating.has_value())
+    this->oscillating = *call_oscillating;
+  auto call_direction = call.get_direction();
+  if (call_direction.has_value())
+    this->direction = *call_direction;
   this->apply_preset_mode_(call);
 
   this->write_state_();
diff --git a/esphome/components/sprinkler/sprinkler.cpp b/esphome/components/sprinkler/sprinkler.cpp
index 44fb9092bc3..d1f74520540 100644
--- a/esphome/components/sprinkler/sprinkler.cpp
+++ b/esphome/components/sprinkler/sprinkler.cpp
@@ -44,7 +44,7 @@ SprinklerControllerSwitch::SprinklerControllerSwitch() = default;
 
 void SprinklerControllerSwitch::loop() {
   // Loop is only enabled when f_ has a value (see setup())
-  auto s = (*this->f_)();
+  auto s = (*this->f_)();  // NOLINT(bugprone-unchecked-optional-access)
   if (s.has_value()) {
     this->publish_state(*s);
   }
@@ -89,20 +89,21 @@ void SprinklerValveOperator::loop() {
   uint32_t now = App.get_loop_component_start_time();
   switch (this->state_) {
     case STARTING:
-      if ((now - *this->start_millis_) > this->start_delay_) {
+      if ((now - *this->start_millis_) > this->start_delay_) {  // NOLINT(bugprone-unchecked-optional-access)
         this->run_();  // start_delay_ has been exceeded, so ensure both valves are on and update the state
       }
       break;
 
     case ACTIVE:
-      if ((now - *this->start_millis_) > (this->start_delay_ + this->run_duration_)) {
+      if ((now - *this->start_millis_) >  // NOLINT(bugprone-unchecked-optional-access)
+          (this->start_delay_ + this->run_duration_)) {
         this->stop();  // start_delay_ + run_duration_ has been exceeded, start shutting down
       }
       break;
 
     case STOPPING:
-      if ((now - *this->stop_millis_) > this->stop_delay_) {
-        this->kill_();  // stop_delay_has been exceeded, ensure all valves are off
+      if ((now - *this->stop_millis_) > this->stop_delay_) {  // NOLINT(bugprone-unchecked-optional-access)
+        this->kill_();                                        // stop_delay_has been exceeded, ensure all valves are off
       }
       break;
 
@@ -1067,7 +1068,8 @@ uint32_t Sprinkler::total_cycle_time_enabled_incomplete_valves() {
     if (this->valve_is_enabled_(valve)) {
       enabled_valve_count++;
       if (!this->valve_cycle_complete_(valve)) {
-        if (!this->active_valve().has_value() || (valve != this->active_valve().value())) {
+        auto active = this->active_valve();
+        if (!active.has_value() || (valve != *active)) {
           total_time_remaining += this->valve_run_duration_adjusted(valve);
           incomplete_valve_count++;
         } else {
@@ -1190,8 +1192,11 @@ switch_::Switch *Sprinkler::valve_switch(const size_t valve_number) {
 }
 
 switch_::Switch *Sprinkler::valve_pump_switch(const size_t valve_number) {
-  if (this->is_a_valid_valve(valve_number) && this->valve_[valve_number].pump_switch_index.has_value()) {
-    return this->pump_[this->valve_[valve_number].pump_switch_index.value()];
+  if (this->is_a_valid_valve(valve_number)) {
+    auto idx = this->valve_[valve_number].pump_switch_index;
+    if (idx.has_value()) {
+      return this->pump_[*idx];
+    }
   }
   return nullptr;
 }
diff --git a/esphome/components/ssd1322_base/ssd1322_base.cpp b/esphome/components/ssd1322_base/ssd1322_base.cpp
index 23576e7b2c4..1fce826ad9d 100644
--- a/esphome/components/ssd1322_base/ssd1322_base.cpp
+++ b/esphome/components/ssd1322_base/ssd1322_base.cpp
@@ -169,7 +169,7 @@ void HOT SSD1322::draw_absolute_pixel_internal(int x, int y, Color color) {
   // ensure 'color4' is valid (only 4 bits aka 1 nibble) and shift the bits left when necessary
   color4 = (color4 & SSD1322_COLORMASK) << shift;
   // first mask off the nibble we must change...
-  this->buffer_[pos] &= (~SSD1322_COLORMASK >> shift);
+  this->buffer_[pos] &= (static_cast<uint8_t>(~SSD1322_COLORMASK) >> shift);
   // ...then lay the new nibble back on top. done!
   this->buffer_[pos] |= color4;
 }
diff --git a/esphome/components/ssd1325_base/ssd1325_base.cpp b/esphome/components/ssd1325_base/ssd1325_base.cpp
index e7d2386ac71..fe7df9674b6 100644
--- a/esphome/components/ssd1325_base/ssd1325_base.cpp
+++ b/esphome/components/ssd1325_base/ssd1325_base.cpp
@@ -202,7 +202,7 @@ void HOT SSD1325::draw_absolute_pixel_internal(int x, int y, Color color) {
   // ensure 'color4' is valid (only 4 bits aka 1 nibble) and shift the bits left when necessary
   color4 = (color4 & SSD1325_COLORMASK) << shift;
   // first mask off the nibble we must change...
-  this->buffer_[pos] &= (~SSD1325_COLORMASK >> shift);
+  this->buffer_[pos] &= (static_cast<uint8_t>(~SSD1325_COLORMASK) >> shift);
   // ...then lay the new nibble back on top. done!
   this->buffer_[pos] |= color4;
 }
diff --git a/esphome/components/ssd1327_base/ssd1327_base.cpp b/esphome/components/ssd1327_base/ssd1327_base.cpp
index 2498bfcd67c..87e52206f2d 100644
--- a/esphome/components/ssd1327_base/ssd1327_base.cpp
+++ b/esphome/components/ssd1327_base/ssd1327_base.cpp
@@ -145,7 +145,7 @@ void HOT SSD1327::draw_absolute_pixel_internal(int x, int y, Color color) {
   // ensure 'color4' is valid (only 4 bits aka 1 nibble) and shift the bits left when necessary
   color4 = (color4 & SSD1327_COLORMASK) << shift;
   // first mask off the nibble we must change...
-  this->buffer_[pos] &= (~SSD1327_COLORMASK >> shift);
+  this->buffer_[pos] &= (static_cast<uint8_t>(~SSD1327_COLORMASK) >> shift);
   // ...then lay the new nibble back on top. done!
   this->buffer_[pos] |= color4;
 }
diff --git a/esphome/components/sx127x/sx127x.cpp b/esphome/components/sx127x/sx127x.cpp
index caf68b6d513..f6aa11b6347 100644
--- a/esphome/components/sx127x/sx127x.cpp
+++ b/esphome/components/sx127x/sx127x.cpp
@@ -186,7 +186,7 @@ void SX127x::configure_fsk_ook_() {
   } else {
     this->write_register_(REG_PREAMBLE_DETECT, PREAMBLE_DETECTOR_OFF);
   }
-  this->write_register_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_ >> 16);
+  this->write_register_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_ >> 8);
   this->write_register_(REG_PREAMBLE_SIZE_LSB, this->preamble_size_ & 0xFF);
 
   // config sync generation and setup ook threshold
@@ -214,7 +214,7 @@ void SX127x::configure_lora_() {
 
   // config preamble
   if (this->preamble_size_ >= 6) {
-    this->write_register_(REG_PREAMBLE_LEN_MSB, this->preamble_size_ >> 16);
+    this->write_register_(REG_PREAMBLE_LEN_MSB, this->preamble_size_ >> 8);
     this->write_register_(REG_PREAMBLE_LEN_LSB, this->preamble_size_ & 0xFF);
   }
 
diff --git a/esphome/components/sx1509/sx1509.cpp b/esphome/components/sx1509/sx1509.cpp
index 746ec9cda35..dfe1277297a 100644
--- a/esphome/components/sx1509/sx1509.cpp
+++ b/esphome/components/sx1509/sx1509.cpp
@@ -56,11 +56,11 @@ void SX1509Component::loop() {
       return;
     }
     int row, col;
-    for (row = 0; row < 7; row++) {
+    for (row = 0; row < 8; row++) {
       if (key_data & (1 << row))
         break;
     }
-    for (col = 8; col < 15; col++) {
+    for (col = 8; col < 16; col++) {
       if (key_data & (1 << col))
         break;
     }
@@ -229,7 +229,7 @@ void SX1509Component::setup_keypad_() {
   this->read_byte_16(REG_DIR_B, &this->ddr_mask_);
   for (int i = 0; i < this->rows_; i++)
     this->ddr_mask_ &= ~(1 << i);
-  for (int i = 8; i < (this->cols_ * 2); i++)
+  for (int i = 8; i < (8 + this->cols_); i++)
     this->ddr_mask_ |= (1 << i);
   this->write_byte_16(REG_DIR_B, this->ddr_mask_);
 
diff --git a/esphome/components/tcl112/tcl112.cpp b/esphome/components/tcl112/tcl112.cpp
index a88e8e96a7e..afeee3d7396 100644
--- a/esphome/components/tcl112/tcl112.cpp
+++ b/esphome/components/tcl112/tcl112.cpp
@@ -89,7 +89,7 @@ void Tcl112Climate::transmit_state() {
 
   // Set fan
   uint8_t selected_fan;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_HIGH:
       selected_fan = TCL112_FAN_HIGH;
       break;
diff --git a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
index 09efe678ce2..651aa3c489e 100644
--- a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
+++ b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
@@ -257,14 +257,16 @@ void TemplateAlarmControlPanel::bypass_before_arming() {
 }
 
 void TemplateAlarmControlPanel::control(const AlarmControlPanelCall &call) {
-  if (call.get_state()) {
-    if (call.get_state() == ACP_STATE_ARMED_AWAY) {
+  auto opt_state = call.get_state();
+  if (opt_state) {
+    auto state = *opt_state;
+    if (state == ACP_STATE_ARMED_AWAY) {
       this->arm_(call.get_code(), ACP_STATE_ARMED_AWAY, this->arming_away_time_);
-    } else if (call.get_state() == ACP_STATE_ARMED_HOME) {
+    } else if (state == ACP_STATE_ARMED_HOME) {
       this->arm_(call.get_code(), ACP_STATE_ARMED_HOME, this->arming_home_time_);
-    } else if (call.get_state() == ACP_STATE_ARMED_NIGHT) {
+    } else if (state == ACP_STATE_ARMED_NIGHT) {
       this->arm_(call.get_code(), ACP_STATE_ARMED_NIGHT, this->arming_night_time_);
-    } else if (call.get_state() == ACP_STATE_DISARMED) {
+    } else if (state == ACP_STATE_DISARMED) {
       if (!this->is_code_valid_(call.get_code())) {
         ESP_LOGW(TAG, "Not disarming code doesn't match");
         return;
@@ -274,13 +276,12 @@ void TemplateAlarmControlPanel::control(const AlarmControlPanelCall &call) {
 #ifdef USE_BINARY_SENSOR
       this->bypassed_sensor_indicies_.clear();
 #endif
-    } else if (call.get_state() == ACP_STATE_TRIGGERED) {
+    } else if (state == ACP_STATE_TRIGGERED) {
       this->publish_state(ACP_STATE_TRIGGERED);
-    } else if (call.get_state() == ACP_STATE_PENDING) {
+    } else if (state == ACP_STATE_PENDING) {
       this->publish_state(ACP_STATE_PENDING);
     } else {
-      ESP_LOGE(TAG, "State not yet implemented: %s",
-               LOG_STR_ARG(alarm_control_panel_state_to_string(*call.get_state())));
+      ESP_LOGE(TAG, "State not yet implemented: %s", LOG_STR_ARG(alarm_control_panel_state_to_string(state)));
     }
   }
 }
diff --git a/esphome/components/template/cover/template_cover.cpp b/esphome/components/template/cover/template_cover.cpp
index 7f5d68623fa..d5e0967e1e3 100644
--- a/esphome/components/template/cover/template_cover.cpp
+++ b/esphome/components/template/cover/template_cover.cpp
@@ -74,8 +74,9 @@ void TemplateCover::control(const CoverCall &call) {
     this->prev_command_trigger_ = &this->toggle_trigger_;
     this->publish_state();
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto pos_val = call.get_position();
+  if (pos_val.has_value()) {
+    auto pos = *pos_val;
     this->stop_prev_trigger_();
 
     if (pos == COVER_OPEN) {
@@ -93,8 +94,9 @@ void TemplateCover::control(const CoverCall &call) {
     }
   }
 
-  if (call.get_tilt().has_value()) {
-    auto tilt = *call.get_tilt();
+  auto tilt_val = call.get_tilt();
+  if (tilt_val.has_value()) {
+    auto tilt = *tilt_val;
     this->tilt_trigger_.trigger(tilt);
 
     if (this->optimistic_) {
diff --git a/esphome/components/template/datetime/template_date.cpp b/esphome/components/template/datetime/template_date.cpp
index 8a5f11b876d..c0f5d96c3da 100644
--- a/esphome/components/template/datetime/template_date.cpp
+++ b/esphome/components/template/datetime/template_date.cpp
@@ -48,46 +48,49 @@ void TemplateDate::update() {
 }
 
 void TemplateDate::control(const datetime::DateCall &call) {
-  bool has_year = call.get_year().has_value();
-  bool has_month = call.get_month().has_value();
-  bool has_day = call.get_day().has_value();
+  auto opt_year = call.get_year();
+  auto opt_month = call.get_month();
+  auto opt_day = call.get_day();
+  bool has_year = opt_year.has_value();
+  bool has_month = opt_month.has_value();
+  bool has_day = opt_day.has_value();
 
   ESPTime value = {};
   if (has_year)
-    value.year = *call.get_year();
+    value.year = *opt_year;
 
   if (has_month)
-    value.month = *call.get_month();
+    value.month = *opt_month;
 
   if (has_day)
-    value.day_of_month = *call.get_day();
+    value.day_of_month = *opt_day;
 
   this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_year)
-      this->year_ = *call.get_year();
+      this->year_ = *opt_year;
     if (has_month)
-      this->month_ = *call.get_month();
+      this->month_ = *opt_month;
     if (has_day)
-      this->day_ = *call.get_day();
+      this->day_ = *opt_day;
     this->publish_state();
   }
 
   if (this->restore_value_) {
     datetime::DateEntityRestoreState temp = {};
     if (has_year) {
-      temp.year = *call.get_year();
+      temp.year = *opt_year;
     } else {
       temp.year = this->year_;
     }
     if (has_month) {
-      temp.month = *call.get_month();
+      temp.month = *opt_month;
     } else {
       temp.month = this->month_;
     }
     if (has_day) {
-      temp.day = *call.get_day();
+      temp.day = *opt_day;
     } else {
       temp.day = this->day_;
     }
diff --git a/esphome/components/template/datetime/template_datetime.cpp b/esphome/components/template/datetime/template_datetime.cpp
index 269a1d06ca8..5b8b308c008 100644
--- a/esphome/components/template/datetime/template_datetime.cpp
+++ b/esphome/components/template/datetime/template_datetime.cpp
@@ -54,79 +54,85 @@ void TemplateDateTime::update() {
 }
 
 void TemplateDateTime::control(const datetime::DateTimeCall &call) {
-  bool has_year = call.get_year().has_value();
-  bool has_month = call.get_month().has_value();
-  bool has_day = call.get_day().has_value();
-  bool has_hour = call.get_hour().has_value();
-  bool has_minute = call.get_minute().has_value();
-  bool has_second = call.get_second().has_value();
+  auto opt_year = call.get_year();
+  auto opt_month = call.get_month();
+  auto opt_day = call.get_day();
+  auto opt_hour = call.get_hour();
+  auto opt_minute = call.get_minute();
+  auto opt_second = call.get_second();
+  bool has_year = opt_year.has_value();
+  bool has_month = opt_month.has_value();
+  bool has_day = opt_day.has_value();
+  bool has_hour = opt_hour.has_value();
+  bool has_minute = opt_minute.has_value();
+  bool has_second = opt_second.has_value();
 
   ESPTime value = {};
   if (has_year)
-    value.year = *call.get_year();
+    value.year = *opt_year;
 
   if (has_month)
-    value.month = *call.get_month();
+    value.month = *opt_month;
 
   if (has_day)
-    value.day_of_month = *call.get_day();
+    value.day_of_month = *opt_day;
 
   if (has_hour)
-    value.hour = *call.get_hour();
+    value.hour = *opt_hour;
 
   if (has_minute)
-    value.minute = *call.get_minute();
+    value.minute = *opt_minute;
 
   if (has_second)
-    value.second = *call.get_second();
+    value.second = *opt_second;
 
   this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_year)
-      this->year_ = *call.get_year();
+      this->year_ = *opt_year;
     if (has_month)
-      this->month_ = *call.get_month();
+      this->month_ = *opt_month;
     if (has_day)
-      this->day_ = *call.get_day();
+      this->day_ = *opt_day;
     if (has_hour)
-      this->hour_ = *call.get_hour();
+      this->hour_ = *opt_hour;
     if (has_minute)
-      this->minute_ = *call.get_minute();
+      this->minute_ = *opt_minute;
     if (has_second)
-      this->second_ = *call.get_second();
+      this->second_ = *opt_second;
     this->publish_state();
   }
 
   if (this->restore_value_) {
     datetime::DateTimeEntityRestoreState temp = {};
     if (has_year) {
-      temp.year = *call.get_year();
+      temp.year = *opt_year;
     } else {
       temp.year = this->year_;
     }
     if (has_month) {
-      temp.month = *call.get_month();
+      temp.month = *opt_month;
     } else {
       temp.month = this->month_;
     }
     if (has_day) {
-      temp.day = *call.get_day();
+      temp.day = *opt_day;
     } else {
       temp.day = this->day_;
     }
     if (has_hour) {
-      temp.hour = *call.get_hour();
+      temp.hour = *opt_hour;
     } else {
       temp.hour = this->hour_;
     }
     if (has_minute) {
-      temp.minute = *call.get_minute();
+      temp.minute = *opt_minute;
     } else {
       temp.minute = this->minute_;
     }
     if (has_second) {
-      temp.second = *call.get_second();
+      temp.second = *opt_second;
     } else {
       temp.second = this->second_;
     }
diff --git a/esphome/components/template/datetime/template_time.cpp b/esphome/components/template/datetime/template_time.cpp
index 9c816871168..b5efa62ae78 100644
--- a/esphome/components/template/datetime/template_time.cpp
+++ b/esphome/components/template/datetime/template_time.cpp
@@ -48,46 +48,49 @@ void TemplateTime::update() {
 }
 
 void TemplateTime::control(const datetime::TimeCall &call) {
-  bool has_hour = call.get_hour().has_value();
-  bool has_minute = call.get_minute().has_value();
-  bool has_second = call.get_second().has_value();
+  auto opt_hour = call.get_hour();
+  auto opt_minute = call.get_minute();
+  auto opt_second = call.get_second();
+  bool has_hour = opt_hour.has_value();
+  bool has_minute = opt_minute.has_value();
+  bool has_second = opt_second.has_value();
 
   ESPTime value = {};
   if (has_hour)
-    value.hour = *call.get_hour();
+    value.hour = *opt_hour;
 
   if (has_minute)
-    value.minute = *call.get_minute();
+    value.minute = *opt_minute;
 
   if (has_second)
-    value.second = *call.get_second();
+    value.second = *opt_second;
 
   this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_hour)
-      this->hour_ = *call.get_hour();
+      this->hour_ = *opt_hour;
     if (has_minute)
-      this->minute_ = *call.get_minute();
+      this->minute_ = *opt_minute;
     if (has_second)
-      this->second_ = *call.get_second();
+      this->second_ = *opt_second;
     this->publish_state();
   }
 
   if (this->restore_value_) {
     datetime::TimeEntityRestoreState temp = {};
     if (has_hour) {
-      temp.hour = *call.get_hour();
+      temp.hour = *opt_hour;
     } else {
       temp.hour = this->hour_;
     }
     if (has_minute) {
-      temp.minute = *call.get_minute();
+      temp.minute = *opt_minute;
     } else {
       temp.minute = this->minute_;
     }
     if (has_second) {
-      temp.second = *call.get_second();
+      temp.second = *opt_second;
     } else {
       temp.second = this->second_;
     }
diff --git a/esphome/components/template/fan/template_fan.cpp b/esphome/components/template/fan/template_fan.cpp
index cd267bd552c..46a5cba9bb3 100644
--- a/esphome/components/template/fan/template_fan.cpp
+++ b/esphome/components/template/fan/template_fan.cpp
@@ -20,14 +20,18 @@ void TemplateFan::setup() {
 void TemplateFan::dump_config() { LOG_FAN("", "Template Fan", this); }
 
 void TemplateFan::control(const fan::FanCall &call) {
-  if (call.get_state().has_value())
-    this->state = *call.get_state();
-  if (call.get_speed().has_value() && (this->speed_count_ > 0))
-    this->speed = *call.get_speed();
-  if (call.get_oscillating().has_value() && this->has_oscillating_)
-    this->oscillating = *call.get_oscillating();
-  if (call.get_direction().has_value() && this->has_direction_)
-    this->direction = *call.get_direction();
+  auto call_state = call.get_state();
+  if (call_state.has_value())
+    this->state = *call_state;
+  auto call_speed = call.get_speed();
+  if (call_speed.has_value() && (this->speed_count_ > 0))
+    this->speed = *call_speed;
+  auto call_oscillating = call.get_oscillating();
+  if (call_oscillating.has_value() && this->has_oscillating_)
+    this->oscillating = *call_oscillating;
+  auto call_direction = call.get_direction();
+  if (call_direction.has_value() && this->has_direction_)
+    this->direction = *call_direction;
   this->apply_preset_mode_(call);
 
   this->publish_state();
diff --git a/esphome/components/template/lock/template_lock.cpp b/esphome/components/template/lock/template_lock.cpp
index dbc4501ce71..6e73623ae9b 100644
--- a/esphome/components/template/lock/template_lock.cpp
+++ b/esphome/components/template/lock/template_lock.cpp
@@ -25,7 +25,10 @@ void TemplateLock::control(const lock::LockCall &call) {
     this->prev_trigger_->stop_action();
   }
 
-  auto state = *call.get_state();
+  auto opt_state = call.get_state();
+  if (!opt_state.has_value())
+    return;
+  auto state = *opt_state;
   if (state == LOCK_STATE_LOCKED) {
     this->prev_trigger_ = &this->lock_trigger_;
     this->lock_trigger_.trigger();
diff --git a/esphome/components/template/valve/template_valve.cpp b/esphome/components/template/valve/template_valve.cpp
index 2817e1a1327..3ebeec12856 100644
--- a/esphome/components/template/valve/template_valve.cpp
+++ b/esphome/components/template/valve/template_valve.cpp
@@ -77,8 +77,9 @@ void TemplateValve::control(const ValveCall &call) {
     this->prev_command_trigger_ = &this->toggle_trigger_;
     this->publish_state();
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto pos_val = call.get_position();
+  if (pos_val.has_value()) {
+    auto pos = *pos_val;
     this->stop_prev_trigger_();
 
     if (pos == VALVE_OPEN) {
diff --git a/esphome/components/template/water_heater/template_water_heater.cpp b/esphome/components/template/water_heater/template_water_heater.cpp
index 57c76286a0d..73081d204b4 100644
--- a/esphome/components/template/water_heater/template_water_heater.cpp
+++ b/esphome/components/template/water_heater/template_water_heater.cpp
@@ -101,9 +101,10 @@ water_heater::WaterHeaterCallInternal TemplateWaterHeater::make_call() {
 }
 
 void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
-  if (call.get_mode().has_value()) {
+  auto mode_val = call.get_mode();
+  if (mode_val.has_value()) {
     if (this->optimistic_) {
-      this->mode_ = *call.get_mode();
+      this->mode_ = *mode_val;
     }
   }
   if (!std::isnan(call.get_target_temperature())) {
@@ -112,14 +113,16 @@ void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
     }
   }
 
-  if (call.get_away().has_value()) {
+  auto away_val = call.get_away();
+  if (away_val.has_value()) {
     if (this->optimistic_) {
-      this->set_state_flag_(water_heater::WATER_HEATER_STATE_AWAY, *call.get_away());
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_AWAY, *away_val);
     }
   }
-  if (call.get_on().has_value()) {
+  auto on_val = call.get_on();
+  if (on_val.has_value()) {
     if (this->optimistic_) {
-      this->set_state_flag_(water_heater::WATER_HEATER_STATE_ON, *call.get_on());
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_ON, *on_val);
     }
   }
 
diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp
index c6664197010..d52a22f880d 100644
--- a/esphome/components/thermostat/thermostat_climate.cpp
+++ b/esphome/components/thermostat/thermostat_climate.cpp
@@ -84,7 +84,7 @@ void ThermostatClimate::refresh() {
   this->switch_to_mode_(this->mode, false);
   this->switch_to_action_(this->compute_action_(), false);
   this->switch_to_supplemental_action_(this->compute_supplemental_action_());
-  this->switch_to_fan_mode_(this->fan_mode.value(), false);
+  this->switch_to_fan_mode_(this->fan_mode.value_or(climate::CLIMATE_FAN_ON), false);
   this->switch_to_swing_mode_(this->swing_mode, false);
   this->switch_to_humidity_control_action_(this->compute_humidity_control_action_());
   this->check_humidity_change_trigger_();
@@ -211,12 +211,13 @@ void ThermostatClimate::validate_target_humidity() {
 void ThermostatClimate::control(const climate::ClimateCall &call) {
   bool target_temperature_high_changed = false;
 
-  if (call.get_preset().has_value()) {
+  auto preset = call.get_preset();
+  if (preset.has_value()) {
     // setup_complete_ blocks modifying/resetting the temps immediately after boot
     if (this->setup_complete_) {
-      this->change_preset_(call.get_preset().value());
+      this->change_preset_(*preset);
     } else {
-      this->preset = call.get_preset().value();
+      this->preset = preset;
     }
   }
   if (call.has_custom_preset()) {
@@ -229,34 +230,41 @@ void ThermostatClimate::control(const climate::ClimateCall &call) {
     }
   }
 
-  if (call.get_mode().has_value()) {
-    this->mode = call.get_mode().value();
+  auto mode = call.get_mode();
+  if (mode.has_value()) {
+    this->mode = *mode;
   }
-  if (call.get_fan_mode().has_value()) {
-    this->fan_mode = call.get_fan_mode().value();
+  auto fan_mode = call.get_fan_mode();
+  if (fan_mode.has_value()) {
+    this->fan_mode = fan_mode;
   }
-  if (call.get_swing_mode().has_value()) {
-    this->swing_mode = call.get_swing_mode().value();
+  auto swing_mode = call.get_swing_mode();
+  if (swing_mode.has_value()) {
+    this->swing_mode = *swing_mode;
   }
   if (this->supports_two_points_) {
-    if (call.get_target_temperature_low().has_value()) {
-      this->target_temperature_low = call.get_target_temperature_low().value();
+    auto target_temp_low = call.get_target_temperature_low();
+    if (target_temp_low.has_value()) {
+      this->target_temperature_low = *target_temp_low;
     }
-    if (call.get_target_temperature_high().has_value()) {
-      target_temperature_high_changed = this->target_temperature_high != call.get_target_temperature_high().value();
-      this->target_temperature_high = call.get_target_temperature_high().value();
+    auto target_temp_high = call.get_target_temperature_high();
+    if (target_temp_high.has_value()) {
+      target_temperature_high_changed = this->target_temperature_high != *target_temp_high;
+      this->target_temperature_high = *target_temp_high;
     }
     // ensure the two set points are valid and adjust one of them if necessary
     this->validate_target_temperatures(target_temperature_high_changed ||
                                        (this->prev_mode_ == climate::CLIMATE_MODE_COOL));
   } else {
-    if (call.get_target_temperature().has_value()) {
-      this->target_temperature = call.get_target_temperature().value();
+    auto target_temp = call.get_target_temperature();
+    if (target_temp.has_value()) {
+      this->target_temperature = *target_temp;
       this->validate_target_temperature();
     }
   }
-  if (call.get_target_humidity().has_value()) {
-    this->target_humidity = call.get_target_humidity().value();
+  auto target_humidity = call.get_target_humidity();
+  if (target_humidity.has_value()) {
+    this->target_humidity = *target_humidity;
     this->validate_target_humidity();
   }
   // make any changes happen
@@ -1264,9 +1272,9 @@ bool ThermostatClimate::change_preset_internal_(const ThermostatClimateTargetTem
     something_changed = true;
   }
 
-  if (config.fan_mode_.has_value() && (this->fan_mode != config.fan_mode_.value())) {
+  if (config.fan_mode_.has_value() && (this->fan_mode != config.fan_mode_)) {
     ESP_LOGV(TAG, "Setting fan mode to %s", LOG_STR_ARG(climate::climate_fan_mode_to_string(*config.fan_mode_)));
-    this->fan_mode = *config.fan_mode_;
+    this->fan_mode = config.fan_mode_;
     something_changed = true;
   }
 
diff --git a/esphome/components/time_based/time_based_cover.cpp b/esphome/components/time_based/time_based_cover.cpp
index f6a3048bd48..c83829ff592 100644
--- a/esphome/components/time_based/time_based_cover.cpp
+++ b/esphome/components/time_based/time_based_cover.cpp
@@ -79,8 +79,9 @@ void TimeBasedCover::control(const CoverCall &call) {
       }
     }
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto pos_val = call.get_position();
+  if (pos_val.has_value()) {
+    auto pos = *pos_val;
     if (pos == this->position) {
       // already at target
       if (this->manual_control_ && (pos == COVER_OPEN || pos == COVER_CLOSED)) {
diff --git a/esphome/components/tormatic/tormatic_cover.cpp b/esphome/components/tormatic/tormatic_cover.cpp
index be412d62a84..37a269088e6 100644
--- a/esphome/components/tormatic/tormatic_cover.cpp
+++ b/esphome/components/tormatic/tormatic_cover.cpp
@@ -66,8 +66,9 @@ void Tormatic::control(const cover::CoverCall &call) {
     return;
   }
 
-  if (call.get_position().has_value()) {
-    auto pos = call.get_position().value();
+  auto pos_val = call.get_position();
+  if (pos_val.has_value()) {
+    auto pos = *pos_val;
     this->control_position_(pos);
     return;
   }
@@ -182,6 +183,9 @@ void Tormatic::recompute_position_() {
     duration = this->close_duration_;
   }
 
+  if (duration == 0)
+    return;
+
   auto delta = direction * diff / duration;
 
   this->position = clamp(this->position + delta, COVER_CLOSED, COVER_OPEN);
diff --git a/esphome/components/toshiba/toshiba.cpp b/esphome/components/toshiba/toshiba.cpp
index 7b5e78af520..e0c150537a9 100644
--- a/esphome/components/toshiba/toshiba.cpp
+++ b/esphome/components/toshiba/toshiba.cpp
@@ -502,7 +502,7 @@ void ToshibaClimate::transmit_generic_() {
   }
 
   uint8_t fan;
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_QUIET:
       fan = TOSHIBA_FAN_SPEED_QUIET;
       break;
@@ -567,7 +567,7 @@ void ToshibaClimate::transmit_rac_pt1411hwru_() {
     message[2] = RAC_PT1411HWRU_NO_FAN.code1;
     message[7] = RAC_PT1411HWRU_NO_FAN.code2;
   } else {
-    switch (this->fan_mode.value()) {
+    switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
       case climate::CLIMATE_FAN_LOW:
         message[2] = RAC_PT1411HWRU_FAN_LOW.code1;
         message[7] = RAC_PT1411HWRU_FAN_LOW.code2;
@@ -811,12 +811,12 @@ void ToshibaClimate::transmit_ras_2819t_() {
     uint8_t temp_code = get_ras_2819t_temp_code(temperature);
 
     // Get fan speed encoding for rc_code_1
-    climate::ClimateFanMode effective_fan_mode = this->fan_mode.value();
+    climate::ClimateFanMode effective_fan_mode = this->fan_mode.value_or(climate::CLIMATE_FAN_ON);
 
     // Dry mode only supports AUTO fan speed
     if (this->mode == climate::CLIMATE_MODE_DRY) {
       effective_fan_mode = climate::CLIMATE_FAN_AUTO;
-      if (this->fan_mode.value() != climate::CLIMATE_FAN_AUTO) {
+      if (this->fan_mode.value_or(climate::CLIMATE_FAN_ON) != climate::CLIMATE_FAN_AUTO) {
         ESP_LOGW(TAG, "Dry mode only supports AUTO fan speed, forcing AUTO");
       }
     }
diff --git a/esphome/components/touchscreen/touchscreen.h b/esphome/components/touchscreen/touchscreen.h
index 8016323d493..7451c207ec3 100644
--- a/esphome/components/touchscreen/touchscreen.h
+++ b/esphome/components/touchscreen/touchscreen.h
@@ -65,7 +65,12 @@ class Touchscreen : public PollingComponent {
 
   void register_listener(TouchListener *listener) { this->touch_listeners_.push_back(listener); }
 
-  optional<TouchPoint> get_touch() { return this->touches_.begin()->second; }
+  optional<TouchPoint> get_touch() {
+    if (this->touches_.empty()) {
+      return {};
+    }
+    return this->touches_.begin()->second;
+  }
 
   TouchPoints_t get_touches() {
     TouchPoints_t touches;
diff --git a/esphome/components/tuya/climate/tuya_climate.cpp b/esphome/components/tuya/climate/tuya_climate.cpp
index 4d8fd4b310a..6602ccd8c9a 100644
--- a/esphome/components/tuya/climate/tuya_climate.cpp
+++ b/esphome/components/tuya/climate/tuya_climate.cpp
@@ -7,8 +7,9 @@ namespace tuya {
 static const char *const TAG = "tuya.climate";
 
 void TuyaClimate::setup() {
-  if (this->switch_id_.has_value()) {
-    this->parent_->register_listener(*this->switch_id_, [this](const TuyaDatapoint &datapoint) {
+  auto switch_id = this->switch_id_;
+  if (switch_id.has_value()) {
+    this->parent_->register_listener(*switch_id, [this](const TuyaDatapoint &datapoint) {
       ESP_LOGV(TAG, "MCU reported switch is: %s", ONOFF(datapoint.value_bool));
       this->mode = climate::CLIMATE_MODE_OFF;
       if (datapoint.value_bool) {
@@ -32,16 +33,18 @@ void TuyaClimate::setup() {
     this->cooling_state_pin_->setup();
     this->cooling_state_ = this->cooling_state_pin_->digital_read();
   }
-  if (this->active_state_id_.has_value()) {
-    this->parent_->register_listener(*this->active_state_id_, [this](const TuyaDatapoint &datapoint) {
+  auto active_state_id = this->active_state_id_;
+  if (active_state_id.has_value()) {
+    this->parent_->register_listener(*active_state_id, [this](const TuyaDatapoint &datapoint) {
       ESP_LOGV(TAG, "MCU reported active state is: %u", datapoint.value_enum);
       this->active_state_ = datapoint.value_enum;
       this->compute_state_();
       this->publish_state();
     });
   }
-  if (this->target_temperature_id_.has_value()) {
-    this->parent_->register_listener(*this->target_temperature_id_, [this](const TuyaDatapoint &datapoint) {
+  auto target_temp_id = this->target_temperature_id_;
+  if (target_temp_id.has_value()) {
+    this->parent_->register_listener(*target_temp_id, [this](const TuyaDatapoint &datapoint) {
       this->manual_temperature_ = datapoint.value_int * this->target_temperature_multiplier_;
       if (this->reports_fahrenheit_) {
         this->manual_temperature_ = (this->manual_temperature_ - 32) * 5 / 9;
@@ -53,8 +56,9 @@ void TuyaClimate::setup() {
       this->publish_state();
     });
   }
-  if (this->current_temperature_id_.has_value()) {
-    this->parent_->register_listener(*this->current_temperature_id_, [this](const TuyaDatapoint &datapoint) {
+  auto current_temp_id = this->current_temperature_id_;
+  if (current_temp_id.has_value()) {
+    this->parent_->register_listener(*current_temp_id, [this](const TuyaDatapoint &datapoint) {
       this->current_temperature = datapoint.value_int * this->current_temperature_multiplier_;
       if (this->reports_fahrenheit_) {
         this->current_temperature = (this->current_temperature - 32) * 5 / 9;
@@ -65,8 +69,9 @@ void TuyaClimate::setup() {
       this->publish_state();
     });
   }
-  if (this->eco_id_.has_value()) {
-    this->parent_->register_listener(*this->eco_id_, [this](const TuyaDatapoint &datapoint) {
+  auto eco_id = this->eco_id_;
+  if (eco_id.has_value()) {
+    this->parent_->register_listener(*eco_id, [this](const TuyaDatapoint &datapoint) {
       // Whether data type is BOOL or ENUM, it will still be a 1 or a 0, so the functions below are valid in both cases
       this->eco_ = datapoint.value_bool;
       this->eco_type_ = datapoint.type;
@@ -76,8 +81,9 @@ void TuyaClimate::setup() {
       this->publish_state();
     });
   }
-  if (this->sleep_id_.has_value()) {
-    this->parent_->register_listener(*this->sleep_id_, [this](const TuyaDatapoint &datapoint) {
+  auto sleep_id = this->sleep_id_;
+  if (sleep_id.has_value()) {
+    this->parent_->register_listener(*sleep_id, [this](const TuyaDatapoint &datapoint) {
       this->sleep_ = datapoint.value_bool;
       ESP_LOGV(TAG, "MCU reported sleep is: %s", ONOFF(this->sleep_));
       this->compute_preset_();
@@ -85,8 +91,9 @@ void TuyaClimate::setup() {
       this->publish_state();
     });
   }
-  if (this->swing_vertical_id_.has_value()) {
-    this->parent_->register_listener(*this->swing_vertical_id_, [this](const TuyaDatapoint &datapoint) {
+  auto swing_vert_id = this->swing_vertical_id_;
+  if (swing_vert_id.has_value()) {
+    this->parent_->register_listener(*swing_vert_id, [this](const TuyaDatapoint &datapoint) {
       this->swing_vertical_ = datapoint.value_bool;
       ESP_LOGV(TAG, "MCU reported vertical swing is: %s", ONOFF(datapoint.value_bool));
       this->compute_swingmode_();
@@ -94,8 +101,9 @@ void TuyaClimate::setup() {
     });
   }
 
-  if (this->swing_horizontal_id_.has_value()) {
-    this->parent_->register_listener(*this->swing_horizontal_id_, [this](const TuyaDatapoint &datapoint) {
+  auto swing_horiz_id = this->swing_horizontal_id_;
+  if (swing_horiz_id.has_value()) {
+    this->parent_->register_listener(*swing_horiz_id, [this](const TuyaDatapoint &datapoint) {
       this->swing_horizontal_ = datapoint.value_bool;
       ESP_LOGV(TAG, "MCU reported horizontal swing is: %s", ONOFF(datapoint.value_bool));
       this->compute_swingmode_();
@@ -103,8 +111,9 @@ void TuyaClimate::setup() {
     });
   }
 
-  if (this->fan_speed_id_.has_value()) {
-    this->parent_->register_listener(*this->fan_speed_id_, [this](const TuyaDatapoint &datapoint) {
+  auto fan_speed_id = this->fan_speed_id_;
+  if (fan_speed_id.has_value()) {
+    this->parent_->register_listener(*fan_speed_id, [this](const TuyaDatapoint &datapoint) {
       ESP_LOGV(TAG, "MCU reported Fan Speed Mode is: %u", datapoint.value_enum);
       this->fan_state_ = datapoint.value_enum;
       this->compute_fanmode_();
@@ -139,21 +148,34 @@ void TuyaClimate::loop() {
 }
 
 void TuyaClimate::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value()) {
-    const bool switch_state = *call.get_mode() != climate::CLIMATE_MODE_OFF;
+  auto mode = call.get_mode();
+  if (mode.has_value()) {
+    const bool switch_state = *mode != climate::CLIMATE_MODE_OFF;
     ESP_LOGV(TAG, "Setting switch: %s", ONOFF(switch_state));
-    this->parent_->set_boolean_datapoint_value(*this->switch_id_, switch_state);
-    const climate::ClimateMode new_mode = *call.get_mode();
+    auto switch_dp_id = this->switch_id_;
+    if (switch_dp_id.has_value()) {
+      this->parent_->set_boolean_datapoint_value(*switch_dp_id, switch_state);
+    }
+    const climate::ClimateMode new_mode = *mode;
 
-    if (this->active_state_id_.has_value()) {
+    auto active_state_dp_id = this->active_state_id_;
+    if (active_state_dp_id.has_value()) {
       if (new_mode == climate::CLIMATE_MODE_HEAT && this->supports_heat_) {
-        this->parent_->set_enum_datapoint_value(*this->active_state_id_, *this->active_state_heating_value_);
+        auto heating_val = this->active_state_heating_value_;
+        if (heating_val.has_value())
+          this->parent_->set_enum_datapoint_value(*active_state_dp_id, *heating_val);
       } else if (new_mode == climate::CLIMATE_MODE_COOL && this->supports_cool_) {
-        this->parent_->set_enum_datapoint_value(*this->active_state_id_, *this->active_state_cooling_value_);
-      } else if (new_mode == climate::CLIMATE_MODE_DRY && this->active_state_drying_value_.has_value()) {
-        this->parent_->set_enum_datapoint_value(*this->active_state_id_, *this->active_state_drying_value_);
-      } else if (new_mode == climate::CLIMATE_MODE_FAN_ONLY && this->active_state_fanonly_value_.has_value()) {
-        this->parent_->set_enum_datapoint_value(*this->active_state_id_, *this->active_state_fanonly_value_);
+        auto cooling_val = this->active_state_cooling_value_;
+        if (cooling_val.has_value())
+          this->parent_->set_enum_datapoint_value(*active_state_dp_id, *cooling_val);
+      } else if (new_mode == climate::CLIMATE_MODE_DRY) {
+        auto drying_val = this->active_state_drying_value_;
+        if (drying_val.has_value())
+          this->parent_->set_enum_datapoint_value(*active_state_dp_id, *drying_val);
+      } else if (new_mode == climate::CLIMATE_MODE_FAN_ONLY) {
+        auto fanonly_val = this->active_state_fanonly_value_;
+        if (fanonly_val.has_value())
+          this->parent_->set_enum_datapoint_value(*active_state_dp_id, *fanonly_val);
       }
     } else {
       ESP_LOGW(TAG, "Active state (mode) datapoint not configured");
@@ -163,31 +185,38 @@ void TuyaClimate::control(const climate::ClimateCall &call) {
   control_swing_mode_(call);
   control_fan_mode_(call);
 
-  if (call.get_target_temperature().has_value()) {
-    float target_temperature = *call.get_target_temperature();
+  auto target_temp = call.get_target_temperature();
+  if (target_temp.has_value()) {
+    float target_temperature = *target_temp;
     if (this->reports_fahrenheit_)
       target_temperature = (target_temperature * 9 / 5) + 32;
 
     ESP_LOGV(TAG, "Setting target temperature: %.1f", target_temperature);
-    this->parent_->set_integer_datapoint_value(*this->target_temperature_id_,
-                                               (int) (target_temperature / this->target_temperature_multiplier_));
+    auto target_temp_dp_id = this->target_temperature_id_;
+    if (target_temp_dp_id.has_value()) {
+      this->parent_->set_integer_datapoint_value(*target_temp_dp_id,
+                                                 (int) (target_temperature / this->target_temperature_multiplier_));
+    }
   }
 
-  if (call.get_preset().has_value()) {
-    const climate::ClimatePreset preset = *call.get_preset();
-    if (this->eco_id_.has_value()) {
+  auto preset_val = call.get_preset();
+  if (preset_val.has_value()) {
+    const climate::ClimatePreset preset = *preset_val;
+    auto eco_dp_id = this->eco_id_;
+    if (eco_dp_id.has_value()) {
       const bool eco = preset == climate::CLIMATE_PRESET_ECO;
       ESP_LOGV(TAG, "Setting eco: %s", ONOFF(eco));
       if (this->eco_type_ == TuyaDatapointType::ENUM) {
-        this->parent_->set_enum_datapoint_value(*this->eco_id_, eco);
+        this->parent_->set_enum_datapoint_value(*eco_dp_id, eco);
       } else {
-        this->parent_->set_boolean_datapoint_value(*this->eco_id_, eco);
+        this->parent_->set_boolean_datapoint_value(*eco_dp_id, eco);
       }
     }
-    if (this->sleep_id_.has_value()) {
+    auto sleep_dp_id = this->sleep_id_;
+    if (sleep_dp_id.has_value()) {
       const bool sleep = preset == climate::CLIMATE_PRESET_SLEEP;
       ESP_LOGV(TAG, "Setting sleep: %s", ONOFF(sleep));
-      this->parent_->set_boolean_datapoint_value(*this->sleep_id_, sleep);
+      this->parent_->set_boolean_datapoint_value(*sleep_dp_id, sleep);
     }
   }
 }
@@ -196,8 +225,9 @@ void TuyaClimate::control_swing_mode_(const climate::ClimateCall &call) {
   bool vertical_swing_changed = false;
   bool horizontal_swing_changed = false;
 
-  if (call.get_swing_mode().has_value()) {
-    const auto swing_mode = *call.get_swing_mode();
+  auto swing_mode_val = call.get_swing_mode();
+  if (swing_mode_val.has_value()) {
+    const auto swing_mode = *swing_mode_val;
 
     switch (swing_mode) {
       case climate::CLIMATE_SWING_OFF:
@@ -241,14 +271,16 @@ void TuyaClimate::control_swing_mode_(const climate::ClimateCall &call) {
     }
   }
 
-  if (vertical_swing_changed && this->swing_vertical_id_.has_value()) {
+  auto vert_dp_id = this->swing_vertical_id_;
+  if (vertical_swing_changed && vert_dp_id.has_value()) {
     ESP_LOGV(TAG, "Setting vertical swing: %s", ONOFF(swing_vertical_));
-    this->parent_->set_boolean_datapoint_value(*this->swing_vertical_id_, swing_vertical_);
+    this->parent_->set_boolean_datapoint_value(*vert_dp_id, swing_vertical_);
   }
 
-  if (horizontal_swing_changed && this->swing_horizontal_id_.has_value()) {
+  auto horiz_dp_id = this->swing_horizontal_id_;
+  if (horizontal_swing_changed && horiz_dp_id.has_value()) {
     ESP_LOGV(TAG, "Setting horizontal swing: %s", ONOFF(swing_horizontal_));
-    this->parent_->set_boolean_datapoint_value(*this->swing_horizontal_id_, swing_horizontal_);
+    this->parent_->set_boolean_datapoint_value(*horiz_dp_id, swing_horizontal_);
   }
 
   // Publish the state after updating the swing mode
@@ -256,33 +288,35 @@ void TuyaClimate::control_swing_mode_(const climate::ClimateCall &call) {
 }
 
 void TuyaClimate::control_fan_mode_(const climate::ClimateCall &call) {
-  if (call.get_fan_mode().has_value()) {
-    climate::ClimateFanMode fan_mode = *call.get_fan_mode();
+  auto fan_mode_val = call.get_fan_mode();
+  if (fan_mode_val.has_value()) {
+    climate::ClimateFanMode fan_mode = *fan_mode_val;
 
     uint8_t tuya_fan_speed;
     switch (fan_mode) {
       case climate::CLIMATE_FAN_LOW:
-        tuya_fan_speed = *fan_speed_low_value_;
+        tuya_fan_speed = this->fan_speed_low_value_.value_or(0);
         break;
       case climate::CLIMATE_FAN_MEDIUM:
-        tuya_fan_speed = *fan_speed_medium_value_;
+        tuya_fan_speed = this->fan_speed_medium_value_.value_or(0);
         break;
       case climate::CLIMATE_FAN_MIDDLE:
-        tuya_fan_speed = *fan_speed_middle_value_;
+        tuya_fan_speed = this->fan_speed_middle_value_.value_or(0);
         break;
       case climate::CLIMATE_FAN_HIGH:
-        tuya_fan_speed = *fan_speed_high_value_;
+        tuya_fan_speed = this->fan_speed_high_value_.value_or(0);
         break;
       case climate::CLIMATE_FAN_AUTO:
-        tuya_fan_speed = *fan_speed_auto_value_;
+        tuya_fan_speed = this->fan_speed_auto_value_.value_or(0);
         break;
       default:
         tuya_fan_speed = 0;
         break;
     }
 
-    if (this->fan_speed_id_.has_value()) {
-      this->parent_->set_enum_datapoint_value(*this->fan_speed_id_, tuya_fan_speed);
+    auto fan_speed_dp_id = this->fan_speed_id_;
+    if (fan_speed_dp_id.has_value()) {
+      this->parent_->set_enum_datapoint_value(*fan_speed_dp_id, tuya_fan_speed);
     }
   }
 }
@@ -337,31 +371,39 @@ climate::ClimateTraits TuyaClimate::traits() {
 
 void TuyaClimate::dump_config() {
   LOG_CLIMATE("", "Tuya Climate", this);
-  if (this->switch_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Switch has datapoint ID %u", *this->switch_id_);
+  auto switch_dp_id = this->switch_id_;
+  if (switch_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Switch has datapoint ID %u", *switch_dp_id);
   }
-  if (this->active_state_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Active state has datapoint ID %u", *this->active_state_id_);
+  auto active_state_dp_id = this->active_state_id_;
+  if (active_state_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Active state has datapoint ID %u", *active_state_dp_id);
   }
-  if (this->target_temperature_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Target Temperature has datapoint ID %u", *this->target_temperature_id_);
+  auto target_temp_dp_id = this->target_temperature_id_;
+  if (target_temp_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Target Temperature has datapoint ID %u", *target_temp_dp_id);
   }
-  if (this->current_temperature_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Current Temperature has datapoint ID %u", *this->current_temperature_id_);
+  auto current_temp_dp_id = this->current_temperature_id_;
+  if (current_temp_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Current Temperature has datapoint ID %u", *current_temp_dp_id);
   }
   LOG_PIN("  Heating State Pin: ", this->heating_state_pin_);
   LOG_PIN("  Cooling State Pin: ", this->cooling_state_pin_);
-  if (this->eco_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Eco has datapoint ID %u", *this->eco_id_);
+  auto eco_dp_id = this->eco_id_;
+  if (eco_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Eco has datapoint ID %u", *eco_dp_id);
   }
-  if (this->sleep_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Sleep has datapoint ID %u", *this->sleep_id_);
+  auto sleep_dp_id = this->sleep_id_;
+  if (sleep_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Sleep has datapoint ID %u", *sleep_dp_id);
   }
-  if (this->swing_vertical_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Swing Vertical has datapoint ID %u", *this->swing_vertical_id_);
+  auto swing_vert_dp_id = this->swing_vertical_id_;
+  if (swing_vert_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Swing Vertical has datapoint ID %u", *swing_vert_dp_id);
   }
-  if (this->swing_horizontal_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Swing Horizontal has datapoint ID %u", *this->swing_horizontal_id_);
+  auto swing_horiz_dp_id = this->swing_horizontal_id_;
+  if (swing_horiz_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Swing Horizontal has datapoint ID %u", *swing_horiz_dp_id);
   }
 }
 
diff --git a/esphome/components/tuya/cover/tuya_cover.cpp b/esphome/components/tuya/cover/tuya_cover.cpp
index 14bf937cf72..125afec0483 100644
--- a/esphome/components/tuya/cover/tuya_cover.cpp
+++ b/esphome/components/tuya/cover/tuya_cover.cpp
@@ -39,6 +39,9 @@ void TuyaCover::setup() {
     }
   });
 
+  if (!this->position_id_.has_value()) {
+    return;
+  }
   uint8_t report_id = *this->position_id_;
   if (this->position_report_id_.has_value()) {
     // A position report datapoint is configured; listen to that instead.
@@ -60,29 +63,30 @@ void TuyaCover::control(const cover::CoverCall &call) {
   if (call.get_stop()) {
     if (this->control_id_.has_value()) {
       this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_STOP);
-    } else {
+    } else if (this->position_id_.has_value()) {
       auto pos = this->position;
       pos = this->invert_position_report_ ? pos : 1.0f - pos;
       auto position_int = static_cast<uint32_t>(pos * this->value_range_);
       position_int = position_int + this->min_value_;
 
-      parent_->force_set_integer_datapoint_value(*this->position_id_, position_int);
+      this->parent_->force_set_integer_datapoint_value(*this->position_id_, position_int);
     }
   }
-  if (call.get_position().has_value()) {
-    auto pos = *call.get_position();
+  auto pos_opt = call.get_position();
+  if (pos_opt.has_value()) {
+    auto pos = *pos_opt;
     if (this->control_id_.has_value() && (pos == COVER_OPEN || pos == COVER_CLOSED)) {
       if (pos == COVER_OPEN) {
         this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_OPEN);
       } else {
         this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_CLOSE);
       }
-    } else {
+    } else if (this->position_id_.has_value()) {
       pos = this->invert_position_report_ ? pos : 1.0f - pos;
       auto position_int = static_cast<uint32_t>(pos * this->value_range_);
       position_int = position_int + this->min_value_;
 
-      parent_->force_set_integer_datapoint_value(*this->position_id_, position_int);
+      this->parent_->force_set_integer_datapoint_value(*this->position_id_, position_int);
     }
   }
 
diff --git a/esphome/components/tuya/fan/tuya_fan.cpp b/esphome/components/tuya/fan/tuya_fan.cpp
index 9b132e0de64..a387606b776 100644
--- a/esphome/components/tuya/fan/tuya_fan.cpp
+++ b/esphome/components/tuya/fan/tuya_fan.cpp
@@ -7,8 +7,9 @@ namespace tuya {
 static const char *const TAG = "tuya.fan";
 
 void TuyaFan::setup() {
-  if (this->speed_id_.has_value()) {
-    this->parent_->register_listener(*this->speed_id_, [this](const TuyaDatapoint &datapoint) {
+  auto speed_id = this->speed_id_;
+  if (speed_id.has_value()) {
+    this->parent_->register_listener(*speed_id, [this](const TuyaDatapoint &datapoint) {
       if (datapoint.type == TuyaDatapointType::ENUM) {
         ESP_LOGV(TAG, "MCU reported speed of: %d", datapoint.value_enum);
         if (datapoint.value_enum >= this->speed_count_) {
@@ -25,15 +26,17 @@ void TuyaFan::setup() {
       this->speed_type_ = datapoint.type;
     });
   }
-  if (this->switch_id_.has_value()) {
-    this->parent_->register_listener(*this->switch_id_, [this](const TuyaDatapoint &datapoint) {
+  auto switch_id = this->switch_id_;
+  if (switch_id.has_value()) {
+    this->parent_->register_listener(*switch_id, [this](const TuyaDatapoint &datapoint) {
       ESP_LOGV(TAG, "MCU reported switch is: %s", ONOFF(datapoint.value_bool));
       this->state = datapoint.value_bool;
       this->publish_state();
     });
   }
-  if (this->oscillation_id_.has_value()) {
-    this->parent_->register_listener(*this->oscillation_id_, [this](const TuyaDatapoint &datapoint) {
+  auto oscillation_id = this->oscillation_id_;
+  if (oscillation_id.has_value()) {
+    this->parent_->register_listener(*oscillation_id, [this](const TuyaDatapoint &datapoint) {
       // Whether data type is BOOL or ENUM, it will still be a 1 or a 0, so the functions below are valid in both
       // scenarios
       ESP_LOGV(TAG, "MCU reported oscillation is: %s", ONOFF(datapoint.value_bool));
@@ -43,8 +46,9 @@ void TuyaFan::setup() {
       this->oscillation_type_ = datapoint.type;
     });
   }
-  if (this->direction_id_.has_value()) {
-    this->parent_->register_listener(*this->direction_id_, [this](const TuyaDatapoint &datapoint) {
+  auto direction_id = this->direction_id_;
+  if (direction_id.has_value()) {
+    this->parent_->register_listener(*direction_id, [this](const TuyaDatapoint &datapoint) {
       ESP_LOGD(TAG, "MCU reported reverse direction is: %s", ONOFF(datapoint.value_bool));
       this->direction = datapoint.value_bool ? fan::FanDirection::REVERSE : fan::FanDirection::FORWARD;
       this->publish_state();
@@ -60,17 +64,21 @@ void TuyaFan::setup() {
 
 void TuyaFan::dump_config() {
   LOG_FAN("", "Tuya Fan", this);
-  if (this->speed_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Speed has datapoint ID %u", *this->speed_id_);
+  auto speed_dp_id = this->speed_id_;
+  if (speed_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Speed has datapoint ID %u", *speed_dp_id);
   }
-  if (this->switch_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Switch has datapoint ID %u", *this->switch_id_);
+  auto switch_dp_id = this->switch_id_;
+  if (switch_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Switch has datapoint ID %u", *switch_dp_id);
   }
-  if (this->oscillation_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Oscillation has datapoint ID %u", *this->oscillation_id_);
+  auto oscillation_dp_id = this->oscillation_id_;
+  if (oscillation_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Oscillation has datapoint ID %u", *oscillation_dp_id);
   }
-  if (this->direction_id_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Direction has datapoint ID %u", *this->direction_id_);
+  auto direction_dp_id = this->direction_id_;
+  if (direction_dp_id.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Direction has datapoint ID %u", *direction_dp_id);
   }
 }
 
@@ -80,25 +88,41 @@ fan::FanTraits TuyaFan::get_traits() {
 }
 
 void TuyaFan::control(const fan::FanCall &call) {
-  if (this->switch_id_.has_value() && call.get_state().has_value()) {
-    this->parent_->set_boolean_datapoint_value(*this->switch_id_, *call.get_state());
-  }
-  if (this->oscillation_id_.has_value() && call.get_oscillating().has_value()) {
-    if (this->oscillation_type_ == TuyaDatapointType::ENUM) {
-      this->parent_->set_enum_datapoint_value(*this->oscillation_id_, *call.get_oscillating());
-    } else if (this->oscillation_type_ == TuyaDatapointType::BOOLEAN) {
-      this->parent_->set_boolean_datapoint_value(*this->oscillation_id_, *call.get_oscillating());
+  auto switch_id = this->switch_id_;
+  if (switch_id.has_value()) {
+    auto state = call.get_state();
+    if (state.has_value()) {
+      this->parent_->set_boolean_datapoint_value(*switch_id, *state);
     }
   }
-  if (this->direction_id_.has_value() && call.get_direction().has_value()) {
-    bool enable = *call.get_direction() == fan::FanDirection::REVERSE;
-    this->parent_->set_enum_datapoint_value(*this->direction_id_, enable);
+  auto osc_id = this->oscillation_id_;
+  if (osc_id.has_value()) {
+    auto oscillating = call.get_oscillating();
+    if (oscillating.has_value()) {
+      if (this->oscillation_type_ == TuyaDatapointType::ENUM) {
+        this->parent_->set_enum_datapoint_value(*osc_id, *oscillating);
+      } else if (this->oscillation_type_ == TuyaDatapointType::BOOLEAN) {
+        this->parent_->set_boolean_datapoint_value(*osc_id, *oscillating);
+      }
+    }
   }
-  if (this->speed_id_.has_value() && call.get_speed().has_value()) {
-    if (this->speed_type_ == TuyaDatapointType::ENUM) {
-      this->parent_->set_enum_datapoint_value(*this->speed_id_, *call.get_speed() - 1);
-    } else if (this->speed_type_ == TuyaDatapointType::INTEGER) {
-      this->parent_->set_integer_datapoint_value(*this->speed_id_, *call.get_speed());
+  auto dir_id = this->direction_id_;
+  if (dir_id.has_value()) {
+    auto direction = call.get_direction();
+    if (direction.has_value()) {
+      bool enable = *direction == fan::FanDirection::REVERSE;
+      this->parent_->set_enum_datapoint_value(*dir_id, enable);
+    }
+  }
+  auto spd_id = this->speed_id_;
+  if (spd_id.has_value()) {
+    auto speed = call.get_speed();
+    if (speed.has_value()) {
+      if (this->speed_type_ == TuyaDatapointType::ENUM) {
+        this->parent_->set_enum_datapoint_value(*spd_id, *speed - 1);
+      } else if (this->speed_type_ == TuyaDatapointType::INTEGER) {
+        this->parent_->set_integer_datapoint_value(*spd_id, *speed);
+      }
     }
   }
 }
diff --git a/esphome/components/tuya/light/tuya_light.cpp b/esphome/components/tuya/light/tuya_light.cpp
index 097b3c1af82..620bb88d0b7 100644
--- a/esphome/components/tuya/light/tuya_light.cpp
+++ b/esphome/components/tuya/light/tuya_light.cpp
@@ -57,6 +57,9 @@ void TuyaLight::setup() {
         return;
       }
 
+      if (!this->color_type_.has_value())
+        return;
+
       float red, green, blue;
       switch (*this->color_type_) {
         case TuyaColorType::RGBHSV:
@@ -185,7 +188,7 @@ void TuyaLight::write_state(light::LightState *state) {
     }
   }
 
-  if (this->color_id_.has_value() && (brightness == 0.0f || !color_interlock_)) {
+  if (this->color_id_.has_value() && this->color_type_.has_value() && (brightness == 0.0f || !color_interlock_)) {
     std::string color_value;
     switch (*this->color_type_) {
       case TuyaColorType::RGB: {
diff --git a/esphome/components/tx20/tx20.cpp b/esphome/components/tx20/tx20.cpp
index 6bc5f0bb514..3e0234fac04 100644
--- a/esphome/components/tx20/tx20.cpp
+++ b/esphome/components/tx20/tx20.cpp
@@ -191,7 +191,7 @@ void IRAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) {
     arg->tx20_available = true;
     return;
   }
-  if (index <= MAX_BUFFER_SIZE) {
+  if (index < MAX_BUFFER_SIZE) {
     arg->buffer[index] = delay;
   }
   arg->spent_time += delay;
diff --git a/esphome/components/ufire_ec/ufire_ec.cpp b/esphome/components/ufire_ec/ufire_ec.cpp
index 3868dc92b7f..a1c3568a1a3 100644
--- a/esphome/components/ufire_ec/ufire_ec.cpp
+++ b/esphome/components/ufire_ec/ufire_ec.cpp
@@ -8,7 +8,7 @@ static const char *const TAG = "ufire_ec";
 
 void UFireECComponent::setup() {
   uint8_t version;
-  if (!this->read_byte(REGISTER_VERSION, &version) && version != 0xFF) {
+  if (!this->read_byte(REGISTER_VERSION, &version) || version == 0xFF) {
     this->mark_failed();
     return;
   }
diff --git a/esphome/components/ufire_ise/ufire_ise.cpp b/esphome/components/ufire_ise/ufire_ise.cpp
index 486a5063913..e967fc53c37 100644
--- a/esphome/components/ufire_ise/ufire_ise.cpp
+++ b/esphome/components/ufire_ise/ufire_ise.cpp
@@ -10,7 +10,7 @@ static const char *const TAG = "ufire_ise";
 
 void UFireISEComponent::setup() {
   uint8_t version;
-  if (!this->read_byte(REGISTER_VERSION, &version) && version != 0xFF) {
+  if (!this->read_byte(REGISTER_VERSION, &version) || version == 0xFF) {
     this->mark_failed();
     return;
   }
diff --git a/esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp b/esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp
index 4256b01c4e8..3eae4d2d966 100644
--- a/esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp
+++ b/esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp
@@ -42,8 +42,9 @@ climate::ClimateTraits UponorSmatrixClimate::traits() {
 }
 
 void UponorSmatrixClimate::control(const climate::ClimateCall &call) {
-  if (call.get_target_temperature().has_value()) {
-    uint16_t temp = celsius_to_raw(*call.get_target_temperature());
+  auto val = call.get_target_temperature();
+  if (val.has_value()) {
+    uint16_t temp = celsius_to_raw(*val);
     if (this->preset == climate::CLIMATE_PRESET_ECO) {
       // During ECO mode, the thermostat automatically substracts the setback value from the setpoint,
       // so we need to add it here first
diff --git a/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp b/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
index d33fb80f781..44de986f9a3 100644
--- a/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
+++ b/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
@@ -161,7 +161,7 @@ void USBCDCACMInstance::setup() {
 
   // Create a simple, unique task name per interface
   char task_name[] = "usb_tx_0";
-  task_name[sizeof(task_name) - 1] = format_hex_char(static_cast<char>(this->itf_));
+  task_name[sizeof(task_name) - 2] = format_hex_char(static_cast<char>(this->itf_));
   xTaskCreate(usb_tx_task_fn, task_name, stack_size, this, 4, &this->usb_tx_task_handle_);
 
   if (this->usb_tx_task_handle_ == nullptr) {
diff --git a/esphome/components/vbus/vbus.cpp b/esphome/components/vbus/vbus.cpp
index b9496a08dec..8616da010d1 100644
--- a/esphome/components/vbus/vbus.cpp
+++ b/esphome/components/vbus/vbus.cpp
@@ -1,6 +1,7 @@
 #include "vbus.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include <algorithm>
 #include <cinttypes>
 
 namespace esphome {
@@ -106,9 +107,10 @@ void VBus::loop() {
         continue;
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
       char hex_buf[format_hex_size(VBUS_MAX_LOG_BYTES)];
+      size_t log_bytes = std::min(this->buffer_.size(), static_cast<size_t>(VBUS_MAX_LOG_BYTES));
 #endif
       ESP_LOGV(TAG, "P2 C%04x %04x->%04x: %s", this->command_, this->source_, this->dest_,
-               format_hex_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
+               format_hex_to(hex_buf, this->buffer_.data(), log_bytes));
       for (auto &listener : this->listeners_)
         listener->on_message(this->command_, this->source_, this->dest_, this->buffer_);
       this->state_ = 0;
diff --git a/esphome/components/veml7700/veml7700.cpp b/esphome/components/veml7700/veml7700.cpp
index eb286ba21b8..1ed484119bd 100644
--- a/esphome/components/veml7700/veml7700.cpp
+++ b/esphome/components/veml7700/veml7700.cpp
@@ -141,7 +141,7 @@ void VEML7700Component::loop() {
     // Datasheet: 2.5 ms before the first measurement is needed, allowing for the correct start of the signal processor
     // and oscillator.
     // Reality: wait for couple integration times to have first samples captured
-    this->set_timeout(2 * this->integration_time_, [this]() { this->state_ = State::IDLE; });
+    this->set_timeout(2 * get_itime_ms(this->integration_time_), [this]() { this->state_ = State::IDLE; });
   }
 
   if (this->is_ready()) {
diff --git a/esphome/components/web_server/ota/ota_web_server.cpp b/esphome/components/web_server/ota/ota_web_server.cpp
index 4be162ccd32..95b166901ad 100644
--- a/esphome/components/web_server/ota/ota_web_server.cpp
+++ b/esphome/components/web_server/ota/ota_web_server.cpp
@@ -1,7 +1,7 @@
 #include "ota_web_server.h"
 #ifdef USE_WEBSERVER_OTA
 
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota/ota_backend_factory.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
 
@@ -71,7 +71,7 @@ class OTARequestHandler : public AsyncWebHandler {
   bool ota_success_{false};
 
  private:
-  std::unique_ptr<ota::OTABackend> ota_backend_{nullptr};
+  ota::OTABackendPtr ota_backend_{nullptr};
 };
 
 void OTARequestHandler::report_ota_progress_(AsyncWebServerRequest *request) {
diff --git a/esphome/components/whirlpool/whirlpool.cpp b/esphome/components/whirlpool/whirlpool.cpp
index 6fe735362dc..e9f602e97f4 100644
--- a/esphome/components/whirlpool/whirlpool.cpp
+++ b/esphome/components/whirlpool/whirlpool.cpp
@@ -82,7 +82,7 @@ void WhirlpoolClimate::transmit_state() {
   remote_state[3] |= (uint8_t) (temp - this->temperature_min_()) << 4;
 
   // Fan speed
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_HIGH:
       remote_state[2] |= WHIRLPOOL_FAN_HIGH;
       break;
diff --git a/esphome/components/whynter/whynter.cpp b/esphome/components/whynter/whynter.cpp
index 9f57fdb8430..003d2e0ba65 100644
--- a/esphome/components/whynter/whynter.cpp
+++ b/esphome/components/whynter/whynter.cpp
@@ -69,7 +69,7 @@ void Whynter::transmit_state() {
   }
   mode_before_ = this->mode;
 
-  switch (this->fan_mode.value()) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
     case climate::CLIMATE_FAN_LOW:
       remote_state |= FAN_LOW;
       break;
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 7d5d0133c1e..8b60810d28a 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -725,6 +725,7 @@ void WiFiComponent::restart_adapter() {
 void WiFiComponent::loop() {
   this->wifi_loop_();
   const uint32_t now = App.get_loop_component_start_time();
+  this->update_connected_state_();
 
   if (this->has_sta()) {
 #if defined(USE_WIFI_CONNECT_TRIGGER) || defined(USE_WIFI_DISCONNECT_TRIGGER)
@@ -776,7 +777,7 @@ void WiFiComponent::loop() {
       }
 
       case WIFI_COMPONENT_STATE_STA_CONNECTED: {
-        if (!this->is_connected()) {
+        if (!this->is_connected_()) {
           ESP_LOGW(TAG, "Connection lost; reconnecting");
           this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING;
           this->retry_connect();
@@ -1094,8 +1095,9 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
   }
 
 #ifdef USE_WIFI_WPA2_EAP
-  if (ap.get_eap().has_value()) {
-    EAPAuth eap_config = ap.get_eap().value();
+  auto eap_opt = ap.get_eap();
+  if (eap_opt.has_value()) {
+    EAPAuth eap_config = *eap_opt;
     // clang-format off
     ESP_LOGV(
         TAG,
@@ -1129,8 +1131,9 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
     ESP_LOGV(TAG, "  Channel not set");
   }
 #ifdef USE_WIFI_MANUAL_IP
-  if (ap.get_manual_ip().has_value()) {
-    ManualIP m = *ap.get_manual_ip();
+  auto manual_ip = ap.get_manual_ip();
+  if (manual_ip.has_value()) {
+    ManualIP m = *manual_ip;
     char static_ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
     char gateway_buf[network::IP_ADDRESS_BUFFER_SIZE];
     char subnet_buf[network::IP_ADDRESS_BUFFER_SIZE];
@@ -2116,15 +2119,16 @@ bool WiFiComponent::can_proceed() {
   if (!this->has_sta() || this->state_ == WIFI_COMPONENT_STATE_DISABLED || this->ap_setup_) {
     return true;
   }
-  return this->is_connected();
+  return this->is_connected_();
 }
 #endif
 
 void WiFiComponent::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
-bool WiFiComponent::is_connected() const {
+bool WiFiComponent::is_connected_() const {
   return this->state_ == WIFI_COMPONENT_STATE_STA_CONNECTED &&
          this->wifi_sta_connect_status_() == WiFiSTAConnectStatus::CONNECTED && !this->error_from_callback_;
 }
+void WiFiComponent::update_connected_state_() { this->connected_ = this->is_connected_(); }
 void WiFiComponent::set_power_save_mode(WiFiPowerSaveMode power_save) {
   this->power_save_ = power_save;
 #if defined(USE_ESP32) && defined(USE_WIFI_RUNTIME_POWER_SAVE)
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index a6f03a08d9d..f340b708c90 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -443,7 +443,7 @@ class WiFiComponent : public Component {
 
   void set_reboot_timeout(uint32_t reboot_timeout);
 
-  bool is_connected() const;
+  bool is_connected() const { return this->connected_; }
 
   void set_power_save_mode(WiFiPowerSaveMode power_save);
   void set_min_auth_mode(WifiMinAuthMode min_auth_mode) { min_auth_mode_ = min_auth_mode; }
@@ -678,6 +678,8 @@ class WiFiComponent : public Component {
   bool wifi_sta_connect_(const WiFiAP &ap);
   void wifi_pre_setup_();
   WiFiSTAConnectStatus wifi_sta_connect_status_() const;
+  bool is_connected_() const;
+  void update_connected_state_();
   bool wifi_scan_start_(bool passive);
 
 #ifdef USE_WIFI_AP
@@ -854,6 +856,7 @@ class WiFiComponent : public Component {
   bool has_completed_scan_after_captive_portal_start_{
       false};  // Tracks if we've completed a scan after captive portal started
   bool skip_cooldown_next_cycle_{false};
+  bool connected_{false};
   bool post_connect_roaming_{true};  // Enabled by default
 #if defined(USE_ESP32) && defined(USE_WIFI_RUNTIME_POWER_SAVE)
   bool is_high_performance_mode_{false};
diff --git a/esphome/components/wifi/wifi_component_esp8266.cpp b/esphome/components/wifi/wifi_component_esp8266.cpp
index bd6a18a99b2..02ce59502b7 100644
--- a/esphome/components/wifi/wifi_component_esp8266.cpp
+++ b/esphome/components/wifi/wifi_component_esp8266.cpp
@@ -298,9 +298,10 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
 
   // setup enterprise authentication if required
 #ifdef USE_WIFI_WPA2_EAP
-  if (ap.get_eap().has_value()) {
+  auto eap_opt = ap.get_eap();
+  if (eap_opt.has_value()) {
     // note: all certificates and keys have to be null terminated. Lengths are appended by +1 to include \0.
-    EAPAuth eap = ap.get_eap().value();
+    EAPAuth eap = *eap_opt;
     ret = wifi_station_set_enterprise_identity((uint8_t *) eap.identity.c_str(), eap.identity.length());
     if (ret) {
       ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_identity failed: %d", ret);
diff --git a/esphome/components/wifi/wifi_component_esp_idf.cpp b/esphome/components/wifi/wifi_component_esp_idf.cpp
index 734d1862052..bf432cea6e5 100644
--- a/esphome/components/wifi/wifi_component_esp_idf.cpp
+++ b/esphome/components/wifi/wifi_component_esp_idf.cpp
@@ -403,9 +403,10 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
 
   // setup enterprise authentication if required
 #ifdef USE_WIFI_WPA2_EAP
-  if (ap.get_eap().has_value()) {
+  auto eap_opt = ap.get_eap();
+  if (eap_opt.has_value()) {
     // note: all certificates and keys have to be null terminated. Lengths are appended by +1 to include \0.
-    EAPAuth eap = ap.get_eap().value();
+    EAPAuth eap = *eap_opt;
 #if (ESP_IDF_VERSION_MAJOR >= 5) && (ESP_IDF_VERSION_MINOR >= 1)
     err = esp_eap_client_set_identity((uint8_t *) eap.identity.c_str(), eap.identity.length());
 #else
diff --git a/esphome/components/wled/wled_light_effect.cpp b/esphome/components/wled/wled_light_effect.cpp
index 87bae5b1da4..db2708d6d02 100644
--- a/esphome/components/wled/wled_light_effect.cpp
+++ b/esphome/components/wled/wled_light_effect.cpp
@@ -161,7 +161,7 @@ bool WLEDLightEffect::parse_notifier_frame_(light::AddressableLight &it, const u
   // https://kno.wled.ge/interfaces/udp-notifier/
   // https://github.com/Aircoookie/WLED/blob/main/wled00/udp.cpp
 
-  if (size < 34) {
+  if (size <= 34) {
     return false;
   }
 
diff --git a/esphome/components/xiaomi_ble/xiaomi_ble.cpp b/esphome/components/xiaomi_ble/xiaomi_ble.cpp
index 0018d35f1f5..97a660f0e3a 100644
--- a/esphome/components/xiaomi_ble/xiaomi_ble.cpp
+++ b/esphome/components/xiaomi_ble/xiaomi_ble.cpp
@@ -121,6 +121,11 @@ bool parse_xiaomi_message(const std::vector<uint8_t> &message, XiaomiParseResult
   // Byte 2: length
   // Byte 3..3+len-1: data point value
 
+  if (result.raw_offset < 0 || static_cast<size_t>(result.raw_offset) >= message.size()) {
+    ESP_LOGVV(TAG, "parse_xiaomi_message(): raw_offset (%d) exceeds message size (%d)!", result.raw_offset,
+              message.size());
+    return false;
+  }
   const uint8_t *payload = message.data() + result.raw_offset;
   uint8_t payload_length = message.size() - result.raw_offset;
   uint8_t payload_offset = 0;
@@ -165,6 +170,10 @@ optional<XiaomiParseResult> parse_xiaomi_header(const esp32_ble_tracker::Service
   }
 
   auto raw = service_data.data;
+  if (raw.size() < 5) {
+    ESP_LOGVV(TAG, "parse_xiaomi_header(): service data too short (%d).", raw.size());
+    return {};
+  }
   result.has_data = raw[0] & 0x40;
   result.has_capability = raw[0] & 0x20;
   result.has_encryption = raw[0] & 0x08;
diff --git a/esphome/components/yashima/yashima.cpp b/esphome/components/yashima/yashima.cpp
index bf91420620e..4a64e6c41c6 100644
--- a/esphome/components/yashima/yashima.cpp
+++ b/esphome/components/yashima/yashima.cpp
@@ -120,10 +120,12 @@ void YashimaClimate::setup() {
 }
 
 void YashimaClimate::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value())
-    this->mode = *call.get_mode();
-  if (call.get_target_temperature().has_value())
-    this->target_temperature = *call.get_target_temperature();
+  auto call_mode = call.get_mode();
+  if (call_mode.has_value())
+    this->mode = *call_mode;
+  auto call_target = call.get_target_temperature();
+  if (call_target.has_value())
+    this->target_temperature = *call_target;
 
   this->transmit_state_();
   this->publish_state();
diff --git a/esphome/components/zhlt01/zhlt01.cpp b/esphome/components/zhlt01/zhlt01.cpp
index 36d1737c14c..e5ab5915e4b 100644
--- a/esphome/components/zhlt01/zhlt01.cpp
+++ b/esphome/components/zhlt01/zhlt01.cpp
@@ -13,7 +13,7 @@ void ZHLT01Climate::transmit_state() {
   ir_message[1] = 0x00;  // Timer off
 
   // Byte 3 : Turbo mode
-  if (this->preset.value() == climate::CLIMATE_PRESET_BOOST) {
+  if (this->preset.value_or(climate::CLIMATE_PRESET_NONE) == climate::CLIMATE_PRESET_BOOST) {
     ir_message[3] = AC1_FAN_TURBO;
   }
 
@@ -47,7 +47,7 @@ void ZHLT01Climate::transmit_state() {
   }
 
   // -- Fan
-  switch (this->preset.value()) {
+  switch (this->preset.value_or(climate::CLIMATE_PRESET_NONE)) {
     case climate::CLIMATE_PRESET_BOOST:
       ir_message[7] |= AC1_FAN3;
       break;
@@ -55,7 +55,7 @@ void ZHLT01Climate::transmit_state() {
       ir_message[7] |= AC1_FAN_SILENT;
       break;
     default:
-      switch (this->fan_mode.value()) {
+      switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
         case climate::CLIMATE_FAN_LOW:
           ir_message[7] |= AC1_FAN1;
           break;
diff --git a/esphome/components/zwave_proxy/zwave_proxy.cpp b/esphome/components/zwave_proxy/zwave_proxy.cpp
index 8506b19e7f4..b0836ac0728 100644
--- a/esphome/components/zwave_proxy/zwave_proxy.cpp
+++ b/esphome/components/zwave_proxy/zwave_proxy.cpp
@@ -281,6 +281,10 @@ bool ZWaveProxy::parse_byte_(uint8_t byte) {
       break;
     }
     case ZWAVE_PARSING_STATE_READ_BL_MENU:
+      if (this->buffer_index_ >= this->buffer_.size()) {
+        this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
+        break;
+      }
       this->buffer_[this->buffer_index_++] = byte;
       if (!byte) {
         this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
diff --git a/esphome/components/zwave_proxy/zwave_proxy.h b/esphome/components/zwave_proxy/zwave_proxy.h
index eb26316f492..12cb9a90a1e 100644
--- a/esphome/components/zwave_proxy/zwave_proxy.h
+++ b/esphome/components/zwave_proxy/zwave_proxy.h
@@ -81,10 +81,10 @@ class ZWaveProxy : public uart::UARTDevice, public Component {
   api::APIConnection *api_connection_{nullptr};  // Current subscribed client
   uint32_t setup_time_{0};                       // Time when setup() was called
 
-  // 8-bit values (grouped together to minimize padding)
-  uint8_t buffer_index_{0};     // Index for populating the data buffer
-  uint8_t end_frame_after_{0};  // Payload reception ends after this index
-  uint8_t last_response_{0};    // Last response type sent
+  // Small values (grouped by size to minimize padding)
+  uint16_t buffer_index_{0};     // Index for populating the data buffer
+  uint16_t end_frame_after_{0};  // Payload reception ends after this index
+  uint8_t last_response_{0};     // Last response type sent
   ZWaveParsingState parsing_state_{ZWAVE_PARSING_STATE_WAIT_START};
   bool in_bootloader_{false};  // True if the device is detected to be in bootloader mode
   bool home_id_ready_{false};  // True when home ID has been received from Z-Wave module
diff --git a/esphome/const.py b/esphome/const.py
index d5625f6a549..060e9625739 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -11,6 +11,9 @@ VALID_SUBSTITUTIONS_CHARACTERS = (
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
 )
 
+# CLI Help Text Constants
+ARGUMENT_HELP_DEVICE = "Manually specify the serial port/address to use, for example /dev/ttyUSB0. Can be specified multiple times for fallback addresses. Use 'OTA' for resolving from MQTT, DNS or mDNS and avoiding the interactive prompt."
+
 
 class Platform(StrEnum):
     """Platform identifiers for ESPHome."""
diff --git a/esphome/core/application.cpp b/esphome/core/application.cpp
index 8c2ba58c86e..db1c8a0c0a1 100644
--- a/esphome/core/application.cpp
+++ b/esphome/core/application.cpp
@@ -153,6 +153,14 @@ void Application::setup() {
   this->setup_wake_loop_threadsafe_();
 #endif
 
+  // Ensure all active looping components are in LOOP state.
+  // Components after the last blocking component only got one call() during setup
+  // (CONSTRUCTION→SETUP) and never received the second call() (SETUP→LOOP).
+  // The main loop calls loop() directly, bypassing call()'s state machine.
+  for (uint16_t i = 0; i < this->looping_components_active_end_; i++) {
+    this->looping_components_[i]->set_component_state_(COMPONENT_STATE_LOOP);
+  }
+
   this->schedule_dump_config();
 }
 void Application::loop() {
@@ -173,7 +181,7 @@ void Application::loop() {
     {
       this->set_current_component(component);
       WarnIfComponentBlockingGuard guard{component, last_op_end_time};
-      component->call();
+      component->loop();
       // Use the finish method to get the current time as the end time
       last_op_end_time = guard.finish();
     }
diff --git a/esphome/core/component.cpp b/esphome/core/component.cpp
index 4ccc7478191..8c2c8d38e8a 100644
--- a/esphome/core/component.cpp
+++ b/esphome/core/component.cpp
@@ -529,9 +529,12 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
   uint32_t blocking_time = curr_time - this->started_;
 #ifdef USE_RUNTIME_STATS
-  // Record component runtime stats
+  // Use micros() for accurate sub-millisecond timing. millis() has insufficient
+  // resolution — most components complete in microseconds but millis() only has
+  // 1ms granularity, so results were essentially random noise.
   if (global_runtime_stats != nullptr) {
-    global_runtime_stats->record_component_time(this->component_, blocking_time, curr_time);
+    uint32_t duration_us = micros() - this->started_us_;
+    global_runtime_stats->record_component_time(this->component_, duration_us, curr_time);
   }
 #endif
   if (blocking_time > WARN_IF_BLOCKING_OVER_MS) {
diff --git a/esphome/core/component.h b/esphome/core/component.h
index e5127b0c9f2..59222dc4f47 100644
--- a/esphome/core/component.h
+++ b/esphome/core/component.h
@@ -563,10 +563,21 @@ class PollingComponent : public Component {
   uint32_t update_interval_;
 };
 
+#ifdef USE_RUNTIME_STATS
+uint32_t micros();  // Forward declare for inline constructor
+#endif
+
 class WarnIfComponentBlockingGuard {
  public:
   WarnIfComponentBlockingGuard(Component *component, uint32_t start_time)
-      : started_(start_time), component_(component) {}
+      : started_(start_time),
+        component_(component)
+#ifdef USE_RUNTIME_STATS
+        ,
+        started_us_(micros())
+#endif
+  {
+  }
 
   // Finish the timing operation and return the current time
   uint32_t finish();
@@ -576,6 +587,9 @@ class WarnIfComponentBlockingGuard {
  protected:
   uint32_t started_;
   Component *component_;
+#ifdef USE_RUNTIME_STATS
+  uint32_t started_us_;
+#endif
 };
 
 // Function to clear setup priority overrides after all components are set up
diff --git a/esphome/core/config.py b/esphome/core/config.py
index 9411949bb92..4f526404fe8 100644
--- a/esphome/core/config.py
+++ b/esphome/core/config.py
@@ -687,6 +687,10 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
+        "static_task.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
         "time_64.cpp": {
             PlatformFramework.ESP8266_ARDUINO,
             PlatformFramework.BK72XX_ARDUINO,
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index 07afefd91aa..1a6d9b3a803 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -137,6 +137,7 @@
 
 // Feature flags which do not work for zephyr
 #ifndef USE_ZEPHYR
+#define AUDIO_FILE_MAX_FILES 4
 #define USE_AUDIO_DAC
 #define USE_AUDIO_FLAC_SUPPORT
 #define USE_AUDIO_MP3_SUPPORT
diff --git a/esphome/core/entity_base.h b/esphome/core/entity_base.h
index e7bd56a161d..ea3998cc483 100644
--- a/esphome/core/entity_base.h
+++ b/esphome/core/entity_base.h
@@ -233,7 +233,7 @@ void log_entity_unit_of_measurement(const char *tag, const char *prefix, const E
 template<typename T> class StatefulEntityBase : public EntityBase {
  public:
   virtual bool has_state() const { return this->state_.has_value(); }
-  virtual const T &get_state() const { return this->state_.value(); }
+  virtual const T &get_state() const { return this->state_.value(); }  // NOLINT(bugprone-unchecked-optional-access)
   virtual T get_state_default(T default_value) const { return this->state_.value_or(default_value); }
   void invalidate_state() { this->set_new_state({}); }
 
diff --git a/esphome/core/optional.h b/esphome/core/optional.h
index 7f9db7817d6..88a02aa8b25 100644
--- a/esphome/core/optional.h
+++ b/esphome/core/optional.h
@@ -1,220 +1,12 @@
 #pragma once
-//
-// Copyright (c) 2017 Martin Moene
-//
-// https://github.com/martinmoene/optional-bare
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// Modified by Otto Winter on 18.05.18
 
-#include <algorithm>
+#include <optional>
 
 namespace esphome {
 
-// type for nullopt
-
-struct nullopt_t {  // NOLINT
-  struct init {};   // NOLINT
-  nullopt_t(init /*unused*/) {}
-};
-
-// extra parenthesis to prevent the most vexing parse:
-
-const nullopt_t nullopt((nullopt_t::init()));  // NOLINT
-
-// Simplistic optional: requires T to be default constructible, copyable.
-
-template<typename T> class optional {  // NOLINT
- private:
-  using safe_bool = void (optional::*)() const;
-
- public:
-  using value_type = T;
-
-  optional() {}
-
-  optional(nullopt_t /*unused*/) {}
-
-  optional(T const &arg) : has_value_(true), value_(arg) {}  // NOLINT
-
-  template<class U> optional(optional<U> const &other) : has_value_(other.has_value()), value_(other.value()) {}
-
-  optional &operator=(nullopt_t /*unused*/) {
-    reset();
-    return *this;
-  }
-  bool operator==(optional<T> const &rhs) const {
-    if (has_value() && rhs.has_value())
-      return value() == rhs.value();
-    return !has_value() && !rhs.has_value();
-  }
-
-  template<class U> optional &operator=(optional<U> const &other) {
-    has_value_ = other.has_value();
-    value_ = other.value();
-    return *this;
-  }
-
-  void swap(optional &rhs) noexcept {
-    using std::swap;
-    if (has_value() && rhs.has_value()) {
-      swap(**this, *rhs);
-    } else if (!has_value() && rhs.has_value()) {
-      initialize(*rhs);
-      rhs.reset();
-    } else if (has_value() && !rhs.has_value()) {
-      rhs.initialize(**this);
-      reset();
-    }
-  }
-
-  // observers
-
-  value_type const *operator->() const { return &value_; }
-
-  value_type *operator->() { return &value_; }
-
-  value_type const &operator*() const { return value_; }
-
-  value_type &operator*() { return value_; }
-
-  operator safe_bool() const { return has_value() ? &optional::this_type_does_not_support_comparisons : nullptr; }
-
-  bool has_value() const { return has_value_; }
-
-  value_type const &value() const { return value_; }
-
-  value_type &value() { return value_; }
-
-  template<class U> value_type value_or(U const &v) const { return has_value() ? value() : static_cast<value_type>(v); }
-
-  // modifiers
-
-  void reset() { has_value_ = false; }
-
- private:
-  void this_type_does_not_support_comparisons() const {}  // NOLINT
-
-  template<typename V> void initialize(V const &value) {  // NOLINT
-    value_ = value;
-    has_value_ = true;
-  }
-
-  bool has_value_{false};  // NOLINT
-  value_type value_;       // NOLINT
-};
-
-// Relational operators
-
-template<typename T, typename U> inline bool operator==(optional<T> const &x, optional<U> const &y) {
-  return bool(x) != bool(y) ? false : !bool(x) ? true : *x == *y;
-}
-
-template<typename T, typename U> inline bool operator!=(optional<T> const &x, optional<U> const &y) {
-  return !(x == y);
-}
-
-template<typename T, typename U> inline bool operator<(optional<T> const &x, optional<U> const &y) {
-  return (!y) ? false : (!x) ? true : *x < *y;
-}
-
-template<typename T, typename U> inline bool operator>(optional<T> const &x, optional<U> const &y) { return (y < x); }
-
-template<typename T, typename U> inline bool operator<=(optional<T> const &x, optional<U> const &y) { return !(y < x); }
-
-template<typename T, typename U> inline bool operator>=(optional<T> const &x, optional<U> const &y) { return !(x < y); }
-
-// Comparison with nullopt
-
-template<typename T> inline bool operator==(optional<T> const &x, nullopt_t /*unused*/) { return (!x); }
-
-template<typename T> inline bool operator==(nullopt_t /*unused*/, optional<T> const &x) { return (!x); }
-
-template<typename T> inline bool operator!=(optional<T> const &x, nullopt_t /*unused*/) { return bool(x); }
-
-template<typename T> inline bool operator!=(nullopt_t /*unused*/, optional<T> const &x) { return bool(x); }
-
-template<typename T> inline bool operator<(optional<T> const & /*unused*/, nullopt_t /*unused*/) { return false; }
-
-template<typename T> inline bool operator<(nullopt_t /*unused*/, optional<T> const &x) { return bool(x); }
-
-template<typename T> inline bool operator<=(optional<T> const &x, nullopt_t /*unused*/) { return (!x); }
-
-template<typename T> inline bool operator<=(nullopt_t /*unused*/, optional<T> const & /*unused*/) { return true; }
-
-template<typename T> inline bool operator>(optional<T> const &x, nullopt_t /*unused*/) { return bool(x); }
-
-template<typename T> inline bool operator>(nullopt_t /*unused*/, optional<T> const & /*unused*/) { return false; }
-
-template<typename T> inline bool operator>=(optional<T> const & /*unused*/, nullopt_t /*unused*/) { return true; }
-
-template<typename T> inline bool operator>=(nullopt_t /*unused*/, optional<T> const &x) { return (!x); }
-
-// Comparison with T
-
-template<typename T, typename U> inline bool operator==(optional<T> const &x, U const &v) {
-  return bool(x) ? *x == v : false;
-}
-
-template<typename T, typename U> inline bool operator==(U const &v, optional<T> const &x) {
-  return bool(x) ? v == *x : false;
-}
-
-template<typename T, typename U> inline bool operator!=(optional<T> const &x, U const &v) {
-  return bool(x) ? *x != v : true;
-}
-
-template<typename T, typename U> inline bool operator!=(U const &v, optional<T> const &x) {
-  return bool(x) ? v != *x : true;
-}
-
-template<typename T, typename U> inline bool operator<(optional<T> const &x, U const &v) {
-  return bool(x) ? *x < v : true;
-}
-
-template<typename T, typename U> inline bool operator<(U const &v, optional<T> const &x) {
-  return bool(x) ? v < *x : false;
-}
-
-template<typename T, typename U> inline bool operator<=(optional<T> const &x, U const &v) {
-  return bool(x) ? *x <= v : true;
-}
-
-template<typename T, typename U> inline bool operator<=(U const &v, optional<T> const &x) {
-  return bool(x) ? v <= *x : false;
-}
-
-template<typename T, typename U> inline bool operator>(optional<T> const &x, U const &v) {
-  return bool(x) ? *x > v : false;
-}
-
-template<typename T, typename U> inline bool operator>(U const &v, optional<T> const &x) {
-  return bool(x) ? v > *x : true;
-}
-
-template<typename T, typename U> inline bool operator>=(optional<T> const &x, U const &v) {
-  return bool(x) ? *x >= v : false;
-}
-
-template<typename T, typename U> inline bool operator>=(U const &v, optional<T> const &x) {
-  return bool(x) ? v >= *x : true;
-}
-
-// Specialized algorithms
-
-template<typename T> void swap(optional<T> &x, optional<T> &y) noexcept { x.swap(y); }
-
-// Convenience function to create an optional.
-
-template<typename T> inline optional<T> make_optional(T const &v) { return optional<T>(v); }
+using std::make_optional;
+using std::nullopt;
+using std::nullopt_t;
+using std::optional;
 
 }  // namespace esphome
diff --git a/esphome/core/static_task.cpp b/esphome/core/static_task.cpp
new file mode 100644
index 00000000000..4cfead44c29
--- /dev/null
+++ b/esphome/core/static_task.cpp
@@ -0,0 +1,64 @@
+#include "esphome/core/static_task.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+
+bool StaticTask::create(TaskFunction_t fn, const char *name, uint32_t stack_size, void *param, UBaseType_t priority,
+                        bool use_psram) {
+  if (this->handle_ != nullptr) {
+    // Task is already created; must call destroy() first
+    return false;
+  }
+
+  if (this->stack_buffer_ != nullptr && (stack_size > this->stack_size_ || use_psram != this->use_psram_)) {
+    // Existing buffer is too small or wrong memory type; deallocate to reallocate below
+    RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
+                                                         : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+    allocator.deallocate(this->stack_buffer_, this->stack_size_);
+    this->stack_buffer_ = nullptr;
+  }
+
+  if (this->stack_buffer_ == nullptr) {
+    this->stack_size_ = stack_size;
+    this->use_psram_ = use_psram;
+    RAMAllocator<StackType_t> allocator(use_psram ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
+                                                  : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+    this->stack_buffer_ = allocator.allocate(stack_size);
+  }
+  if (this->stack_buffer_ == nullptr) {
+    return false;
+  }
+
+  this->handle_ = xTaskCreateStatic(fn, name, this->stack_size_, param, priority, this->stack_buffer_, &this->tcb_);
+  if (this->handle_ == nullptr) {
+    this->deallocate();
+    return false;
+  }
+  return true;
+}
+
+void StaticTask::destroy() {
+  if (this->handle_ != nullptr) {
+    TaskHandle_t handle = this->handle_;
+    this->handle_ = nullptr;
+    vTaskDelete(handle);
+  }
+}
+
+void StaticTask::deallocate() {
+  this->destroy();
+  if (this->stack_buffer_ != nullptr) {
+    RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
+                                                         : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+    allocator.deallocate(this->stack_buffer_, this->stack_size_);
+    this->stack_buffer_ = nullptr;
+    this->stack_size_ = 0;
+  }
+}
+
+}  // namespace esphome
+
+#endif  // USE_ESP32
diff --git a/esphome/core/static_task.h b/esphome/core/static_task.h
new file mode 100644
index 00000000000..5fd5b38f9ef
--- /dev/null
+++ b/esphome/core/static_task.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <cstdint>
+
+namespace esphome {
+
+/** Helper for FreeRTOS static task management.
+ * Bundles TaskHandle_t, StaticTask_t, and the stack buffer into one object with create/destroy methods.
+ */
+class StaticTask {
+ public:
+  /// @brief Check if the task has been created and not yet destroyed.
+  bool is_created() const { return this->handle_ != nullptr; }
+
+  /// @brief Get the FreeRTOS task handle.
+  TaskHandle_t get_handle() const { return this->handle_; }
+
+  /// @brief Allocate stack and create task.
+  /// @param fn         Task function
+  /// @param name       Task name (for debug)
+  /// @param stack_size Stack size in StackType_t words
+  /// @param param      Parameter passed to task function
+  /// @param priority   FreeRTOS task priority
+  /// @param use_psram  If true, allocate stack in PSRAM; otherwise internal RAM
+  /// @return true on success
+  bool create(TaskFunction_t fn, const char *name, uint32_t stack_size, void *param, UBaseType_t priority,
+              bool use_psram);
+
+  /// @brief Delete the task but keep the stack buffer allocated for reuse by a subsequent create() call.
+  void destroy();
+
+  /// @brief Delete the task (if running) and free the stack buffer.
+  void deallocate();
+
+ protected:
+  TaskHandle_t handle_{nullptr};
+  StaticTask_t tcb_;
+  StackType_t *stack_buffer_{nullptr};
+  uint32_t stack_size_{0};
+  bool use_psram_{false};
+};
+
+}  // namespace esphome
+
+#endif  // USE_ESP32
diff --git a/esphome/cpp_types.py b/esphome/cpp_types.py
index 6d255bc0be4..8dd77de8434 100644
--- a/esphome/cpp_types.py
+++ b/esphome/cpp_types.py
@@ -31,9 +31,7 @@ Component = esphome_ns.class_("Component")
 ComponentPtr = Component.operator("ptr")
 PollingComponent = esphome_ns.class_("PollingComponent", Component)
 Application = esphome_ns.class_("Application")
-# Create optional with explicit namespace to avoid ambiguity with std::optional
-# The generated code will use esphome::optional instead of just optional
-optional = global_ns.namespace("esphome").class_("optional")
+optional = global_ns.namespace("std").class_("optional")
 arduino_json_ns = global_ns.namespace("ArduinoJson")
 JsonObject = arduino_json_ns.class_("JsonObject")
 JsonObjectConst = arduino_json_ns.class_("JsonObjectConst")
diff --git a/script/ci-custom.py b/script/ci-custom.py
index b60d7d77401..8e1652b505d 100755
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -72,6 +72,7 @@ ignore_types = (
     ".gif",
     ".webp",
     ".bin",
+    ".wav",
 )
 
 LINT_FILE_CHECKS = []
diff --git a/script/cpp_unit_test.py b/script/cpp_unit_test.py
index 02b133060aa..b87261ab332 100755
--- a/script/cpp_unit_test.py
+++ b/script/cpp_unit_test.py
@@ -12,6 +12,7 @@ from esphome.__main__ import command_compile, parse_args
 from esphome.config import validate_config
 from esphome.core import CORE
 from esphome.platformio_api import get_idedata
+from esphome.yaml_util import load_yaml
 
 # This must coincide with the version in /platformio.ini
 PLATFORMIO_GOOGLE_TEST_LIB = "google/googletest@^1.15.2"
@@ -44,6 +45,38 @@ def filter_components_without_tests(components: list[str]) -> list[str]:
     return filtered_components
 
 
+# Name of optional per-component YAML config merged into the test build
+# before validation so that platform defines (USE_SENSOR, etc.) are generated.
+CPP_TEST_CONFIG_FILE = "cpp_test.yaml"
+
+
+def load_component_test_configs(components: list[str]) -> dict:
+    """Load cpp_test.yaml files from test component directories.
+
+    These configs are merged into the base test config *before* validation
+    so that entity registration runs during code generation, which causes
+    the corresponding USE_* defines to be emitted.
+    """
+    merged: dict = {}
+    for component in components:
+        config_file = COMPONENTS_TESTS_DIR / component / CPP_TEST_CONFIG_FILE
+        if not config_file.exists():
+            continue
+        component_config = load_yaml(config_file)
+        if not component_config:
+            continue
+        for key, value in component_config.items():
+            if (
+                key in merged
+                and isinstance(merged[key], list)
+                and isinstance(value, list)
+            ):
+                merged[key].extend(value)
+            else:
+                merged[key] = value
+    return merged
+
+
 def create_test_config(config_name: str, includes: list[str]) -> dict:
     """Create ESPHome test configuration for C++ unit tests.
 
@@ -115,6 +148,11 @@ def run_tests(selected_components: list[str]) -> int:
 
     config = create_test_config(config_name, includes)
 
+    # Merge component-specific test configs (e.g. sensor instances) before
+    # validation so that entity registration and USE_* defines work.
+    extra_config = load_component_test_configs(components)
+    config.update(extra_config)
+
     CORE.config_path = COMPONENTS_TESTS_DIR / "dummy.yaml"
     CORE.dashboard = None
 
@@ -122,8 +160,10 @@ def run_tests(selected_components: list[str]) -> int:
     config = validate_config(config, {})
 
     # Add all components and dependencies to the base configuration after validation, so their files
-    # are added to the build.
-    config.update({key: {} for key in components_with_dependencies})
+    # are added to the build.  Use setdefault to avoid overwriting entries that were
+    # already validated (e.g. sensor instances from cpp_test.yaml).
+    for key in components_with_dependencies:
+        config.setdefault(key, {})
 
     print(f"Testing components: {', '.join(components)}")
     CORE.config = config
diff --git a/tests/component_tests/text/test_text.py b/tests/component_tests/text/test_text.py
index 8a16d995401..2d168aa79dd 100644
--- a/tests/component_tests/text/test_text.py
+++ b/tests/component_tests/text/test_text.py
@@ -66,5 +66,20 @@ def test_text_config_lamda_is_set(generate_main):
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
     # Then
-    assert "it_4->set_template([]() -> esphome::optional<std::string> {" in main_cpp
+    assert "it_4->set_template([]() -> std::optional<std::string> {" in main_cpp
     assert 'return std::string{"Hello"};' in main_cpp
+
+
+def test_esphome_optional_alias_works(generate_main):
+    """
+    Test that esphome::optional alias compiles (backward compatibility)
+    """
+    # Given
+
+    # When
+    main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
+
+    # Then
+    # Codegen emits std::optional, but esphome::optional must also work
+    # via the using alias in esphome/core/optional.h
+    assert "std::optional<std::string>" in main_cpp
diff --git a/tests/components/audio_file/common.yaml b/tests/components/audio_file/common.yaml
new file mode 100644
index 00000000000..94042080946
--- /dev/null
+++ b/tests/components/audio_file/common.yaml
@@ -0,0 +1,5 @@
+audio_file:
+  - id: test_audio
+    file:
+      type: local
+      path: $component_dir/test.wav
diff --git a/tests/components/audio_file/test.esp32-idf.yaml b/tests/components/audio_file/test.esp32-idf.yaml
new file mode 100644
index 00000000000..dade44d145b
--- /dev/null
+++ b/tests/components/audio_file/test.esp32-idf.yaml
@@ -0,0 +1 @@
+<<: !include common.yaml
diff --git a/tests/components/audio_file/test.wav b/tests/components/audio_file/test.wav
new file mode 100644
index 00000000000..f9d07ef2238
Binary files /dev/null and b/tests/components/audio_file/test.wav differ
diff --git a/tests/components/globals/common.yaml b/tests/components/globals/common.yaml
index efa3cba0766..35dca0624f3 100644
--- a/tests/components/globals/common.yaml
+++ b/tests/components/globals/common.yaml
@@ -27,3 +27,14 @@ globals:
     type: bool
     restore_value: false
     initial_value: "false"
+  # Test restore_value with string "false" - should be converted to bool false
+  - id: glob_no_restore_string_false
+    type: int
+    restore_value: "false"
+    initial_value: "42"
+  # Test restore_value with string "true" - should be converted to bool true
+  - id: glob_restore_string_true
+    type: int
+    restore_value: "true"
+    initial_value: "99"
+    update_interval: 5s
diff --git a/tests/components/integration/common-esp32.yaml b/tests/components/integration/common-esp32.yaml
index 248106fd608..26550d3c5c9 100644
--- a/tests/components/integration/common-esp32.yaml
+++ b/tests/components/integration/common-esp32.yaml
@@ -1,9 +1,19 @@
+esphome:
+  on_boot:
+    then:
+      - sensor.integration.reset:
+          id: integration_sensor
+      - sensor.integration.set_value:
+          id: integration_sensor
+          value: 100.0
+
 sensor:
   - platform: adc
     id: my_sensor
     pin: ${pin}
     attenuation: 12db
   - platform: integration
+    id: integration_sensor
     sensor: my_sensor
     name: Integration Sensor
     time_unit: s
diff --git a/tests/components/openthread/test.esp32-c6-idf.yaml b/tests/components/openthread/test.esp32-c6-idf.yaml
index 77abc433c14..008edd53972 100644
--- a/tests/components/openthread/test.esp32-c6-idf.yaml
+++ b/tests/components/openthread/test.esp32-c6-idf.yaml
@@ -1,3 +1,9 @@
+esp32:
+  board: esp32-c6-devkitc-1
+  framework:
+    type: esp-idf
+    log_level: DEBUG
+
 network:
   enable_ipv6: true
 
diff --git a/tests/components/packet_transport/common.h b/tests/components/packet_transport/common.h
new file mode 100644
index 00000000000..f8caa7bb683
--- /dev/null
+++ b/tests/components/packet_transport/common.h
@@ -0,0 +1,98 @@
+#pragma once
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#include <gtest/gtest.h>
+#include "esphome/components/packet_transport/packet_transport.h"
+
+namespace esphome::packet_transport::testing {
+
+// Protocol constants mirrored from packet_transport.cpp for test packet construction.
+static constexpr uint16_t MAGIC_NUMBER = 0x4553;
+static constexpr uint16_t MAGIC_PING = 0x5048;
+
+// Concrete testable implementation of PacketTransport.
+// Captures sent packets and exposes protected members for verification.
+//
+// Sensor round-trip tests require USE_SENSOR / USE_BINARY_SENSOR to be defined,
+// which happens when 'sensor' and 'binary_sensor' components are in the build.
+// Run with --all or include those components to enable the full test suite.
+class TestablePacketTransport : public PacketTransport {
+ public:
+  using PacketTransport::add_key_;
+  using PacketTransport::data_;
+  using PacketTransport::encryption_key_;
+  using PacketTransport::flush_;
+  using PacketTransport::header_;
+  using PacketTransport::increment_code_;
+  using PacketTransport::init_data_;
+  using PacketTransport::is_encrypted_;
+  using PacketTransport::is_provider_;
+  using PacketTransport::name_;
+  using PacketTransport::ping_key_;
+  using PacketTransport::ping_keys_;
+  using PacketTransport::ping_pong_enable_;
+  using PacketTransport::ping_pong_recyle_time_;
+  using PacketTransport::process_;
+  using PacketTransport::providers_;
+  using PacketTransport::rolling_code_;
+  using PacketTransport::rolling_code_enable_;
+  using PacketTransport::send_data_;
+  using PacketTransport::updated_;
+#ifdef USE_SENSOR
+  using PacketTransport::add_data_;
+  using PacketTransport::remote_sensors_;
+  using PacketTransport::sensors_;
+#endif
+#ifdef USE_BINARY_SENSOR
+  using PacketTransport::add_binary_data_;
+  using PacketTransport::binary_sensors_;
+  using PacketTransport::remote_binary_sensors_;
+#endif
+
+  // NOTE: std::vector is used here for test convenience. For production code,
+  // consider using StaticVector or FixedVector from esphome/core/helpers.h instead.
+  mutable std::vector<std::vector<uint8_t>> sent_packets;
+  size_t max_packet_size{512};
+  bool send_enabled{true};
+
+  void send_packet(const std::vector<uint8_t> &buf) const override { this->sent_packets.push_back(buf); }
+  size_t get_max_packet_size() override { return this->max_packet_size; }
+  bool should_send() override { return this->send_enabled; }
+
+  /// Build the packet header for testing without requiring App or global_preferences.
+  void init_for_test(const char *name) {
+    this->name_ = name;
+    this->header_.clear();
+    // MAGIC_NUMBER as uint16_t little-endian
+    this->header_.push_back(MAGIC_NUMBER & 0xFF);
+    this->header_.push_back((MAGIC_NUMBER >> 8) & 0xFF);
+    // Length-prefixed hostname
+    auto len = strlen(name);
+    this->header_.push_back(static_cast<uint8_t>(len));
+    for (size_t i = 0; i < len; i++)
+      this->header_.push_back(name[i]);
+    // Pad to 4-byte boundary
+    while (this->header_.size() & 0x3)
+      this->header_.push_back(0);
+  }
+};
+
+/// Build a MAGIC_PING packet for testing add_key_ / ping-pong flows.
+inline std::vector<uint8_t> build_ping_packet(const char *hostname, uint32_t key) {
+  std::vector<uint8_t> packet;
+  packet.push_back(MAGIC_PING & 0xFF);
+  packet.push_back((MAGIC_PING >> 8) & 0xFF);
+  auto len = strlen(hostname);
+  packet.push_back(static_cast<uint8_t>(len));
+  for (size_t i = 0; i < len; i++)
+    packet.push_back(hostname[i]);
+  packet.push_back(key & 0xFF);
+  packet.push_back((key >> 8) & 0xFF);
+  packet.push_back((key >> 16) & 0xFF);
+  packet.push_back((key >> 24) & 0xFF);
+  return packet;
+}
+
+}  // namespace esphome::packet_transport::testing
diff --git a/tests/components/packet_transport/cpp_test.yaml b/tests/components/packet_transport/cpp_test.yaml
new file mode 100644
index 00000000000..fa39df3c0ae
--- /dev/null
+++ b/tests/components/packet_transport/cpp_test.yaml
@@ -0,0 +1,11 @@
+# Extra component configuration required by C++ unit tests.
+# Loaded by cpp_unit_test.py and merged into the test build config
+# before validation, so that platform defines (USE_SENSOR, etc.) are generated.
+
+sensor:
+  - platform: template
+    id: test_cpp_sensor
+
+binary_sensor:
+  - platform: template
+    id: test_cpp_binary_sensor
diff --git a/tests/components/packet_transport/packet_transport_test.cpp b/tests/components/packet_transport/packet_transport_test.cpp
new file mode 100644
index 00000000000..d8f11ca6072
--- /dev/null
+++ b/tests/components/packet_transport/packet_transport_test.cpp
@@ -0,0 +1,445 @@
+#include "common.h"
+
+namespace esphome::packet_transport::testing {
+
+// --- Configuration setter tests ---
+
+TEST(PacketTransportTest, SetIsProvider) {
+  TestablePacketTransport transport;
+  transport.set_is_provider(true);
+  EXPECT_TRUE(transport.is_provider_);
+}
+
+TEST(PacketTransportTest, SetEncryptionKey) {
+  TestablePacketTransport transport;
+  std::vector<uint8_t> key(32, 0xAB);
+  transport.set_encryption_key(key);
+  EXPECT_EQ(transport.encryption_key_, key);
+  EXPECT_TRUE(transport.is_encrypted_());
+}
+
+TEST(PacketTransportTest, NoEncryptionByDefault) {
+  TestablePacketTransport transport;
+  EXPECT_FALSE(transport.is_encrypted_());
+}
+
+TEST(PacketTransportTest, SetRollingCodeEnable) {
+  TestablePacketTransport transport;
+  transport.set_rolling_code_enable(true);
+  EXPECT_TRUE(transport.rolling_code_enable_);
+}
+
+TEST(PacketTransportTest, SetPingPongEnable) {
+  TestablePacketTransport transport;
+  transport.set_ping_pong_enable(true);
+  EXPECT_TRUE(transport.ping_pong_enable_);
+}
+
+TEST(PacketTransportTest, SetPingPongRecycleTime) {
+  TestablePacketTransport transport;
+  transport.set_ping_pong_recycle_time(600);
+  EXPECT_EQ(transport.ping_pong_recyle_time_, 600u);
+}
+
+// --- Provider management ---
+
+TEST(PacketTransportTest, AddProvider) {
+  TestablePacketTransport transport;
+  transport.add_provider("host1");
+  EXPECT_TRUE(transport.providers_.contains("host1"));
+  EXPECT_EQ(transport.providers_.size(), 1u);
+}
+
+TEST(PacketTransportTest, AddProviderDuplicate) {
+  TestablePacketTransport transport;
+  transport.add_provider("host1");
+  transport.add_provider("host1");
+  EXPECT_EQ(transport.providers_.size(), 1u);
+}
+
+TEST(PacketTransportTest, SetProviderEncryption) {
+  TestablePacketTransport transport;
+  transport.add_provider("host1");
+  std::vector<uint8_t> key(32, 0xCD);
+  transport.set_provider_encryption("host1", key);
+  EXPECT_EQ(transport.providers_["host1"].encryption_key, key);
+}
+
+// --- Sensor management (requires USE_SENSOR / USE_BINARY_SENSOR) ---
+
+#ifdef USE_SENSOR
+TEST(PacketTransportTest, AddSensor) {
+  TestablePacketTransport transport;
+  sensor::Sensor s;
+  transport.add_sensor("temp", &s);
+  ASSERT_EQ(transport.sensors_.size(), 1u);
+  EXPECT_STREQ(transport.sensors_[0].id, "temp");
+  EXPECT_EQ(transport.sensors_[0].sensor, &s);
+  EXPECT_TRUE(transport.sensors_[0].updated);
+}
+
+TEST(PacketTransportTest, AddRemoteSensor) {
+  TestablePacketTransport transport;
+  sensor::Sensor s;
+  transport.add_remote_sensor("host1", "remote_temp", &s);
+  EXPECT_TRUE(transport.providers_.contains("host1"));
+  EXPECT_EQ(transport.remote_sensors_["host1"]["remote_temp"], &s);
+}
+#endif
+
+#ifdef USE_BINARY_SENSOR
+TEST(PacketTransportTest, AddBinarySensor) {
+  TestablePacketTransport transport;
+  binary_sensor::BinarySensor bs;
+  transport.add_binary_sensor("motion", &bs);
+  ASSERT_EQ(transport.binary_sensors_.size(), 1u);
+  EXPECT_STREQ(transport.binary_sensors_[0].id, "motion");
+  EXPECT_EQ(transport.binary_sensors_[0].sensor, &bs);
+}
+
+TEST(PacketTransportTest, AddRemoteBinarySensor) {
+  TestablePacketTransport transport;
+  binary_sensor::BinarySensor bs;
+  transport.add_remote_binary_sensor("host1", "remote_motion", &bs);
+  EXPECT_TRUE(transport.providers_.contains("host1"));
+  EXPECT_EQ(transport.remote_binary_sensors_["host1"]["remote_motion"], &bs);
+}
+#endif
+
+// --- Unencrypted round-trip tests (require USE_SENSOR / USE_BINARY_SENSOR) ---
+
+#ifdef USE_SENSOR
+TEST(PacketTransportTest, UnencryptedSensorRoundTrip) {
+  // Encoder
+  TestablePacketTransport encoder;
+  encoder.init_for_test("sender");
+  sensor::Sensor local_sensor;
+  local_sensor.state = 42.5f;
+  encoder.add_sensor("temp", &local_sensor);
+
+  encoder.send_data_(true);
+  ASSERT_EQ(encoder.sent_packets.size(), 1u);
+
+  // Decoder
+  TestablePacketTransport decoder;
+  decoder.init_for_test("receiver");
+  sensor::Sensor remote_sensor;
+  remote_sensor.state = -999.0f;  // sentinel
+  decoder.add_remote_sensor("sender", "temp", &remote_sensor);
+
+  auto &packet = encoder.sent_packets[0];
+  decoder.process_({packet.data(), packet.size()});
+  EXPECT_FLOAT_EQ(remote_sensor.state, 42.5f);
+}
+#endif
+
+#ifdef USE_BINARY_SENSOR
+TEST(PacketTransportTest, UnencryptedBinarySensorRoundTrip) {
+  TestablePacketTransport encoder;
+  encoder.init_for_test("sender");
+  binary_sensor::BinarySensor local_bs;
+  local_bs.state = true;
+  encoder.add_binary_sensor("motion", &local_bs);
+
+  encoder.send_data_(true);
+  ASSERT_EQ(encoder.sent_packets.size(), 1u);
+
+  TestablePacketTransport decoder;
+  decoder.init_for_test("receiver");
+  binary_sensor::BinarySensor remote_bs;
+  decoder.add_remote_binary_sensor("sender", "motion", &remote_bs);
+
+  auto &packet = encoder.sent_packets[0];
+  decoder.process_({packet.data(), packet.size()});
+  EXPECT_TRUE(remote_bs.state);
+}
+#endif
+
+#if defined(USE_SENSOR) && defined(USE_BINARY_SENSOR)
+TEST(PacketTransportTest, MultipleSensorsRoundTrip) {
+  TestablePacketTransport encoder;
+  encoder.init_for_test("sender");
+
+  sensor::Sensor s1, s2;
+  s1.state = 10.0f;
+  s2.state = 20.0f;
+  encoder.add_sensor("s1", &s1);
+  encoder.add_sensor("s2", &s2);
+
+  binary_sensor::BinarySensor bs1;
+  bs1.state = true;
+  encoder.add_binary_sensor("bs1", &bs1);
+
+  encoder.send_data_(true);
+  ASSERT_EQ(encoder.sent_packets.size(), 1u);
+
+  TestablePacketTransport decoder;
+  decoder.init_for_test("receiver");
+  sensor::Sensor rs1, rs2;
+  binary_sensor::BinarySensor rbs1;
+  rs1.state = -999.0f;
+  rs2.state = -999.0f;
+  decoder.add_remote_sensor("sender", "s1", &rs1);
+  decoder.add_remote_sensor("sender", "s2", &rs2);
+  decoder.add_remote_binary_sensor("sender", "bs1", &rbs1);
+
+  auto &packet = encoder.sent_packets[0];
+  decoder.process_({packet.data(), packet.size()});
+
+  EXPECT_FLOAT_EQ(rs1.state, 10.0f);
+  EXPECT_FLOAT_EQ(rs2.state, 20.0f);
+  EXPECT_TRUE(rbs1.state);
+}
+#endif
+
+// --- Encrypted round-trip ---
+
+#ifdef USE_SENSOR
+TEST(PacketTransportTest, EncryptedSensorRoundTrip) {
+  std::vector<uint8_t> key(32);
+  for (int i = 0; i < 32; i++)
+    key[i] = i;
+
+  TestablePacketTransport encoder;
+  encoder.init_for_test("sender");
+  encoder.set_encryption_key(key);
+  sensor::Sensor local_sensor;
+  local_sensor.state = 99.9f;
+  encoder.add_sensor("temp", &local_sensor);
+
+  encoder.send_data_(true);
+  ASSERT_EQ(encoder.sent_packets.size(), 1u);
+
+  TestablePacketTransport decoder;
+  decoder.init_for_test("receiver");
+  sensor::Sensor remote_sensor;
+  remote_sensor.state = -999.0f;
+  decoder.add_remote_sensor("sender", "temp", &remote_sensor);
+  decoder.set_provider_encryption("sender", key);
+
+  auto &packet = encoder.sent_packets[0];
+  decoder.process_({packet.data(), packet.size()});
+  EXPECT_FLOAT_EQ(remote_sensor.state, 99.9f);
+}
+
+// --- Selective send ---
+
+TEST(PacketTransportTest, SendDataOnlyUpdated) {
+  TestablePacketTransport encoder;
+  encoder.init_for_test("sender");
+
+  sensor::Sensor s1, s2;
+  s1.state = 1.0f;
+  s2.state = 2.0f;
+  encoder.add_sensor("s1", &s1);
+  encoder.add_sensor("s2", &s2);
+
+  // Mark s1 as not updated, only s2 as updated
+  encoder.sensors_[0].updated = false;
+  encoder.sensors_[1].updated = true;
+
+  encoder.send_data_(false);
+  ASSERT_EQ(encoder.sent_packets.size(), 1u);
+
+  TestablePacketTransport decoder;
+  decoder.init_for_test("receiver");
+  sensor::Sensor rs1, rs2;
+  rs1.state = -999.0f;
+  rs2.state = -999.0f;
+  decoder.add_remote_sensor("sender", "s1", &rs1);
+  decoder.add_remote_sensor("sender", "s2", &rs2);
+
+  auto &packet = encoder.sent_packets[0];
+  decoder.process_({packet.data(), packet.size()});
+
+  EXPECT_FLOAT_EQ(rs1.state, -999.0f);  // not updated, not sent
+  EXPECT_FLOAT_EQ(rs2.state, 2.0f);     // updated, sent
+}
+#endif
+
+// --- Ping key tests ---
+
+TEST(PacketTransportTest, PingKeyStoredWhenEncrypted) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  transport.set_encryption_key(std::vector<uint8_t>(32, 0xAA));
+
+  auto ping = build_ping_packet("requester", 0xDEADBEEF);
+  transport.process_({ping.data(), ping.size()});
+
+  ASSERT_EQ(transport.ping_keys_.size(), 1u);
+  EXPECT_EQ(transport.ping_keys_["requester"], 0xDEADBEEFu);
+}
+
+TEST(PacketTransportTest, PingKeyIgnoredWhenNotEncrypted) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  // No encryption key — add_key_ should be a no-op
+
+  auto ping = build_ping_packet("requester", 0xDEADBEEF);
+  transport.process_({ping.data(), ping.size()});
+
+  EXPECT_TRUE(transport.ping_keys_.empty());
+}
+
+TEST(PacketTransportTest, PingKeyUpdatedOnRepeat) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  transport.set_encryption_key(std::vector<uint8_t>(32, 0xAA));
+
+  auto ping1 = build_ping_packet("host1", 0x1111);
+  transport.process_({ping1.data(), ping1.size()});
+  EXPECT_EQ(transport.ping_keys_["host1"], 0x1111u);
+
+  // Same host, new key value — should update in place
+  auto ping2 = build_ping_packet("host1", 0x2222);
+  transport.process_({ping2.data(), ping2.size()});
+  EXPECT_EQ(transport.ping_keys_.size(), 1u);
+  EXPECT_EQ(transport.ping_keys_["host1"], 0x2222u);
+}
+
+TEST(PacketTransportTest, PingKeyMaxLimit) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  transport.set_encryption_key(std::vector<uint8_t>(32, 0xAA));
+
+  // Fill to MAX_PING_KEYS (4)
+  for (int i = 0; i < 4; i++) {
+    char name[16];
+    snprintf(name, sizeof(name), "host%d", i);
+    auto ping = build_ping_packet(name, 0x1000 + i);
+    transport.process_({ping.data(), ping.size()});
+  }
+  EXPECT_EQ(transport.ping_keys_.size(), 4u);
+
+  // 5th key should be discarded
+  auto ping = build_ping_packet("host4", 0x9999);
+  transport.process_({ping.data(), ping.size()});
+  EXPECT_EQ(transport.ping_keys_.size(), 4u);
+  EXPECT_FALSE(transport.ping_keys_.contains("host4"));
+}
+
+#ifdef USE_SENSOR
+TEST(PacketTransportTest, PingKeyIncludedInTransmittedPacket) {
+  std::vector<uint8_t> key(32, 0xBB);
+
+  // Responder: encrypted, owns a sensor
+  TestablePacketTransport responder;
+  responder.init_for_test("responder");
+  responder.set_encryption_key(key);
+  sensor::Sensor local_sensor;
+  local_sensor.state = 77.7f;
+  responder.add_sensor("temp", &local_sensor);
+
+  // Requester sends a MAGIC_PING that the responder processes
+  auto ping = build_ping_packet("requester", 0xDEADBEEF);
+  responder.process_({ping.data(), ping.size()});
+  ASSERT_EQ(responder.ping_keys_.size(), 1u);
+
+  // Responder sends sensor data — ping key should be embedded
+  responder.send_data_(true);
+  ASSERT_EQ(responder.sent_packets.size(), 1u);
+
+  // Requester: encrypted provider, ping-pong enabled, expects key 0xDEADBEEF
+  TestablePacketTransport requester;
+  requester.init_for_test("requester");
+  requester.set_ping_pong_enable(true);
+  requester.ping_key_ = 0xDEADBEEF;
+  sensor::Sensor remote_sensor;
+  remote_sensor.state = -999.0f;
+  requester.add_remote_sensor("responder", "temp", &remote_sensor);
+  requester.set_provider_encryption("responder", key);
+
+  // The requester decrypts the packet and finds its ping key echoed back,
+  // which gates the sensor data — if the key is missing, data is blocked.
+  auto &packet = responder.sent_packets[0];
+  requester.process_({packet.data(), packet.size()});
+  EXPECT_FLOAT_EQ(remote_sensor.state, 77.7f);
+}
+
+TEST(PacketTransportTest, MissingPingKeyBlocksSensorData) {
+  std::vector<uint8_t> key(32, 0xBB);
+
+  // Responder sends data WITHOUT receiving any MAGIC_PING first — no ping keys
+  TestablePacketTransport responder;
+  responder.init_for_test("responder");
+  responder.set_encryption_key(key);
+  sensor::Sensor local_sensor;
+  local_sensor.state = 77.7f;
+  responder.add_sensor("temp", &local_sensor);
+  responder.send_data_(true);
+  ASSERT_EQ(responder.sent_packets.size(), 1u);
+
+  // Requester with ping-pong enabled expects a key that isn't in the packet
+  TestablePacketTransport requester;
+  requester.init_for_test("requester");
+  requester.set_ping_pong_enable(true);
+  requester.ping_key_ = 0xDEADBEEF;
+  sensor::Sensor remote_sensor;
+  remote_sensor.state = -999.0f;
+  requester.add_remote_sensor("responder", "temp", &remote_sensor);
+  requester.set_provider_encryption("responder", key);
+
+  auto &packet = responder.sent_packets[0];
+  requester.process_({packet.data(), packet.size()});
+  EXPECT_FLOAT_EQ(remote_sensor.state, -999.0f);  // blocked — ping key not found
+}
+#endif
+
+// --- Process error handling ---
+
+TEST(PacketTransportTest, ProcessShortBuffer) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  uint8_t buf[] = {0x53};
+  // Too short for a magic number - should return safely
+  transport.process_({buf, 1});
+}
+
+TEST(PacketTransportTest, ProcessBadMagic) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  uint8_t buf[] = {0xFF, 0xFF, 0x00, 0x00};
+  // Wrong magic - should return safely
+  transport.process_({buf, sizeof(buf)});
+}
+
+TEST(PacketTransportTest, ProcessOwnHostname) {
+  TestablePacketTransport transport;
+  transport.init_for_test("myself");
+  // Build a packet from "myself" using a separate encoder
+  TestablePacketTransport fake_sender;
+  fake_sender.init_for_test("myself");
+  fake_sender.send_data_(true);
+  ASSERT_EQ(fake_sender.sent_packets.size(), 1u);
+
+  auto &packet = fake_sender.sent_packets[0];
+  // Should be silently ignored because hostname matches our own
+  transport.process_({packet.data(), packet.size()});
+}
+
+TEST(PacketTransportTest, ProcessUnknownHostname) {
+  TestablePacketTransport transport;
+  transport.init_for_test("receiver");
+  // No providers registered - "unknown" will not be found
+  TestablePacketTransport sender;
+  sender.init_for_test("unknown");
+  sender.send_data_(true);
+  ASSERT_EQ(sender.sent_packets.size(), 1u);
+
+  auto &packet = sender.sent_packets[0];
+  // Should return safely without crash
+  transport.process_({packet.data(), packet.size()});
+}
+
+// --- Send disabled ---
+
+TEST(PacketTransportTest, NoSendWhenDisabled) {
+  TestablePacketTransport transport;
+  transport.init_for_test("sender");
+  transport.send_enabled = false;
+  transport.send_data_(true);
+  EXPECT_TRUE(transport.sent_packets.empty());
+}
+
+}  // namespace esphome::packet_transport::testing
diff --git a/tests/components/template/common-base.yaml b/tests/components/template/common-base.yaml
index e9ddfcf43e4..ed398b0abd9 100644
--- a/tests/components/template/common-base.yaml
+++ b/tests/components/template/common-base.yaml
@@ -28,9 +28,14 @@ esphome:
     # Test C++ API: set_template() with stateless lambda (no captures)
     # NOTE: set_template() is not intended to be a public API, but we test it to ensure it doesn't break.
     - lambda: |-
-        id(template_sens).set_template([]() -> esphome::optional<float> {
+        id(template_sens).set_template([]() -> std::optional<float> {
           return 123.0f;
         });
+    # Test that esphome::optional alias still works for backward compatibility
+    - lambda: |-
+        id(template_sens).set_template([]() -> esphome::optional<float> {
+          return 42.0f;
+        });
 
     - datetime.date.set:
         id: test_date
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index 36df1bc83ec..b7f7fc60b3b 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -73,11 +73,6 @@ def shared_platformio_cache() -> Generator[Path]:
     test_cache_dir = Path.home() / ".esphome-integration-tests"
     cache_dir = test_cache_dir / "platformio"
 
-    # Create the temp directory that PlatformIO uses to avoid race conditions
-    # This ensures it exists and won't be deleted by parallel processes
-    platformio_tmp_dir = cache_dir / ".cache" / "tmp"
-    platformio_tmp_dir.mkdir(parents=True, exist_ok=True)
-
     # Use a lock file in the home directory to ensure only one process initializes the cache
     # This is needed when running with pytest-xdist
     # The lock file must be in a directory that already exists to avoid race conditions
@@ -87,8 +82,9 @@ def shared_platformio_cache() -> Generator[Path]:
     with open(lock_file, "w") as lock_fd:
         fcntl.flock(lock_fd.fileno(), fcntl.LOCK_EX)
 
-        # Check if cache needs initialization while holding the lock
-        if not cache_dir.exists() or not any(cache_dir.iterdir()):
+        # Check if the native platform is installed (the actual indicator of a populated cache)
+        native_platform = cache_dir / "platforms" / "native"
+        if not native_platform.exists():
             # Create the test cache directory if it doesn't exist
             test_cache_dir.mkdir(exist_ok=True)
 
diff --git a/tests/integration/fixtures/external_components/uart_mock/__init__.py b/tests/integration/fixtures/external_components/uart_mock/__init__.py
index 8deab4c21ec..abb3abcc419 100644
--- a/tests/integration/fixtures/external_components/uart_mock/__init__.py
+++ b/tests/integration/fixtures/external_components/uart_mock/__init__.py
@@ -43,6 +43,7 @@ CONF_INJECT_RX = "inject_rx"
 CONF_EXPECT_TX = "expect_tx"
 CONF_PERIODIC_RX = "periodic_rx"
 CONF_ON_TX = "on_tx"
+CONF_AUTO_START = "auto_start"
 
 UART_PARITY_OPTIONS = {
     "NONE": uart.UARTParityOptions.UART_CONFIG_PARITY_NONE,
@@ -95,6 +96,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional(CONF_INJECTIONS, default=[]): cv.ensure_list(INJECTION_SCHEMA),
         cv.Optional(CONF_RESPONSES, default=[]): cv.ensure_list(RESPONSE_SCHEMA),
         cv.Optional(CONF_PERIODIC_RX, default=[]): cv.ensure_list(PERIODIC_RX_SCHEMA),
+        cv.Optional(CONF_AUTO_START, default=True): cv.boolean,
         cv.Optional(CONF_ON_TX): automation.validate_automation(
             {
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MockUartTXTrigger),
@@ -138,6 +140,9 @@ async def to_code(config):
     cg.add(var.set_data_bits(config[CONF_DATA_BITS]))
     cg.add(var.set_parity(config[CONF_PARITY]))
 
+    if not config[CONF_AUTO_START]:
+        cg.add(var.set_auto_start(False))
+
     for injection in config[CONF_INJECTIONS]:
         rx_data = injection[CONF_INJECT_RX]
         delay_ms = injection[CONF_DELAY]
diff --git a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
index a4a1c41234c..83a13793be7 100644
--- a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
+++ b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
@@ -16,17 +16,21 @@ void MockUartComponent::setup() {
 }
 
 void MockUartComponent::loop() {
-  uint32_t now = App.get_loop_component_start_time();
-
-  // Initialize scenario start time on first loop() call, after all components have
-  // finished setup(). This prevents injection delays from being consumed during setup.
   if (!this->loop_started_) {
     this->loop_started_ = true;
-    this->scenario_start_ms_ = now;
-    this->cumulative_delay_ms_ = 0;
-    ESP_LOGD(TAG, "Scenario started at %u ms", now);
+    if (this->auto_start_) {
+      this->start_scenario();
+    } else {
+      ESP_LOGD(TAG, "Scenario waiting for manual start");
+    }
   }
 
+  if (!this->scenario_active_) {
+    return;
+  }
+
+  uint32_t now = App.get_loop_component_start_time();
+
   // Process at most ONE timed injection per loop iteration.
   // This ensures each injection is in a separate loop cycle, giving the consuming
   // component (e.g., LD2410) a chance to process each batch independently.
@@ -50,6 +54,19 @@ void MockUartComponent::loop() {
   }
 }
 
+void MockUartComponent::start_scenario() {
+  uint32_t now = App.get_loop_component_start_time();
+  this->scenario_active_ = true;
+  this->scenario_start_ms_ = now;
+  this->cumulative_delay_ms_ = 0;
+  this->injection_index_ = 0;
+  this->tx_buffer_.clear();
+  for (auto &periodic : this->periodic_rx_) {
+    periodic.last_inject_ms = now;
+  }
+  ESP_LOGD(TAG, "Scenario started at %u ms", now);
+}
+
 void MockUartComponent::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Mock UART Component:\n"
@@ -78,10 +95,12 @@ void MockUartComponent::write_array(const uint8_t *data, size_t len) {
   }
 #endif
 
-  this->try_match_response_();
+  if (this->scenario_active_) {
+    this->try_match_response_();
+  }
 
   // This directly calls a tx_hook (lambda) as an alternative to the simpler match_response mechanism.
-  if (this->tx_hook_) {
+  if (this->tx_hook_ && this->scenario_active_) {
     std::vector<uint8_t> buf(data, data + len);
     this->tx_hook_(buf);
   }
diff --git a/tests/integration/fixtures/external_components/uart_mock/uart_mock.h b/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
index 5bbc3c1bf60..b721512f96c 100644
--- a/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
+++ b/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
@@ -37,6 +37,8 @@ class MockUartComponent : public uart::UARTComponent, public Component {
   void add_response(const std::vector<uint8_t> &expect_tx, const std::vector<uint8_t> &inject_rx);
   void add_periodic_rx(const std::vector<uint8_t> &data, uint32_t interval_ms);
 
+  void start_scenario();
+  void set_auto_start(bool auto_start) { this->auto_start_ = auto_start; }
   void set_tx_hook(std::function<void(const std::vector<uint8_t> &)> &&cb) { this->tx_hook_ = std::move(cb); }
   void inject_to_rx_buffer(const std::vector<uint8_t> &data);
   void inject_to_rx_buffer(const uint8_t *data, size_t len);
@@ -55,6 +57,8 @@ class MockUartComponent : public uart::UARTComponent, public Component {
   uint32_t scenario_start_ms_{0};
   uint32_t cumulative_delay_ms_{0};
   bool loop_started_{false};
+  bool auto_start_{true};
+  bool scenario_active_{false};
 
   // TX-triggered responses
   struct Response {
diff --git a/tests/integration/fixtures/uart_mock_ld2410.yaml b/tests/integration/fixtures/uart_mock_ld2410.yaml
index 9a814682630..59838b0599c 100644
--- a/tests/integration/fixtures/uart_mock_ld2410.yaml
+++ b/tests/integration/fixtures/uart_mock_ld2410.yaml
@@ -20,6 +20,7 @@ uart:
 uart_mock:
   id: mock_uart
   baud_rate: 256000
+  auto_start: false
   injections:
     # Phase 1 (t=100ms): Valid LD2410 normal mode data frame - happy path
     # The buffer is clean at this point, so this frame should parse correctly.
@@ -143,3 +144,10 @@ binary_sensor:
       name: "Has Moving Target"
     has_still_target:
       name: "Has Still Target"
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
diff --git a/tests/integration/fixtures/uart_mock_ld2410_engineering.yaml b/tests/integration/fixtures/uart_mock_ld2410_engineering.yaml
index 3b730fc1f8b..4625ae85115 100644
--- a/tests/integration/fixtures/uart_mock_ld2410_engineering.yaml
+++ b/tests/integration/fixtures/uart_mock_ld2410_engineering.yaml
@@ -19,6 +19,7 @@ uart:
 uart_mock:
   id: mock_uart
   baud_rate: 256000
+  auto_start: false
   injections:
     # Phase 1 (t=100ms): Valid LD2410 engineering mode data frame
     # Captured from a real Screek Human Presence Sensor 1U with LD2410 firmware 2.4.x
@@ -154,3 +155,10 @@ binary_sensor:
       name: "Has Still Target"
     out_pin_presence_status:
       name: "Out Pin Presence"
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
diff --git a/tests/integration/fixtures/uart_mock_ld2412.yaml b/tests/integration/fixtures/uart_mock_ld2412.yaml
new file mode 100644
index 00000000000..9cf9d6bb873
--- /dev/null
+++ b/tests/integration/fixtures/uart_mock_ld2412.yaml
@@ -0,0 +1,179 @@
+esphome:
+  name: uart-mock-ld2412-test
+
+host:
+api:
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy ld2412's DEPENDENCIES = ["uart"]
+# The actual UART bus used is the uart_mock component below
+uart:
+  baud_rate: 115200
+  port: /dev/null
+
+uart_mock:
+  id: mock_uart
+  baud_rate: 256000
+  auto_start: false
+  injections:
+    # Phase 1 (t=100ms): Valid LD2412 normal mode data frame - happy path
+    # The buffer is clean at this point, so this frame should parse correctly.
+    # Moving target: 100cm, energy 50
+    # Still target: 120cm, energy 25
+    # Target state: 0x03 (moving + still)
+    # detection_distance = 100 (LD2412 computes from moving target when MOVE_BITMASK set)
+    #
+    # Frame layout (24 bytes):
+    #   [0-3]   F4 F3 F2 F1 = data frame header
+    #   [4-5]   0D 00       = length 13
+    #   [6]     02          = data type (normal)
+    #   [7]     AA          = data header marker
+    #   [8]     03          = target states (moving+still)
+    #   [9-10]  64 00       = moving distance 100 (0x0064)
+    #   [11]    32          = moving energy 50
+    #   [12-13] 78 00       = still distance 120 (0x0078)
+    #   [14]    19          = still energy 25
+    #   [15-16] 64 00       = detect distance bytes (ignored by LD2412 code)
+    #   [17]    00          = padding
+    #   [18]    55          = data footer marker
+    #   [19]    00          = CRC/check
+    #   [20-23] F8 F7 F6 F5 = data frame footer
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x0D, 0x00,
+          0x02, 0xAA,
+          0x03,
+          0x64, 0x00,
+          0x32,
+          0x78, 0x00,
+          0x19,
+          0x64, 0x00,
+          0x00,
+          0x55, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+    # Phase 2 (t=300ms): Garbage bytes
+    # LD2412's parser rejects bytes that don't match the frame header at
+    # position 0 (must start with F4 or FD), so buffer stays empty.
+    - delay: 200ms
+      inject_rx: [0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11, 0x22]
+
+    # Phase 3 (t=400ms): Truncated frame (header + partial data, no footer)
+    # Starts with valid data frame header so parser accepts it.
+    # After this, buffer_pos_ = 8.
+    - delay: 100ms
+      inject_rx: [0xF4, 0xF3, 0xF2, 0xF1, 0x0D, 0x00, 0x02, 0xAA]
+
+    # Phase 4 (t=600ms): Overflow - inject 60 bytes of 0xFF (MAX_LINE_LENGTH=54)
+    # Buffer has 8 bytes from phase 3 (garbage in phase 2 was rejected).
+    # Overflow math: buffer_pos_ starts at 8, overflow triggers when
+    # buffer_pos_ reaches 53 (MAX_LINE_LENGTH - 1). Need 45 more bytes to
+    # fill positions 8-52, then byte 46 triggers overflow. After overflow,
+    # buffer_pos_ = 0 and remaining 0xFF bytes are rejected (don't match header).
+    - delay: 200ms
+      inject_rx:
+        [
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        ]
+
+    # Phase 5 (t=700ms): Valid frame after overflow - recovery test
+    # Buffer was reset by overflow. This valid frame should parse correctly.
+    # Moving target: 50cm, energy 100
+    # Still target: 75cm, energy 80
+    # detection_distance = 50 (moving target distance, since MOVE_BITMASK set)
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x0D, 0x00,
+          0x02, 0xAA,
+          0x03,
+          0x32, 0x00,
+          0x64,
+          0x4B, 0x00,
+          0x50,
+          0x32, 0x00,
+          0x00,
+          0x55, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+ld2412:
+  id: ld2412_dev
+  uart_id: mock_uart
+
+sensor:
+  - platform: ld2412
+    ld2412_id: ld2412_dev
+    moving_distance:
+      name: "Moving Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    still_distance:
+      name: "Still Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    moving_energy:
+      name: "Moving Energy"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    still_energy:
+      name: "Still Energy"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    detection_distance:
+      name: "Detection Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+
+binary_sensor:
+  - platform: ld2412
+    ld2412_id: ld2412_dev
+    has_target:
+      name: "Has Target"
+      filters:
+        - settle: 50ms
+    has_moving_target:
+      name: "Has Moving Target"
+      filters:
+        - settle: 50ms
+    has_still_target:
+      name: "Has Still Target"
+      filters:
+        - settle: 50ms
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
diff --git a/tests/integration/fixtures/uart_mock_ld2412_engineering.yaml b/tests/integration/fixtures/uart_mock_ld2412_engineering.yaml
new file mode 100644
index 00000000000..103dbed132f
--- /dev/null
+++ b/tests/integration/fixtures/uart_mock_ld2412_engineering.yaml
@@ -0,0 +1,221 @@
+esphome:
+  name: uart-mock-ld2412-eng-test
+
+host:
+api:
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy ld2412's DEPENDENCIES = ["uart"]
+uart:
+  baud_rate: 115200
+  port: /dev/null
+
+uart_mock:
+  id: mock_uart
+  baud_rate: 256000
+  auto_start: false
+  injections:
+    # Phase 1 (t=100ms): Valid LD2412 engineering mode data frame
+    #
+    # Engineering mode frame layout (52 bytes):
+    #   [0-3]   F4 F3 F2 F1 = data frame header
+    #   [4-5]   2A 00       = length 42
+    #   [6]     01          = data type (engineering mode)
+    #   [7]     AA          = data header marker
+    #   [8]     03          = target states (moving+still)
+    #   [9-10]  1E 00       = moving distance 30 (0x001E)
+    #   [11]    64          = moving energy 100
+    #   [12-13] 1E 00       = still distance 30 (0x001E)
+    #   [14]    64          = still energy 100
+    #   [15-16] 00 00       = detection distance bytes (ignored)
+    #   [17-30] gate moving energies (14 gates)
+    #   [31-44] gate still energies (14 gates)
+    #   [45]    57          = light sensor value 87
+    #   [46]    55          = data footer marker
+    #   [47]    00          = check
+    #   [48-51] F8 F7 F6 F5 = data frame footer
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x2A, 0x00,
+          0x01, 0xAA,
+          0x03,
+          0x1E, 0x00,
+          0x64,
+          0x1E, 0x00,
+          0x64,
+          0x00, 0x00,
+          0x64, 0x41, 0x06, 0x0E, 0x2B, 0x16, 0x03, 0x03, 0x07, 0x05, 0x09, 0x08, 0x07, 0x06,
+          0x00, 0x00, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x50, 0x40, 0x30, 0x20, 0x10,
+          0x57,
+          0x55, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+    # Phase 2 (t=200ms): Second engineering mode frame with different values
+    # Moving at 73cm, still at 30cm
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x2A, 0x00,
+          0x01, 0xAA,
+          0x03,
+          0x49, 0x00,
+          0x64,
+          0x1E, 0x00,
+          0x64,
+          0x21, 0x00,
+          0x11, 0x64, 0x05, 0x29, 0x39, 0x10, 0x03, 0x11, 0x0E, 0x08, 0x06, 0x04, 0x03, 0x02,
+          0x00, 0x00, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x50, 0x40, 0x30, 0x20, 0x10,
+          0x57,
+          0x55, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+    # Phase 3 (t=300ms): Frame with still target at 291cm (multi-byte distance)
+    # This tests encode_uint16 with high byte > 0
+    # Target state: 0x02 (still only) -> detection_distance = still distance = 291
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x2A, 0x00,
+          0x01, 0xAA,
+          0x02,
+          0x2F, 0x00,
+          0x36,
+          0x23, 0x01,
+          0x64,
+          0x21, 0x00,
+          0x2F, 0x36, 0x09, 0x0D, 0x15, 0x0B, 0x06, 0x06, 0x08, 0x09, 0x08, 0x07, 0x06, 0x05,
+          0x00, 0x00, 0x64, 0x64, 0x64, 0x64, 0x64, 0x5A, 0x3D, 0x30, 0x20, 0x10, 0x08, 0x04,
+          0x57,
+          0x55, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+ld2412:
+  id: ld2412_dev
+  uart_id: mock_uart
+
+sensor:
+  - platform: ld2412
+    ld2412_id: ld2412_dev
+    moving_distance:
+      name: "Moving Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    still_distance:
+      name: "Still Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    moving_energy:
+      name: "Moving Energy"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    still_energy:
+      name: "Still Energy"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    detection_distance:
+      name: "Detection Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    light:
+      name: "Light"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+    gate_0:
+      move_energy:
+        name: "Gate 0 Move Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+      still_energy:
+        name: "Gate 0 Still Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+    gate_1:
+      move_energy:
+        name: "Gate 1 Move Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+      still_energy:
+        name: "Gate 1 Still Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+    gate_2:
+      move_energy:
+        name: "Gate 2 Move Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+      still_energy:
+        name: "Gate 2 Still Energy"
+        filters:
+          - timeout:
+              timeout: 50ms
+              value: last
+          - throttle_with_priority: 50ms
+
+binary_sensor:
+  - platform: ld2412
+    ld2412_id: ld2412_dev
+    has_target:
+      name: "Has Target"
+      filters:
+        - settle: 50ms
+    has_moving_target:
+      name: "Has Moving Target"
+      filters:
+        - settle: 50ms
+    has_still_target:
+      name: "Has Still Target"
+      filters:
+        - settle: 50ms
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
diff --git a/tests/integration/fixtures/uart_mock_modbus.yaml b/tests/integration/fixtures/uart_mock_modbus.yaml
index 89b9b91861f..0a3492a0d2f 100644
--- a/tests/integration/fixtures/uart_mock_modbus.yaml
+++ b/tests/integration/fixtures/uart_mock_modbus.yaml
@@ -22,6 +22,7 @@ uart_mock:
     baud_rate: 9600
     rx_full_threshold: 120
     rx_timeout: 2
+    auto_start: false
     debug:
     responses:
       - expect_tx: [0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x74, 0x0A] # Read holding register 1 on device 1
@@ -38,3 +39,10 @@ sensor:
     name: "basic_register"
     address: 0x03
     register_type: holding
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(virtual_uart_dev).start_scenario();'
diff --git a/tests/integration/fixtures/uart_mock_modbus_timing.yaml b/tests/integration/fixtures/uart_mock_modbus_timing.yaml
index cd485ca3944..c4e29e5fe8d 100644
--- a/tests/integration/fixtures/uart_mock_modbus_timing.yaml
+++ b/tests/integration/fixtures/uart_mock_modbus_timing.yaml
@@ -22,6 +22,7 @@ uart_mock:
     baud_rate: 9600
     rx_full_threshold: 120
     rx_timeout: 2
+    auto_start: false
     debug:
     on_tx:
       - then:
@@ -52,3 +53,10 @@ sensor:
     phase_a:
       voltage:
         name: sdm_voltage
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    on_press:
+      - lambda: 'id(virtual_uart_dev).start_scenario();'
diff --git a/tests/integration/state_utils.py b/tests/integration/state_utils.py
index b649056f2ba..e8c2cc5e663 100644
--- a/tests/integration/state_utils.py
+++ b/tests/integration/state_utils.py
@@ -3,10 +3,17 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Callable
 import logging
 from typing import TypeVar
 
-from aioesphomeapi import ButtonInfo, EntityInfo, EntityState
+from aioesphomeapi import (
+    BinarySensorState,
+    ButtonInfo,
+    EntityInfo,
+    EntityState,
+    SensorState,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -234,3 +241,90 @@ class InitialStateHelper:
             asyncio.TimeoutError: If initial states aren't received within timeout
         """
         await asyncio.wait_for(self._initial_states_received, timeout=timeout)
+
+
+class SensorStateCollector:
+    """Collects sensor and binary sensor state updates and provides wait helpers.
+
+    Usage:
+        collector = SensorStateCollector(
+            sensor_names=["moving_distance", "still_distance"],
+            binary_sensor_names=["has_target"],
+        )
+        # Use collector.on_state as the callback (or wrap it)
+        client.subscribe_states(helper.on_state_wrapper(collector.on_state))
+
+        # Wait for all sensors to have at least one value
+        await collector.wait_for_all(timeout=3.0)
+
+        # Access collected states
+        assert collector.sensor_states["moving_distance"][0] == approx(100.0)
+    """
+
+    def __init__(
+        self,
+        sensor_names: list[str],
+        binary_sensor_names: list[str] | None = None,
+        entities: list[EntityInfo] | None = None,
+    ) -> None:
+        self.sensor_states: dict[str, list[float]] = {name: [] for name in sensor_names}
+        self.binary_states: dict[str, list[bool]] = {
+            name: [] for name in (binary_sensor_names or [])
+        }
+        self._key_to_sensor: dict[int, str] = {}
+        self._waiters: list[tuple[Callable[[], bool], asyncio.Future[bool]]] = []
+
+        if entities is not None:
+            self.build_key_mapping(entities)
+
+    def build_key_mapping(self, entities: list[EntityInfo]) -> None:
+        """Build key-to-name mapping from entities. Sorted by descending length."""
+        all_names = list(self.sensor_states.keys()) + list(self.binary_states.keys())
+        all_names.sort(key=len, reverse=True)
+        self._key_to_sensor = build_key_to_entity_mapping(entities, all_names)
+
+    def on_state(self, state: EntityState) -> None:
+        """Process a state update."""
+        if isinstance(state, SensorState) and not state.missing_state:
+            sensor_name = self._key_to_sensor.get(state.key)
+            if sensor_name and sensor_name in self.sensor_states:
+                self.sensor_states[sensor_name].append(state.state)
+                self._check_waiters()
+        elif isinstance(state, BinarySensorState):
+            sensor_name = self._key_to_sensor.get(state.key)
+            if sensor_name and sensor_name in self.binary_states:
+                self.binary_states[sensor_name].append(state.state)
+                self._check_waiters()
+
+    def _check_waiters(self) -> None:
+        """Check all pending waiters and resolve any whose condition is met."""
+        for condition, future in self._waiters:
+            if not future.done() and condition():
+                future.set_result(True)
+
+    def _all_have_values(self) -> bool:
+        """Check if all sensor and binary sensor lists have at least one value."""
+        return all(len(v) >= 1 for v in self.sensor_states.values()) and all(
+            len(v) >= 1 for v in self.binary_states.values()
+        )
+
+    async def wait_for_all(self, timeout: float = 3.0) -> None:
+        """Wait until all sensors and binary sensors have at least one value."""
+        if self._all_have_values():
+            return
+        future: asyncio.Future[bool] = asyncio.get_running_loop().create_future()
+        self._waiters.append((self._all_have_values, future))
+        await asyncio.wait_for(future, timeout=timeout)
+
+    def add_waiter(self, condition: Callable[[], bool]) -> asyncio.Future[bool]:
+        """Add a custom waiter that resolves when condition returns True.
+
+        Returns:
+            A future that resolves when the condition is met.
+        """
+        future: asyncio.Future[bool] = asyncio.get_running_loop().create_future()
+        if condition():
+            future.set_result(True)
+        else:
+            self._waiters.append((condition, future))
+        return future
diff --git a/tests/integration/test_uart_mock_ld2410.py b/tests/integration/test_uart_mock_ld2410.py
index e01d6ff8e82..ce0e1bb7ec2 100644
--- a/tests/integration/test_uart_mock_ld2410.py
+++ b/tests/integration/test_uart_mock_ld2410.py
@@ -21,16 +21,10 @@ from __future__ import annotations
 import asyncio
 from pathlib import Path
 
-from aioesphomeapi import (
-    BinarySensorInfo,
-    BinarySensorState,
-    EntityState,
-    SensorInfo,
-    SensorState,
-)
+from aioesphomeapi import ButtonInfo
 import pytest
 
-from .state_utils import InitialStateHelper, build_key_to_entity_mapping, find_entity
+from .state_utils import InitialStateHelper, SensorStateCollector, find_entity
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 
@@ -64,100 +58,65 @@ async def test_uart_mock_ld2410(
         if "uart_mock" in line and "TX " in line:
             tx_log_lines.append(line)
 
-    # Track sensor state updates (after initial state is swallowed)
-    sensor_states: dict[str, list[float]] = {
-        "moving_distance": [],
-        "still_distance": [],
-        "moving_energy": [],
-        "still_energy": [],
-        "detection_distance": [],
-    }
-    binary_states: dict[str, list[bool]] = {
-        "has_target": [],
-        "has_moving_target": [],
-        "has_still_target": [],
-    }
+    collector = SensorStateCollector(
+        sensor_names=[
+            "moving_distance",
+            "still_distance",
+            "moving_energy",
+            "still_energy",
+            "detection_distance",
+        ],
+        binary_sensor_names=[
+            "has_target",
+            "has_moving_target",
+            "has_still_target",
+        ],
+    )
 
     # Signal when we see recovery frame values
-    recovery_received = loop.create_future()
-
-    def on_state(state: EntityState) -> None:
-        if isinstance(state, SensorState) and not state.missing_state:
-            sensor_name = key_to_sensor.get(state.key)
-            if sensor_name and sensor_name in sensor_states:
-                sensor_states[sensor_name].append(state.state)
-                # Check if this is the recovery frame (moving_distance = 50)
-                if (
-                    sensor_name == "moving_distance"
-                    and state.state == pytest.approx(50.0)
-                    and not recovery_received.done()
-                ):
-                    recovery_received.set_result(True)
-        elif isinstance(state, BinarySensorState):
-            sensor_name = key_to_sensor.get(state.key)
-            if sensor_name and sensor_name in binary_states:
-                binary_states[sensor_name].append(state.state)
+    recovery_received = collector.add_waiter(
+        lambda: pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+    )
 
     async with (
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
         entities, _ = await client.list_entities_services()
-
-        # Build key mappings for all sensor types
-        all_names = list(sensor_states.keys()) + list(binary_states.keys())
-        key_to_sensor = build_key_to_entity_mapping(entities, all_names)
+        collector.build_key_mapping(entities)
 
         # Set up initial state helper
         initial_state_helper = InitialStateHelper(entities)
-        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
 
         try:
             await initial_state_helper.wait_for_initial_states()
         except TimeoutError:
             pytest.fail("Timeout waiting for initial states")
 
-        # Phase 1 values are in the initial states (swallowed by InitialStateHelper).
-        # Verify them via initial_states dict.
-        moving_dist_entity = find_entity(entities, "moving_distance", SensorInfo)
-        assert moving_dist_entity is not None
-        initial_moving = initial_state_helper.initial_states.get(moving_dist_entity.key)
-        assert initial_moving is not None and isinstance(initial_moving, SensorState)
-        assert initial_moving.state == pytest.approx(100.0), (
-            f"Initial moving distance should be 100, got {initial_moving.state}"
-        )
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
 
-        still_dist_entity = find_entity(entities, "still_distance", SensorInfo)
-        assert still_dist_entity is not None
-        initial_still = initial_state_helper.initial_states.get(still_dist_entity.key)
-        assert initial_still is not None and isinstance(initial_still, SensorState)
-        assert initial_still.state == pytest.approx(120.0), (
-            f"Initial still distance should be 120, got {initial_still.state}"
-        )
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
 
-        moving_energy_entity = find_entity(entities, "moving_energy", SensorInfo)
-        assert moving_energy_entity is not None
-        initial_me = initial_state_helper.initial_states.get(moving_energy_entity.key)
-        assert initial_me is not None and isinstance(initial_me, SensorState)
-        assert initial_me.state == pytest.approx(50.0), (
-            f"Initial moving energy should be 50, got {initial_me.state}"
-        )
-
-        still_energy_entity = find_entity(entities, "still_energy", SensorInfo)
-        assert still_energy_entity is not None
-        initial_se = initial_state_helper.initial_states.get(still_energy_entity.key)
-        assert initial_se is not None and isinstance(initial_se, SensorState)
-        assert initial_se.state == pytest.approx(25.0), (
-            f"Initial still energy should be 25, got {initial_se.state}"
-        )
-
-        detect_dist_entity = find_entity(entities, "detection_distance", SensorInfo)
-        assert detect_dist_entity is not None
-        initial_dd = initial_state_helper.initial_states.get(detect_dist_entity.key)
-        assert initial_dd is not None and isinstance(initial_dd, SensorState)
-        assert initial_dd.state == pytest.approx(300.0), (
-            f"Initial detection distance should be 300, got {initial_dd.state}"
-        )
+        # Phase 1 values: moving=100, still=120, energy=50/25, detect=300
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(100.0)
+        assert collector.sensor_states["still_distance"][0] == pytest.approx(120.0)
+        assert collector.sensor_states["moving_energy"][0] == pytest.approx(50.0)
+        assert collector.sensor_states["still_energy"][0] == pytest.approx(25.0)
+        assert collector.sensor_states["detection_distance"][0] == pytest.approx(300.0)
 
         # Wait for the recovery frame (Phase 5) to be parsed
         # This proves the component survived garbage + truncated + overflow
@@ -165,12 +124,8 @@ async def test_uart_mock_ld2410(
             await asyncio.wait_for(recovery_received, timeout=15.0)
         except TimeoutError:
             pytest.fail(
-                f"Timeout waiting for recovery frame. Received sensor states:\n"
-                f"  moving_distance: {sensor_states['moving_distance']}\n"
-                f"  still_distance: {sensor_states['still_distance']}\n"
-                f"  moving_energy: {sensor_states['moving_energy']}\n"
-                f"  still_energy: {sensor_states['still_energy']}\n"
-                f"  detection_distance: {sensor_states['detection_distance']}"
+                f"Timeout waiting for recovery frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}"
             )
 
         # Verify overflow warning was logged
@@ -183,67 +138,36 @@ async def test_uart_mock_ld2410(
         # A5 (MAC), AB (distance res), AE (light), 61 (params), FE (config off)
         assert len(tx_log_lines) > 0, "Expected TX log lines from uart_mock"
         tx_data = " ".join(tx_log_lines)
-        # Verify command frame header appears (FD:FC:FB:FA)
         assert "FD:FC:FB:FA" in tx_data, (
             "Expected LD2410 command frame header FD:FC:FB:FA in TX log"
         )
-        # Verify command frame footer appears (04:03:02:01)
         assert "04:03:02:01" in tx_data, (
             "Expected LD2410 command frame footer 04:03:02:01 in TX log"
         )
 
-        # Recovery frame values (Phase 5, after overflow)
-        assert len(sensor_states["moving_distance"]) >= 1, (
-            f"Expected recovery moving_distance, got: {sensor_states['moving_distance']}"
-        )
-        # Find the recovery value (moving_distance = 50)
-        recovery_values = [
-            v for v in sensor_states["moving_distance"] if v == pytest.approx(50.0)
-        ]
-        assert len(recovery_values) >= 1, (
-            f"Expected moving_distance=50 in recovery, got: {sensor_states['moving_distance']}"
-        )
-
         # Recovery frame: moving=50, still=75, energy=100/80, detect=127
         recovery_idx = next(
             i
-            for i, v in enumerate(sensor_states["moving_distance"])
+            for i, v in enumerate(collector.sensor_states["moving_distance"])
             if v == pytest.approx(50.0)
         )
-        assert sensor_states["still_distance"][recovery_idx] == pytest.approx(75.0), (
-            f"Recovery still distance should be 75, got {sensor_states['still_distance'][recovery_idx]}"
+        assert collector.sensor_states["still_distance"][recovery_idx] == pytest.approx(
+            75.0
         )
-        assert sensor_states["moving_energy"][recovery_idx] == pytest.approx(100.0), (
-            f"Recovery moving energy should be 100, got {sensor_states['moving_energy'][recovery_idx]}"
+        assert collector.sensor_states["moving_energy"][recovery_idx] == pytest.approx(
+            100.0
         )
-        assert sensor_states["still_energy"][recovery_idx] == pytest.approx(80.0), (
-            f"Recovery still energy should be 80, got {sensor_states['still_energy'][recovery_idx]}"
-        )
-        assert sensor_states["detection_distance"][recovery_idx] == pytest.approx(
-            127.0
-        ), (
-            f"Recovery detection distance should be 127, got {sensor_states['detection_distance'][recovery_idx]}"
+        assert collector.sensor_states["still_energy"][recovery_idx] == pytest.approx(
+            80.0
         )
+        assert collector.sensor_states["detection_distance"][
+            recovery_idx
+        ] == pytest.approx(127.0)
 
-        # Verify binary sensors detected targets
-        # Binary sensors could be in initial states or forwarded states
-        has_target_entity = find_entity(entities, "has_target", BinarySensorInfo)
-        assert has_target_entity is not None
-        initial_ht = initial_state_helper.initial_states.get(has_target_entity.key)
-        assert initial_ht is not None and isinstance(initial_ht, BinarySensorState)
-        assert initial_ht.state is True, "Has target should be True"
-
-        has_moving_entity = find_entity(entities, "has_moving_target", BinarySensorInfo)
-        assert has_moving_entity is not None
-        initial_hm = initial_state_helper.initial_states.get(has_moving_entity.key)
-        assert initial_hm is not None and isinstance(initial_hm, BinarySensorState)
-        assert initial_hm.state is True, "Has moving target should be True"
-
-        has_still_entity = find_entity(entities, "has_still_target", BinarySensorInfo)
-        assert has_still_entity is not None
-        initial_hs = initial_state_helper.initial_states.get(has_still_entity.key)
-        assert initial_hs is not None and isinstance(initial_hs, BinarySensorState)
-        assert initial_hs.state is True, "Has still target should be True"
+        # Verify binary sensors detected targets (from Phase 1 frame)
+        assert collector.binary_states["has_target"][0] is True
+        assert collector.binary_states["has_moving_target"][0] is True
+        assert collector.binary_states["has_still_target"][0] is True
 
 
 @pytest.mark.asyncio
@@ -260,133 +184,82 @@ async def test_uart_mock_ld2410_engineering(
         "EXTERNAL_COMPONENT_PATH", external_components_path
     )
 
-    loop = asyncio.get_running_loop()
+    collector = SensorStateCollector(
+        sensor_names=[
+            "moving_distance",
+            "still_distance",
+            "moving_energy",
+            "still_energy",
+            "detection_distance",
+            "light",
+            "gate_0_move_energy",
+            "gate_1_move_energy",
+            "gate_2_move_energy",
+            "gate_0_still_energy",
+            "gate_1_still_energy",
+            "gate_2_still_energy",
+        ],
+        binary_sensor_names=[
+            "has_target",
+            "has_moving_target",
+            "has_still_target",
+            "out_pin_presence",
+        ],
+    )
 
-    # Track sensor state updates (after initial state is swallowed)
-    sensor_states: dict[str, list[float]] = {
-        "moving_distance": [],
-        "still_distance": [],
-        "moving_energy": [],
-        "still_energy": [],
-        "detection_distance": [],
-        "light": [],
-        "gate_0_move_energy": [],
-        "gate_1_move_energy": [],
-        "gate_2_move_energy": [],
-        "gate_0_still_energy": [],
-        "gate_1_still_energy": [],
-        "gate_2_still_energy": [],
-    }
-    binary_states: dict[str, list[bool]] = {
-        "has_target": [],
-        "has_moving_target": [],
-        "has_still_target": [],
-        "out_pin_presence": [],
-    }
-
-    # Signal when we see Phase 3 frame (still_distance = 291)
-    phase3_received = loop.create_future()
-
-    def on_state(state: EntityState) -> None:
-        if isinstance(state, SensorState) and not state.missing_state:
-            sensor_name = key_to_sensor.get(state.key)
-            if sensor_name and sensor_name in sensor_states:
-                sensor_states[sensor_name].append(state.state)
-                if (
-                    sensor_name == "still_distance"
-                    and state.state == pytest.approx(291.0)
-                    and not phase3_received.done()
-                ):
-                    phase3_received.set_result(True)
-        elif isinstance(state, BinarySensorState):
-            sensor_name = key_to_sensor.get(state.key)
-            if sensor_name and sensor_name in binary_states:
-                binary_states[sensor_name].append(state.state)
+    # Signal when we see Phase 3 frame values
+    phase3_received = collector.add_waiter(
+        lambda: pytest.approx(291.0) in collector.sensor_states["still_distance"]
+    )
 
     async with (
         run_compiled(yaml_config),
         api_client_connected() as client,
     ):
         entities, _ = await client.list_entities_services()
-
-        all_names = list(sensor_states.keys()) + list(binary_states.keys())
-        key_to_sensor = build_key_to_entity_mapping(entities, all_names)
+        collector.build_key_mapping(entities)
 
         initial_state_helper = InitialStateHelper(entities)
-        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
 
         try:
             await initial_state_helper.wait_for_initial_states()
         except TimeoutError:
             pytest.fail("Timeout waiting for initial states")
 
-        # Phase 1 initial values (engineering mode frame):
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
+
+        # Phase 1 values (engineering mode frame):
         # moving=30, energy=100, still=30, energy=100, detect=0
-        moving_dist_entity = find_entity(entities, "moving_distance", SensorInfo)
-        assert moving_dist_entity is not None
-        initial_moving = initial_state_helper.initial_states.get(moving_dist_entity.key)
-        assert initial_moving is not None and isinstance(initial_moving, SensorState)
-        assert initial_moving.state == pytest.approx(30.0), (
-            f"Initial moving distance should be 30, got {initial_moving.state}"
-        )
-
-        still_dist_entity = find_entity(entities, "still_distance", SensorInfo)
-        assert still_dist_entity is not None
-        initial_still = initial_state_helper.initial_states.get(still_dist_entity.key)
-        assert initial_still is not None and isinstance(initial_still, SensorState)
-        assert initial_still.state == pytest.approx(30.0), (
-            f"Initial still distance should be 30, got {initial_still.state}"
-        )
-
-        # Verify engineering mode sensors from initial state
-        # Gate 0 moving energy = 0x64 = 100
-        gate0_move_entity = find_entity(entities, "gate_0_move_energy", SensorInfo)
-        assert gate0_move_entity is not None
-        initial_g0m = initial_state_helper.initial_states.get(gate0_move_entity.key)
-        assert initial_g0m is not None and isinstance(initial_g0m, SensorState)
-        assert initial_g0m.state == pytest.approx(100.0), (
-            f"Gate 0 move energy should be 100, got {initial_g0m.state}"
-        )
-
-        # Gate 1 moving energy = 0x41 = 65
-        gate1_move_entity = find_entity(entities, "gate_1_move_energy", SensorInfo)
-        assert gate1_move_entity is not None
-        initial_g1m = initial_state_helper.initial_states.get(gate1_move_entity.key)
-        assert initial_g1m is not None and isinstance(initial_g1m, SensorState)
-        assert initial_g1m.state == pytest.approx(65.0), (
-            f"Gate 1 move energy should be 65, got {initial_g1m.state}"
-        )
-
-        # Light sensor = 0x57 = 87
-        light_entity = find_entity(entities, "light", SensorInfo)
-        assert light_entity is not None
-        initial_light = initial_state_helper.initial_states.get(light_entity.key)
-        assert initial_light is not None and isinstance(initial_light, SensorState)
-        assert initial_light.state == pytest.approx(87.0), (
-            f"Light sensor should be 87, got {initial_light.state}"
-        )
-
-        # Out pin presence = 0x01 = True
-        out_pin_entity = find_entity(entities, "out_pin_presence", BinarySensorInfo)
-        assert out_pin_entity is not None
-        initial_out = initial_state_helper.initial_states.get(out_pin_entity.key)
-        assert initial_out is not None and isinstance(initial_out, BinarySensorState)
-        assert initial_out.state is True, "Out pin presence should be True"
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(30.0)
+        assert collector.sensor_states["still_distance"][0] == pytest.approx(30.0)
+        assert collector.sensor_states["gate_0_move_energy"][0] == pytest.approx(100.0)
+        assert collector.sensor_states["gate_1_move_energy"][0] == pytest.approx(65.0)
+        assert collector.sensor_states["light"][0] == pytest.approx(87.0)
+        assert collector.binary_states["out_pin_presence"][0] is True
 
         # Wait for Phase 3 frame (still_distance = 291cm, multi-byte)
         try:
             await asyncio.wait_for(phase3_received, timeout=15.0)
         except TimeoutError:
             pytest.fail(
-                f"Timeout waiting for Phase 3 frame. Received sensor states:\n"
-                f"  still_distance: {sensor_states['still_distance']}\n"
-                f"  moving_distance: {sensor_states['moving_distance']}"
+                f"Timeout waiting for Phase 3 frame. Received:\n"
+                f"  still_distance: {collector.sensor_states['still_distance']}"
             )
 
-        # Phase 3: still distance = 0x0123 = 291cm (multi-byte distance test)
-        phase3_still = [
-            v for v in sensor_states["still_distance"] if v == pytest.approx(291.0)
-        ]
-        assert len(phase3_still) >= 1, (
-            f"Expected still_distance=291, got: {sensor_states['still_distance']}"
-        )
+        assert pytest.approx(291.0) in collector.sensor_states["still_distance"]
diff --git a/tests/integration/test_uart_mock_ld2412.py b/tests/integration/test_uart_mock_ld2412.py
new file mode 100644
index 00000000000..a964ba00738
--- /dev/null
+++ b/tests/integration/test_uart_mock_ld2412.py
@@ -0,0 +1,275 @@
+"""Integration test for LD2412 component with mock UART.
+
+Tests:
+test_uart_mock_ld2412 (normal mode):
+  1. Happy path - valid data frame publishes correct sensor values
+  2. Garbage resilience - random bytes don't crash the component
+  3. Truncated frame handling - partial frame doesn't corrupt state
+  4. Buffer overflow recovery - overflow resets the parser
+  5. Post-overflow parsing - next valid frame after overflow is parsed correctly
+  6. TX logging - verifies LD2412 sends expected setup commands
+
+test_uart_mock_ld2412_engineering (engineering mode):
+  1. Engineering mode frames with per-gate energy data and light sensor
+  2. Multi-byte still distance (291cm) using high byte > 0
+  3. Gate energy sensor values
+  4. Detection distance computed from target state
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from aioesphomeapi import ButtonInfo
+import pytest
+
+from .state_utils import InitialStateHelper, SensorStateCollector, find_entity
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_uart_mock_ld2412(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test LD2412 data parsing with happy path, garbage, overflow, and recovery."""
+    # Replace external component path placeholder
+    external_components_path = str(
+        Path(__file__).parent / "fixtures" / "external_components"
+    )
+    yaml_config = yaml_config.replace(
+        "EXTERNAL_COMPONENT_PATH", external_components_path
+    )
+
+    loop = asyncio.get_running_loop()
+
+    # Track overflow warning in logs
+    overflow_seen = loop.create_future()
+
+    # Track TX data logged by the mock for assertions
+    tx_log_lines: list[str] = []
+
+    def line_callback(line: str) -> None:
+        if "Max command length exceeded" in line and not overflow_seen.done():
+            overflow_seen.set_result(True)
+        # Capture all TX log lines from uart_mock
+        if "uart_mock" in line and "TX " in line:
+            tx_log_lines.append(line)
+
+    collector = SensorStateCollector(
+        sensor_names=[
+            "moving_distance",
+            "still_distance",
+            "moving_energy",
+            "still_energy",
+            "detection_distance",
+        ],
+        binary_sensor_names=[
+            "has_target",
+            "has_moving_target",
+            "has_still_target",
+        ],
+    )
+
+    # Signal when we see recovery frame values
+    recovery_received = collector.add_waiter(
+        lambda: pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+    )
+
+    async with (
+        run_compiled(yaml_config, line_callback=line_callback),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        collector.build_key_mapping(entities)
+
+        # Set up initial state helper
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
+
+        # Phase 1 values: moving=100, still=120, energy=50/25, detect=100
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(100.0)
+        assert collector.sensor_states["still_distance"][0] == pytest.approx(120.0)
+        assert collector.sensor_states["moving_energy"][0] == pytest.approx(50.0)
+        assert collector.sensor_states["still_energy"][0] == pytest.approx(25.0)
+        assert collector.sensor_states["detection_distance"][0] == pytest.approx(100.0)
+
+        # Wait for the recovery frame (Phase 5) to be parsed
+        # This proves the component survived garbage + truncated + overflow
+        try:
+            await asyncio.wait_for(recovery_received, timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for recovery frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}"
+            )
+
+        # Verify overflow warning was logged
+        assert overflow_seen.done(), (
+            "Expected 'Max command length exceeded' warning in logs"
+        )
+
+        # Verify LD2412 sent setup commands (TX logging)
+        assert len(tx_log_lines) > 0, "Expected TX log lines from uart_mock"
+        tx_data = " ".join(tx_log_lines)
+        assert "FD:FC:FB:FA" in tx_data, (
+            "Expected LD2412 command frame header FD:FC:FB:FA in TX log"
+        )
+        assert "04:03:02:01" in tx_data, (
+            "Expected LD2412 command frame footer 04:03:02:01 in TX log"
+        )
+
+        # Recovery frame: moving=50, still=75, energy=100/80, detect=50
+        recovery_idx = next(
+            i
+            for i, v in enumerate(collector.sensor_states["moving_distance"])
+            if v == pytest.approx(50.0)
+        )
+        assert collector.sensor_states["still_distance"][recovery_idx] == pytest.approx(
+            75.0
+        )
+        assert collector.sensor_states["moving_energy"][recovery_idx] == pytest.approx(
+            100.0
+        )
+        assert collector.sensor_states["still_energy"][recovery_idx] == pytest.approx(
+            80.0
+        )
+        assert collector.sensor_states["detection_distance"][
+            recovery_idx
+        ] == pytest.approx(50.0)
+
+        # Verify binary sensors detected targets (from Phase 1 frame)
+        assert collector.binary_states["has_target"][0] is True
+        assert collector.binary_states["has_moving_target"][0] is True
+        assert collector.binary_states["has_still_target"][0] is True
+
+
+@pytest.mark.asyncio
+async def test_uart_mock_ld2412_engineering(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test LD2412 engineering mode with per-gate energy, light, and multi-byte distance."""
+    external_components_path = str(
+        Path(__file__).parent / "fixtures" / "external_components"
+    )
+    yaml_config = yaml_config.replace(
+        "EXTERNAL_COMPONENT_PATH", external_components_path
+    )
+
+    collector = SensorStateCollector(
+        sensor_names=[
+            "moving_distance",
+            "still_distance",
+            "moving_energy",
+            "still_energy",
+            "detection_distance",
+            "light",
+            "gate_0_move_energy",
+            "gate_1_move_energy",
+            "gate_2_move_energy",
+            "gate_0_still_energy",
+            "gate_1_still_energy",
+            "gate_2_still_energy",
+        ],
+        binary_sensor_names=[
+            "has_target",
+            "has_moving_target",
+            "has_still_target",
+        ],
+    )
+
+    # Signal when we see Phase 3 frame values
+    phase3_still_received = collector.add_waiter(
+        lambda: pytest.approx(291.0) in collector.sensor_states["still_distance"]
+    )
+    phase3_detect_received = collector.add_waiter(
+        lambda: pytest.approx(291.0) in collector.sensor_states["detection_distance"]
+    )
+
+    async with (
+        run_compiled(yaml_config),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        collector.build_key_mapping(entities)
+
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
+
+        # Phase 1 values (engineering mode frame):
+        # moving=30, energy=100, still=30, energy=100, detect=30
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(30.0)
+        assert collector.sensor_states["still_distance"][0] == pytest.approx(30.0)
+        assert collector.sensor_states["gate_0_move_energy"][0] == pytest.approx(100.0)
+        assert collector.sensor_states["gate_1_move_energy"][0] == pytest.approx(65.0)
+        assert collector.sensor_states["light"][0] == pytest.approx(87.0)
+
+        # Wait for Phase 3 frame: still_distance = 291cm (multi-byte)
+        try:
+            await asyncio.wait_for(phase3_still_received, timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 3 still_distance. Received:\n"
+                f"  still_distance: {collector.sensor_states['still_distance']}"
+            )
+
+        assert pytest.approx(291.0) in collector.sensor_states["still_distance"]
+
+        # Wait for Phase 3: detection_distance = 291 (still-only target)
+        try:
+            await asyncio.wait_for(phase3_detect_received, timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for detection_distance=291. "
+                f"Received: {collector.sensor_states['detection_distance']}"
+            )
+
+        assert pytest.approx(291.0) in collector.sensor_states["detection_distance"]
diff --git a/tests/integration/test_uart_mock_modbus.py b/tests/integration/test_uart_mock_modbus.py
index 309cb56dc99..bf3c0697502 100644
--- a/tests/integration/test_uart_mock_modbus.py
+++ b/tests/integration/test_uart_mock_modbus.py
@@ -12,10 +12,10 @@ from __future__ import annotations
 import asyncio
 from pathlib import Path
 
-from aioesphomeapi import EntityState, SensorState
+from aioesphomeapi import ButtonInfo, EntityState, SensorState
 import pytest
 
-from .state_utils import InitialStateHelper, build_key_to_entity_mapping
+from .state_utils import InitialStateHelper, build_key_to_entity_mapping, find_entity
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 
@@ -74,6 +74,11 @@ async def test_uart_mock_modbus(
         except TimeoutError:
             pytest.fail("Timeout waiting for initial states")
 
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
         # Wait for basic register to be updated with successful parse
         try:
             await asyncio.wait_for(basic_register_changed, timeout=15.0)
@@ -143,6 +148,11 @@ async def test_uart_mock_modbus_timing(
         except TimeoutError:
             pytest.fail("Timeout waiting for initial states")
 
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
         # Wait for voltage to be updated with successful parse
         try:
             await asyncio.wait_for(voltage_changed, timeout=15.0)