Update color scheme in ZHA network visualization

* Dont add store token for external auth flows

* Apply suggestion from @MindFreeze

---------

Co-authored-by: Petar Petrov <MindFreeze@users.noreply.github.com>

.github/copilot-instructions.md

@@ -2,6 +2,8 @@
 
 You are an assistant helping with development of the Home Assistant frontend. The frontend is built using Lit-based Web Components and TypeScript, providing a responsive and performant interface for home automation control.
 
+**Note**: This file contains high-level guidelines and references to implementation patterns. For detailed component documentation, API references, and usage examples, refer to the `gallery/` directory.
+
 ## Table of Contents
 
 - [Quick Reference](#quick-reference)
@@ -151,6 +153,10 @@ try {
 ### Styling Guidelines
 
 - **Use CSS custom properties**: Leverage the theme system
+- **Use spacing tokens**: Prefer `--ha-space-*` tokens over hardcoded values for consistent spacing
+  - Spacing scale: `--ha-space-0` (0px) through `--ha-space-20` (80px) in 4px increments
+  - Defined in `src/resources/theme/core.globals.ts`
+  - Common values: `--ha-space-2` (8px), `--ha-space-4` (16px), `--ha-space-8` (32px)
 - **Mobile-first responsive**: Design for mobile, enhance for desktop
 - **Follow Material Design**: Use Material Web Components where appropriate
 - **Support RTL**: Ensure all layouts work in RTL languages
@@ -159,21 +165,68 @@ try {
 static get styles() {
   return css`
     :host {
-      --spacing: 16px;
-      padding: var(--spacing);
+      padding: var(--ha-space-4);
       color: var(--primary-text-color);
       background-color: var(--card-background-color);
     }
 
+    .content {
+      gap: var(--ha-space-2);
+    }
+
     @media (max-width: 600px) {
       :host {
-        --spacing: 8px;
+        padding: var(--ha-space-2);
       }
     }
   `;
 }
 ```
 
+### View Transitions
+
+The View Transitions API creates smooth animations between DOM state changes. When implementing view transitions:
+
+**Core Resources:**
+
+- **Utility wrapper**: `src/common/util/view-transition.ts` - `withViewTransition()` function with graceful fallback
+- **Real-world example**: `src/util/launch-screen.ts` - Launch screen fade pattern with browser support detection
+- **Animation keyframes**: `src/resources/theme/animations.globals.ts` - Global `fade-in`, `fade-out`, `scale` animations
+- **Animation duration**: `src/resources/theme/core.globals.ts` - `--ha-animation-base-duration` (350ms, respects `prefers-reduced-motion`)
+
+**Implementation Guidelines:**
+
+1. Always use `withViewTransition()` wrapper for automatic fallback
+2. Keep transitions simple (subtle crossfades and fades work best)
+3. Use `--ha-animation-base-duration` CSS variable for consistent timing
+4. Assign unique `view-transition-name` to elements (must be unique at any given time)
+5. For Lit components: Override `performUpdate()` or use `::part()` for internal elements
+
+**Default Root Transition:**
+
+By default, `:root` receives `view-transition-name: root`, creating a full-page crossfade. Target with [`::view-transition-group(root)`](https://developer.mozilla.org/en-US/docs/Web/CSS/::view-transition-group) to customize the default page transition.
+
+**Important Constraints:**
+
+- Each `view-transition-name` must be unique at any given time
+- Only one view transition can run at a time
+- **Shadow DOM incompatibility**: View transitions operate at document level and do not work within Shadow DOM due to style isolation ([spec discussion](https://github.com/w3c/csswg-drafts/issues/10303)). For web components, set `view-transition-name` on the `:host` element or use document-level transitions
+
+**Current Usage & Planned Applications:**
+
+- Launch screen fade out (implemented)
+- Automation sidebar transitions (planned - #27238)
+- More info dialog content changes (planned - #27672)
+- Toolbar navigation, ha-spinner transitions (planned)
+
+**Specification & Documentation:**
+
+For browser support, API details, and current specifications, refer to these authoritative sources (note: check publication dates as specs evolve):
+
+- [MDN: View Transition API](https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API) - Comprehensive API reference
+- [Chrome for Developers: View Transitions](https://developer.chrome.com/docs/web-platform/view-transitions) - Implementation guide and examples
+- [W3C Draft Specification](https://drafts.csswg.org/css-view-transitions/) - Official specification (evolving)
+
 ### Performance Best Practices
 
 - **Code split**: Split code at the panel/dialog level
@@ -195,8 +248,9 @@ static get styles() {
 
 **Available Dialog Types:**
 
-- `ha-md-dialog` - Preferred for new code (Material Design 3)
-- `ha-dialog` - Legacy component still widely used
+- `ha-wa-dialog` - Preferred for new dialogs (Web Awesome based)
+- `ha-md-dialog` - Material Design 3 dialog component
+- `ha-dialog` - Legacy component (still widely used)
 
 **Opening Dialogs (Fire Event Pattern - Recommended):**
 
@@ -211,15 +265,45 @@ fireEvent(this, "show-dialog", {
 **Dialog Implementation Requirements:**
 
 - Implement `HassDialog<T>` interface
-- Use `createCloseHeading()` for standard headers
-- Import `haStyleDialog` for consistent styling
+- Use `@state() private _open = false` to control dialog visibility
+- Set `_open = true` in `showDialog()`, `_open = false` in `closeDialog()`
 - Return `nothing` when no params (loading state)
-- Fire `dialog-closed` event when closing
-- Add `dialogInitialFocus` for accessibility
+- Fire `dialog-closed` event in `_dialogClosed()` handler
+- Use `header-title` attribute for simple titles
+- Use `header-subtitle` attribute for simple subtitles
+- Use slots for custom content where the standard attributes are not enough
+- Use `ha-dialog-footer` with `primaryAction`/`secondaryAction` slots for footer content
+- Add `autofocus` to first focusable element (e.g., `<ha-form autofocus>`). The component may need to forward this attribute internally.
 
-````
+**Dialog Sizing:**
+
+- Use `width` attribute with predefined sizes: `"small"` (320px), `"medium"` (560px - default), `"large"` (720px), or `"full"`
+- Custom sizing is NOT recommended - use the standard width presets
+- Example: `<ha-wa-dialog width="small">` for alert/confirmation dialogs
+
+**Button Appearance Guidelines:**
+
+- **Primary action buttons**: Default appearance (no appearance attribute) or omit for standard styling
+- **Secondary action buttons**: Use `appearance="plain"` for cancel/dismiss actions
+- **Destructive actions**: Use `appearance="filled"` for delete/remove operations (combined with appropriate semantic styling)
+- **Button sizes**: Use `size="small"` (32px height) or default/medium (40px height)
+- Always place primary action in `slot="primaryAction"` and secondary in `slot="secondaryAction"` within `ha-dialog-footer`
+
+**Recent Examples:**
+
+See these files for current patterns:
+
+- `src/panels/config/repairs/dialog-repairs-issue.ts`
+- `src/dialogs/restart/dialog-restart.ts`
+- `src/panels/config/lovelace/resources/dialog-lovelace-resource-detail.ts`
+
+**Gallery Documentation:**
+
+- `gallery/src/pages/components/ha-wa-dialog.markdown`
+- `gallery/src/pages/components/ha-dialogs.markdown`
 
 ### Form Component (ha-form)
+
 - Schema-driven using `HaFormSchema[]`
 - Supports entity, device, area, target, number, boolean, time, action, text, object, select, icon, media, location selectors
 - Built-in validation with error display
@@ -235,7 +319,11 @@ fireEvent(this, "show-dialog", {
   .computeLabel=${(schema) => this.hass.localize(`ui.panel.${schema.name}`)}
   @value-changed=${this._valueChanged}
 ></ha-form>
-````
+```
+
+**Gallery Documentation:**
+
+- `gallery/src/pages/components/ha-form.markdown`
 
 ### Alert Component (ha-alert)
 
@@ -249,6 +337,35 @@ fireEvent(this, "show-dialog", {
 <ha-alert alert-type="success" dismissable>Success message</ha-alert>
 ```
 
+**Gallery Documentation:**
+
+- `gallery/src/pages/components/ha-alert.markdown`
+
+### Keyboard Shortcuts (ShortcutManager)
+
+The `ShortcutManager` class provides a unified way to register keyboard shortcuts with automatic input field protection.
+
+**Key Features:**
+
+- Automatically blocks shortcuts when input fields are focused
+- Prevents shortcuts during text selection (configurable via `allowWhenTextSelected`)
+- Supports both character-based and KeyCode-based shortcuts (for non-latin keyboards)
+
+**Implementation:**
+
+- **Class definition**: `src/common/keyboard/shortcuts.ts`
+- **Real-world example**: `src/state/quick-bar-mixin.ts` - Global shortcuts (e, c, d, m, a, Shift+?) with non-latin keyboard fallbacks
+
+### Tooltip Component (ha-tooltip)
+
+The `ha-tooltip` component wraps Web Awesome tooltip with Home Assistant theming. Use for providing contextual help text on hover.
+
+**Implementation:**
+
+- **Component definition**: `src/components/ha-tooltip.ts`
+- **Usage example**: `src/components/ha-label.ts`
+- **Gallery documentation**: `gallery/src/pages/components/ha-tooltip.markdown`
+
 ## Common Patterns
 
 ### Creating a Panel
@@ -289,11 +406,19 @@ export class DialogMyFeature
   @state()
   private _params?: MyDialogParams;
 
+  @state()
+  private _open = false;
+
   public async showDialog(params: MyDialogParams): Promise<void> {
     this._params = params;
+    this._open = true;
   }
 
   public closeDialog(): void {
+    this._open = false;
+  }
+
+  private _dialogClosed(): void {
     this._params = undefined;
     fireEvent(this, "dialog-closed", { dialog: this.localName });
   }
@@ -304,23 +429,27 @@ export class DialogMyFeature
     }
 
     return html`
-      <ha-dialog
-        open
-        @closed=${this.closeDialog}
-        .heading=${createCloseHeading(this.hass, this._params.title)}
+      <ha-wa-dialog
+        .hass=${this.hass}
+        .open=${this._open}
+        header-title=${this._params.title}
+        header-subtitle=${this._params.subtitle}
+        @closed=${this._dialogClosed}
       >
-        <!-- Dialog content -->
-        <ha-button
-          appearance="plain"
-          @click=${this.closeDialog}
-          slot="secondaryAction"
-        >
-          ${this.hass.localize("ui.common.cancel")}
-        </ha-button>
-        <ha-button @click=${this._submit} slot="primaryAction">
-          ${this.hass.localize("ui.common.save")}
-        </ha-button>
-      </ha-dialog>
+        <p>Dialog content</p>
+        <ha-dialog-footer slot="footer">
+          <ha-button
+            slot="secondaryAction"
+            appearance="plain"
+            @click=${this.closeDialog}
+          >
+            ${this.hass.localize("ui.common.cancel")}
+          </ha-button>
+          <ha-button slot="primaryAction" @click=${this._submit}>
+            ${this.hass.localize("ui.common.save")}
+          </ha-button>
+        </ha-dialog-footer>
+      </ha-wa-dialog>
     `;
   }
 

.github/workflows/codeql-analysis.yml

@@ -36,14 +36,14 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         with:
           languages: ${{ matrix.language }}
 
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/autobuild@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -57,4 +57,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3

.yarnrc.yml

@@ -6,4 +6,4 @@ enableGlobalCache: false
 
 nodeLinker: node-modules
 
-yarnPath: .yarn/releases/yarn-4.10.3.cjs
+yarnPath: .yarn/releases/yarn-4.11.0.cjs

AGENTS.md

@@ -0,0 +1 @@
+.github/copilot-instructions.md

build-scripts/rspack.cjs

@@ -260,7 +260,6 @@ const createRspackConfig = ({
       ),
     },
     experiments: {
-      layers: true,
       outputModule: true,
     },
   };

gallery/src/pages/automation/describe-trigger.ts

@@ -3,7 +3,7 @@ import { css, html, LitElement, nothing } from "lit";
 import { customElement, property, state } from "lit/decorators";
 import "../../../../src/components/ha-card";
 import "../../../../src/components/ha-yaml-editor";
-import type { Trigger } from "../../../../src/data/automation";
+import type { LegacyTrigger } from "../../../../src/data/automation";
 import { describeTrigger } from "../../../../src/data/automation_i18n";
 import { getEntity } from "../../../../src/fake_data/entity";
 import { provideHass } from "../../../../src/fake_data/provide_hass";
@@ -66,7 +66,7 @@ const triggers = [
   },
 ];
 
-const initialTrigger: Trigger = {
+const initialTrigger: LegacyTrigger = {
   trigger: "state",
   entity_id: "light.kitchen",
 };

gallery/src/pages/components/ha-dropdown.markdown

@@ -0,0 +1,55 @@
+---
+title: Dropdown
+---
+
+# Dropdown `<ha-dropdown>`
+
+## Implementation
+
+A compact, accessible dropdown menu for choosing actions or settings. `ha-dropdown` supports composed menu items (`<ha-dropdown-item>`) for icons, submenus, checkboxes, disabled entries, and destructive variants. Use composition with `slot="trigger"` to control the trigger button and use `<ha-dropdown-item>` for rich item content.
+
+### Example usage (composition)
+
+```html
+<ha-dropdown open>
+  <ha-button slot="trigger" with-caret>Dropdown</ha-button>
+
+  <ha-dropdown-item>
+    <ha-svg-icon .path="mdiContentCut" slot="icon"></ha-svg-icon>
+    Cut
+  </ha-dropdown-item>
+
+  <ha-dropdown-item>
+    <ha-svg-icon .path="mdiContentCopy" slot="icon"></ha-svg-icon>
+    Copy
+  </ha-dropdown-item>
+
+  <ha-dropdown-item disabled>
+    <ha-svg-icon .path="mdiContentPaste" slot="icon"></ha-svg-icon>
+    Paste
+  </ha-dropdown-item>
+
+  <ha-dropdown-item>
+    Show images
+    <ha-dropdown-item slot="submenu" value="show-all-images"
+      >Show all images</ha-dropdown-item
+    >
+    <ha-dropdown-item slot="submenu" value="show-thumbnails"
+      >Show thumbnails</ha-dropdown-item
+    >
+  </ha-dropdown-item>
+
+  <ha-dropdown-item type="checkbox" checked>Emoji shortcuts</ha-dropdown-item>
+  <ha-dropdown-item type="checkbox" checked>Word wrap</ha-dropdown-item>
+
+  <ha-dropdown-item variant="danger">
+    <ha-svg-icon .path="mdiDelete" slot="icon"></ha-svg-icon>
+    Delete
+  </ha-dropdown-item>
+</ha-dropdown>
+```
+
+### API
+
+This component is based on the webawesome dropdown component.
+Check the [webawesome documentation](https://webawesome.com/docs/components/dropdown/) for more details.

gallery/src/pages/components/ha-dropdown.ts

@@ -0,0 +1,133 @@
+import "@home-assistant/webawesome/dist/components/button/button";
+import "@home-assistant/webawesome/dist/components/dropdown/dropdown";
+import "@home-assistant/webawesome/dist/components/icon/icon";
+import "@home-assistant/webawesome/dist/components/popup/popup";
+import {
+  mdiContentCopy,
+  mdiContentCut,
+  mdiContentPaste,
+  mdiDelete,
+} from "@mdi/js";
+import type { TemplateResult } from "lit";
+import { css, html, LitElement } from "lit";
+import { customElement } from "lit/decorators";
+import { applyThemesOnElement } from "../../../../src/common/dom/apply_themes_on_element";
+import "../../../../src/components/ha-button";
+import "../../../../src/components/ha-card";
+import "../../../../src/components/ha-dropdown";
+import "../../../../src/components/ha-dropdown-item";
+import "../../../../src/components/ha-icon-button";
+import "../../../../src/components/ha-svg-icon";
+
+@customElement("demo-components-ha-dropdown")
+export class DemoHaDropdown extends LitElement {
+  protected render(): TemplateResult {
+    return html`
+      ${["light", "dark"].map(
+        (mode) => html`
+          <div class=${mode}>
+            <ha-card header="ha-button in ${mode}">
+              <div class="card-content">
+                <ha-dropdown open>
+                  <ha-button slot="trigger" with-caret>Dropdown</ha-button>
+
+                  <ha-dropdown-item>
+                    <ha-svg-icon
+                      .path=${mdiContentCut}
+                      slot="icon"
+                    ></ha-svg-icon>
+                    Cut
+                  </ha-dropdown-item>
+                  <ha-dropdown-item>
+                    <ha-svg-icon
+                      .path=${mdiContentCopy}
+                      slot="icon"
+                    ></ha-svg-icon>
+                    Copy
+                  </ha-dropdown-item>
+                  <ha-dropdown-item disabled>
+                    <ha-svg-icon
+                      .path=${mdiContentPaste}
+                      slot="icon"
+                    ></ha-svg-icon>
+                    Paste
+                  </ha-dropdown-item>
+                  <ha-dropdown-item>
+                    Show images
+                    <ha-dropdown-item slot="submenu" value="show-all-images"
+                      >Show All Images</ha-dropdown-item
+                    >
+                    <ha-dropdown-item slot="submenu" value="show-thumbnails"
+                      >Show Thumbnails</ha-dropdown-item
+                    >
+                  </ha-dropdown-item>
+                  <ha-dropdown-item type="checkbox" checked
+                    >Emoji Shortcuts</ha-dropdown-item
+                  >
+                  <ha-dropdown-item type="checkbox" checked
+                    >Word Wrap</ha-dropdown-item
+                  >
+                  <ha-dropdown-item variant="danger">
+                    <ha-svg-icon .path=${mdiDelete} slot="icon"></ha-svg-icon>
+                    Delete
+                  </ha-dropdown-item>
+                </ha-dropdown>
+              </div>
+            </ha-card>
+          </div>
+        `
+      )}
+    `;
+  }
+
+  firstUpdated(changedProps) {
+    super.firstUpdated(changedProps);
+    applyThemesOnElement(
+      this.shadowRoot!.querySelector(".dark"),
+      {
+        default_theme: "default",
+        default_dark_theme: "default",
+        themes: {},
+        darkMode: true,
+        theme: "default",
+      },
+      undefined,
+      undefined,
+      true
+    );
+  }
+
+  static styles = css`
+    :host {
+      display: flex;
+      justify-content: center;
+    }
+    .dark,
+    .light {
+      display: block;
+      background-color: var(--primary-background-color);
+      padding: 0 50px;
+    }
+    .button {
+      padding: unset;
+    }
+    ha-card {
+      margin: 24px auto;
+    }
+    .card-content {
+      display: flex;
+      flex-direction: column;
+      gap: 24px;
+    }
+    .card-content div {
+      display: flex;
+      gap: 8px;
+    }
+  `;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "demo-components-ha-dropdown": DemoHaDropdown;
+  }
+}

package.json

@@ -52,7 +52,7 @@
     "@fullcalendar/list": "6.1.19",
     "@fullcalendar/luxon3": "6.1.19",
     "@fullcalendar/timegrid": "6.1.19",
-    "@home-assistant/webawesome": "3.0.0-beta.6.ha.7",
+    "@home-assistant/webawesome": "3.0.0",
     "@lezer/highlight": "1.2.3",
     "@lit-labs/motion": "1.0.9",
     "@lit-labs/observers": "2.0.6",
@@ -89,8 +89,8 @@
     "@thomasloven/round-slider": "0.6.0",
     "@tsparticles/engine": "3.9.1",
     "@tsparticles/preset-links": "3.2.0",
-    "@vaadin/combo-box": "24.9.4",
-    "@vaadin/vaadin-themable-mixin": "24.9.4",
+    "@vaadin/combo-box": "24.9.5",
+    "@vaadin/vaadin-themable-mixin": "24.9.5",
     "@vibrant/color": "4.0.0",
     "@vue/web-component-wrapper": "1.3.0",
     "@webcomponents/scoped-custom-element-registry": "0.0.10",
@@ -115,14 +115,14 @@
     "home-assistant-js-websocket": "9.5.0",
     "idb-keyval": "6.2.2",
     "intl-messageformat": "10.7.18",
-    "js-yaml": "4.1.0",
+    "js-yaml": "4.1.1",
     "leaflet": "1.9.4",
     "leaflet-draw": "patch:leaflet-draw@npm%3A1.0.4#./.yarn/patches/leaflet-draw-npm-1.0.4-0ca0ebcf65.patch",
     "leaflet.markercluster": "1.5.3",
     "lit": "3.3.1",
     "lit-html": "3.3.1",
     "luxon": "3.7.2",
-    "marked": "16.4.2",
+    "marked": "17.0.0",
     "memoize-one": "6.0.0",
     "node-vibrant": "4.0.3",
     "object-hash": "3.0.0",
@@ -178,7 +178,7 @@
     "@types/tar": "6.1.13",
     "@types/ua-parser-js": "0.7.39",
     "@types/webspeechapi": "0.0.29",
-    "@vitest/coverage-v8": "4.0.7",
+    "@vitest/coverage-v8": "4.0.8",
     "babel-loader": "10.0.0",
     "babel-plugin-template-html-minifier": "4.1.0",
     "browserslist-useragent-regexp": "4.1.3",
@@ -194,7 +194,7 @@
     "eslint-plugin-wc": "3.0.2",
     "fancy-log": "2.0.0",
     "fs-extra": "11.3.2",
-    "glob": "11.0.3",
+    "glob": "12.0.0",
     "gulp": "5.0.1",
     "gulp-brotli": "3.0.0",
     "gulp-json-transform": "0.5.0",
@@ -219,7 +219,7 @@
     "typescript": "5.9.3",
     "typescript-eslint": "8.46.3",
     "vite-tsconfig-paths": "5.1.4",
-    "vitest": "4.0.7",
+    "vitest": "4.0.8",
     "webpack-stats-plugin": "1.1.3",
     "webpackbar": "7.0.0",
     "workbox-build": "patch:workbox-build@npm%3A7.1.1#~/.yarn/patches/workbox-build-npm-7.1.1-a854f3faae.patch"
@@ -233,9 +233,10 @@
     "@fullcalendar/daygrid": "6.1.19",
     "globals": "16.5.0",
     "tslib": "2.8.1",
-    "@material/mwc-list@^0.27.0": "patch:@material/mwc-list@npm%3A0.27.0#~/.yarn/patches/@material-mwc-list-npm-0.27.0-5344fc9de4.patch"
+    "@material/mwc-list@^0.27.0": "patch:@material/mwc-list@npm%3A0.27.0#~/.yarn/patches/@material-mwc-list-npm-0.27.0-5344fc9de4.patch",
+    "glob@^10.2.2": "^10.5.0"
   },
-  "packageManager": "yarn@4.10.3",
+  "packageManager": "yarn@4.11.0",
   "volta": {
     "node": "22.21.1"
   }

src/auth/ha-auth-flow.ts

@@ -59,7 +59,8 @@ export class HaAuthFlow extends LitElement {
   willUpdate(changedProps: PropertyValues) {
     super.willUpdate(changedProps);
 
-    if (!this.hasUpdated) {
+    if (!this.hasUpdated && this.clientId === genClientId()) {
+      // Preselect store token when logging in to own instance
       this._storeToken = this.initStoreToken;
     }
 

src/common/areas/areas-floor-hierarchy.ts

@@ -0,0 +1,53 @@
+import type { AreaRegistryEntry } from "../../data/area_registry";
+import type { FloorRegistryEntry } from "../../data/floor_registry";
+
+export interface AreasFloorHierarchy {
+  floors: {
+    id: string;
+    areas: string[];
+  }[];
+  areas: string[];
+}
+
+export const getAreasFloorHierarchy = (
+  floors: FloorRegistryEntry[],
+  areas: AreaRegistryEntry[]
+): AreasFloorHierarchy => {
+  const floorAreas = new Map<string, string[]>();
+  const unassignedAreas: string[] = [];
+
+  for (const area of areas) {
+    if (area.floor_id) {
+      if (!floorAreas.has(area.floor_id)) {
+        floorAreas.set(area.floor_id, []);
+      }
+      floorAreas.get(area.floor_id)!.push(area.area_id);
+    } else {
+      unassignedAreas.push(area.area_id);
+    }
+  }
+
+  const hierarchy: AreasFloorHierarchy = {
+    floors: floors.map((floor) => ({
+      id: floor.floor_id,
+      areas: floorAreas.get(floor.floor_id) || [],
+    })),
+    areas: unassignedAreas,
+  };
+
+  return hierarchy;
+};
+
+export const getAreasOrder = (hierarchy: AreasFloorHierarchy): string[] => {
+  const order: string[] = [];
+
+  for (const floor of hierarchy.floors) {
+    order.push(...floor.areas);
+  }
+  order.push(...hierarchy.areas);
+
+  return order;
+};
+
+export const getFloorOrder = (hierarchy: AreasFloorHierarchy): string[] =>
+  hierarchy.floors.map((floor) => floor.id);

src/common/condition/extract.ts

@@ -0,0 +1,36 @@
+import type {
+  Condition,
+  TimeCondition,
+} from "../../panels/lovelace/common/validate-condition";
+
+/**
+ * Extract media queries from conditions recursively
+ */
+export function extractMediaQueries(conditions: Condition[]): string[] {
+  return conditions.reduce<string[]>((array, c) => {
+    if ("conditions" in c && c.conditions) {
+      array.push(...extractMediaQueries(c.conditions));
+    }
+    if (c.condition === "screen" && c.media_query) {
+      array.push(c.media_query);
+    }
+    return array;
+  }, []);
+}
+
+/**
+ * Extract time conditions from conditions recursively
+ */
+export function extractTimeConditions(
+  conditions: Condition[]
+): TimeCondition[] {
+  return conditions.reduce<TimeCondition[]>((array, c) => {
+    if ("conditions" in c && c.conditions) {
+      array.push(...extractTimeConditions(c.conditions));
+    }
+    if (c.condition === "time") {
+      array.push(c);
+    }
+    return array;
+  }, []);
+}

src/common/condition/listeners.ts

@@ -0,0 +1,89 @@
+import { listenMediaQuery } from "../dom/media_query";
+import type { HomeAssistant } from "../../types";
+import type { Condition } from "../../panels/lovelace/common/validate-condition";
+import { checkConditionsMet } from "../../panels/lovelace/common/validate-condition";
+import { extractMediaQueries, extractTimeConditions } from "./extract";
+import { calculateNextTimeUpdate } from "./time-calculator";
+
+/** Maximum delay for setTimeout (2^31 - 1 milliseconds, ~24.8 days)
+ * Values exceeding this will overflow and execute immediately
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout#maximum_delay_value
+ */
+const MAX_TIMEOUT_DELAY = 2147483647;
+
+/**
+ * Helper to setup media query listeners for conditional visibility
+ */
+export function setupMediaQueryListeners(
+  conditions: Condition[],
+  hass: HomeAssistant,
+  addListener: (unsub: () => void) => void,
+  onUpdate: (conditionsMet: boolean) => void
+): void {
+  const mediaQueries = extractMediaQueries(conditions);
+
+  if (mediaQueries.length === 0) return;
+
+  // Optimization for single media query
+  const hasOnlyMediaQuery =
+    conditions.length === 1 &&
+    conditions[0].condition === "screen" &&
+    !!conditions[0].media_query;
+
+  mediaQueries.forEach((mediaQuery) => {
+    const unsub = listenMediaQuery(mediaQuery, (matches) => {
+      if (hasOnlyMediaQuery) {
+        onUpdate(matches);
+      } else {
+        const conditionsMet = checkConditionsMet(conditions, hass);
+        onUpdate(conditionsMet);
+      }
+    });
+    addListener(unsub);
+  });
+}
+
+/**
+ * Helper to setup time-based listeners for conditional visibility
+ */
+export function setupTimeListeners(
+  conditions: Condition[],
+  hass: HomeAssistant,
+  addListener: (unsub: () => void) => void,
+  onUpdate: (conditionsMet: boolean) => void
+): void {
+  const timeConditions = extractTimeConditions(conditions);
+
+  if (timeConditions.length === 0) return;
+
+  timeConditions.forEach((timeCondition) => {
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+    const scheduleUpdate = () => {
+      const delay = calculateNextTimeUpdate(hass, timeCondition);
+
+      if (delay === undefined) return;
+
+      // Cap delay to prevent setTimeout overflow
+      const cappedDelay = Math.min(delay, MAX_TIMEOUT_DELAY);
+
+      timeoutId = setTimeout(() => {
+        if (delay <= MAX_TIMEOUT_DELAY) {
+          const conditionsMet = checkConditionsMet(conditions, hass);
+          onUpdate(conditionsMet);
+        }
+        scheduleUpdate();
+      }, cappedDelay);
+    };
+
+    // Register cleanup function once, outside of scheduleUpdate
+    addListener(() => {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+    });
+
+    scheduleUpdate();
+  });
+}

src/common/condition/time-calculator.ts

@@ -0,0 +1,73 @@
+import { TZDate } from "@date-fns/tz";
+import {
+  startOfDay,
+  addDays,
+  addMinutes,
+  differenceInMilliseconds,
+} from "date-fns";
+import type { HomeAssistant } from "../../types";
+import { TimeZone } from "../../data/translation";
+import { parseTimeString } from "../datetime/check_time";
+import type { TimeCondition } from "../../panels/lovelace/common/validate-condition";
+
+/**
+ * Calculate milliseconds until next time boundary for a time condition
+ * @param hass Home Assistant object
+ * @param timeCondition Time condition to calculate next update for
+ * @returns Milliseconds until next boundary, or undefined if no boundaries
+ */
+export function calculateNextTimeUpdate(
+  hass: HomeAssistant,
+  { after, before, weekdays }: Omit<TimeCondition, "condition">
+): number | undefined {
+  const timezone =
+    hass.locale.time_zone === TimeZone.server
+      ? hass.config.time_zone
+      : Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  const now = new TZDate(new Date(), timezone);
+  const updates: Date[] = [];
+
+  // Calculate next occurrence of after time
+  if (after) {
+    let afterDate = parseTimeString(after, timezone);
+    if (afterDate <= now) {
+      // If time has passed today, schedule for tomorrow
+      afterDate = addDays(afterDate, 1);
+    }
+    updates.push(afterDate);
+  }
+
+  // Calculate next occurrence of before time
+  if (before) {
+    let beforeDate = parseTimeString(before, timezone);
+    if (beforeDate <= now) {
+      // If time has passed today, schedule for tomorrow
+      beforeDate = addDays(beforeDate, 1);
+    }
+    updates.push(beforeDate);
+  }
+
+  // If weekdays are specified, check for midnight (weekday transition)
+  if (weekdays && weekdays.length > 0 && weekdays.length < 7) {
+    // Calculate next midnight using startOfDay + addDays
+    const tomorrow = addDays(now, 1);
+    const midnight = startOfDay(tomorrow);
+    updates.push(midnight);
+  }
+
+  if (updates.length === 0) {
+    return undefined;
+  }
+
+  // Find the soonest update time
+  const nextUpdate = updates.reduce((soonest, current) =>
+    current < soonest ? current : soonest
+  );
+
+  // Add 1 minute buffer to ensure we're past the boundary
+  const updateWithBuffer = addMinutes(nextUpdate, 1);
+
+  // Calculate difference in milliseconds
+  return differenceInMilliseconds(updateWithBuffer, now);
+}

src/common/datetime/check_time.ts

@@ -0,0 +1,131 @@
+import { TZDate } from "@date-fns/tz";
+import { isBefore, isAfter, isWithinInterval } from "date-fns";
+import type { HomeAssistant } from "../../types";
+import { TimeZone } from "../../data/translation";
+import { WEEKDAY_MAP } from "./weekday";
+import type { TimeCondition } from "../../panels/lovelace/common/validate-condition";
+
+/**
+ * Validate a time string format and value ranges without creating Date objects
+ * @param timeString Time string to validate (HH:MM or HH:MM:SS)
+ * @returns true if valid, false otherwise
+ */
+export function isValidTimeString(timeString: string): boolean {
+  // Reject empty strings
+  if (!timeString || timeString.trim() === "") {
+    return false;
+  }
+
+  const parts = timeString.split(":");
+
+  if (parts.length < 2 || parts.length > 3) {
+    return false;
+  }
+
+  // Ensure each part contains only digits (and optional leading zeros)
+  // This prevents "8:00 AM" from passing validation
+  if (!parts.every((part) => /^\d+$/.test(part))) {
+    return false;
+  }
+
+  const hours = parseInt(parts[0], 10);
+  const minutes = parseInt(parts[1], 10);
+  const seconds = parts.length === 3 ? parseInt(parts[2], 10) : 0;
+
+  if (isNaN(hours) || isNaN(minutes) || isNaN(seconds)) {
+    return false;
+  }
+
+  return (
+    hours >= 0 &&
+    hours <= 23 &&
+    minutes >= 0 &&
+    minutes <= 59 &&
+    seconds >= 0 &&
+    seconds <= 59
+  );
+}
+
+/**
+ * Parse a time string (HH:MM or HH:MM:SS) and set it on today's date in the given timezone
+ *
+ * Note: This function assumes the time string has already been validated by
+ * isValidTimeString() at configuration time. It does not re-validate at runtime
+ * for consistency with other condition types (screen, user, location, etc.)
+ *
+ * @param timeString The time string to parse (must be pre-validated)
+ * @param timezone The timezone to use
+ * @returns The Date object
+ */
+export const parseTimeString = (timeString: string, timezone: string): Date => {
+  const parts = timeString.split(":");
+  const hours = parseInt(parts[0], 10);
+  const minutes = parseInt(parts[1], 10);
+  const seconds = parts.length === 3 ? parseInt(parts[2], 10) : 0;
+
+  const now = new TZDate(new Date(), timezone);
+  const dateWithTime = new TZDate(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate(),
+    hours,
+    minutes,
+    seconds,
+    0,
+    timezone
+  );
+
+  return new Date(dateWithTime.getTime());
+};
+
+/**
+ * Check if the current time matches the time condition (after/before/weekday)
+ * @param hass Home Assistant object
+ * @param timeCondition Time condition to check
+ * @returns true if current time matches the condition
+ */
+export const checkTimeInRange = (
+  hass: HomeAssistant,
+  { after, before, weekdays }: Omit<TimeCondition, "condition">
+): boolean => {
+  const timezone =
+    hass.locale.time_zone === TimeZone.server
+      ? hass.config.time_zone
+      : Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  const now = new TZDate(new Date(), timezone);
+
+  // Check weekday condition
+  if (weekdays && weekdays.length > 0) {
+    const currentWeekday = WEEKDAY_MAP[now.getDay()];
+    if (!weekdays.includes(currentWeekday)) {
+      return false;
+    }
+  }
+
+  // Check time conditions
+  if (!after && !before) {
+    return true;
+  }
+
+  const afterDate = after ? parseTimeString(after, timezone) : undefined;
+  const beforeDate = before ? parseTimeString(before, timezone) : undefined;
+
+  if (afterDate && beforeDate) {
+    if (isBefore(beforeDate, afterDate)) {
+      // Crosses midnight (e.g., 22:00 to 06:00)
+      return !isBefore(now, afterDate) || !isAfter(now, beforeDate);
+    }
+    return isWithinInterval(now, { start: afterDate, end: beforeDate });
+  }
+
+  if (afterDate) {
+    return !isBefore(now, afterDate);
+  }
+
+  if (beforeDate) {
+    return !isAfter(now, beforeDate);
+  }
+
+  return true;
+};

src/common/datetime/first_weekday.ts

@@ -1,18 +1,7 @@
 import { getWeekStartByLocale } from "weekstart";
 import type { FrontendLocaleData } from "../../data/translation";
 import { FirstWeekday } from "../../data/translation";
-
-export const weekdays = [
-  "sunday",
-  "monday",
-  "tuesday",
-  "wednesday",
-  "thursday",
-  "friday",
-  "saturday",
-] as const;
-
-type WeekdayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+import { WEEKDAYS_LONG, type WeekdayIndex } from "./weekday";
 
 export const firstWeekdayIndex = (locale: FrontendLocaleData): WeekdayIndex => {
   if (locale.first_weekday === FirstWeekday.language) {
@@ -23,12 +12,12 @@ export const firstWeekdayIndex = (locale: FrontendLocaleData): WeekdayIndex => {
     }
     return (getWeekStartByLocale(locale.language) % 7) as WeekdayIndex;
   }
-  return weekdays.includes(locale.first_weekday)
-    ? (weekdays.indexOf(locale.first_weekday) as WeekdayIndex)
+  return WEEKDAYS_LONG.includes(locale.first_weekday)
+    ? (WEEKDAYS_LONG.indexOf(locale.first_weekday) as WeekdayIndex)
     : 1;
 };
 
 export const firstWeekday = (locale: FrontendLocaleData) => {
   const index = firstWeekdayIndex(locale);
-  return weekdays[index];
+  return WEEKDAYS_LONG[index];
 };

src/common/datetime/weekday.ts

@@ -0,0 +1,59 @@
+export type WeekdayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export type WeekdayShort =
+  | "sun"
+  | "mon"
+  | "tue"
+  | "wed"
+  | "thu"
+  | "fri"
+  | "sat";
+
+export type WeekdayLong =
+  | "sunday"
+  | "monday"
+  | "tuesday"
+  | "wednesday"
+  | "thursday"
+  | "friday"
+  | "saturday";
+
+export const WEEKDAYS_SHORT = [
+  "sun",
+  "mon",
+  "tue",
+  "wed",
+  "thu",
+  "fri",
+  "sat",
+] as const satisfies readonly WeekdayShort[];
+
+export const WEEKDAYS_LONG = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+] as const satisfies readonly WeekdayLong[];
+
+export const WEEKDAY_MAP = {
+  0: "sun",
+  1: "mon",
+  2: "tue",
+  3: "wed",
+  4: "thu",
+  5: "fri",
+  6: "sat",
+} as const satisfies Record<WeekdayIndex, WeekdayShort>;
+
+export const WEEKDAY_SHORT_TO_LONG = {
+  sun: "sunday",
+  mon: "monday",
+  tue: "tuesday",
+  wed: "wednesday",
+  thu: "thursday",
+  fri: "friday",
+  sat: "saturday",
+} as const satisfies Record<WeekdayShort, WeekdayLong>;

src/common/dom/apply_themes_on_element.ts

@@ -1,5 +1,6 @@
 import type { ThemeVars } from "../../data/ws-themes";
 import { darkColorVariables } from "../../resources/theme/color";
+import { darkSemanticVariables } from "../../resources/theme/semantic.globals";
 import { derivedStyles } from "../../resources/theme/theme";
 import type { HomeAssistant } from "../../types";
 import {
@@ -52,7 +53,7 @@ export const applyThemesOnElement = (
 
   if (themeToApply && darkMode) {
     cacheKey = `${cacheKey}__dark`;
-    themeRules = { ...darkColorVariables };
+    themeRules = { ...darkSemanticVariables, ...darkColorVariables };
   }
 
   if (themeToApply === "default") {

src/common/keyboard/shortcuts.ts

@@ -0,0 +1,67 @@
+import { tinykeys } from "tinykeys";
+import { canOverrideAlphanumericInput } from "../dom/can-override-input";
+
+/**
+ * A function to handle a keyboard shortcut.
+ */
+export type ShortcutHandler = (event: KeyboardEvent) => void;
+
+/**
+ * Configuration for a keyboard shortcut.
+ */
+export interface ShortcutConfig {
+  handler: ShortcutHandler;
+  /**
+   * If true, allows shortcuts even when text is selected.
+   * Default is false to avoid interrupting copy/paste.
+   */
+  allowWhenTextSelected?: boolean;
+}
+
+/**
+ * Register keyboard shortcuts using tinykeys.
+ * Automatically blocks shortcuts in input fields and during text selection.
+ */
+function registerShortcuts(
+  shortcuts: Record<string, ShortcutConfig>
+): () => void {
+  const wrappedShortcuts: Record<string, ShortcutHandler> = {};
+
+  Object.entries(shortcuts).forEach(([key, config]) => {
+    wrappedShortcuts[key] = (event: KeyboardEvent) => {
+      if (!canOverrideAlphanumericInput(event.composedPath())) {
+        return;
+      }
+      if (!config.allowWhenTextSelected && window.getSelection()?.toString()) {
+        return;
+      }
+      config.handler(event);
+    };
+  });
+
+  return tinykeys(window, wrappedShortcuts);
+}
+
+/**
+ * Manages keyboard shortcuts registration and cleanup.
+ */
+export class ShortcutManager {
+  private _disposer?: () => void;
+
+  /**
+   * Register keyboard shortcuts.
+   * Uses tinykeys syntax: https://github.com/jamiebuilds/tinykeys#usage
+   */
+  public add(shortcuts: Record<string, ShortcutConfig>) {
+    this._disposer?.();
+    this._disposer = registerShortcuts(shortcuts);
+  }
+
+  /**
+   * Remove all registered shortcuts.
+   */
+  public remove() {
+    this._disposer?.();
+    this._disposer = undefined;
+  }
+}

src/common/util/parse-animation-duration.ts

@@ -0,0 +1,36 @@
+/**
+ * Parses a CSS duration string (e.g., "300ms", "3s") and returns the duration in milliseconds.
+ *
+ * @param duration - A CSS duration string (e.g., "300ms", "3s", "0.5s")
+ * @returns The duration in milliseconds, or 0 if the input is invalid
+ *
+ * @example
+ * parseAnimationDuration("300ms") // Returns 300
+ * parseAnimationDuration("3s")    // Returns 3000
+ * parseAnimationDuration("0.5s")  // Returns 500
+ * parseAnimationDuration("invalid") // Returns 0
+ */
+export const parseAnimationDuration = (duration: string): number => {
+  const trimmed = duration.trim();
+
+  let value: number;
+  let multiplier: number;
+
+  if (trimmed.endsWith("ms")) {
+    value = parseFloat(trimmed.slice(0, -2));
+    multiplier = 1;
+  } else if (trimmed.endsWith("s")) {
+    value = parseFloat(trimmed.slice(0, -1));
+    multiplier = 1000;
+  } else {
+    // No recognized unit, try parsing as number (assume ms)
+    value = parseFloat(trimmed);
+    multiplier = 1;
+  }
+
+  if (!isFinite(value) || value < 0) {
+    return 0;
+  }
+
+  return value * multiplier;
+};

src/common/util/select-unit.ts

@@ -119,8 +119,8 @@ type Thresholds = Record<
 >;
 
 export const DEFAULT_THRESHOLDS: Thresholds = {
-  second: 45, // seconds to minute
-  minute: 45, // minutes to hour
+  second: 59, // seconds to minute
+  minute: 59, // minutes to hour
   hour: 22, // hour to day
   day: 5, // day to week
   week: 4, // week to months

src/common/util/view-transition.ts

@@ -0,0 +1,30 @@
+/**
+ * Executes a callback within a View Transition if supported, otherwise runs it directly.
+ *
+ * @param callback - Function to execute. Can be synchronous or return a Promise. The callback will be passed a boolean indicating whether the view transition is available.
+ * @returns Promise that resolves when the transition completes (or immediately if not supported)
+ *
+ * @example
+ * ```typescript
+ * // Synchronous callback
+ * withViewTransition(() => {
+ *   this.large = !this.large;
+ * });
+ *
+ * // Async callback
+ * await withViewTransition(async () => {
+ *   await this.updateData();
+ * });
+ * ```
+ */
+export const withViewTransition = (
+  callback: (viewTransitionAvailable: boolean) => void | Promise<void>
+): Promise<void> => {
+  if (document.startViewTransition) {
+    return document.startViewTransition(() => callback(true)).finished;
+  }
+
+  // Fallback: Execute callback directly without transition
+  const result = callback(false);
+  return result instanceof Promise ? result : Promise.resolve();
+};

src/components/chart/down-sample.ts

@@ -6,7 +6,8 @@ export function downSampleLineData<
   data: T[] | undefined,
   maxDetails: number,
   minX?: number,
-  maxX?: number
+  maxX?: number,
+  useMean = false
 ): T[] {
   if (!data) {
     return [];
@@ -17,15 +18,13 @@ export function downSampleLineData<
   const min = minX ?? getPointData(data[0]!)[0];
   const max = maxX ?? getPointData(data[data.length - 1]!)[0];
   const step = Math.ceil((max - min) / Math.floor(maxDetails));
-  const frames = new Map<
-    number,
-    {
-      min: { point: (typeof data)[number]; x: number; y: number };
-      max: { point: (typeof data)[number]; x: number; y: number };
-    }
-  >();
 
   // Group points into frames
+  const frames = new Map<
+    number,
+    { point: (typeof data)[number]; x: number; y: number }[]
+  >();
+
   for (const point of data) {
     const pointData = getPointData(point);
     if (!Array.isArray(pointData)) continue;
@@ -36,28 +35,53 @@ export function downSampleLineData<
     const frameIndex = Math.floor((x - min) / step);
     const frame = frames.get(frameIndex);
     if (!frame) {
-      frames.set(frameIndex, { min: { point, x, y }, max: { point, x, y } });
+      frames.set(frameIndex, [{ point, x, y }]);
     } else {
-      if (frame.min.y > y) {
-        frame.min = { point, x, y };
-      }
-      if (frame.max.y < y) {
-        frame.max = { point, x, y };
-      }
+      frame.push({ point, x, y });
     }
   }
 
   // Convert frames back to points
   const result: T[] = [];
-  for (const [_i, frame] of frames) {
-    // Use min/max points to preserve visual accuracy
-    // The order of the data must be preserved so max may be before min
-    if (frame.min.x > frame.max.x) {
-      result.push(frame.max.point);
+
+  if (useMean) {
+    // Use mean values for each frame
+    for (const [_i, framePoints] of frames) {
+      const sumY = framePoints.reduce((acc, p) => acc + p.y, 0);
+      const meanY = sumY / framePoints.length;
+      const sumX = framePoints.reduce((acc, p) => acc + p.x, 0);
+      const meanX = sumX / framePoints.length;
+
+      const firstPoint = framePoints[0].point;
+      const pointData = getPointData(firstPoint);
+      const meanPoint = (
+        Array.isArray(pointData) ? [meanX, meanY] : { value: [meanX, meanY] }
+      ) as T;
+      result.push(meanPoint);
     }
-    result.push(frame.min.point);
-    if (frame.min.x < frame.max.x) {
-      result.push(frame.max.point);
+  } else {
+    // Use min/max values for each frame
+    for (const [_i, framePoints] of frames) {
+      let minPoint = framePoints[0];
+      let maxPoint = framePoints[0];
+
+      for (const p of framePoints) {
+        if (p.y < minPoint.y) {
+          minPoint = p;
+        }
+        if (p.y > maxPoint.y) {
+          maxPoint = p;
+        }
+      }
+
+      // The order of the data must be preserved so max may be before min
+      if (minPoint.x > maxPoint.x) {
+        result.push(maxPoint.point);
+      }
+      result.push(minPoint.point);
+      if (minPoint.x < maxPoint.x) {
+        result.push(maxPoint.point);
+      }
     }
   }
 

src/components/chart/ha-chart-base.ts

@@ -427,6 +427,7 @@ export class HaChartBase extends LitElement {
                         ...axis.axisPointer?.handle,
                         show: true,
                       },
+                      label: { show: false },
                     },
                   }
                 : axis

src/components/chart/ha-network-graph.ts

@@ -188,6 +188,7 @@ export class HaNetworkGraph extends SubscribeMixin(LitElement) {
       layout: physicsEnabled ? "force" : "none",
       draggable: true,
       roam: true,
+      roamTrigger: "global",
       selectedMode: "single",
       label: {
         show: showLabels,

src/components/chips/ha-filter-chip.ts

@@ -30,6 +30,7 @@ export class HaFilterChip extends FilterChip {
           var(--rgb-primary-text-color),
           0.15
         );
+        --_label-text-font: var(--ha-font-family-body);
         border-radius: var(--ha-border-radius-md);
       }
     `,

src/components/data-table/ha-data-table-labels.ts

@@ -62,6 +62,7 @@ class HaDataTableLabels extends LitElement {
         @click=${clickAction ? this._labelClicked : undefined}
         @keydown=${clickAction ? this._labelClicked : undefined}
         style=${color ? `--color: ${color}` : ""}
+        .description=${label.description}
       >
         ${label?.icon
           ? html`<ha-icon slot="icon" .icon=${label.icon}></ha-icon>`

src/components/data-table/ha-data-table.ts

@@ -298,6 +298,18 @@ export class HaDataTable extends LitElement {
     }
 
     if (properties.has("data")) {
+      // Clean up checked rows that no longer exist in the data
+      if (this._checkedRows.length) {
+        const validIds = new Set(this.data.map((row) => String(row[this.id])));
+        const validCheckedRows = this._checkedRows.filter((id) =>
+          validIds.has(id)
+        );
+        if (validCheckedRows.length !== this._checkedRows.length) {
+          this._checkedRows = validCheckedRows;
+          this._checkedRowsChanged();
+        }
+      }
+
       this._checkableRowsCount = this.data.filter(
         (row) => row.selectable !== false
       ).length;

src/components/device/ha-device-picker.ts

@@ -197,9 +197,6 @@ export class HaDevicePicker extends LitElement {
     const placeholder =
       this.placeholder ??
       this.hass.localize("ui.components.device-picker.placeholder");
-    const notFoundLabel = this.hass.localize(
-      "ui.components.device-picker.no_match"
-    );
 
     const valueRenderer = this._valueRenderer(this._configEntryLookup);
 
@@ -209,7 +206,10 @@ export class HaDevicePicker extends LitElement {
         .autofocus=${this.autofocus}
         .label=${this.label}
         .searchLabel=${this.searchLabel}
-        .notFoundLabel=${notFoundLabel}
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass.localize(
+          "ui.components.device-picker.no_devices"
+        )}
         .placeholder=${placeholder}
         .value=${this.value}
         .rowRenderer=${this._rowRenderer}
@@ -233,6 +233,11 @@ export class HaDevicePicker extends LitElement {
     this.value = value;
     fireEvent(this, "value-changed", { value });
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.device-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/entity/ha-entity-picker.ts

@@ -269,9 +269,6 @@ export class HaEntityPicker extends LitElement {
     const placeholder =
       this.placeholder ??
       this.hass.localize("ui.components.entity.entity-picker.placeholder");
-    const notFoundLabel = this.hass.localize(
-      "ui.components.entity.entity-picker.no_match"
-    );
 
     return html`
       <ha-generic-picker
@@ -282,7 +279,7 @@ export class HaEntityPicker extends LitElement {
         .label=${this.label}
         .helper=${this.helper}
         .searchLabel=${this.searchLabel}
-        .notFoundLabel=${notFoundLabel}
+        .notFoundLabel=${this._notFoundLabel}
         .placeholder=${placeholder}
         .value=${this.addButton ? undefined : this.value}
         .rowRenderer=${this._rowRenderer}
@@ -356,6 +353,11 @@ export class HaEntityPicker extends LitElement {
     fireEvent(this, "value-changed", { value });
     fireEvent(this, "change");
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.entity.entity-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/entity/ha-statistic-picker.ts

@@ -21,7 +21,6 @@ import "../ha-combo-box-item";
 import "../ha-generic-picker";
 import type { HaGenericPicker } from "../ha-generic-picker";
 import "../ha-icon-button";
-import "../ha-input-helper-text";
 import type {
   PickerComboBoxItem,
   PickerComboBoxSearchFn,
@@ -271,7 +270,6 @@ export class HaStatisticPicker extends LitElement {
         const secondary = [areaName, entityName ? deviceName : undefined]
           .filter(Boolean)
           .join(isRTL ? " ◂ " : " ▸ ");
-        const a11yLabel = [deviceName, entityName].filter(Boolean).join(" - ");
 
         const sortingPrefix = `${TYPE_ORDER.indexOf("entity")}`;
         output.push({
@@ -279,7 +277,6 @@ export class HaStatisticPicker extends LitElement {
           statistic_id: id,
           primary,
           secondary,
-          a11y_label: a11yLabel,
           stateObj: stateObj,
           type: "entity",
           sorting_label: [sortingPrefix, deviceName, entityName].join("_"),
@@ -458,9 +455,6 @@ export class HaStatisticPicker extends LitElement {
     const placeholder =
       this.placeholder ??
       this.hass.localize("ui.components.statistic-picker.placeholder");
-    const notFoundLabel = this.hass.localize(
-      "ui.components.statistic-picker.no_match"
-    );
 
     return html`
       <ha-generic-picker
@@ -468,7 +462,10 @@ export class HaStatisticPicker extends LitElement {
         .autofocus=${this.autofocus}
         .allowCustomValue=${this.allowCustomEntity}
         .label=${this.label}
-        .notFoundLabel=${notFoundLabel}
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass.localize(
+          "ui.components.statistic-picker.no_statistics"
+        )}
         .placeholder=${placeholder}
         .value=${this.value}
         .rowRenderer=${this._rowRenderer}
@@ -477,6 +474,7 @@ export class HaStatisticPicker extends LitElement {
         .hideClearIcon=${this.hideClearIcon}
         .searchFn=${this._searchFn}
         .valueRenderer=${this._valueRenderer}
+        .helper=${this.helper}
         @value-changed=${this._valueChanged}
       >
       </ha-generic-picker>
@@ -521,6 +519,11 @@ export class HaStatisticPicker extends LitElement {
     await this.updateComplete;
     await this._picker?.open();
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.statistic-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/ha-area-picker.ts

@@ -369,9 +369,10 @@ export class HaAreaPicker extends LitElement {
         .autofocus=${this.autofocus}
         .label=${this.label}
         .helper=${this.helper}
-        .notFoundLabel=${this.hass.localize(
-          "ui.components.area-picker.no_match"
-        )}
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass.localize("ui.components.area-picker.no_areas")}
+        .disabled=${this.disabled}
+        .required=${this.required}
         .placeholder=${placeholder}
         .value=${this.value}
         .getItems=${this._getItems}
@@ -425,6 +426,11 @@ export class HaAreaPicker extends LitElement {
     fireEvent(this, "value-changed", { value });
     fireEvent(this, "change");
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.area-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/ha-assist-chat.ts

@@ -17,6 +17,7 @@ import type { HomeAssistant } from "../types";
 import { AudioRecorder } from "../util/audio-recorder";
 import { documentationUrl } from "../util/documentation-url";
 import "./ha-alert";
+import "./ha-markdown";
 import "./ha-textfield";
 import type { HaTextField } from "./ha-textfield";
 
@@ -40,7 +41,11 @@ export class HaAssistChat extends LitElement {
 
   @query("#message-input") private _messageInput!: HaTextField;
 
-  @query("#scroll-container") private _scrollContainer!: HTMLDivElement;
+  @query(".message:last-child")
+  private _lastChatMessage!: LitElement;
+
+  @query(".message:last-child img:last-of-type")
+  private _lastChatMessageImage: HTMLImageElement | undefined;
 
   @state() private _conversation: AssistMessage[] = [];
 
@@ -92,10 +97,7 @@ export class HaAssistChat extends LitElement {
   public disconnectedCallback() {
     super.disconnectedCallback();
     this._audioRecorder?.close();
-    this._audioRecorder = undefined;
     this._unloadAudio();
-    this._conversation = [];
-    this._conversationId = null;
   }
 
   protected render(): TemplateResult {
@@ -112,7 +114,7 @@ export class HaAssistChat extends LitElement {
     const supportsSTT = this.pipeline?.stt_engine && !this.disableSpeech;
 
     return html`
-      <div class="messages" id="scroll-container">
+      <div class="messages">
         ${controlHA
           ? nothing
           : html`
@@ -124,11 +126,18 @@ export class HaAssistChat extends LitElement {
             `}
         <div class="spacer"></div>
         ${this._conversation!.map(
-          // New lines matter for messages
-          // prettier-ignore
           (message) => html`
-                <div class="message ${classMap({ error: !!message.error, [message.who]: true })}">${message.text}</div>
-              `
+            <ha-markdown
+              class="message ${classMap({
+                error: !!message.error,
+                [message.who]: true,
+              })}"
+              breaks
+              cache
+              .content=${message.text}
+            >
+            </ha-markdown>
+          `
         )}
       </div>
       <div class="input" slot="primaryAction">
@@ -189,12 +198,28 @@ export class HaAssistChat extends LitElement {
     `;
   }
 
-  private _scrollMessagesBottom() {
-    const scrollContainer = this._scrollContainer;
-    if (!scrollContainer) {
-      return;
+  private async _scrollMessagesBottom() {
+    const lastChatMessage = this._lastChatMessage;
+    if (!lastChatMessage.hasUpdated) {
+      await lastChatMessage.updateComplete;
+    }
+    if (
+      this._lastChatMessageImage &&
+      !this._lastChatMessageImage.naturalHeight
+    ) {
+      try {
+        await this._lastChatMessageImage.decode();
+      } catch (err: any) {
+        // eslint-disable-next-line no-console
+        console.warn("Failed to decode image:", err);
+      }
+    }
+    const isLastMessageFullyVisible =
+      lastChatMessage.getBoundingClientRect().y <
+      this.getBoundingClientRect().top + 24;
+    if (!isLastMessageFullyVisible) {
+      lastChatMessage.scrollIntoView({ behavior: "smooth", block: "start" });
     }
-    scrollContainer.scrollTo(0, scrollContainer.scrollHeight);
   }
 
   private _handleKeyUp(ev: KeyboardEvent) {
@@ -586,42 +611,31 @@ export class HaAssistChat extends LitElement {
       flex: 1;
     }
     .message {
-      white-space: pre-line;
       font-size: var(--ha-font-size-l);
       clear: both;
+      max-width: -webkit-fill-available;
+      overflow-wrap: break-word;
+      scroll-margin-top: 24px;
       margin: 8px 0;
       padding: 8px;
       border-radius: var(--ha-border-radius-xl);
     }
-    .message:last-child {
-      margin-bottom: 0;
-    }
-
     @media all and (max-width: 450px), all and (max-height: 500px) {
       .message {
         font-size: var(--ha-font-size-l);
       }
     }
-
-    .message p {
-      margin: 0;
-    }
-    .message p:not(:last-child) {
-      margin-bottom: 8px;
-    }
-
     .message.user {
       margin-left: 24px;
       margin-inline-start: 24px;
       margin-inline-end: initial;
       align-self: flex-end;
-      text-align: right;
       border-bottom-right-radius: 0px;
+      --markdown-link-color: var(--text-primary-color);
       background-color: var(--chat-background-color-user, var(--primary-color));
       color: var(--text-primary-color);
       direction: var(--direction);
     }
-
     .message.hass {
       margin-right: 24px;
       margin-inline-end: 24px;
@@ -636,20 +650,21 @@ export class HaAssistChat extends LitElement {
       color: var(--primary-text-color);
       direction: var(--direction);
     }
-
-    .message.user a {
-      color: var(--text-primary-color);
-    }
-
-    .message.hass a {
-      color: var(--primary-text-color);
-    }
-
     .message.error {
       background-color: var(--error-color);
       color: var(--text-primary-color);
     }
-
+    ha-markdown {
+      --markdown-image-border-radius: calc(var(--ha-border-radius-xl) / 2);
+      --markdown-table-border-color: var(--divider-color);
+      --markdown-code-background-color: var(--primary-background-color);
+      --markdown-code-text-color: var(--primary-text-color);
+      &:not(:has(ha-markdown-element)) {
+        min-height: 1lh;
+        min-width: 1lh;
+        flex-shrink: 0;
+      }
+    }
     .bouncer {
       width: 48px;
       height: 48px;

src/components/ha-date-input.ts

@@ -94,6 +94,12 @@ export class HaDateInput extends LitElement {
   }
 
   private _keyDown(ev: KeyboardEvent) {
+    if (["Space", "Enter"].includes(ev.code)) {
+      ev.preventDefault();
+      ev.stopPropagation();
+      this._openDialog();
+      return;
+    }
     if (!this.canClear) {
       return;
     }

src/components/ha-dialog.ts

@@ -90,7 +90,8 @@ export class HaDialog extends DialogBase {
       }
       .mdc-dialog__actions {
         justify-content: var(--justify-action-buttons, flex-end);
-        padding: 12px 16px 16px 16px;
+        padding: var(--ha-space-3) var(--ha-space-4) var(--ha-space-4)
+          var(--ha-space-4);
       }
       .mdc-dialog__actions span:nth-child(1) {
         flex: var(--secondary-action-button-flex, unset);
@@ -100,22 +101,24 @@ export class HaDialog extends DialogBase {
       }
       .mdc-dialog__container {
         align-items: var(--vertical-align-dialog, center);
+        padding: var(--dialog-container-padding, var(--ha-space-0));
       }
       .mdc-dialog__title {
-        padding: 16px 16px 0 16px;
+        padding: var(--ha-space-4) var(--ha-space-4) var(--ha-space-0)
+          var(--ha-space-4);
       }
       .mdc-dialog__title:has(span) {
-        padding: 12px 12px 0;
+        padding: var(--ha-space-3) var(--ha-space-3) var(--ha-space-0);
       }
       .mdc-dialog__title::before {
         content: unset;
       }
       .mdc-dialog .mdc-dialog__content {
         position: var(--dialog-content-position, relative);
-        padding: var(--dialog-content-padding, 24px);
+        padding: var(--dialog-content-padding, var(--ha-space-6));
       }
       :host([hideactions]) .mdc-dialog .mdc-dialog__content {
-        padding-bottom: var(--dialog-content-padding, 24px);
+        padding-bottom: var(--dialog-content-padding, var(--ha-space-6));
       }
       .mdc-dialog .mdc-dialog__surface {
         position: var(--dialog-surface-position, relative);
@@ -133,7 +136,7 @@ export class HaDialog extends DialogBase {
           --ha-dialog-surface-background,
           var(--mdc-theme-surface, #fff)
         );
-        padding: var(--dialog-surface-padding);
+        padding: var(--dialog-surface-padding, var(--ha-space-0));
       }
       :host([flexContent]) .mdc-dialog .mdc-dialog__content {
         display: flex;
@@ -150,22 +153,22 @@ export class HaDialog extends DialogBase {
         text-overflow: ellipsis;
         white-space: nowrap;
         display: block;
-        padding-left: 4px;
-        padding-right: 4px;
-        margin-right: 12px;
-        margin-inline-end: 12px;
+        padding-left: var(--ha-space-1);
+        padding-right: var(--ha-space-1);
+        margin-right: var(--ha-space-3);
+        margin-inline-end: var(--ha-space-3);
         margin-inline-start: initial;
       }
       .header_button {
         text-decoration: none;
         color: inherit;
         inset-inline-start: initial;
-        inset-inline-end: -12px;
+        inset-inline-end: calc(var(--ha-space-3) * -1);
         direction: var(--direction);
       }
       .dialog-actions {
         inset-inline-start: initial !important;
-        inset-inline-end: 0px !important;
+        inset-inline-end: var(--ha-space-0) !important;
         direction: var(--direction);
       }
     `,

src/components/ha-dropdown-item.ts

@@ -0,0 +1,41 @@
+import DropdownItem from "@home-assistant/webawesome/dist/components/dropdown-item/dropdown-item";
+import { css, type CSSResultGroup } from "lit";
+import { customElement } from "lit/decorators";
+
+/**
+ * Home Assistant dropdown item component
+ *
+ * @element ha-dropdown-item
+ * @extends {DropdownItem}
+ *
+ * @summary
+ * A stylable dropdown item component supporting Home Assistant theming, variants, and appearances based on webawesome dropdown item.
+ *
+ */
+@customElement("ha-dropdown-item")
+export class HaDropdownItem extends DropdownItem {
+  static get styles(): CSSResultGroup {
+    return [
+      DropdownItem.styles,
+      css`
+        :host {
+          min-height: var(--ha-space-10);
+        }
+
+        #icon ::slotted(*) {
+          color: var(--ha-color-on-neutral-normal);
+        }
+
+        :host([variant="danger"]) #icon ::slotted(*) {
+          color: var(--ha-color-on-danger-quiet);
+        }
+      `,
+    ];
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "ha-dropdown-item": HaDropdownItem;
+  }
+}

src/components/ha-dropdown.ts

@@ -0,0 +1,45 @@
+import Dropdown from "@home-assistant/webawesome/dist/components/dropdown/dropdown";
+import { css, type CSSResultGroup } from "lit";
+import { customElement, property } from "lit/decorators";
+
+/**
+ * Home Assistant dropdown component
+ *
+ * @element ha-dropdown
+ * @extends {Dropdown}
+ *
+ * @summary
+ * A stylable dropdown component supporting Home Assistant theming, variants, and appearances based on webawesome dropdown.
+ *
+ */
+@customElement("ha-dropdown")
+export class HaDropdown extends Dropdown {
+  @property({ attribute: false }) dropdownTag = "ha-dropdown";
+
+  @property({ attribute: false }) dropdownItemTag = "ha-dropdown-item";
+
+  static get styles(): CSSResultGroup {
+    return [
+      Dropdown.styles,
+      css`
+        :host {
+          font-size: var(--ha-dropdown-font-size, var(--ha-font-size-m));
+          --wa-color-surface-raised: var(
+            --card-background-color,
+            var(--ha-dialog-surface-background, var(--mdc-theme-surface, #fff)),
+          );
+        }
+
+        #menu {
+          padding: var(--ha-space-1);
+        }
+      `,
+    ];
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "ha-dropdown": HaDropdown;
+  }
+}

src/components/ha-filter-labels.ts

@@ -109,7 +109,10 @@ export class HaFilterLabels extends SubscribeMixin(LitElement) {
                       .selected=${(this.value || []).includes(label.label_id)}
                       hasMeta
                     >
-                      <ha-label style=${color ? `--color: ${color}` : ""}>
+                      <ha-label
+                        style=${color ? `--color: ${color}` : ""}
+                        .description=${label.description}
+                      >
                         ${label.icon
                           ? html`<ha-icon
                               slot="icon"

src/components/ha-floor-picker.ts

@@ -383,8 +383,9 @@ export class HaFloorPicker extends LitElement {
         .hass=${this.hass}
         .autofocus=${this.autofocus}
         .label=${this.label}
-        .notFoundLabel=${this.hass.localize(
-          "ui.components.floor-picker.no_match"
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass.localize(
+          "ui.components.floor-picker.no_floors"
         )}
         .placeholder=${placeholder}
         .value=${this.value}
@@ -444,6 +445,11 @@ export class HaFloorPicker extends LitElement {
     fireEvent(this, "value-changed", { value });
     fireEvent(this, "change");
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.floor-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/ha-generic-picker.ts

@@ -25,9 +25,6 @@ import "./ha-svg-icon";
 export class HaGenericPicker extends LitElement {
   @property({ attribute: false }) public hass?: HomeAssistant;
 
-  // eslint-disable-next-line lit/no-native-attributes
-  @property({ type: Boolean }) public autofocus = false;
-
   @property({ type: Boolean }) public disabled = false;
 
   @property({ type: Boolean }) public required = false;
@@ -49,8 +46,11 @@ export class HaGenericPicker extends LitElement {
   @property({ attribute: "hide-clear-icon", type: Boolean })
   public hideClearIcon = false;
 
-  @property({ attribute: false, type: Array })
-  public getItems?: () => PickerComboBoxItem[];
+  @property({ attribute: false })
+  public getItems?: (
+    searchString?: string,
+    section?: string
+  ) => (PickerComboBoxItem | string)[];
 
   @property({ attribute: false, type: Array })
   public getAdditionalItems?: (searchString?: string) => PickerComboBoxItem[];
@@ -64,8 +64,11 @@ export class HaGenericPicker extends LitElement {
   @property({ attribute: false })
   public searchFn?: PickerComboBoxSearchFn<PickerComboBoxItem>;
 
-  @property({ attribute: "not-found-label", type: String })
-  public notFoundLabel?: string;
+  @property({ attribute: false })
+  public notFoundLabel?: string | ((search: string) => string);
+
+  @property({ attribute: "empty-label" })
+  public emptyLabel?: string;
 
   @property({ attribute: "popover-placement" })
   public popoverPlacement:
@@ -85,6 +88,25 @@ export class HaGenericPicker extends LitElement {
   /** If set picker shows an add button instead of textbox when value isn't set */
   @property({ attribute: "add-button-label" }) public addButtonLabel?: string;
 
+  /** Section filter buttons for the list, section headers needs to be defined in getItems as strings */
+  @property({ attribute: false }) public sections?: (
+    | {
+        id: string;
+        label: string;
+      }
+    | "separator"
+  )[];
+
+  @property({ attribute: false }) public sectionTitleFunction?: (listInfo: {
+    firstIndex: number;
+    lastIndex: number;
+    firstItem: PickerComboBoxItem | string;
+    secondItem: PickerComboBoxItem | string;
+    itemsCount: number;
+  }) => string | undefined;
+
+  @property({ attribute: "selected-section" }) public selectedSection?: string;
+
   @query(".container") private _containerElement?: HTMLDivElement;
 
   @query("ha-picker-combo-box") private _comboBox?: HaPickerComboBox;
@@ -97,6 +119,11 @@ export class HaGenericPicker extends LitElement {
 
   @state() private _openedNarrow = false;
 
+  static shadowRootOptions = {
+    ...LitElement.shadowRootOptions,
+    delegatesFocus: true,
+  };
+
   private _narrow = false;
 
   // helper to set new value after closing picker, to avoid flicker
@@ -189,16 +216,19 @@ export class HaGenericPicker extends LitElement {
       <ha-picker-combo-box
         .hass=${this.hass}
         .allowCustomValue=${this.allowCustomValue}
-        .label=${this.searchLabel ??
-        (this.hass?.localize("ui.common.search") || "Search")}
+        .label=${this.searchLabel}
         .value=${this.value}
         @value-changed=${this._valueChanged}
         .rowRenderer=${this.rowRenderer}
         .notFoundLabel=${this.notFoundLabel}
+        .emptyLabel=${this.emptyLabel}
         .getItems=${this.getItems}
         .getAdditionalItems=${this.getAdditionalItems}
         .searchFn=${this.searchFn}
         .mode=${dialogMode ? "dialog" : "popover"}
+        .sections=${this.sections}
+        .sectionTitleFunction=${this.sectionTitleFunction}
+        .selectedSection=${this.selectedSection}
       ></ha-picker-combo-box>
     `;
   }

src/components/ha-hls-player.ts

@@ -60,6 +60,10 @@ class HaHLSPlayer extends LitElement {
   private static streamCount = 0;
 
   private _handleVisibilityChange = () => {
+    if (document.pictureInPictureElement) {
+      // video is playing in picture-in-picture mode, don't do anything
+      return;
+    }
     if (document.hidden) {
       this._cleanUp();
     } else {

src/components/ha-label-picker.ts

@@ -224,8 +224,9 @@ export class HaLabelPicker extends SubscribeMixin(LitElement) {
         .hass=${this.hass}
         .autofocus=${this.autofocus}
         .label=${this.label}
-        .notFoundLabel=${this.hass.localize(
-          "ui.components.label-picker.no_match"
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass.localize(
+          "ui.components.label-picker.no_labels"
         )}
         .addButtonLabel=${this.hass.localize("ui.components.label-picker.add")}
         .placeholder=${placeholder}
@@ -288,6 +289,11 @@ export class HaLabelPicker extends SubscribeMixin(LitElement) {
       fireEvent(this, "change");
     }, 0);
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.label-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/components/ha-label.ts

@@ -1,17 +1,32 @@
 import type { CSSResultGroup, TemplateResult } from "lit";
 import { css, html, LitElement } from "lit";
 import { customElement, property } from "lit/decorators";
+import { uid } from "../common/util/uid";
+import "./ha-tooltip";
 
 @customElement("ha-label")
 class HaLabel extends LitElement {
   @property({ type: Boolean, reflect: true }) dense = false;
 
+  @property({ attribute: "description" })
+  public description?: string;
+
+  private _elementId = "label-" + uid();
+
   protected render(): TemplateResult {
     return html`
-      <span class="content">
-        <slot name="icon"></slot>
-        <slot></slot>
-      </span>
+      <ha-tooltip
+        .for=${this._elementId}
+        .disabled=${!this.description?.trim()}
+      >
+        ${this.description}
+      </ha-tooltip>
+      <div class="container" .id=${this._elementId}>
+        <span class="content">
+          <slot name="icon"></slot>
+          <slot></slot>
+        </span>
+      </div>
     `;
   }
 
@@ -36,9 +51,7 @@ class HaLabel extends LitElement {
           font-weight: var(--ha-font-weight-medium);
           line-height: var(--ha-line-height-condensed);
           letter-spacing: 0.1px;
-          vertical-align: middle;
           height: 32px;
-          padding: 0 16px;
           border-radius: var(--ha-border-radius-xl);
           color: var(--ha-label-text-color);
           --mdc-icon-size: 12px;
@@ -66,15 +79,24 @@ class HaLabel extends LitElement {
           display: flex;
         }
 
+        .container {
+          display: flex;
+          position: relative;
+          height: 100%;
+          padding: 0 16px;
+        }
+
         span {
           display: inline-flex;
         }
 
         :host([dense]) {
           height: 20px;
-          padding: 0 12px;
           border-radius: var(--ha-border-radius-md);
         }
+        :host([dense]) .container {
+          padding: 0 12px;
+        }
         :host([dense]) ::slotted([slot="icon"]) {
           margin-right: 4px;
           margin-left: -4px;

src/components/ha-labels-picker.ts

@@ -21,6 +21,7 @@ import "./chips/ha-input-chip";
 import type { HaDevicePickerDeviceFilterFunc } from "./device/ha-device-picker";
 import "./ha-label-picker";
 import type { HaLabelPicker } from "./ha-label-picker";
+import "./ha-tooltip";
 
 @customElement("ha-labels-picker")
 export class HaLabelsPicker extends SubscribeMixin(LitElement) {
@@ -142,9 +143,17 @@ export class HaLabelsPicker extends SubscribeMixin(LitElement) {
                   const color = label?.color
                     ? computeCssColor(label.color)
                     : undefined;
+                  const elementId = "label-" + label.label_id;
                   return html`
+                    <ha-tooltip
+                      .for=${elementId}
+                      .disabled=${!label?.description?.trim()}
+                    >
+                      ${label?.description}
+                    </ha-tooltip>
                     <ha-input-chip
                       .item=${label}
+                      .id=${elementId}
                       @remove=${this._removeItem}
                       @click=${this._openDetail}
                       .disabled=${this.disabled}

src/components/ha-language-picker.ts

@@ -125,9 +125,10 @@ export class HaLanguagePicker extends LitElement {
         .hass=${this.hass}
         .autofocus=${this.autofocus}
         popover-placement="bottom-end"
-        .notFoundLabel=${this.hass?.localize(
-          "ui.components.language-picker.no_match"
-        )}
+        .notFoundLabel=${this._notFoundLabel}
+        .emptyLabel=${this.hass?.localize(
+          "ui.components.language-picker.no_languages"
+        ) || "No languages available"}
         .placeholder=${this.label ??
         (this.hass?.localize("ui.components.language-picker.language") ||
           "Language")}
@@ -172,6 +173,15 @@ export class HaLanguagePicker extends LitElement {
     this.value = ev.detail.value;
     fireEvent(this, "value-changed", { value: this.value });
   }
+
+  private _notFoundLabel = (search: string) => {
+    const term = html`<b>‘${search}’</b>`;
+    return this.hass
+      ? this.hass.localize("ui.components.language-picker.no_match", {
+          term,
+        })
+      : html`No languages found for ${term}`;
+  };
 }
 
 declare global {

src/components/ha-markdown-element.ts

@@ -1,11 +1,15 @@
 import type { PropertyValues } from "lit";
-import { ReactiveElement } from "lit";
+import { ReactiveElement, render, html } from "lit";
 import { customElement, property } from "lit/decorators";
+// eslint-disable-next-line import/extensions
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
 import hash from "object-hash";
 import { fireEvent } from "../common/dom/fire_event";
 import { renderMarkdown } from "../resources/render-markdown";
 import { CacheManager } from "../util/cache-manager";
 
+const h = (template: ReturnType<typeof unsafeHTML>) => html`${template}`;
+
 const markdownCache = new CacheManager<string>(1000);
 
 const _gitHubMarkdownAlerts = {
@@ -48,18 +52,26 @@ class HaMarkdownElement extends ReactiveElement {
     return this;
   }
 
+  private _renderPromise: ReturnType<typeof this._render> = Promise.resolve();
+
   protected update(changedProps) {
     super.update(changedProps);
     if (this.content !== undefined) {
-      this._render();
+      this._renderPromise = this._render();
     }
   }
 
+  protected async getUpdateComplete(): Promise<boolean> {
+    await super.getUpdateComplete();
+    await this._renderPromise;
+    return true;
+  }
+
   protected willUpdate(_changedProperties: PropertyValues): void {
     if (!this.innerHTML && this.cache) {
       const key = this._computeCacheKey();
       if (markdownCache.has(key)) {
-        this.innerHTML = markdownCache.get(key)!;
+        render(markdownCache.get(key)!, this.renderRoot);
         this._resize();
       }
     }
@@ -75,7 +87,7 @@ class HaMarkdownElement extends ReactiveElement {
   }
 
   private async _render() {
-    this.innerHTML = await renderMarkdown(
+    const elements = await renderMarkdown(
       String(this.content),
       {
         breaks: this.breaks,
@@ -87,6 +99,11 @@ class HaMarkdownElement extends ReactiveElement {
       }
     );
 
+    render(
+      elements.map((e) => h(unsafeHTML(e))),
+      this.renderRoot
+    );
+
     this._resize();
 
     const walker = document.createTreeWalker(

src/components/ha-markdown.ts

@@ -1,5 +1,12 @@
-import { css, html, LitElement, nothing, type CSSResultGroup } from "lit";
-import { customElement, property } from "lit/decorators";
+import {
+  css,
+  html,
+  LitElement,
+  nothing,
+  type ReactiveElement,
+  type CSSResultGroup,
+} from "lit";
+import { customElement, property, query } from "lit/decorators";
 import "./ha-markdown-element";
 
 @customElement("ha-markdown")
@@ -18,6 +25,14 @@ export class HaMarkdown extends LitElement {
 
   @property({ type: Boolean }) public cache = false;
 
+  @query("ha-markdown-element") private _markdownElement!: ReactiveElement;
+
+  protected async getUpdateComplete() {
+    const result = await super.getUpdateComplete();
+    await this._markdownElement.updateComplete;
+    return result;
+  }
+
   protected render() {
     if (!this.content) {
       return nothing;
@@ -53,19 +68,46 @@ export class HaMarkdown extends LitElement {
       margin: var(--ha-space-1) 0;
     }
     a {
-      color: var(--primary-color);
+      color: var(--markdown-link-color, var(--primary-color));
     }
     img {
+      background-color: rgba(10, 10, 10, 0.15);
+      border-radius: var(--markdown-image-border-radius);
       max-width: 100%;
+      min-height: 2lh;
+      height: auto;
+      width: auto;
+      text-indent: 4px;
+      transition: height 0.2s ease-in-out;
+    }
+    p:first-child > img:first-child {
+      vertical-align: top;
+    }
+    p:first-child > img:last-child {
+      vertical-align: top;
+    }
+    ol,
+    ul {
+      list-style-position: inside;
+      padding-inline-start: 0;
+    }
+    li {
+      &:has(input[type="checkbox"]) {
+        list-style: none;
+        & > input[type="checkbox"] {
+          margin-left: 0;
+        }
+      }
+    }
+    svg {
+      background-color: var(--markdown-svg-background-color, none);
+      color: var(--markdown-svg-color, none);
     }
     code,
     pre {
       background-color: var(--markdown-code-background-color, none);
       border-radius: var(--ha-border-radius-sm);
-    }
-    svg {
-      background-color: var(--markdown-svg-background-color, none);
-      color: var(--markdown-svg-color, none);
+      color: var(--markdown-code-text-color, inherit);
     }
     code {
       font-size: var(--ha-font-size-s);
@@ -97,6 +139,24 @@ export class HaMarkdown extends LitElement {
       border-bottom: none;
       margin: var(--ha-space-4) 0;
     }
+    table {
+      border-collapse: collapse;
+      display: block;
+      overflow-x: auto;
+    }
+    th {
+      text-align: start;
+    }
+    td,
+    th {
+      border: 1px solid var(--markdown-table-border-color, transparent);
+      padding: 0.25em 0.5em;
+    }
+    blockquote {
+      border-left: 4px solid var(--divider-color);
+      margin-inline: 0;
+      padding-inline: 1em;
+    }
   ` as CSSResultGroup;
 }
 

src/components/ha-md-dialog.ts

@@ -175,10 +175,10 @@ export class HaMdDialog extends Dialog {
         }
 
         .container {
-          padding-top: var(--safe-area-inset-top);
-          padding-bottom: var(--safe-area-inset-bottom);
-          padding-left: var(--safe-area-inset-left);
-          padding-right: var(--safe-area-inset-right);
+          margin-top: var(--safe-area-inset-top, var(--ha-space-0));
+          margin-bottom: var(--safe-area-inset-bottom, var(--ha-space-0));
+          margin-left: var(--safe-area-inset-left, var(--ha-space-0));
+          margin-right: var(--safe-area-inset-right, var(--ha-space-0));
         }
       }
 
@@ -187,7 +187,7 @@ export class HaMdDialog extends Dialog {
       }
 
       slot[name="actions"]::slotted(*) {
-        padding: 16px;
+        padding: var(--ha-space-4);
       }
 
       .scroller {
@@ -195,7 +195,7 @@ export class HaMdDialog extends Dialog {
       }
 
       slot[name="content"]::slotted(*) {
-        padding: var(--dialog-content-padding, 24px);
+        padding: var(--dialog-content-padding, var(--ha-space-6));
       }
       .scrim {
         z-index: 10; /* overlay navigation */

src/components/ha-md-list-item.ts

@@ -1,7 +1,8 @@
 import { ListItemEl } from "@material/web/list/internal/listitem/list-item";
 import { styles } from "@material/web/list/internal/listitem/list-item-styles";
-import { css } from "lit";
+import { css, html, nothing, type TemplateResult } from "lit";
 import { customElement } from "lit/decorators";
+import "./ha-ripple";
 
 export const haMdListStyles = [
   styles,
@@ -25,6 +26,18 @@ export const haMdListStyles = [
 @customElement("ha-md-list-item")
 export class HaMdListItem extends ListItemEl {
   static override styles = haMdListStyles;
+
+  protected renderRipple(): TemplateResult | typeof nothing {
+    if (this.type === "text") {
+      return nothing;
+    }
+
+    return html`<ha-ripple
+      part="ripple"
+      for="item"
+      ?disabled=${this.disabled && this.type !== "link"}
+    ></ha-ripple>`;
+  }
 }
 
 declare global {

src/components/ha-navigation-picker.ts

@@ -6,6 +6,7 @@ import { fireEvent } from "../common/dom/fire_event";
 import { titleCase } from "../common/string/title-case";
 import { fetchConfig } from "../data/lovelace/config/types";
 import type { LovelaceViewRawConfig } from "../data/lovelace/config/view";
+import { getDefaultPanelUrlPath } from "../data/panel";
 import type { HomeAssistant, PanelInfo, ValueChangedEvent } from "../types";
 import "./ha-combo-box";
 import type { HaComboBox } from "./ha-combo-box";
@@ -44,7 +45,7 @@ const createPanelNavigationItem = (hass: HomeAssistant, panel: PanelInfo) => ({
   path: `/${panel.url_path}`,
   icon: panel.icon ?? "mdi:view-dashboard",
   title:
-    panel.url_path === hass.defaultPanel
+    panel.url_path === getDefaultPanelUrlPath(hass)
       ? hass.localize("panel.states")
       : hass.localize(`panel.${panel.title}`) ||
         panel.title ||

src/components/ha-picker-combo-box.ts

@@ -1,6 +1,6 @@
 import type { LitVirtualizer } from "@lit-labs/virtualizer";
 import type { RenderItemFunction } from "@lit-labs/virtualizer/virtualize";
-import { mdiMagnify } from "@mdi/js";
+import { mdiMagnify, mdiMinusBoxOutline } from "@mdi/js";
 import Fuse from "fuse.js";
 import { css, html, LitElement, nothing } from "lit";
 import {
@@ -14,11 +14,12 @@ import memoizeOne from "memoize-one";
 import { tinykeys } from "tinykeys";
 import { fireEvent } from "../common/dom/fire_event";
 import { caseInsensitiveStringCompare } from "../common/string/compare";
-import type { LocalizeFunc } from "../common/translations/localize";
 import { HaFuse } from "../resources/fuse";
 import { haStyleScrollbar } from "../resources/styles";
 import { loadVirtualizer } from "../resources/virtualizer";
 import type { HomeAssistant } from "../types";
+import "./chips/ha-chip-set";
+import "./chips/ha-filter-chip";
 import "./ha-combo-box-item";
 import "./ha-icon";
 import "./ha-textfield";
@@ -27,28 +28,18 @@ import type { HaTextField } from "./ha-textfield";
 export interface PickerComboBoxItem {
   id: string;
   primary: string;
-  a11y_label?: string;
   secondary?: string;
   search_labels?: string[];
   sorting_label?: string;
   icon_path?: string;
   icon?: string;
 }
-
-// Hack to force empty label to always display empty value by default in the search field
-export interface PickerComboBoxItemWithLabel extends PickerComboBoxItem {
-  a11y_label: string;
-}
-
-const NO_MATCHING_ITEMS_FOUND_ID = "___no_matching_items_found___";
+const NO_ITEMS_AVAILABLE_ID = "___no_items_available___";
 
 const DEFAULT_ROW_RENDERER: RenderItemFunction<PickerComboBoxItem> = (
   item
 ) => html`
-  <ha-combo-box-item
-    .type=${item.id === NO_MATCHING_ITEMS_FOUND_ID ? "text" : "button"}
-    compact
-  >
+  <ha-combo-box-item type="button" compact>
     ${item.icon
       ? html`<ha-icon slot="start" .icon=${item.icon}></ha-icon>`
       : item.icon_path
@@ -87,8 +78,11 @@ export class HaPickerComboBox extends LitElement {
 
   @state() private _listScrolled = false;
 
-  @property({ attribute: false, type: Array })
-  public getItems?: () => PickerComboBoxItem[];
+  @property({ attribute: false })
+  public getItems?: (
+    searchString?: string,
+    section?: string
+  ) => (PickerComboBoxItem | string)[];
 
   @property({ attribute: false, type: Array })
   public getAdditionalItems?: (searchString?: string) => PickerComboBoxItem[];
@@ -96,21 +90,45 @@ export class HaPickerComboBox extends LitElement {
   @property({ attribute: false })
   public rowRenderer?: RenderItemFunction<PickerComboBoxItem>;
 
-  @property({ attribute: "not-found-label", type: String })
-  public notFoundLabel?: string;
+  @property({ attribute: false })
+  public notFoundLabel?: string | ((search: string) => string);
+
+  @property({ attribute: "empty-label" })
+  public emptyLabel?: string;
 
   @property({ attribute: false })
   public searchFn?: PickerComboBoxSearchFn<PickerComboBoxItem>;
 
   @property({ reflect: true }) public mode: "popover" | "dialog" = "popover";
 
+  /** Section filter buttons for the list, section headers needs to be defined in getItems as strings */
+  @property({ attribute: false }) public sections?: (
+    | {
+        id: string;
+        label: string;
+      }
+    | "separator"
+  )[];
+
+  @property({ attribute: false }) public sectionTitleFunction?: (listInfo: {
+    firstIndex: number;
+    lastIndex: number;
+    firstItem: PickerComboBoxItem | string;
+    secondItem: PickerComboBoxItem | string;
+    itemsCount: number;
+  }) => string | undefined;
+
+  @property({ attribute: "selected-section" }) public selectedSection?: string;
+
   @query("lit-virtualizer") private _virtualizerElement?: LitVirtualizer;
 
   @query("ha-textfield") private _searchFieldElement?: HaTextField;
 
-  @state() private _items: PickerComboBoxItemWithLabel[] = [];
+  @state() private _items: (PickerComboBoxItem | string)[] = [];
 
-  private _allItems: PickerComboBoxItemWithLabel[] = [];
+  @state() private _sectionTitle?: string;
+
+  private _allItems: (PickerComboBoxItem | string)[] = [];
 
   private _selectedItemIndex = -1;
 
@@ -121,6 +139,8 @@ export class HaPickerComboBox extends LitElement {
 
   private _removeKeyboardShortcuts?: () => void;
 
+  private _search = "";
+
   protected firstUpdated() {
     this._registerKeyboardShortcuts();
   }
@@ -145,74 +165,142 @@ export class HaPickerComboBox extends LitElement {
         "Search"}
         @input=${this._filterChanged}
       ></ha-textfield>
+      ${this._renderSectionButtons()}
+      ${this.sections?.length
+        ? html`
+            <div class="section-title-wrapper">
+              <div
+                class="section-title ${!this.selectedSection &&
+                this._sectionTitle
+                  ? "show"
+                  : ""}"
+              >
+                ${this._sectionTitle}
+              </div>
+            </div>
+          `
+        : nothing}
       <lit-virtualizer
-        @scroll=${this._onScrollList}
+        .keyFunction=${this._keyFunction}
         tabindex="0"
         scroller
         .items=${this._items}
         .renderItem=${this._renderItem}
         style="min-height: 36px;"
         class=${this._listScrolled ? "scrolled" : ""}
+        @scroll=${this._onScrollList}
         @focus=${this._focusList}
+        @visibilityChanged=${this._visibilityChanged}
       >
       </lit-virtualizer> `;
   }
 
-  private _defaultNotFoundItem = memoizeOne(
-    (
-      label: this["notFoundLabel"],
-      localize?: LocalizeFunc
-    ): PickerComboBoxItemWithLabel => ({
-      id: NO_MATCHING_ITEMS_FOUND_ID,
-      primary:
-        label ||
-        (localize && localize("ui.components.combo-box.no_match")) ||
-        "No matching items found",
-      icon_path: mdiMagnify,
-      a11y_label:
-        label ||
-        (localize && localize("ui.components.combo-box.no_match")) ||
-        "No matching items found",
-    })
-  );
+  private _renderSectionButtons() {
+    if (!this.sections || this.sections.length === 0) {
+      return nothing;
+    }
 
-  private _getAdditionalItems = (searchString?: string) => {
-    const items = this.getAdditionalItems?.(searchString) || [];
+    return html`
+      <ha-chip-set class="sections">
+        ${this.sections.map((section) =>
+          section === "separator"
+            ? html`<div class="separator"></div>`
+            : html`<ha-filter-chip
+                @click=${this._toggleSection}
+                .section-id=${section.id}
+                .selected=${this.selectedSection === section.id}
+                .label=${section.label}
+              >
+              </ha-filter-chip>`
+        )}
+      </ha-chip-set>
+    `;
+  }
 
-    return items.map<PickerComboBoxItemWithLabel>((item) => ({
-      ...item,
-      a11y_label: item.a11y_label || item.primary,
-    }));
-  };
+  @eventOptions({ passive: true })
+  private _visibilityChanged(ev) {
+    if (
+      this._virtualizerElement &&
+      this.sectionTitleFunction &&
+      this.sections?.length
+    ) {
+      const firstItem = this._virtualizerElement.items[ev.first];
+      const secondItem = this._virtualizerElement.items[ev.first + 1];
+      this._sectionTitle = this.sectionTitleFunction({
+        firstIndex: ev.first,
+        lastIndex: ev.last,
+        firstItem: firstItem as PickerComboBoxItem | string,
+        secondItem: secondItem as PickerComboBoxItem | string,
+        itemsCount: this._virtualizerElement.items.length,
+      });
+    }
+  }
 
-  private _getItems = (): PickerComboBoxItemWithLabel[] => {
-    const items = this.getItems ? this.getItems() : [];
+  private _getAdditionalItems = (searchString?: string) =>
+    this.getAdditionalItems?.(searchString) || [];
 
-    const sortedItems = items
-      .map<PickerComboBoxItemWithLabel>((item) => ({
-        ...item,
-        a11y_label: item.a11y_label || item.primary,
-      }))
-      .sort((entityA, entityB) =>
+  private _getItems = () => {
+    let items = [
+      ...(this.getItems
+        ? this.getItems(this._search, this.selectedSection)
+        : []),
+    ];
+
+    if (!this.sections?.length) {
+      items = items.sort((entityA, entityB) =>
         caseInsensitiveStringCompare(
-          entityA.sorting_label!,
-          entityB.sorting_label!,
+          (entityA as PickerComboBoxItem).sorting_label!,
+          (entityB as PickerComboBoxItem).sorting_label!,
           this.hass?.locale.language ?? navigator.language
         )
       );
+    }
 
-    if (!sortedItems.length) {
-      sortedItems.push(
-        this._defaultNotFoundItem(this.notFoundLabel, this.hass?.localize)
-      );
+    if (!items.length) {
+      items.push(NO_ITEMS_AVAILABLE_ID);
     }
 
     const additionalItems = this._getAdditionalItems();
-    sortedItems.push(...additionalItems);
-    return sortedItems;
+    items.push(...additionalItems);
+
+    if (this.mode === "dialog") {
+      items.push("padding"); // padding for safe area inset
+    }
+
+    return items;
   };
 
-  private _renderItem = (item: PickerComboBoxItem, index: number) => {
+  private _renderItem = (item: PickerComboBoxItem | string, index: number) => {
+    if (item === "padding") {
+      return html`<div class="bottom-padding"></div>`;
+    }
+    if (item === NO_ITEMS_AVAILABLE_ID) {
+      return html`
+        <div class="combo-box-row">
+          <ha-combo-box-item type="text" compact>
+            <ha-svg-icon
+              slot="start"
+              .path=${this._search ? mdiMagnify : mdiMinusBoxOutline}
+            ></ha-svg-icon>
+            <span slot="headline"
+              >${this._search
+                ? typeof this.notFoundLabel === "function"
+                  ? this.notFoundLabel(this._search)
+                  : this.notFoundLabel ||
+                    this.hass?.localize("ui.components.combo-box.no_match") ||
+                    "No matching items found"
+                : this.emptyLabel ||
+                  this.hass?.localize("ui.components.combo-box.no_items") ||
+                  "No items available"}</span
+            >
+          </ha-combo-box-item>
+        </div>
+      `;
+    }
+    if (typeof item === "string") {
+      return html`<div class="title">${item}</div>`;
+    }
+
     const renderer = this.rowRenderer || DEFAULT_ROW_RENDERER;
     return html`<div
       id=${`list-item-${index}`}
@@ -221,9 +309,7 @@ export class HaPickerComboBox extends LitElement {
       .index=${index}
       @click=${this._valueSelected}
     >
-      ${item.id === NO_MATCHING_ITEMS_FOUND_ID
-        ? DEFAULT_ROW_RENDERER(item, index)
-        : renderer(item, index)}
+      ${renderer(item, index)}
     </div>`;
   };
 
@@ -242,10 +328,6 @@ export class HaPickerComboBox extends LitElement {
     const value = (ev.currentTarget as any).value as string;
     const newValue = value?.trim();
 
-    if (newValue === NO_MATCHING_ITEMS_FOUND_ID) {
-      return;
-    }
-
     fireEvent(this, "value-changed", { value: newValue });
   };
 
@@ -256,51 +338,83 @@ export class HaPickerComboBox extends LitElement {
   private _filterChanged = (ev: Event) => {
     const textfield = ev.target as HaTextField;
     const searchString = textfield.value.trim();
+    this._search = searchString;
 
-    if (!searchString) {
-      this._items = this._allItems;
-      return;
-    }
+    if (this.sections?.length) {
+      this._items = this._getItems();
+    } else {
+      if (!searchString) {
+        this._items = this._allItems;
+        return;
+      }
 
-    const index = this._fuseIndex(this._allItems);
-    const fuse = new HaFuse(
-      this._allItems,
-      {
-        shouldSort: false,
-        minMatchCharLength: Math.min(searchString.length, 2),
-      },
-      index
-    );
+      const index = this._fuseIndex(this._allItems as PickerComboBoxItem[]);
+      const fuse = new HaFuse(
+        this._allItems as PickerComboBoxItem[],
+        {
+          shouldSort: false,
+          minMatchCharLength: Math.min(searchString.length, 2),
+        },
+        index
+      );
 
-    const results = fuse.multiTermsSearch(searchString);
-    let filteredItems = this._allItems as PickerComboBoxItem[];
-    if (results) {
-      const items = results.map((result) => result.item);
-      if (items.length === 0) {
-        items.push(
-          this._defaultNotFoundItem(this.notFoundLabel, this.hass?.localize)
+      const results = fuse.multiTermsSearch(searchString);
+      let filteredItems = [...this._allItems];
+
+      if (results) {
+        const items: (PickerComboBoxItem | string)[] = results.map(
+          (result) => result.item
+        );
+
+        if (!items.length) {
+          filteredItems.push(NO_ITEMS_AVAILABLE_ID);
+        }
+
+        const additionalItems = this._getAdditionalItems();
+        items.push(...additionalItems);
+
+        filteredItems = items;
+      }
+
+      if (this.searchFn) {
+        filteredItems = this.searchFn(
+          searchString,
+          filteredItems as PickerComboBoxItem[],
+          this._allItems as PickerComboBoxItem[]
         );
       }
-      const additionalItems = this._getAdditionalItems(searchString);
-      items.push(...additionalItems);
-      filteredItems = items;
+
+      this._items = filteredItems as PickerComboBoxItem[];
     }
 
-    if (this.searchFn) {
-      filteredItems = this.searchFn(
-        searchString,
-        filteredItems,
-        this._allItems
-      );
-    }
-
-    this._items = filteredItems as PickerComboBoxItemWithLabel[];
     this._selectedItemIndex = -1;
     if (this._virtualizerElement) {
       this._virtualizerElement.scrollTo(0, 0);
     }
   };
 
+  private _toggleSection(ev: Event) {
+    ev.stopPropagation();
+    this._resetSelectedItem();
+    this._sectionTitle = undefined;
+    const section = (ev.target as HTMLElement)["section-id"] as string;
+    if (!section) {
+      return;
+    }
+    if (this.selectedSection === section) {
+      this.selectedSection = undefined;
+    } else {
+      this.selectedSection = section;
+    }
+
+    this._items = this._getItems();
+
+    // Reset scroll position when filter changes
+    if (this._virtualizerElement) {
+      this._virtualizerElement.scrollToIndex(0);
+    }
+  }
+
   private _registerKeyboardShortcuts() {
     this._removeKeyboardShortcuts = tinykeys(this, {
       ArrowUp: this._selectPreviousItem,
@@ -344,7 +458,7 @@ export class HaPickerComboBox extends LitElement {
       return;
     }
 
-    if (items[nextIndex].id === NO_MATCHING_ITEMS_FOUND_ID) {
+    if (typeof items[nextIndex] === "string") {
       // Skip titles, padding and empty search
       if (nextIndex === maxItems) {
         return;
@@ -373,7 +487,7 @@ export class HaPickerComboBox extends LitElement {
         return;
       }
 
-      if (items[nextIndex]?.id === NO_MATCHING_ITEMS_FOUND_ID) {
+      if (typeof items[nextIndex] === "string") {
         // Skip titles, padding and empty search
         if (nextIndex === 0) {
           return;
@@ -395,13 +509,6 @@ export class HaPickerComboBox extends LitElement {
 
     const nextIndex = 0;
 
-    if (
-      (this._virtualizerElement.items[nextIndex] as PickerComboBoxItem)?.id ===
-      NO_MATCHING_ITEMS_FOUND_ID
-    ) {
-      return;
-    }
-
     if (typeof this._virtualizerElement.items[nextIndex] === "string") {
       this._selectedItemIndex = nextIndex + 1;
     } else {
@@ -419,13 +526,6 @@ export class HaPickerComboBox extends LitElement {
 
     const nextIndex = this._virtualizerElement.items.length - 1;
 
-    if (
-      (this._virtualizerElement.items[nextIndex] as PickerComboBoxItem)?.id ===
-      NO_MATCHING_ITEMS_FOUND_ID
-    ) {
-      return;
-    }
-
     if (typeof this._virtualizerElement.items[nextIndex] === "string") {
       this._selectedItemIndex = nextIndex - 1;
     } else {
@@ -453,10 +553,7 @@ export class HaPickerComboBox extends LitElement {
     ev.stopPropagation();
     const firstItem = this._virtualizerElement?.items[0] as PickerComboBoxItem;
 
-    if (
-      this._virtualizerElement?.items.length === 1 &&
-      firstItem.id !== NO_MATCHING_ITEMS_FOUND_ID
-    ) {
+    if (this._virtualizerElement?.items.length === 1) {
       fireEvent(this, "value-changed", {
         value: firstItem.id,
       });
@@ -472,7 +569,7 @@ export class HaPickerComboBox extends LitElement {
     const item = this._virtualizerElement?.items[
       this._selectedItemIndex
     ] as PickerComboBoxItem;
-    if (item && item.id !== NO_MATCHING_ITEMS_FOUND_ID) {
+    if (item) {
       fireEvent(this, "value-changed", { value: item.id });
     }
   };
@@ -484,6 +581,9 @@ export class HaPickerComboBox extends LitElement {
     this._selectedItemIndex = -1;
   }
 
+  private _keyFunction = (item: PickerComboBoxItem | string) =>
+    typeof item === "string" ? item : item.id;
+
   static styles = [
     haStyleScrollbar,
     css`
@@ -558,6 +658,80 @@ export class HaPickerComboBox extends LitElement {
           background-color: var(--ha-color-fill-neutral-normal-hover);
         }
       }
+
+      .sections {
+        display: flex;
+        flex-wrap: nowrap;
+        gap: var(--ha-space-2);
+        padding: var(--ha-space-3) var(--ha-space-3);
+        overflow: auto;
+      }
+
+      :host([mode="dialog"]) .sections {
+        padding: var(--ha-space-3) var(--ha-space-4);
+      }
+
+      .sections ha-filter-chip {
+        flex-shrink: 0;
+        --md-filter-chip-selected-container-color: var(
+          --ha-color-fill-primary-normal-hover
+        );
+        color: var(--primary-color);
+      }
+
+      .sections .separator {
+        height: var(--ha-space-8);
+        width: 0;
+        border: 1px solid var(--ha-color-border-neutral-quiet);
+      }
+
+      .section-title,
+      .title {
+        background-color: var(--ha-color-fill-neutral-quiet-resting);
+        padding: var(--ha-space-1) var(--ha-space-2);
+        font-weight: var(--ha-font-weight-bold);
+        color: var(--secondary-text-color);
+        min-height: var(--ha-space-6);
+        display: flex;
+        align-items: center;
+      }
+
+      .title {
+        width: 100%;
+      }
+
+      :host([mode="dialog"]) .title {
+        padding: var(--ha-space-1) var(--ha-space-4);
+      }
+
+      :host([mode="dialog"]) ha-textfield {
+        padding: 0 var(--ha-space-4);
+      }
+
+      .section-title-wrapper {
+        height: 0;
+        position: relative;
+      }
+
+      .section-title {
+        opacity: 0;
+        position: absolute;
+        top: 1px;
+        width: calc(100% - var(--ha-space-8));
+      }
+
+      .section-title.show {
+        opacity: 1;
+        z-index: 1;
+      }
+
+      .empty-search {
+        display: flex;
+        width: 100%;
+        flex-direction: column;
+        align-items: center;
+        padding: var(--ha-space-3);
+      }
     `,
   ];
 }

src/components/ha-selector/ha-selector-state.ts

@@ -1,6 +1,8 @@
+import type { HassServiceTarget } from "home-assistant-js-websocket";
 import { html, LitElement } from "lit";
-import { customElement, property } from "lit/decorators";
+import { customElement, property, state } from "lit/decorators";
 import type { StateSelector } from "../../data/selector";
+import { extractFromTarget } from "../../data/target";
 import { SubscribeMixin } from "../../mixins/subscribe-mixin";
 import type { HomeAssistant } from "../../types";
 import "../entity/ha-entity-state-picker";
@@ -25,15 +27,29 @@ export class HaSelectorState extends SubscribeMixin(LitElement) {
   @property({ attribute: false }) public context?: {
     filter_attribute?: string;
     filter_entity?: string | string[];
+    filter_target?: HassServiceTarget;
   };
 
+  @state() private _entityIds?: string | string[];
+
+  willUpdate(changedProps) {
+    if (changedProps.has("selector") || changedProps.has("context")) {
+      this._resolveEntityIds(
+        this.selector.state?.entity_id,
+        this.context?.filter_entity,
+        this.context?.filter_target
+      ).then((entityIds) => {
+        this._entityIds = entityIds;
+      });
+    }
+  }
+
   protected render() {
     if (this.selector.state?.multiple) {
       return html`
         <ha-entity-states-picker
           .hass=${this.hass}
-          .entityId=${this.selector.state?.entity_id ||
-          this.context?.filter_entity}
+          .entityId=${this._entityIds}
           .attribute=${this.selector.state?.attribute ||
           this.context?.filter_attribute}
           .extraOptions=${this.selector.state?.extra_options}
@@ -50,8 +66,7 @@ export class HaSelectorState extends SubscribeMixin(LitElement) {
     return html`
       <ha-entity-state-picker
         .hass=${this.hass}
-        .entityId=${this.selector.state?.entity_id ||
-        this.context?.filter_entity}
+        .entityId=${this._entityIds}
         .attribute=${this.selector.state?.attribute ||
         this.context?.filter_attribute}
         .extraOptions=${this.selector.state?.extra_options}
@@ -65,6 +80,24 @@ export class HaSelectorState extends SubscribeMixin(LitElement) {
       ></ha-entity-state-picker>
     `;
   }
+
+  private async _resolveEntityIds(
+    selectorEntityId: string | string[] | undefined,
+    contextFilterEntity: string | string[] | undefined,
+    contextFilterTarget: HassServiceTarget | undefined
+  ): Promise<string | string[] | undefined> {
+    if (selectorEntityId !== undefined) {
+      return selectorEntityId;
+    }
+    if (contextFilterEntity !== undefined) {
+      return contextFilterEntity;
+    }
+    if (contextFilterTarget !== undefined) {
+      const result = await extractFromTarget(this.hass, contextFilterTarget);
+      return result.referenced_entities;
+    }
+    return undefined;
+  }
 }
 
 declare global {

src/components/ha-service-control.ts

@@ -33,6 +33,7 @@ import type { HomeAssistant, ValueChangedEvent } from "../types";
 import { documentationUrl } from "../util/documentation-url";
 import "./ha-checkbox";
 import "./ha-icon-button";
+import "./ha-markdown";
 import "./ha-selector/ha-selector";
 import "./ha-service-picker";
 import "./ha-service-section-icon";
@@ -684,10 +685,14 @@ export class HaServiceControl extends LitElement {
             dataField.key}</span
           >
           <span slot="description"
-            >${this.hass.localize(
-              `component.${domain}.services.${serviceName}.fields.${dataField.key}.description`
-            ) || dataField?.description}</span
-          >
+            ><ha-markdown
+              breaks
+              allow-svg
+              .content=${this.hass.localize(
+                `component.${domain}.services.${serviceName}.fields.${dataField.key}.description`
+              ) || dataField?.description}
+            ></ha-markdown>
+          </span>
           <ha-selector
             .context=${this._selectorContext(targetEntities)}
             .disabled=${this.disabled ||

src/components/ha-sidebar.ts

@@ -33,6 +33,7 @@ import { computeRTL } from "../common/util/compute_rtl";
 import { throttle } from "../common/util/throttle";
 import { subscribeFrontendUserData } from "../data/frontend";
 import type { ActionHandlerDetail } from "../data/lovelace/action_handler";
+import { getDefaultPanelUrlPath } from "../data/panel";
 import type { PersistentNotification } from "../data/persistent_notification";
 import { subscribeNotifications } from "../data/persistent_notification";
 import { subscribeRepairsIssueRegistry } from "../data/repairs";
@@ -142,7 +143,7 @@ const defaultPanelSorter = (
 export const computePanels = memoizeOne(
   (
     panels: HomeAssistant["panels"],
-    defaultPanel: HomeAssistant["defaultPanel"],
+    defaultPanel: string,
     panelsOrder: string[],
     hiddenPanels: string[],
     locale: HomeAssistant["locale"]
@@ -158,7 +159,8 @@ export const computePanels = memoizeOne(
       if (
         hiddenPanels.includes(panel.url_path) ||
         (!panel.title && panel.url_path !== defaultPanel) ||
-        (!panel.default_visible && !panelsOrder.includes(panel.url_path))
+        (panel.default_visible === false &&
+          !panelsOrder.includes(panel.url_path))
       ) {
         return;
       }
@@ -297,7 +299,8 @@ class HaSidebar extends SubscribeMixin(LitElement) {
       hass.localize !== oldHass.localize ||
       hass.locale !== oldHass.locale ||
       hass.states !== oldHass.states ||
-      hass.defaultPanel !== oldHass.defaultPanel ||
+      hass.userData !== oldHass.userData ||
+      hass.systemData !== oldHass.systemData ||
       hass.connected !== oldHass.connected
     );
   }
@@ -400,9 +403,11 @@ class HaSidebar extends SubscribeMixin(LitElement) {
       `;
     }
 
+    const defaultPanel = getDefaultPanelUrlPath(this.hass);
+
     const [beforeSpacer, afterSpacer] = computePanels(
       this.hass.panels,
-      this.hass.defaultPanel,
+      defaultPanel,
       this._panelOrder,
       this._hiddenPanels,
       this.hass.locale
@@ -417,23 +422,27 @@ class HaSidebar extends SubscribeMixin(LitElement) {
         @scroll=${this._listboxScroll}
         @keydown=${this._listboxKeydown}
       >
-        ${this._renderPanels(beforeSpacer, selectedPanel)}
+        ${this._renderPanels(beforeSpacer, selectedPanel, defaultPanel)}
         ${this._renderSpacer()}
-        ${this._renderPanels(afterSpacer, selectedPanel)}
+        ${this._renderPanels(afterSpacer, selectedPanel, defaultPanel)}
         ${this._renderExternalConfiguration()}
       </ha-md-list>
     `;
   }
 
-  private _renderPanels(panels: PanelInfo[], selectedPanel: string) {
+  private _renderPanels(
+    panels: PanelInfo[],
+    selectedPanel: string,
+    defaultPanel: string
+  ) {
     return panels.map((panel) =>
       this._renderPanel(
         panel.url_path,
-        panel.url_path === this.hass.defaultPanel
+        panel.url_path === defaultPanel
           ? panel.title || this.hass.localize("panel.states")
           : this.hass.localize(`panel.${panel.title}`) || panel.title,
         panel.icon,
-        panel.url_path === this.hass.defaultPanel && !panel.icon
+        panel.url_path === defaultPanel && !panel.icon
           ? PANEL_ICONS.lovelace
           : panel.url_path in PANEL_ICONS
             ? PANEL_ICONS[panel.url_path]

src/components/ha-target-picker.ts

@@ -1,15 +1,31 @@
 import "@home-assistant/webawesome/dist/components/popover/popover";
+import { consume } from "@lit/context";
 // @ts-ignore
 import chipStyles from "@material/chips/dist/mdc.chips.min.css";
-import { mdiPlaylistPlus } from "@mdi/js";
+import { mdiPlus, mdiTextureBox } from "@mdi/js";
+import Fuse from "fuse.js";
 import type { HassServiceTarget } from "home-assistant-js-websocket";
-import type { CSSResultGroup } from "lit";
+import type { CSSResultGroup, PropertyValues } from "lit";
 import { LitElement, css, html, nothing, unsafeCSS } from "lit";
-import { customElement, property, query, state } from "lit/decorators";
+import { customElement, property, state } from "lit/decorators";
+import { styleMap } from "lit/directives/style-map";
+import memoizeOne from "memoize-one";
 import { ensureArray } from "../common/array/ensure-array";
 import { fireEvent } from "../common/dom/fire_event";
 import { isValidEntityId } from "../common/entity/valid_entity_id";
+import { computeRTL } from "../common/util/compute_rtl";
+import {
+  getAreasAndFloors,
+  type AreaFloorValue,
+  type FloorComboBoxItem,
+} from "../data/area_floor";
+import { getConfigEntries, type ConfigEntry } from "../data/config_entries";
+import { labelsContext } from "../data/context";
+import { getDevices, type DevicePickerItem } from "../data/device_registry";
 import type { HaEntityPickerEntityFilterFunc } from "../data/entity";
+import { getEntities, type EntityComboBoxItem } from "../data/entity_registry";
+import { domainToName } from "../data/integration";
+import { getLabels, type LabelRegistryEntry } from "../data/label_registry";
 import {
   areaMeetsFilter,
   deviceMeetsFilter,
@@ -18,18 +34,23 @@ import {
   type TargetTypeFloorless,
 } from "../data/target";
 import { SubscribeMixin } from "../mixins/subscribe-mixin";
+import { isHelperDomain } from "../panels/config/helpers/const";
 import { showHelperDetailDialog } from "../panels/config/helpers/show-dialog-helper-detail";
+import { HaFuse } from "../resources/fuse";
 import type { HomeAssistant } from "../types";
+import { brandsUrl } from "../util/brands-url";
 import type { HaDevicePickerDeviceFilterFunc } from "./device/ha-device-picker";
-import "./ha-bottom-sheet";
-import "./ha-button";
-import "./ha-input-helper-text";
+import "./ha-generic-picker";
+import type { PickerComboBoxItem } from "./ha-picker-combo-box";
 import "./ha-svg-icon";
+import "./ha-tree-indicator";
 import "./target-picker/ha-target-picker-item-group";
-import "./target-picker/ha-target-picker-selector";
-import type { HaTargetPickerSelector } from "./target-picker/ha-target-picker-selector";
 import "./target-picker/ha-target-picker-value-chip";
 
+const EMPTY_SEARCH = "___EMPTY_SEARCH___";
+const SEPARATOR = "________";
+const CREATE_ID = "___create-new-entity___";
+
 @customElement("ha-target-picker")
 export class HaTargetPicker extends SubscribeMixin(LitElement) {
   @property({ attribute: false }) public hass!: HomeAssistant;
@@ -68,23 +89,54 @@ export class HaTargetPicker extends SubscribeMixin(LitElement) {
 
   @property({ attribute: "add-on-top", type: Boolean }) public addOnTop = false;
 
-  @state() private _open = false;
+  @state() private _selectedSection?: TargetTypeFloorless;
 
-  @state() private _addTargetWidth = 0;
+  @state() private _configEntryLookup: Record<string, ConfigEntry> = {};
 
-  @state() private _narrow = false;
-
-  @state() private _pickerFilter?: TargetTypeFloorless;
-
-  @state() private _pickerWrapperOpen = false;
-
-  @query(".add-target-wrapper") private _addTargetWrapper?: HTMLDivElement;
-
-  @query("ha-target-picker-selector")
-  private _targetPickerSelectorElement?: HaTargetPickerSelector;
+  @state()
+  @consume({ context: labelsContext, subscribe: true })
+  private _labelRegistry!: LabelRegistryEntry[];
 
   private _newTarget?: { type: TargetType; id: string };
 
+  private _getDevicesMemoized = memoizeOne(getDevices);
+
+  private _getLabelsMemoized = memoizeOne(getLabels);
+
+  private _getEntitiesMemoized = memoizeOne(getEntities);
+
+  private _getAreasAndFloorsMemoized = memoizeOne(getAreasAndFloors);
+
+  private get _showEntityId() {
+    return this.hass.userData?.showEntityIdPicker;
+  }
+
+  private _fuseIndexes = {
+    area: memoizeOne((states: FloorComboBoxItem[]) =>
+      this._createFuseIndex(states)
+    ),
+    entity: memoizeOne((states: EntityComboBoxItem[]) =>
+      this._createFuseIndex(states)
+    ),
+    device: memoizeOne((states: DevicePickerItem[]) =>
+      this._createFuseIndex(states)
+    ),
+    label: memoizeOne((states: PickerComboBoxItem[]) =>
+      this._createFuseIndex(states)
+    ),
+  };
+
+  public willUpdate(changedProps: PropertyValues) {
+    super.willUpdate(changedProps);
+
+    if (!this.hasUpdated) {
+      this._loadConfigEntries();
+    }
+  }
+
+  private _createFuseIndex = (states) =>
+    Fuse.createIndex(["search_labels"], states);
+
   protected render() {
     if (this.addOnTop) {
       return html` ${this._renderPicker()} ${this._renderItems()} `;
@@ -289,137 +341,63 @@ export class HaTargetPicker extends SubscribeMixin(LitElement) {
   }
 
   private _renderPicker() {
+    const sections = [
+      {
+        id: "entity",
+        label: this.hass.localize("ui.components.target-picker.type.entities"),
+      },
+      {
+        id: "device",
+        label: this.hass.localize("ui.components.target-picker.type.devices"),
+      },
+      {
+        id: "area",
+        label: this.hass.localize("ui.components.target-picker.type.areas"),
+      },
+      "separator" as const,
+      {
+        id: "label",
+        label: this.hass.localize("ui.components.target-picker.type.labels"),
+      },
+    ];
+
     return html`
       <div class="add-target-wrapper">
-        <ha-button
-          id="add-target-button"
-          size="small"
-          appearance="filled"
-          @click=${this._showPicker}
+        <ha-generic-picker
+          .hass=${this.hass}
+          .disabled=${this.disabled}
+          .autofocus=${this.autofocus}
+          .helper=${this.helper}
+          .sections=${sections}
+          .notFoundLabel=${this._noTargetFoundLabel}
+          .emptyLabel=${this.hass.localize(
+            "ui.components.target-picker.no_targets"
+          )}
+          .sectionTitleFunction=${this._sectionTitleFunction}
+          .selectedSection=${this._selectedSection}
+          .rowRenderer=${this._renderRow}
+          .getItems=${this._getItems}
+          @value-changed=${this._targetPicked}
+          .addButtonLabel=${this.hass.localize(
+            "ui.components.target-picker.add_target"
+          )}
+          .getAdditionalItems=${this._getAdditionalItems}
         >
-          <ha-svg-icon .path=${mdiPlaylistPlus} slot="start"></ha-svg-icon>
-          ${this.hass.localize("ui.components.target-picker.add_target")}
-        </ha-button>
-        ${!this._narrow && (this._pickerWrapperOpen || this._open)
-          ? html`
-              <wa-popover
-                .open=${this._pickerWrapperOpen}
-                style="--body-width: ${this._addTargetWidth}px;"
-                without-arrow
-                distance="-4"
-                placement="bottom-start"
-                for="add-target-button"
-                auto-size="vertical"
-                auto-size-padding="16"
-                @wa-after-show=${this._showSelector}
-                @wa-after-hide=${this._hidePicker}
-                trap-focus
-                role="dialog"
-                aria-modal="true"
-                aria-label=${this.hass.localize(
-                  "ui.components.target-picker.add_target"
-                )}
-              >
-                ${this._renderTargetSelector()}
-              </wa-popover>
-            `
-          : this._pickerWrapperOpen || this._open
-            ? html`<ha-bottom-sheet
-                flexcontent
-                .open=${this._pickerWrapperOpen}
-                @wa-after-show=${this._showSelector}
-                @closed=${this._hidePicker}
-                role="dialog"
-                aria-modal="true"
-                aria-label=${this.hass.localize(
-                  "ui.components.target-picker.add_target"
-                )}
-              >
-                ${this._renderTargetSelector(true)}
-              </ha-bottom-sheet>`
-            : nothing}
+        </ha-generic-picker>
       </div>
-      ${this.helper
-        ? html`<ha-input-helper-text .disabled=${this.disabled}
-            >${this.helper}</ha-input-helper-text
-          >`
-        : nothing}
     `;
   }
 
-  connectedCallback() {
-    super.connectedCallback();
-    this._handleResize();
-    window.addEventListener("resize", this._handleResize);
-  }
-
-  public disconnectedCallback() {
-    super.disconnectedCallback();
-    window.removeEventListener("resize", this._handleResize);
-  }
-
-  private _handleResize = () => {
-    this._narrow =
-      window.matchMedia("(max-width: 870px)").matches ||
-      window.matchMedia("(max-height: 500px)").matches;
-  };
-
-  private _showPicker() {
-    this._addTargetWidth = this._addTargetWrapper?.offsetWidth || 0;
-    this._pickerWrapperOpen = true;
-  }
-
-  // wait for drawer animation to finish
-  private _showSelector = () => {
-    this._open = true;
-    requestAnimationFrame(() => {
-      this._targetPickerSelectorElement?.focus();
-    });
-  };
-
-  private _handleUpdatePickerFilter(
-    ev: CustomEvent<TargetTypeFloorless | undefined>
-  ) {
-    this._updatePickerFilter(
-      typeof ev.detail === "string" ? ev.detail : undefined
-    );
-  }
-
-  private _updatePickerFilter = (filter?: TargetTypeFloorless) => {
-    this._pickerFilter = filter;
-  };
-
-  private _hidePicker(ev) {
+  private _targetPicked(ev: CustomEvent<{ value: string }>) {
     ev.stopPropagation();
-    this._open = false;
-    this._pickerWrapperOpen = false;
-
-    if (this._newTarget) {
-      this._addTarget(this._newTarget.id, this._newTarget.type);
-      this._newTarget = undefined;
+    const value = ev.detail.value;
+    if (value.startsWith(CREATE_ID)) {
+      this._createNewDomainElement(value.substring(CREATE_ID.length));
+      return;
     }
-  }
 
-  private _renderTargetSelector(dialogMode = false) {
-    if (!this._open) {
-      return nothing;
-    }
-    return html`
-      <ha-target-picker-selector
-        .hass=${this.hass}
-        @filter-type-changed=${this._handleUpdatePickerFilter}
-        .filterType=${this._pickerFilter}
-        @target-picked=${this._handleTargetPicked}
-        @create-domain-picked=${this._handleCreateDomain}
-        .targetValue=${this.value}
-        .deviceFilter=${this.deviceFilter}
-        .entityFilter=${this.entityFilter}
-        .includeDomains=${this.includeDomains}
-        .includeDeviceClasses=${this.includeDeviceClasses}
-        .createDomains=${this.createDomains}
-        .mode=${dialogMode ? "dialog" : "popover"}
-      ></ha-target-picker-selector>
-    `;
+    const [type, id] = ev.detail.value.split(SEPARATOR);
+    this._addTarget(id, type as TargetType);
   }
 
   private _addTarget(id: string, type: TargetType) {
@@ -454,26 +432,7 @@ export class HaTargetPicker extends SubscribeMixin(LitElement) {
       ?.removeAttribute("collapsed");
   }
 
-  private _handleTargetPicked = async (
-    ev: CustomEvent<{ type: TargetType; id: string }>
-  ) => {
-    ev.stopPropagation();
-
-    this._pickerWrapperOpen = false;
-
-    if (!ev.detail.type || !ev.detail.id) {
-      return;
-    }
-
-    // save new target temporarily to add it after dialog closes
-    this._newTarget = ev.detail;
-  };
-
-  private _handleCreateDomain = (ev: CustomEvent<string>) => {
-    this._pickerWrapperOpen = false;
-
-    const domain = ev.detail;
-
+  private _createNewDomainElement = (domain: string) => {
     showHelperDetailDialog(this, {
       domain,
       dialogClosedCallback: (item) => {
@@ -675,6 +634,459 @@ export class HaTargetPicker extends SubscribeMixin(LitElement) {
     return undefined;
   }
 
+  private _getRowType = (
+    item:
+      | PickerComboBoxItem
+      | (FloorComboBoxItem & { last?: boolean | undefined })
+      | EntityComboBoxItem
+      | DevicePickerItem
+  ) => {
+    if (
+      (item as FloorComboBoxItem).type === "area" ||
+      (item as FloorComboBoxItem).type === "floor"
+    ) {
+      return (item as FloorComboBoxItem).type;
+    }
+
+    if ("domain" in item) {
+      return "device";
+    }
+
+    if ("stateObj" in item) {
+      return "entity";
+    }
+
+    if (item.id === EMPTY_SEARCH) {
+      return "empty";
+    }
+
+    return "label";
+  };
+
+  private _sectionTitleFunction = ({
+    firstIndex,
+    lastIndex,
+    firstItem,
+    secondItem,
+    itemsCount,
+  }: {
+    firstIndex: number;
+    lastIndex: number;
+    firstItem: PickerComboBoxItem | string;
+    secondItem: PickerComboBoxItem | string;
+    itemsCount: number;
+  }) => {
+    if (
+      firstItem === undefined ||
+      secondItem === undefined ||
+      typeof firstItem === "string" ||
+      (typeof secondItem === "string" && secondItem !== "padding") ||
+      (firstIndex === 0 && lastIndex === itemsCount - 1)
+    ) {
+      return undefined;
+    }
+
+    const type = this._getRowType(firstItem as PickerComboBoxItem);
+    const translationType:
+      | "areas"
+      | "entities"
+      | "devices"
+      | "labels"
+      | undefined =
+      type === "area" || type === "floor"
+        ? "areas"
+        : type === "entity"
+          ? "entities"
+          : type && type !== "empty"
+            ? `${type}s`
+            : undefined;
+
+    return translationType
+      ? this.hass.localize(
+          `ui.components.target-picker.type.${translationType}`
+        )
+      : undefined;
+  };
+
+  private _getItems = (searchString: string, section: string) => {
+    this._selectedSection = section as TargetTypeFloorless | undefined;
+
+    return this._getItemsMemoized(
+      this.hass.localize,
+      this.entityFilter,
+      this.deviceFilter,
+      this.includeDomains,
+      this.includeDeviceClasses,
+      this.value,
+      searchString,
+      this._configEntryLookup,
+      this._selectedSection
+    );
+  };
+
+  private _getItemsMemoized = memoizeOne(
+    (
+      localize: HomeAssistant["localize"],
+      entityFilter: this["entityFilter"],
+      deviceFilter: this["deviceFilter"],
+      includeDomains: this["includeDomains"],
+      includeDeviceClasses: this["includeDeviceClasses"],
+      targetValue: this["value"],
+      searchTerm: string,
+      configEntryLookup: Record<string, ConfigEntry>,
+      filterType?: TargetTypeFloorless
+    ) => {
+      const items: (
+        | string
+        | FloorComboBoxItem
+        | EntityComboBoxItem
+        | PickerComboBoxItem
+      )[] = [];
+
+      if (!filterType || filterType === "entity") {
+        let entityItems = this._getEntitiesMemoized(
+          this.hass,
+          includeDomains,
+          undefined,
+          entityFilter,
+          includeDeviceClasses,
+          undefined,
+          undefined,
+          targetValue?.entity_id
+            ? ensureArray(targetValue.entity_id)
+            : undefined,
+          undefined,
+          `entity${SEPARATOR}`
+        );
+
+        if (searchTerm) {
+          entityItems = this._filterGroup(
+            "entity",
+            entityItems,
+            searchTerm,
+            (item: EntityComboBoxItem) =>
+              item.stateObj?.entity_id === searchTerm
+          ) as EntityComboBoxItem[];
+        }
+
+        if (!filterType && entityItems.length) {
+          // show group title
+          items.push(localize("ui.components.target-picker.type.entities"));
+        }
+
+        items.push(...entityItems);
+      }
+
+      if (!filterType || filterType === "device") {
+        let deviceItems = this._getDevicesMemoized(
+          this.hass,
+          configEntryLookup,
+          includeDomains,
+          undefined,
+          includeDeviceClasses,
+          deviceFilter,
+          entityFilter,
+          targetValue?.device_id
+            ? ensureArray(targetValue.device_id)
+            : undefined,
+          undefined,
+          `device${SEPARATOR}`
+        );
+
+        if (searchTerm) {
+          deviceItems = this._filterGroup("device", deviceItems, searchTerm);
+        }
+
+        if (!filterType && deviceItems.length) {
+          // show group title
+          items.push(localize("ui.components.target-picker.type.devices"));
+        }
+
+        items.push(...deviceItems);
+      }
+
+      if (!filterType || filterType === "area") {
+        let areasAndFloors = this._getAreasAndFloorsMemoized(
+          this.hass.states,
+          this.hass.floors,
+          this.hass.areas,
+          this.hass.devices,
+          this.hass.entities,
+          memoizeOne((value: AreaFloorValue): string =>
+            [value.type, value.id].join(SEPARATOR)
+          ),
+          includeDomains,
+          undefined,
+          includeDeviceClasses,
+          deviceFilter,
+          entityFilter,
+          targetValue?.area_id ? ensureArray(targetValue.area_id) : undefined,
+          targetValue?.floor_id ? ensureArray(targetValue.floor_id) : undefined
+        );
+
+        if (searchTerm) {
+          areasAndFloors = this._filterGroup(
+            "area",
+            areasAndFloors,
+            searchTerm
+          ) as FloorComboBoxItem[];
+        }
+
+        if (!filterType && areasAndFloors.length) {
+          // show group title
+          items.push(localize("ui.components.target-picker.type.areas"));
+        }
+
+        items.push(
+          ...areasAndFloors.map((item, index) => {
+            const nextItem = areasAndFloors[index + 1];
+
+            if (
+              !nextItem ||
+              (item.type === "area" && nextItem.type === "floor")
+            ) {
+              return {
+                ...item,
+                last: true,
+              };
+            }
+
+            return item;
+          })
+        );
+      }
+
+      if (!filterType || filterType === "label") {
+        let labels = this._getLabelsMemoized(
+          this.hass,
+          this._labelRegistry,
+          includeDomains,
+          undefined,
+          includeDeviceClasses,
+          deviceFilter,
+          entityFilter,
+          targetValue?.label_id ? ensureArray(targetValue.label_id) : undefined,
+          `label${SEPARATOR}`
+        );
+
+        if (searchTerm) {
+          labels = this._filterGroup("label", labels, searchTerm);
+        }
+
+        if (!filterType && labels.length) {
+          // show group title
+          items.push(localize("ui.components.target-picker.type.labels"));
+        }
+
+        items.push(...labels);
+      }
+
+      return items;
+    }
+  );
+
+  private _filterGroup(
+    type: TargetType,
+    items: (FloorComboBoxItem | PickerComboBoxItem | EntityComboBoxItem)[],
+    searchTerm: string,
+    checkExact?: (
+      item: FloorComboBoxItem | PickerComboBoxItem | EntityComboBoxItem
+    ) => boolean
+  ) {
+    const fuseIndex = this._fuseIndexes[type](items);
+    const fuse = new HaFuse(
+      items,
+      {
+        shouldSort: false,
+        minMatchCharLength: Math.min(searchTerm.length, 2),
+      },
+      fuseIndex
+    );
+
+    const results = fuse.multiTermsSearch(searchTerm);
+    let filteredItems = items;
+    if (results) {
+      filteredItems = results.map((result) => result.item);
+    }
+
+    if (!checkExact) {
+      return filteredItems;
+    }
+
+    // If there is exact match for entity id, put it first
+    const index = filteredItems.findIndex((item) => checkExact(item));
+    if (index === -1) {
+      return filteredItems;
+    }
+
+    const [exactMatch] = filteredItems.splice(index, 1);
+    filteredItems.unshift(exactMatch);
+
+    return filteredItems;
+  }
+
+  private _getAdditionalItems = () => this._getCreateItems(this.createDomains);
+
+  private _getCreateItems = memoizeOne(
+    (createDomains: this["createDomains"]) => {
+      if (!createDomains?.length) {
+        return [];
+      }
+
+      return createDomains.map((domain) => {
+        const primary = this.hass.localize(
+          "ui.components.entity.entity-picker.create_helper",
+          {
+            domain: isHelperDomain(domain)
+              ? this.hass.localize(`ui.panel.config.helpers.types.${domain}`)
+              : domainToName(this.hass.localize, domain),
+          }
+        );
+
+        return {
+          id: CREATE_ID + domain,
+          primary: primary,
+          secondary: this.hass.localize(
+            "ui.components.entity.entity-picker.new_entity"
+          ),
+          icon_path: mdiPlus,
+        } satisfies EntityComboBoxItem;
+      });
+    }
+  );
+
+  private async _loadConfigEntries() {
+    const configEntries = await getConfigEntries(this.hass);
+    this._configEntryLookup = Object.fromEntries(
+      configEntries.map((entry) => [entry.entry_id, entry])
+    );
+  }
+
+  private _renderRow = (
+    item:
+      | PickerComboBoxItem
+      | (FloorComboBoxItem & { last?: boolean | undefined })
+      | EntityComboBoxItem
+      | DevicePickerItem,
+    index: number
+  ) => {
+    if (!item) {
+      return nothing;
+    }
+
+    const type = this._getRowType(item);
+    let hasFloor = false;
+    let rtl = false;
+    let showEntityId = false;
+
+    if (type === "area" || type === "floor") {
+      item.id = item[type]?.[`${type}_id`];
+
+      rtl = computeRTL(this.hass);
+      hasFloor =
+        type === "area" && !!(item as FloorComboBoxItem).area?.floor_id;
+    }
+
+    if (type === "entity") {
+      showEntityId = !!this._showEntityId;
+    }
+
+    return html`
+      <ha-combo-box-item
+        id=${`list-item-${index}`}
+        tabindex="-1"
+        .type=${type === "empty" ? "text" : "button"}
+        class=${type === "empty" ? "empty" : ""}
+        style=${(item as FloorComboBoxItem).type === "area" && hasFloor
+          ? "--md-list-item-leading-space: var(--ha-space-12);"
+          : ""}
+      >
+        ${(item as FloorComboBoxItem).type === "area" && hasFloor
+          ? html`
+              <ha-tree-indicator
+                style=${styleMap({
+                  width: "var(--ha-space-12)",
+                  position: "absolute",
+                  top: "var(--ha-space-0)",
+                  left: rtl ? undefined : "var(--ha-space-1)",
+                  right: rtl ? "var(--ha-space-1)" : undefined,
+                  transform: rtl ? "scaleX(-1)" : "",
+                })}
+                .end=${(
+                  item as FloorComboBoxItem & { last?: boolean | undefined }
+                ).last}
+                slot="start"
+              ></ha-tree-indicator>
+            `
+          : nothing}
+        ${item.icon
+          ? html`<ha-icon slot="start" .icon=${item.icon}></ha-icon>`
+          : item.icon_path
+            ? html`<ha-svg-icon
+                slot="start"
+                .path=${item.icon_path}
+              ></ha-svg-icon>`
+            : type === "entity" && (item as EntityComboBoxItem).stateObj
+              ? html`
+                  <state-badge
+                    slot="start"
+                    .stateObj=${(item as EntityComboBoxItem).stateObj}
+                    .hass=${this.hass}
+                  ></state-badge>
+                `
+              : type === "device" && (item as DevicePickerItem).domain
+                ? html`
+                    <img
+                      slot="start"
+                      alt=""
+                      crossorigin="anonymous"
+                      referrerpolicy="no-referrer"
+                      src=${brandsUrl({
+                        domain: (item as DevicePickerItem).domain!,
+                        type: "icon",
+                        darkOptimized: this.hass.themes.darkMode,
+                      })}
+                    />
+                  `
+                : type === "floor"
+                  ? html`<ha-floor-icon
+                      slot="start"
+                      .floor=${(item as FloorComboBoxItem).floor!}
+                    ></ha-floor-icon>`
+                  : type === "area"
+                    ? html`<ha-svg-icon
+                        slot="start"
+                        .path=${item.icon_path || mdiTextureBox}
+                      ></ha-svg-icon>`
+                    : nothing}
+        <span slot="headline">${item.primary}</span>
+        ${item.secondary
+          ? html`<span slot="supporting-text">${item.secondary}</span>`
+          : nothing}
+        ${(item as EntityComboBoxItem).stateObj && showEntityId
+          ? html`
+              <span slot="supporting-text" class="code">
+                ${(item as EntityComboBoxItem).stateObj?.entity_id}
+              </span>
+            `
+          : nothing}
+        ${(item as EntityComboBoxItem).domain_name &&
+        (type !== "entity" || !showEntityId)
+          ? html`
+              <div slot="trailing-supporting-text" class="domain">
+                ${(item as EntityComboBoxItem).domain_name}
+              </div>
+            `
+          : nothing}
+      </ha-combo-box-item>
+    `;
+  };
+
+  private _noTargetFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.target-picker.no_target_found", {
+      term: html`<b>‘${search}’</b>`,
+    });
+
   static get styles(): CSSResultGroup {
     return css`
       .add-target-wrapper {
@@ -683,31 +1095,8 @@ export class HaTargetPicker extends SubscribeMixin(LitElement) {
         margin-top: var(--ha-space-3);
       }
 
-      wa-popover {
-        --wa-space-l: var(--ha-space-0);
-      }
-
-      wa-popover::part(body) {
-        width: min(max(var(--body-width), 336px), 600px);
-        max-width: min(max(var(--body-width), 336px), 600px);
-        max-height: 500px;
-        height: 70vh;
-        overflow: hidden;
-      }
-
-      @media (max-height: 1000px) {
-        wa-popover::part(body) {
-          max-height: 400px;
-        }
-      }
-
-      ha-bottom-sheet {
-        --ha-bottom-sheet-height: 90vh;
-        --ha-bottom-sheet-height: calc(100dvh - var(--ha-space-12));
-        --ha-bottom-sheet-max-height: var(--ha-bottom-sheet-height);
-        --ha-bottom-sheet-max-width: 600px;
-        --ha-bottom-sheet-padding: var(--ha-space-0);
-        --ha-bottom-sheet-surface-background: var(--card-background-color);
+      ha-generic-picker {
+        width: 100%;
       }
 
       ${unsafeCSS(chipStyles)}

src/components/ha-trigger-icon.ts

@@ -0,0 +1,97 @@
+import {
+  mdiAvTimer,
+  mdiCalendar,
+  mdiClockOutline,
+  mdiCodeBraces,
+  mdiDevices,
+  mdiFormatListBulleted,
+  mdiGestureDoubleTap,
+  mdiHomeAssistant,
+  mdiMapMarker,
+  mdiMapMarkerRadius,
+  mdiMessageAlert,
+  mdiMicrophoneMessage,
+  mdiNfcVariant,
+  mdiNumeric,
+  mdiStateMachine,
+  mdiSwapHorizontal,
+  mdiWeatherSunny,
+  mdiWebhook,
+} from "@mdi/js";
+import { html, LitElement, nothing } from "lit";
+import { customElement, property } from "lit/decorators";
+import { until } from "lit/directives/until";
+import { computeDomain } from "../common/entity/compute_domain";
+import { FALLBACK_DOMAIN_ICONS, triggerIcon } from "../data/icons";
+import type { HomeAssistant } from "../types";
+import "./ha-icon";
+import "./ha-svg-icon";
+
+export const TRIGGER_ICONS = {
+  calendar: mdiCalendar,
+  device: mdiDevices,
+  event: mdiGestureDoubleTap,
+  state: mdiStateMachine,
+  geo_location: mdiMapMarker,
+  homeassistant: mdiHomeAssistant,
+  mqtt: mdiSwapHorizontal,
+  numeric_state: mdiNumeric,
+  sun: mdiWeatherSunny,
+  conversation: mdiMicrophoneMessage,
+  tag: mdiNfcVariant,
+  template: mdiCodeBraces,
+  time: mdiClockOutline,
+  time_pattern: mdiAvTimer,
+  webhook: mdiWebhook,
+  persistent_notification: mdiMessageAlert,
+  zone: mdiMapMarkerRadius,
+  list: mdiFormatListBulleted,
+};
+
+@customElement("ha-trigger-icon")
+export class HaTriggerIcon extends LitElement {
+  @property({ attribute: false }) public hass!: HomeAssistant;
+
+  @property() public trigger?: string;
+
+  @property() public icon?: string;
+
+  protected render() {
+    if (this.icon) {
+      return html`<ha-icon .icon=${this.icon}></ha-icon>`;
+    }
+
+    if (!this.trigger) {
+      return nothing;
+    }
+
+    if (!this.hass) {
+      return this._renderFallback();
+    }
+
+    const icon = triggerIcon(this.hass, this.trigger).then((icn) => {
+      if (icn) {
+        return html`<ha-icon .icon=${icn}></ha-icon>`;
+      }
+      return this._renderFallback();
+    });
+
+    return html`${until(icon)}`;
+  }
+
+  private _renderFallback() {
+    const domain = computeDomain(this.trigger!);
+
+    return html`
+      <ha-svg-icon
+        .path=${TRIGGER_ICONS[this.trigger!] || FALLBACK_DOMAIN_ICONS[domain]}
+      ></ha-svg-icon>
+    `;
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "ha-trigger-icon": HaTriggerIcon;
+  }
+}

src/components/ha-web-rtc-player.ts

@@ -62,6 +62,10 @@ class HaWebRtcPlayer extends LitElement {
   private _candidatesList: RTCIceCandidate[] = [];
 
   private _handleVisibilityChange = () => {
+    if (document.pictureInPictureElement) {
+      // video is playing in picture-in-picture mode, don't do anything
+      return;
+    }
     if (document.hidden) {
       this._cleanUp();
     } else {

src/components/media-player/dialog-media-manage.ts

@@ -18,7 +18,7 @@ import {
   removeLocalMedia,
 } from "../../data/media_source";
 import { showConfirmationDialog } from "../../dialogs/generic/show-dialog-box";
-import { haStyleDialog } from "../../resources/styles";
+import { haStyleDialog, haStyleDialogFixedTop } from "../../resources/styles";
 import type { HomeAssistant } from "../../types";
 import "../ha-button";
 import "../ha-check-list-item";
@@ -305,6 +305,7 @@ class DialogMediaManage extends LitElement {
   static get styles(): CSSResultGroup {
     return [
       haStyleDialog,
+      haStyleDialogFixedTop,
       css`
         ha-dialog {
           --dialog-z-index: 9;
@@ -314,9 +315,9 @@ class DialogMediaManage extends LitElement {
         @media (min-width: 800px) {
           ha-dialog {
             --mdc-dialog-max-width: 800px;
-            --dialog-surface-position: fixed;
-            --dialog-surface-top: 40px;
-            --mdc-dialog-max-height: calc(100vh - 72px);
+            --mdc-dialog-max-height: calc(
+              100vh - var(--ha-space-18) - var(--safe-area-inset-y)
+            );
           }
         }
 

src/components/media-player/dialog-media-player-browse.ts

@@ -19,7 +19,7 @@ import type {
   MediaPlayerItem,
   MediaPlayerLayoutType,
 } from "../../data/media-player";
-import { haStyleDialog } from "../../resources/styles";
+import { haStyleDialog, haStyleDialogFixedTop } from "../../resources/styles";
 import type { HomeAssistant } from "../../types";
 import "../ha-dialog";
 import "../ha-dialog-header";
@@ -223,6 +223,7 @@ class DialogMediaPlayerBrowse extends LitElement {
   static get styles(): CSSResultGroup {
     return [
       haStyleDialog,
+      haStyleDialogFixedTop,
       css`
         ha-dialog {
           --dialog-z-index: 9;
@@ -230,23 +231,27 @@ class DialogMediaPlayerBrowse extends LitElement {
         }
 
         ha-media-player-browse {
-          --media-browser-max-height: calc(100vh - 65px);
+          --media-browser-max-height: calc(
+            100vh - 65px - var(--safe-area-inset-y)
+          );
         }
 
         :host(.opened) ha-media-player-browse {
-          height: calc(100vh - 65px);
+          height: calc(100vh - 65px - var(--safe-area-inset-y));
         }
 
         @media (min-width: 800px) {
           ha-dialog {
             --mdc-dialog-max-width: 800px;
-            --dialog-surface-position: fixed;
-            --dialog-surface-top: 40px;
-            --mdc-dialog-max-height: calc(100vh - 72px);
+            --mdc-dialog-max-height: calc(
+              100vh - var(--ha-space-18) - var(--safe-area-inset-y)
+            );
           }
           ha-media-player-browse {
             position: initial;
-            --media-browser-max-height: calc(100vh - 145px);
+            --media-browser-max-height: calc(
+              100vh - 145px - var(--safe-area-inset-y)
+            );
             width: 700px;
           }
         }

src/components/search-input.ts

@@ -34,6 +34,7 @@ class SearchInput extends LitElement {
     return html`
       <ha-textfield
         .autofocus=${this.autofocus}
+        autocomplete="off"
         .label=${this.label || this.hass.localize("ui.common.search")}
         .value=${this.filter || ""}
         icon

src/components/target-picker/ha-target-picker-item-row.ts

@@ -545,7 +545,7 @@ export class HaTargetPickerItemRow extends LitElement {
         name: entityName || deviceName || item,
         context,
         stateObject,
-        notFound: !stateObject && item !== "all",
+        notFound: !stateObject && item !== "all" && item !== "none",
       };
     }
 

src/components/user/ha-user-picker.ts

@@ -128,9 +128,7 @@ class HaUserPicker extends LitElement {
         .hass=${this.hass}
         .autofocus=${this.autofocus}
         .label=${this.label}
-        .notFoundLabel=${this.hass.localize(
-          "ui.components.user-picker.no_match"
-        )}
+        .notFoundLabel=${this._notFoundLabel}
         .placeholder=${placeholder}
         .value=${this.value}
         .getItems=${this._getItems}
@@ -149,6 +147,11 @@ class HaUserPicker extends LitElement {
     fireEvent(this, "value-changed", { value });
     fireEvent(this, "change");
   }
+
+  private _notFoundLabel = (search: string) =>
+    this.hass.localize("ui.components.user-picker.no_match", {
+      term: html`<b>‘${search}’</b>`,
+    });
 }
 
 declare global {

src/data/action.ts

@@ -50,7 +50,7 @@ export const ACTION_COLLECTIONS: AutomationElementGroupCollection[] = [
   {
     groups: {
       device_id: {},
-      serviceGroups: {},
+      dynamicGroups: {},
     },
   },
   {
@@ -117,14 +117,6 @@ export const VIRTUAL_ACTIONS: Partial<
   },
 } as const;
 
-export const SERVICE_PREFIX = "__SERVICE__";
-
-export const isService = (key: string | undefined): boolean | undefined =>
-  key?.startsWith(SERVICE_PREFIX);
-
-export const getService = (key: string): string =>
-  key.substring(SERVICE_PREFIX.length);
-
 export const COLLAPSIBLE_ACTION_ELEMENTS = [
   "ha-automation-action-choose",
   "ha-automation-action-condition",

src/data/area_floor.ts

@@ -1,3 +1,4 @@
+import { getAreasFloorHierarchy } from "../common/areas/areas-floor-hierarchy";
 import { computeAreaName } from "../common/entity/compute_area_name";
 import { computeDomain } from "../common/entity/compute_domain";
 import { computeFloorName } from "../common/entity/compute_floor_name";
@@ -12,11 +13,7 @@ import {
 } from "./device_registry";
 import type { HaEntityPickerEntityFilterFunc } from "./entity";
 import type { EntityRegistryDisplayEntry } from "./entity_registry";
-import {
-  floorCompare,
-  getFloorAreaLookup,
-  type FloorRegistryEntry,
-} from "./floor_registry";
+import type { FloorRegistryEntry } from "./floor_registry";
 
 export interface FloorComboBoxItem extends PickerComboBoxItem {
   type: "floor" | "area";
@@ -182,68 +179,59 @@ export const getAreasAndFloors = (
     );
   }
 
-  const floorAreaLookup = getFloorAreaLookup(outputAreas);
-  const unassignedAreas = Object.values(outputAreas).filter(
-    (area) => !area.floor_id || !floorAreaLookup[area.floor_id]
-  );
-
-  const compare = floorCompare(haFloors);
-
-  // @ts-ignore
-  const floorAreaEntries: [
-    FloorRegistryEntry | undefined,
-    AreaRegistryEntry[],
-  ][] = Object.entries(floorAreaLookup)
-    .map(([floorId, floorAreas]) => {
-      const floor = floors.find((fl) => fl.floor_id === floorId)!;
-      return [floor, floorAreas] as const;
-    })
-    .sort(([floorA], [floorB]) => compare(floorA.floor_id, floorB.floor_id));
+  const hierarchy = getAreasFloorHierarchy(floors, outputAreas);
 
   const items: FloorComboBoxItem[] = [];
 
-  floorAreaEntries.forEach(([floor, floorAreas]) => {
-    if (floor) {
-      const floorName = computeFloorName(floor);
+  hierarchy.floors.forEach((f) => {
+    const floor = haFloors[f.id];
+    const floorAreas = f.areas.map((areaId) => haAreas[areaId]);
 
-      const areaSearchLabels = floorAreas
-        .map((area) => {
-          const areaName = computeAreaName(area) || area.area_id;
-          return [area.area_id, areaName, ...area.aliases];
-        })
-        .flat();
+    const floorName = computeFloorName(floor);
+
+    const areaSearchLabels = floorAreas
+      .map((area) => {
+        const areaName = computeAreaName(area);
+        return [area.area_id, ...(areaName ? [areaName] : []), ...area.aliases];
+      })
+      .flat();
+
+    items.push({
+      id: formatId({ id: floor.floor_id, type: "floor" }),
+      type: "floor",
+      primary: floorName,
+      floor: floor,
+      icon: floor.icon || undefined,
+      search_labels: [
+        floor.floor_id,
+        floorName,
+        ...floor.aliases,
+        ...areaSearchLabels,
+      ],
+    });
 
-      items.push({
-        id: formatId({ id: floor.floor_id, type: "floor" }),
-        type: "floor",
-        primary: floorName,
-        floor: floor,
-        icon: floor.icon || undefined,
-        search_labels: [
-          floor.floor_id,
-          floorName,
-          ...floor.aliases,
-          ...areaSearchLabels,
-        ],
-      });
-    }
     items.push(
       ...floorAreas.map((area) => {
-        const areaName = computeAreaName(area) || area.area_id;
+        const areaName = computeAreaName(area);
         return {
           id: formatId({ id: area.area_id, type: "area" }),
           type: "area" as const,
-          primary: areaName,
+          primary: areaName || area.area_id,
           area: area,
           icon: area.icon || undefined,
-          search_labels: [area.area_id, areaName, ...area.aliases],
+          search_labels: [
+            area.area_id,
+            ...(areaName ? [areaName] : []),
+            ...area.aliases,
+          ],
         };
       })
     );
   });
 
   items.push(
-    ...unassignedAreas.map((area) => {
+    ...hierarchy.areas.map((areaId) => {
+      const area = haAreas[areaId];
       const areaName = computeAreaName(area) || area.area_id;
       return {
         id: formatId({ id: area.area_id, type: "area" }),

src/data/area_registry.ts

@@ -59,6 +59,15 @@ export const deleteAreaRegistryEntry = (hass: HomeAssistant, areaId: string) =>
     area_id: areaId,
   });
 
+export const reorderAreaRegistryEntries = (
+  hass: HomeAssistant,
+  areaIds: string[]
+) =>
+  hass.callWS({
+    type: "config/area_registry/reorder",
+    area_ids: areaIds,
+  });
+
 export const getAreaEntityLookup = (
   entities: EntityRegistryEntry[]
 ): AreaEntityLookup => {

src/data/automation.ts

@@ -1,8 +1,10 @@
 import type {
   HassEntityAttributeBase,
   HassEntityBase,
+  HassServiceTarget,
 } from "home-assistant-js-websocket";
 import { ensureArray } from "../common/array/ensure-array";
+import type { WeekdayShort } from "../common/datetime/weekday";
 import { navigate } from "../common/navigate";
 import type { LocalizeKeys } from "../common/translations/localize";
 import { createSearchParam } from "../common/url/search-params";
@@ -12,10 +14,19 @@ import { CONDITION_BUILDING_BLOCKS } from "./condition";
 import type { DeviceCondition, DeviceTrigger } from "./device_automation";
 import type { Action, Field, MODES } from "./script";
 import { migrateAutomationAction } from "./script";
+import type { TriggerDescription } from "./trigger";
 
 export const AUTOMATION_DEFAULT_MODE: (typeof MODES)[number] = "single";
 export const AUTOMATION_DEFAULT_MAX = 10;
 
+export const DYNAMIC_PREFIX = "__DYNAMIC__";
+
+export const isDynamic = (key: string | undefined): boolean | undefined =>
+  key?.startsWith(DYNAMIC_PREFIX);
+
+export const getValueFromDynamic = (key: string): string =>
+  key.substring(DYNAMIC_PREFIX.length);
+
 export interface AutomationEntity extends HassEntityBase {
   attributes: HassEntityAttributeBase & {
     id?: string;
@@ -85,6 +96,12 @@ export interface BaseTrigger {
   id?: string;
   variables?: Record<string, unknown>;
   enabled?: boolean;
+  options?: Record<string, unknown>;
+}
+
+export interface PlatformTrigger extends BaseTrigger {
+  trigger: Exclude<string, LegacyTrigger["trigger"]>;
+  target?: HassServiceTarget;
 }
 
 export interface StateTrigger extends BaseTrigger {
@@ -194,7 +211,7 @@ export interface CalendarTrigger extends BaseTrigger {
   offset: string;
 }
 
-export type Trigger =
+export type LegacyTrigger =
   | StateTrigger
   | MqttTrigger
   | GeoLocationTrigger
@@ -211,8 +228,9 @@ export type Trigger =
   | TemplateTrigger
   | EventTrigger
   | DeviceTrigger
-  | CalendarTrigger
-  | TriggerList;
+  | CalendarTrigger;
+
+export type Trigger = LegacyTrigger | TriggerList | PlatformTrigger;
 
 interface BaseCondition {
   condition: string;
@@ -257,13 +275,11 @@ export interface ZoneCondition extends BaseCondition {
   zone: string;
 }
 
-type Weekday = "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
-
 export interface TimeCondition extends BaseCondition {
   condition: "time";
   after?: string;
   before?: string;
-  weekday?: Weekday | Weekday[];
+  weekday?: WeekdayShort | WeekdayShort[];
 }
 
 export interface TemplateCondition extends BaseCondition {
@@ -576,6 +592,7 @@ export interface TriggerSidebarConfig extends BaseSidebarConfig {
   insertAfter: (value: Trigger | Trigger[]) => boolean;
   toggleYamlMode: () => void;
   config: Trigger;
+  description?: TriggerDescription;
   yamlMode: boolean;
   uiSupported: boolean;
 }

src/data/automation_i18n.ts

@@ -16,8 +16,9 @@ import {
   formatListWithAnds,
   formatListWithOrs,
 } from "../common/string/format-list";
+import { hasTemplate } from "../common/string/has-template";
 import type { HomeAssistant } from "../types";
-import type { Condition, ForDict, Trigger } from "./automation";
+import type { Condition, ForDict, LegacyTrigger, Trigger } from "./automation";
 import type { DeviceCondition, DeviceTrigger } from "./device_automation";
 import {
   localizeDeviceAutomationCondition,
@@ -25,8 +26,7 @@ import {
 } from "./device_automation";
 import type { EntityRegistryEntry } from "./entity_registry";
 import type { FrontendLocaleData } from "./translation";
-import { isTriggerList } from "./trigger";
-import { hasTemplate } from "../common/string/has-template";
+import { getTriggerDomain, getTriggerObjectId, isTriggerList } from "./trigger";
 
 const triggerTranslationBaseKey =
   "ui.panel.config.automation.editor.triggers.type";
@@ -121,6 +121,37 @@ const tryDescribeTrigger = (
     return trigger.alias;
   }
 
+  const description = describeLegacyTrigger(
+    trigger as LegacyTrigger,
+    hass,
+    entityRegistry
+  );
+
+  if (description) {
+    return description;
+  }
+
+  const triggerType = trigger.trigger;
+
+  const domain = getTriggerDomain(trigger.trigger);
+  const type = getTriggerObjectId(trigger.trigger);
+
+  return (
+    hass.localize(
+      `component.${domain}.triggers.${type}.description_configured`
+    ) ||
+    hass.localize(
+      `ui.panel.config.automation.editor.triggers.type.${triggerType as LegacyTrigger["trigger"]}.label`
+    ) ||
+    hass.localize(`ui.panel.config.automation.editor.triggers.unknown_trigger`)
+  );
+};
+
+const describeLegacyTrigger = (
+  trigger: LegacyTrigger,
+  hass: HomeAssistant,
+  entityRegistry: EntityRegistryEntry[]
+) => {
   // Event Trigger
   if (trigger.trigger === "event" && trigger.event_type) {
     const eventTypes: string[] = [];
@@ -802,13 +833,7 @@ const tryDescribeTrigger = (
       }
     );
   }
-
-  return (
-    hass.localize(
-      `ui.panel.config.automation.editor.triggers.type.${trigger.trigger}.label`
-    ) ||
-    hass.localize(`ui.panel.config.automation.editor.triggers.unknown_trigger`)
-  );
+  return undefined;
 };
 
 export const describeCondition = (

src/data/backup.ts

@@ -10,6 +10,7 @@ import {
 import { formatTime } from "../common/datetime/format_time";
 import type { LocalizeFunc } from "../common/translations/localize";
 import type { HomeAssistant } from "../types";
+import { documentationUrl } from "../util/documentation-url";
 import { fileDownload } from "../util/file_download";
 import { handleFetchPromise } from "../util/hass-call-api";
 import type { BackupManagerState, ManagerStateEvent } from "./backup_manager";
@@ -414,7 +415,7 @@ ${hass.auth.data.hassUrl}
 ${hass.localize("ui.panel.config.backup.emergency_kit_file.encryption_key")}
 ${encryptionKey}
 
-${hass.localize("ui.panel.config.backup.emergency_kit_file.more_info", { link: "https://www.home-assistant.io/more-info/backup-emergency-kit" })}`);
+${hass.localize("ui.panel.config.backup.emergency_kit_file.more_info", { link: documentationUrl(hass, "/more-info/backup-emergency-kit") })}`);
 
 export const geneateEmergencyKitFileName = (
   hass: HomeAssistant,

src/data/calendar.ts

@@ -31,6 +31,7 @@ export interface CalendarEventData {
   dtend: string;
   rrule?: string;
   description?: string;
+  location?: string;
 }
 
 export interface CalendarEventMutableParams {
@@ -39,6 +40,7 @@ export interface CalendarEventMutableParams {
   dtend: string;
   rrule?: string;
   description?: string;
+  location?: string;
 }
 
 // The scope of a delete/update for a recurring event
@@ -96,6 +98,7 @@ export const fetchCalendarEvents = async (
         uid: ev.uid,
         summary: ev.summary,
         description: ev.description,
+        location: ev.location,
         dtstart: eventStart,
         dtend: eventEnd,
         recurrence_id: ev.recurrence_id,

src/data/device_registry.ts

@@ -186,7 +186,8 @@ export const getDevices = (
   deviceFilter?: HaDevicePickerDeviceFilterFunc,
   entityFilter?: HaEntityPickerEntityFilterFunc,
   excludeDevices?: string[],
-  value?: string
+  value?: string,
+  idPrefix = ""
 ): DevicePickerItem[] => {
   const devices = Object.values(hass.devices);
   const entities = Object.values(hass.entities);
@@ -298,7 +299,7 @@ export const getDevices = (
     const domainName = domain ? domainToName(hass.localize, domain) : undefined;
 
     return {
-      id: device.id,
+      id: `${idPrefix}${device.id}`,
       label: "",
       primary:
         deviceName ||

src/data/energy.ts

@@ -102,6 +102,7 @@ export type EnergySolarForecasts = Record<string, EnergySolarForecast>;
 export interface DeviceConsumptionEnergyPreference {
   // This is an ever increasing value
   stat_consumption: string;
+  stat_rate?: string;
   name?: string;
   included_in_stat?: string;
 }
@@ -130,11 +131,17 @@ export interface FlowToGridSourceEnergyPreference {
   number_energy_price: number | null;
 }
 
+export interface GridPowerSourceEnergyPreference {
+  // W meter
+  stat_rate: string;
+}
+
 export interface GridSourceTypeEnergyPreference {
   type: "grid";
 
   flow_from: FlowFromGridSourceEnergyPreference[];
   flow_to: FlowToGridSourceEnergyPreference[];
+  power?: GridPowerSourceEnergyPreference[];
 
   cost_adjustment_day: number;
 }
@@ -143,6 +150,7 @@ export interface SolarSourceTypeEnergyPreference {
   type: "solar";
 
   stat_energy_from: string;
+  stat_rate?: string;
   config_entry_solar_forecast: string[] | null;
 }
 
@@ -150,6 +158,7 @@ export interface BatterySourceTypeEnergyPreference {
   type: "battery";
   stat_energy_from: string;
   stat_energy_to: string;
+  stat_rate?: string;
 }
 export interface GasSourceTypeEnergyPreference {
   type: "gas";
@@ -351,6 +360,35 @@ export const getReferencedStatisticIds = (
   return statIDs;
 };
 
+export const getReferencedStatisticIdsPower = (
+  prefs: EnergyPreferences
+): string[] => {
+  const statIDs: (string | undefined)[] = [];
+
+  for (const source of prefs.energy_sources) {
+    if (source.type === "gas" || source.type === "water") {
+      continue;
+    }
+
+    if (source.type === "solar") {
+      statIDs.push(source.stat_rate);
+      continue;
+    }
+
+    if (source.type === "battery") {
+      statIDs.push(source.stat_rate);
+      continue;
+    }
+
+    if (source.power) {
+      statIDs.push(...source.power.map((p) => p.stat_rate));
+    }
+  }
+  statIDs.push(...prefs.device_consumption.map((d) => d.stat_rate));
+
+  return statIDs.filter(Boolean) as string[];
+};
+
 export const enum CompareMode {
   NONE = "",
   PREVIOUS = "previous",
@@ -398,9 +436,10 @@ const getEnergyData = async (
     "gas",
     "device",
   ]);
+  const powerStatIds = getReferencedStatisticIdsPower(prefs);
   const waterStatIds = getReferencedStatisticIds(prefs, info, ["water"]);
 
-  const allStatIDs = [...energyStatIds, ...waterStatIds];
+  const allStatIDs = [...energyStatIds, ...waterStatIds, ...powerStatIds];
 
   const dayDifference = differenceInDays(end || new Date(), start);
   const period =
@@ -411,6 +450,8 @@ const getEnergyData = async (
       : dayDifference > 2
         ? "day"
         : "hour";
+  const finePeriod =
+    dayDifference > 64 ? "day" : dayDifference > 8 ? "hour" : "5minute";
 
   const statsMetadata: Record<string, StatisticsMetaData> = {};
   const statsMetadataArray = allStatIDs.length
@@ -432,6 +473,9 @@ const getEnergyData = async (
       ? (gasUnit as (typeof VOLUME_UNITS)[number])
       : undefined,
   };
+  const powerUnits: StatisticsUnitConfiguration = {
+    power: "kW",
+  };
   const waterUnit = getEnergyWaterUnit(hass, prefs, statsMetadata);
   const waterUnits: StatisticsUnitConfiguration = {
     volume: waterUnit,
@@ -442,6 +486,12 @@ const getEnergyData = async (
         "change",
       ])
     : {};
+  const _powerStats: Statistics | Promise<Statistics> = powerStatIds.length
+    ? fetchStatistics(hass!, start, end, powerStatIds, finePeriod, powerUnits, [
+        "mean",
+      ])
+    : {};
+
   const _waterStats: Statistics | Promise<Statistics> = waterStatIds.length
     ? fetchStatistics(hass!, start, end, waterStatIds, period, waterUnits, [
         "change",
@@ -548,6 +598,7 @@ const getEnergyData = async (
 
   const [
     energyStats,
+    powerStats,
     waterStats,
     energyStatsCompare,
     waterStatsCompare,
@@ -555,13 +606,14 @@ const getEnergyData = async (
     fossilEnergyConsumptionCompare,
   ] = await Promise.all([
     _energyStats,
+    _powerStats,
     _waterStats,
     _energyStatsCompare,
     _waterStatsCompare,
     _fossilEnergyConsumption,
     _fossilEnergyConsumptionCompare,
   ]);
-  const stats = { ...energyStats, ...waterStats };
+  const stats = { ...energyStats, ...waterStats, ...powerStats };
   if (compare) {
     statsCompare = { ...energyStatsCompare, ...waterStatsCompare };
   }

src/data/entity_registry.ts

@@ -344,7 +344,8 @@ export const getEntities = (
   includeUnitOfMeasurement?: string[],
   includeEntities?: string[],
   excludeEntities?: string[],
-  value?: string
+  value?: string,
+  idPrefix = ""
 ): EntityComboBoxItem[] => {
   let items: EntityComboBoxItem[] = [];
 
@@ -395,10 +396,9 @@ export const getEntities = (
     const secondary = [areaName, entityName ? deviceName : undefined]
       .filter(Boolean)
       .join(isRTL ? " ◂ " : " ▸ ");
-    const a11yLabel = [deviceName, entityName].filter(Boolean).join(" - ");
 
     return {
-      id: entityId,
+      id: `${idPrefix}${entityId}`,
       primary: primary,
       secondary: secondary,
       domain_name: domainName,
@@ -411,7 +411,6 @@ export const getEntities = (
         friendlyName,
         entityId,
       ].filter(Boolean) as string[],
-      a11y_label: a11yLabel,
       stateObj: stateObj,
     };
   });

src/data/floor_registry.ts

@@ -51,6 +51,15 @@ export const deleteFloorRegistryEntry = (
     floor_id: floorId,
   });
 
+export const reorderFloorRegistryEntries = (
+  hass: HomeAssistant,
+  floorIds: string[]
+) =>
+  hass.callWS({
+    type: "config/floor_registry/reorder",
+    floor_ids: floorIds,
+  });
+
 export const getFloorAreaLookup = (
   areas: AreaRegistryEntry[]
 ): FloorAreaLookup => {

src/data/frontend.ts

@@ -3,6 +3,7 @@ import type { Connection } from "home-assistant-js-websocket";
 export interface CoreFrontendUserData {
   showAdvanced?: boolean;
   showEntityIdPicker?: boolean;
+  defaultPanel?: string;
 }
 
 export interface SidebarFrontendUserData {
@@ -10,15 +11,24 @@ export interface SidebarFrontendUserData {
   hiddenPanels: string[];
 }
 
+export interface CoreFrontendSystemData {
+  defaultPanel?: string;
+}
+
 declare global {
   interface FrontendUserData {
     core: CoreFrontendUserData;
     sidebar: SidebarFrontendUserData;
   }
+  interface FrontendSystemData {
+    core: CoreFrontendSystemData;
+  }
 }
 
 export type ValidUserDataKey = keyof FrontendUserData;
 
+export type ValidSystemDataKey = keyof FrontendSystemData;
+
 export const fetchFrontendUserData = async <
   UserDataKey extends ValidUserDataKey,
 >(
@@ -59,3 +69,46 @@ export const subscribeFrontendUserData = <UserDataKey extends ValidUserDataKey>(
       key: userDataKey,
     }
   );
+
+export const fetchFrontendSystemData = async <
+  SystemDataKey extends ValidSystemDataKey,
+>(
+  conn: Connection,
+  key: SystemDataKey
+): Promise<FrontendSystemData[SystemDataKey] | null> => {
+  const result = await conn.sendMessagePromise<{
+    value: FrontendSystemData[SystemDataKey] | null;
+  }>({
+    type: "frontend/get_system_data",
+    key,
+  });
+  return result.value;
+};
+
+export const saveFrontendSystemData = async <
+  SystemDataKey extends ValidSystemDataKey,
+>(
+  conn: Connection,
+  key: SystemDataKey,
+  value: FrontendSystemData[SystemDataKey]
+): Promise<void> =>
+  conn.sendMessagePromise<undefined>({
+    type: "frontend/set_system_data",
+    key,
+    value,
+  });
+
+export const subscribeFrontendSystemData = <
+  SystemDataKey extends ValidSystemDataKey,
+>(
+  conn: Connection,
+  systemDataKey: SystemDataKey,
+  onChange: (data: { value: FrontendSystemData[SystemDataKey] | null }) => void
+) =>
+  conn.subscribeMessage<{ value: FrontendSystemData[SystemDataKey] | null }>(
+    onChange,
+    {
+      type: "frontend/subscribe_system_data",
+      key: systemDataKey,
+    }
+  );

src/data/icons.ts

@@ -59,6 +59,7 @@ import type {
 } from "./entity_registry";
 
 import { mdiHomeAssistant } from "../resources/home-assistant-logo-svg";
+import { getTriggerDomain, getTriggerObjectId } from "./trigger";
 
 /** Icon to use when no icon specified for service. */
 export const DEFAULT_SERVICE_ICON = mdiRoomService;
@@ -133,14 +134,19 @@ const resources: {
     all?: Promise<Record<string, ServiceIcons>>;
     domains: Record<string, ServiceIcons | Promise<ServiceIcons>>;
   };
+  triggers: {
+    all?: Promise<Record<string, TriggerIcons>>;
+    domains: Record<string, TriggerIcons | Promise<TriggerIcons>>;
+  };
 } = {
   entity: {},
   entity_component: {},
   services: { domains: {} },
+  triggers: { domains: {} },
 };
 
 interface IconResources<
-  T extends ComponentIcons | PlatformIcons | ServiceIcons,
+  T extends ComponentIcons | PlatformIcons | ServiceIcons | TriggerIcons,
 > {
   resources: Record<string, T>;
 }
@@ -184,12 +190,22 @@ type ServiceIcons = Record<
   { service: string; sections?: Record<string, string> }
 >;
 
-export type IconCategory = "entity" | "entity_component" | "services";
+type TriggerIcons = Record<
+  string,
+  { trigger: string; sections?: Record<string, string> }
+>;
+
+export type IconCategory =
+  | "entity"
+  | "entity_component"
+  | "services"
+  | "triggers";
 
 interface CategoryType {
   entity: PlatformIcons;
   entity_component: ComponentIcons;
   services: ServiceIcons;
+  triggers: TriggerIcons;
 }
 
 export const getHassIcons = async <T extends IconCategory>(
@@ -258,42 +274,59 @@ export const getComponentIcons = async (
   return resources.entity_component.resources.then((res) => res[domain]);
 };
 
-export const getServiceIcons = async (
+export const getCategoryIcons = async <
+  T extends Exclude<IconCategory, "entity" | "entity_component">,
+>(
   hass: HomeAssistant,
+  category: T,
   domain?: string,
   force = false
-): Promise<ServiceIcons | Record<string, ServiceIcons> | undefined> => {
+): Promise<CategoryType[T] | Record<string, CategoryType[T]> | undefined> => {
   if (!domain) {
-    if (!force && resources.services.all) {
-      return resources.services.all;
+    if (!force && resources[category].all) {
+      return resources[category].all as Promise<
+        Record<string, CategoryType[T]>
+      >;
     }
-    resources.services.all = getHassIcons(hass, "services", domain).then(
-      (res) => {
-        resources.services.domains = res.resources;
-        return res?.resources;
-      }
-    );
-    return resources.services.all;
+    resources[category].all = getHassIcons(hass, category).then((res) => {
+      resources[category].domains = res.resources as any;
+      return res?.resources as Record<string, CategoryType[T]>;
+    }) as any;
+    return resources[category].all as Promise<Record<string, CategoryType[T]>>;
   }
-  if (!force && domain in resources.services.domains) {
-    return resources.services.domains[domain];
+  if (!force && domain in resources[category].domains) {
+    return resources[category].domains[domain] as Promise<CategoryType[T]>;
   }
-  if (resources.services.all && !force) {
-    await resources.services.all;
-    if (domain in resources.services.domains) {
-      return resources.services.domains[domain];
+  if (resources[category].all && !force) {
+    await resources[category].all;
+    if (domain in resources[category].domains) {
+      return resources[category].domains[domain] as Promise<CategoryType[T]>;
     }
   }
   if (!isComponentLoaded(hass, domain)) {
     return undefined;
   }
-  const result = getHassIcons(hass, "services", domain);
-  resources.services.domains[domain] = result.then(
+  const result = getHassIcons(hass, category, domain);
+  resources[category].domains[domain] = result.then(
     (res) => res?.resources[domain]
-  );
-  return resources.services.domains[domain];
+  ) as any;
+  return resources[category].domains[domain] as Promise<CategoryType[T]>;
 };
 
+export const getServiceIcons = async (
+  hass: HomeAssistant,
+  domain?: string,
+  force = false
+): Promise<ServiceIcons | Record<string, ServiceIcons> | undefined> =>
+  getCategoryIcons(hass, "services", domain, force);
+
+export const getTriggerIcons = async (
+  hass: HomeAssistant,
+  domain?: string,
+  force = false
+): Promise<TriggerIcons | Record<string, TriggerIcons> | undefined> =>
+  getCategoryIcons(hass, "triggers", domain, force);
+
 // Cache for sorted range keys
 const sortedRangeCache = new WeakMap<Record<string, string>, number[]>();
 
@@ -473,6 +506,26 @@ export const attributeIcon = async (
   return icon;
 };
 
+export const triggerIcon = async (
+  hass: HomeAssistant,
+  trigger: string
+): Promise<string | undefined> => {
+  let icon: string | undefined;
+
+  const domain = getTriggerDomain(trigger);
+  const triggerName = getTriggerObjectId(trigger);
+
+  const triggerIcons = await getTriggerIcons(hass, domain);
+  if (triggerIcons) {
+    const trgrIcon = triggerIcons[triggerName] as TriggerIcons[string];
+    icon = trgrIcon?.trigger;
+  }
+  if (!icon) {
+    icon = await domainIcon(hass, domain);
+  }
+  return icon;
+};
+
 export const serviceIcon = async (
   hass: HomeAssistant,
   service: string

src/data/label_registry.ts

@@ -108,7 +108,8 @@ export const getLabels = (
   includeDeviceClasses?: string[],
   deviceFilter?: HaDevicePickerDeviceFilterFunc,
   entityFilter?: HaEntityPickerEntityFilterFunc,
-  excludeLabels?: string[]
+  excludeLabels?: string[],
+  idPrefix = ""
 ): PickerComboBoxItem[] => {
   if (!labels || labels.length === 0) {
     return [];
@@ -262,7 +263,7 @@ export const getLabels = (
   }
 
   const items = outputLabels.map<PickerComboBoxItem>((label) => ({
-    id: label.label_id,
+    id: `${idPrefix}${label.label_id}`,
     primary: label.name,
     secondary: label.description ?? "",
     icon: label.icon || undefined,

src/data/labs.ts

@@ -0,0 +1,78 @@
+import type { Connection } from "home-assistant-js-websocket";
+import { createCollection } from "home-assistant-js-websocket";
+import type { Store } from "home-assistant-js-websocket/dist/store";
+import { debounce } from "../common/util/debounce";
+import type { HomeAssistant } from "../types";
+
+export interface LabPreviewFeature {
+  preview_feature: string;
+  domain: string;
+  enabled: boolean;
+  is_built_in: boolean;
+  feedback_url?: string;
+  learn_more_url?: string;
+  report_issue_url?: string;
+}
+
+export interface LabPreviewFeaturesResponse {
+  features: LabPreviewFeature[];
+}
+
+export const fetchLabFeatures = async (
+  hass: HomeAssistant
+): Promise<LabPreviewFeature[]> => {
+  const response = await hass.callWS<LabPreviewFeaturesResponse>({
+    type: "labs/list",
+  });
+  return response.features;
+};
+
+export const labsUpdatePreviewFeature = (
+  hass: HomeAssistant,
+  domain: string,
+  preview_feature: string,
+  enabled: boolean,
+  create_backup?: boolean
+): Promise<void> =>
+  hass.callWS({
+    type: "labs/update",
+    domain,
+    preview_feature,
+    enabled,
+    ...(create_backup !== undefined && { create_backup }),
+  });
+
+const fetchLabFeaturesCollection = (conn: Connection) =>
+  conn
+    .sendMessagePromise<LabPreviewFeaturesResponse>({
+      type: "labs/list",
+    })
+    .then((response) => response.features);
+
+const subscribeLabUpdates = (
+  conn: Connection,
+  store: Store<LabPreviewFeature[]>
+) =>
+  conn.subscribeEvents(
+    debounce(
+      () =>
+        fetchLabFeaturesCollection(conn).then((features: LabPreviewFeature[]) =>
+          store.setState(features, true)
+        ),
+      500,
+      true
+    ),
+    "labs_updated"
+  );
+
+export const subscribeLabFeatures = (
+  conn: Connection,
+  onChange: (features: LabPreviewFeature[]) => void
+) =>
+  createCollection<LabPreviewFeature[]>(
+    "_labFeatures",
+    fetchLabFeaturesCollection,
+    subscribeLabUpdates,
+    conn,
+    onChange
+  );

src/data/panel.ts

@@ -1,26 +1,24 @@
-import { fireEvent } from "../common/dom/fire_event";
 import type { HomeAssistant, PanelInfo } from "../types";
 
 /** Panel to show when no panel is picked. */
 export const DEFAULT_PANEL = "lovelace";
 
-export const getStorageDefaultPanelUrlPath = (): string => {
+export const getLegacyDefaultPanelUrlPath = (): string | null => {
   const defaultPanel = window.localStorage.getItem("defaultPanel");
-
-  return defaultPanel ? JSON.parse(defaultPanel) : DEFAULT_PANEL;
+  return defaultPanel ? JSON.parse(defaultPanel) : null;
 };
 
-export const setDefaultPanel = (
-  element: HTMLElement,
-  urlPath: string
-): void => {
-  fireEvent(element, "hass-default-panel", { defaultPanel: urlPath });
-};
+export const getDefaultPanelUrlPath = (hass: HomeAssistant): string =>
+  hass.userData?.defaultPanel ||
+  hass.systemData?.defaultPanel ||
+  getLegacyDefaultPanelUrlPath() ||
+  DEFAULT_PANEL;
 
-export const getDefaultPanel = (hass: HomeAssistant): PanelInfo =>
-  hass.panels[hass.defaultPanel]
-    ? hass.panels[hass.defaultPanel]
-    : hass.panels[DEFAULT_PANEL];
+export const getDefaultPanel = (hass: HomeAssistant): PanelInfo => {
+  const panel = getDefaultPanelUrlPath(hass);
+
+  return (panel ? hass.panels[panel] : undefined) ?? hass.panels[DEFAULT_PANEL];
+};
 
 export const getPanelNameTranslationKey = (panel: PanelInfo) => {
   if (panel.url_path === "lovelace") {

src/data/todo.ts

@@ -28,6 +28,7 @@ export interface TodoItem {
   status: TodoItemStatus | null;
   description?: string | null;
   due?: string | null;
+  completed?: string | null;
 }
 
 export const enum TodoListEntityFeature {

src/data/translation.ts

@@ -72,8 +72,10 @@ export type TranslationCategory =
   | "system_health"
   | "application_credentials"
   | "issues"
+  | "preview_features"
   | "selector"
-  | "services";
+  | "services"
+  | "triggers";
 
 export const subscribeTranslationPreferences = (
   hass: HomeAssistant,

src/data/trigger.ts

@@ -1,57 +1,20 @@
-import {
-  mdiAvTimer,
-  mdiCalendar,
-  mdiClockOutline,
-  mdiCodeBraces,
-  mdiDevices,
-  mdiFormatListBulleted,
-  mdiGestureDoubleTap,
-  mdiMapClock,
-  mdiMapMarker,
-  mdiMapMarkerRadius,
-  mdiMessageAlert,
-  mdiMicrophoneMessage,
-  mdiNfcVariant,
-  mdiNumeric,
-  mdiShape,
-  mdiStateMachine,
-  mdiSwapHorizontal,
-  mdiWeatherSunny,
-  mdiWebhook,
-} from "@mdi/js";
+import { mdiMapClock, mdiShape } from "@mdi/js";
 
-import { mdiHomeAssistant } from "../resources/home-assistant-logo-svg";
+import { computeDomain } from "../common/entity/compute_domain";
+import { computeObjectId } from "../common/entity/compute_object_id";
+import type { HomeAssistant } from "../types";
 import type {
   AutomationElementGroupCollection,
   Trigger,
   TriggerList,
 } from "./automation";
-
-export const TRIGGER_ICONS = {
-  calendar: mdiCalendar,
-  device: mdiDevices,
-  event: mdiGestureDoubleTap,
-  state: mdiStateMachine,
-  geo_location: mdiMapMarker,
-  homeassistant: mdiHomeAssistant,
-  mqtt: mdiSwapHorizontal,
-  numeric_state: mdiNumeric,
-  sun: mdiWeatherSunny,
-  conversation: mdiMicrophoneMessage,
-  tag: mdiNfcVariant,
-  template: mdiCodeBraces,
-  time: mdiClockOutline,
-  time_pattern: mdiAvTimer,
-  webhook: mdiWebhook,
-  persistent_notification: mdiMessageAlert,
-  zone: mdiMapMarkerRadius,
-  list: mdiFormatListBulleted,
-};
+import type { Selector, TargetSelector } from "./selector";
 
 export const TRIGGER_COLLECTIONS: AutomationElementGroupCollection[] = [
   {
     groups: {
       device: {},
+      dynamicGroups: {},
       entity: { icon: mdiShape, members: { state: {}, numeric_state: {} } },
       time_location: {
         icon: mdiMapClock,
@@ -83,3 +46,33 @@ export const TRIGGER_COLLECTIONS: AutomationElementGroupCollection[] = [
 
 export const isTriggerList = (trigger: Trigger): trigger is TriggerList =>
   "triggers" in trigger;
+
+export interface TriggerDescription {
+  target?: TargetSelector["target"];
+  fields: Record<
+    string,
+    {
+      example?: string | boolean | number;
+      default?: unknown;
+      required?: boolean;
+      selector?: Selector;
+      context?: Record<string, string>;
+    }
+  >;
+}
+
+export type TriggerDescriptions = Record<string, TriggerDescription>;
+
+export const subscribeTriggers = (
+  hass: HomeAssistant,
+  callback: (triggers: TriggerDescriptions) => void
+) =>
+  hass.connection.subscribeMessage<TriggerDescriptions>(callback, {
+    type: "trigger_platforms/subscribe",
+  });
+
+export const getTriggerDomain = (trigger: string) =>
+  trigger.includes(".") ? computeDomain(trigger) : trigger;
+
+export const getTriggerObjectId = (trigger: string) =>
+  trigger.includes(".") ? computeObjectId(trigger) : "_";

src/dialogs/config-entry-system-options/dialog-config-entry-system-options.ts

@@ -2,7 +2,8 @@ import type { CSSResultGroup } from "lit";
 import { css, html, LitElement, nothing } from "lit";
 import { customElement, property, state } from "lit/decorators";
 import { fireEvent } from "../../common/dom/fire_event";
-import { createCloseHeading } from "../../components/ha-dialog";
+import "../../components/ha-wa-dialog";
+import "../../components/ha-dialog-footer";
 import "../../components/ha-formfield";
 import "../../components/ha-switch";
 import "../../components/ha-button";
@@ -28,6 +29,8 @@ class DialogConfigEntrySystemOptions extends LitElement {
 
   @state() private _submitting = false;
 
+  @state() private _open = false;
+
   public async showDialog(
     params: ConfigEntrySystemOptionsDialogParams
   ): Promise<void> {
@@ -35,9 +38,14 @@ class DialogConfigEntrySystemOptions extends LitElement {
     this._error = undefined;
     this._disableNewEntities = params.entry.pref_disable_new_entities;
     this._disablePolling = params.entry.pref_disable_polling;
+    this._open = true;
   }
 
   public closeDialog(): void {
+    this._open = false;
+  }
+
+  private _dialogClosed(): void {
     this._error = "";
     this._params = undefined;
     fireEvent(this, "dialog-closed", { dialog: this.localName });
@@ -49,18 +57,19 @@ class DialogConfigEntrySystemOptions extends LitElement {
     }
 
     return html`
-      <ha-dialog
-        open
-        @closed=${this.closeDialog}
-        .heading=${createCloseHeading(
-          this.hass,
-          this.hass.localize("ui.dialogs.config_entry_system_options.title", {
+      <ha-wa-dialog
+        .hass=${this.hass}
+        .open=${this._open}
+        header-title=${this.hass.localize(
+          "ui.dialogs.config_entry_system_options.title",
+          {
             integration:
               this.hass.localize(
                 `component.${this._params.entry.domain}.title`
               ) || this._params.entry.domain,
-          })
+          }
         )}
+        @closed=${this._dialogClosed}
       >
         ${this._error ? html` <div class="error">${this._error}</div> ` : ""}
         <ha-formfield
@@ -82,10 +91,10 @@ class DialogConfigEntrySystemOptions extends LitElement {
             </p>`}
         >
           <ha-switch
+            autofocus
             .checked=${!this._disableNewEntities}
             @change=${this._disableNewEntitiesChanged}
             .disabled=${this._submitting}
-            dialogInitialFocus
           ></ha-switch>
         </ha-formfield>
 
@@ -113,22 +122,27 @@ class DialogConfigEntrySystemOptions extends LitElement {
             .disabled=${this._submitting}
           ></ha-switch>
         </ha-formfield>
-        <ha-button
-          appearance="plain"
-          slot="primaryAction"
-          @click=${this.closeDialog}
-          .disabled=${this._submitting}
-        >
-          ${this.hass.localize("ui.common.cancel")}
-        </ha-button>
-        <ha-button
-          slot="primaryAction"
-          @click=${this._updateEntry}
-          .disabled=${this._submitting}
-        >
-          ${this.hass.localize("ui.dialogs.config_entry_system_options.update")}
-        </ha-button>
-      </ha-dialog>
+
+        <ha-dialog-footer slot="footer">
+          <ha-button
+            appearance="plain"
+            slot="secondaryAction"
+            @click=${this.closeDialog}
+            .disabled=${this._submitting}
+          >
+            ${this.hass.localize("ui.common.cancel")}
+          </ha-button>
+          <ha-button
+            slot="primaryAction"
+            @click=${this._updateEntry}
+            .disabled=${this._submitting}
+          >
+            ${this.hass.localize(
+              "ui.dialogs.config_entry_system_options.update"
+            )}
+          </ha-button>
+        </ha-dialog-footer>
+      </ha-wa-dialog>
     `;
   }
 

src/dialogs/more-info/ha-more-info-dialog.ts

@@ -50,7 +50,7 @@ import { lightSupportsFavoriteColors } from "../../data/light";
 import type { ItemType } from "../../data/search";
 import { SearchableDomains } from "../../data/search";
 import { getSensorNumericDeviceClasses } from "../../data/sensor";
-import { haStyleDialog } from "../../resources/styles";
+import { haStyleDialog, haStyleDialogFixedTop } from "../../resources/styles";
 import "../../state-summary/state-card-content";
 import type { HomeAssistant } from "../../types";
 import {
@@ -707,14 +707,9 @@ export class MoreInfoDialog extends LitElement {
   static get styles() {
     return [
       haStyleDialog,
+      haStyleDialogFixedTop,
       css`
         ha-dialog {
-          /* Set the top top of the dialog to a fixed position, so it doesnt jump when the content changes size */
-          --vertical-align-dialog: flex-start;
-          --dialog-surface-margin-top: max(
-            var(--ha-space-10),
-            var(--safe-area-inset-top, var(--ha-space-0))
-          );
           --dialog-content-padding: 0;
         }
 
@@ -737,13 +732,6 @@ export class MoreInfoDialog extends LitElement {
           display: block;
         }
 
-        @media all and (max-width: 450px), all and (max-height: 500px) {
-          /* When in fullscreen dialog should be attached to top */
-          ha-dialog {
-            --dialog-surface-margin-top: var(--ha-space-0);
-          }
-        }
-
         @media all and (min-width: 600px) and (min-height: 501px) {
           ha-dialog {
             --mdc-dialog-min-width: 580px;

src/dialogs/quick-bar/ha-quick-bar.ts

@@ -46,7 +46,11 @@ import { getPanelNameTranslationKey } from "../../data/panel";
 import type { PageNavigation } from "../../layouts/hass-tabs-subpage";
 import { configSections } from "../../panels/config/ha-panel-config";
 import { HaFuse } from "../../resources/fuse";
-import { haStyleDialog, haStyleScrollbar } from "../../resources/styles";
+import {
+  haStyleDialog,
+  haStyleDialogFixedTop,
+  haStyleScrollbar,
+} from "../../resources/styles";
 import { loadVirtualizer } from "../../resources/virtualizer";
 import type { HomeAssistant } from "../../types";
 import { brandsUrl } from "../../util/brands-url";
@@ -986,6 +990,7 @@ export class QuickBar extends LitElement {
     return [
       haStyleScrollbar,
       haStyleDialog,
+      haStyleDialogFixedTop,
       css`
         ha-list {
           position: relative;
@@ -1010,9 +1015,9 @@ export class QuickBar extends LitElement {
           ha-dialog {
             --mdc-dialog-max-width: 800px;
             --mdc-dialog-min-width: 500px;
-            --dialog-surface-position: fixed;
-            --dialog-surface-top: var(--ha-space-10);
-            --mdc-dialog-max-height: calc(100% - var(--ha-space-18));
+            --mdc-dialog-max-height: calc(
+              100vh - var(--ha-space-18) - var(--safe-area-inset-y)
+            );
           }
         }
 

src/dialogs/sidebar/dialog-edit-sidebar.ts

@@ -20,6 +20,7 @@ import {
 } from "../../data/frontend";
 import type { HomeAssistant } from "../../types";
 import { showConfirmationDialog } from "../generic/show-dialog-box";
+import { getDefaultPanelUrlPath } from "../../data/panel";
 
 @customElement("dialog-edit-sidebar")
 class DialogEditSidebar extends LitElement {
@@ -94,9 +95,11 @@ class DialogEditSidebar extends LitElement {
 
     const panels = this._panels(this.hass.panels);
 
+    const defaultPanel = getDefaultPanelUrlPath(this.hass);
+
     const [beforeSpacer, afterSpacer] = computePanels(
       this.hass.panels,
-      this.hass.defaultPanel,
+      defaultPanel,
       this._order,
       this._hidden,
       this.hass.locale
@@ -105,7 +108,7 @@ class DialogEditSidebar extends LitElement {
     // Add default hidden panels that are missing in hidden
     for (const panel of panels) {
       if (
-        !panel.default_visible &&
+        panel.default_visible === false &&
         !this._order.includes(panel.url_path) &&
         !this._hidden.includes(panel.url_path)
       ) {
@@ -120,12 +123,12 @@ class DialogEditSidebar extends LitElement {
     ].map((panel) => ({
       value: panel.url_path,
       label:
-        panel.url_path === this.hass.defaultPanel
+        panel.url_path === defaultPanel
           ? panel.title || this.hass.localize("panel.states")
           : this.hass.localize(`panel.${panel.title}`) || panel.title || "?",
       icon: panel.icon || undefined,
       iconPath:
-        panel.url_path === this.hass.defaultPanel && !panel.icon
+        panel.url_path === defaultPanel && !panel.icon
           ? PANEL_ICONS.lovelace
           : panel.url_path in PANEL_ICONS
             ? PANEL_ICONS[panel.url_path]

src/html/index.html.template

@@ -20,23 +20,44 @@
     <meta name="color-scheme" content="dark light" />
     <%= renderTemplate("_style_base.html.template") %>
     <style>
+      @keyframes fade-out {
+        from {
+          opacity: 1;
+        }
+        to {
+          opacity: 0;
+        }
+      }
+      ::view-transition-group(launch-screen) {
+        animation-duration: var(--ha-animation-base-duration, 350ms);
+        animation-timing-function: ease-out;
+      }
+      ::view-transition-old(launch-screen) {
+        animation: fade-out var(--ha-animation-base-duration, 350ms) ease-out;
+      }
       html {
         background-color: var(--primary-background-color, #fafafa);
         color: var(--primary-text-color, #212121);
         height: 100vh;
       }
-      @media (prefers-color-scheme: dark) {
-        html {
-          background-color: var(--primary-background-color, #111111);
-          color: var(--primary-text-color, #e1e1e1);
-        }
-      }
       #ha-launch-screen {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        width: 100%;
         height: 100%;
         display: flex;
         flex-direction: column;
         justify-content: center;
         align-items: center;
+        view-transition-name: launch-screen;
+        background-color: var(--primary-background-color, #fafafa);
+        z-index: 100;
+      }
+      #ha-launch-screen.removing {
+        opacity: 0;
       }
       #ha-launch-screen svg {
         width: 112px;
@@ -59,6 +80,14 @@
         opacity: .66;
       }
       @media (prefers-color-scheme: dark) {
+        html {
+          background-color: var(--primary-background-color, #111111);
+          color: var(--primary-text-color, #e1e1e1);
+        }
+        /* body selector to avoid minification causing bad jinja2 */
+        body #ha-launch-screen {
+          background-color: var(--primary-background-color, #111111);
+        }
         .ohf-logo {
           filter: invert(1);
         }

src/layouts/home-assistant-main.ts

@@ -1,5 +1,5 @@
 import type { PropertyValues, TemplateResult } from "lit";
-import { css, html, LitElement } from "lit";
+import { css, html, LitElement, nothing } from "lit";
 import { customElement, property, state } from "lit/decorators";
 import type { HASSDomEvent } from "../common/dom/fire_event";
 import { fireEvent } from "../common/dom/fire_event";
@@ -46,10 +46,13 @@ export class HomeAssistantMain extends LitElement {
   protected render(): TemplateResult {
     const sidebarNarrow = this._sidebarNarrow || this._externalSidebar;
 
+    const isPanelReady =
+      this.hass.panels && this.hass.userData && this.hass.systemData;
+
     return html`
       <ha-drawer
         .type=${sidebarNarrow ? "modal" : ""}
-        .open=${sidebarNarrow ? this._drawerOpen : undefined}
+        .open=${sidebarNarrow ? this._drawerOpen : false}
         .direction=${computeRTLDirection(this.hass)}
         @MDCDrawer:closed=${this._drawerClosed}
       >
@@ -59,12 +62,14 @@ export class HomeAssistantMain extends LitElement {
           .route=${this.route}
           .alwaysExpand=${sidebarNarrow || this.hass.dockedSidebar === "docked"}
         ></ha-sidebar>
-        <partial-panel-resolver
-          .narrow=${this.narrow}
-          .hass=${this.hass}
-          .route=${this.route}
-          slot="appContent"
-        ></partial-panel-resolver>
+        ${isPanelReady
+          ? html`<partial-panel-resolver
+              .narrow=${this.narrow}
+              .hass=${this.hass}
+              .route=${this.route}
+              slot="appContent"
+            ></partial-panel-resolver>`
+          : nothing}
       </ha-drawer>
     `;
   }

src/layouts/home-assistant.ts

@@ -1,10 +1,10 @@
+import type { Connection } from "home-assistant-js-websocket";
 import type { PropertyValues } from "lit";
 import { html } from "lit";
 import { customElement, state } from "lit/decorators";
-import type { Connection } from "home-assistant-js-websocket";
+import { storage } from "../common/decorators/storage";
 import { isNavigationClick } from "../common/dom/is-navigation-click";
 import { navigate } from "../common/navigate";
-import { getStorageDefaultPanelUrlPath } from "../data/panel";
 import type { WindowWithPreloads } from "../data/preloads";
 import type { RecorderInfo } from "../data/recorder";
 import { getRecorderInfo } from "../data/recorder";
@@ -23,7 +23,6 @@ import {
 } from "../util/register-service-worker";
 import "./ha-init-page";
 import "./home-assistant-main";
-import { storage } from "../common/decorators/storage";
 
 const useHash = __DEMO__;
 const curPath = () =>
@@ -53,11 +52,6 @@ export class HomeAssistantAppEl extends QuickBarMixin(HassElement) {
     super();
     const path = curPath();
 
-    if (["", "/"].includes(path)) {
-      navigate(`/${getStorageDefaultPanelUrlPath()}${location.search}`, {
-        replace: true,
-      });
-    }
     this._route = {
       prefix: "",
       path,

src/layouts/partial-panel-resolver.ts

@@ -35,6 +35,7 @@ const COMPONENTS = {
   light: () => import("../panels/light/ha-panel-light"),
   security: () => import("../panels/security/ha-panel-security"),
   climate: () => import("../panels/climate/ha-panel-climate"),
+  home: () => import("../panels/home/ha-panel-home"),
 };
 
 @customElement("partial-panel-resolver")

src/layouts/supervisor-error-screen.ts

@@ -5,6 +5,7 @@ import { atLeastVersion } from "../common/config/version";
 import { applyThemesOnElement } from "../common/dom/apply_themes_on_element";
 import "../components/ha-card";
 import { haStyle } from "../resources/styles";
+import { documentationUrl } from "../util/documentation-url";
 import type { HomeAssistant } from "../types";
 import "./hass-subpage";
 
@@ -57,7 +58,7 @@ class SupervisorErrorScreen extends LitElement {
               </li>
               <li>
                 <a
-                  href="https://www.home-assistant.io/help/"
+                  href=${documentationUrl(this.hass, "/help/")}
                   target="_blank"
                   rel="noreferrer"
                 >

src/mixins/conditional-listener-mixin.ts

@@ -1,82 +1,56 @@
 import type { ReactiveElement } from "lit";
-import { listenMediaQuery } from "../common/dom/media_query";
 import type { HomeAssistant } from "../types";
+import {
+  setupMediaQueryListeners,
+  setupTimeListeners,
+} from "../common/condition/listeners";
 import type { Condition } from "../panels/lovelace/common/validate-condition";
-import { checkConditionsMet } from "../panels/lovelace/common/validate-condition";
 
 type Constructor<T> = abstract new (...args: any[]) => T;
 
 /**
- * Extract media queries from conditions recursively
+ * Base config type that can be used with conditional listeners
  */
-export function extractMediaQueries(conditions: Condition[]): string[] {
-  return conditions.reduce<string[]>((array, c) => {
-    if ("conditions" in c && c.conditions) {
-      array.push(...extractMediaQueries(c.conditions));
-    }
-    if (c.condition === "screen" && c.media_query) {
-      array.push(c.media_query);
-    }
-    return array;
-  }, []);
-}
-
-/**
- * Helper to setup media query listeners for conditional visibility
- */
-export function setupMediaQueryListeners(
-  conditions: Condition[],
-  hass: HomeAssistant,
-  addListener: (unsub: () => void) => void,
-  onUpdate: (conditionsMet: boolean) => void
-): void {
-  const mediaQueries = extractMediaQueries(conditions);
-
-  if (mediaQueries.length === 0) return;
-
-  // Optimization for single media query
-  const hasOnlyMediaQuery =
-    conditions.length === 1 &&
-    conditions[0].condition === "screen" &&
-    !!conditions[0].media_query;
-
-  mediaQueries.forEach((mediaQuery) => {
-    const unsub = listenMediaQuery(mediaQuery, (matches) => {
-      if (hasOnlyMediaQuery) {
-        onUpdate(matches);
-      } else {
-        const conditionsMet = checkConditionsMet(conditions, hass);
-        onUpdate(conditionsMet);
-      }
-    });
-    addListener(unsub);
-  });
+export interface ConditionalConfig {
+  visibility?: Condition[];
+  [key: string]: any;
 }
 
 /**
  * Mixin to handle conditional listeners for visibility control
  *
- * Provides lifecycle management for listeners (media queries, time-based, state changes, etc.)
- * that control conditional visibility of components.
+ * Provides lifecycle management for listeners that control conditional
+ * visibility of components.
  *
  * Usage:
- * 1. Extend your component with ConditionalListenerMixin(ReactiveElement)
- * 2. Override setupConditionalListeners() to setup your listeners
- * 3. Use addConditionalListener() to register unsubscribe functions
- * 4. Call clearConditionalListeners() and setupConditionalListeners() when config changes
+ * 1. Extend your component with ConditionalListenerMixin<YourConfigType>(ReactiveElement)
+ * 2. Ensure component has config.visibility or _config.visibility property with conditions
+ * 3. Ensure component has _updateVisibility() or _updateElement() method
+ * 4. Override setupConditionalListeners() if custom behavior needed (e.g., filter conditions)
  *
  * The mixin automatically:
  * - Sets up listeners when component connects to DOM
  * - Cleans up listeners when component disconnects from DOM
+ * - Handles conditional visibility based on defined conditions
  */
 export const ConditionalListenerMixin = <
-  T extends Constructor<ReactiveElement>,
+  TConfig extends ConditionalConfig = ConditionalConfig,
 >(
-  superClass: T
+  superClass: Constructor<ReactiveElement>
 ) => {
   abstract class ConditionalListenerClass extends superClass {
     private __listeners: (() => void)[] = [];
 
+    protected _config?: TConfig;
+
+    public config?: TConfig;
+
+    public hass?: HomeAssistant;
+
+    protected _updateElement?(config: TConfig): void;
+
+    protected _updateVisibility?(conditionsMet?: boolean): void;
+
     public connectedCallback() {
       super.connectedCallback();
       this.setupConditionalListeners();
@@ -87,17 +61,72 @@ export const ConditionalListenerMixin = <
       this.clearConditionalListeners();
     }
 
+    /**
+     * Clear conditional listeners
+     *
+     * This method is called when the component is disconnected from the DOM.
+     * It clears all the listeners that were set up by the setupConditionalListeners() method.
+     */
     protected clearConditionalListeners(): void {
       this.__listeners.forEach((unsub) => unsub());
       this.__listeners = [];
     }
 
+    /**
+     * Add a conditional listener to the list of listeners
+     *
+     * This method is called when a new listener is added.
+     * It adds the listener to the list of listeners.
+     *
+     * @param unsubscribe - The unsubscribe function to call when the listener is no longer needed
+     * @returns void
+     */
     protected addConditionalListener(unsubscribe: () => void): void {
       this.__listeners.push(unsubscribe);
     }
 
-    protected setupConditionalListeners(): void {
-      // Override in subclass
+    /**
+     * Setup conditional listeners for visibility control
+     *
+     * Default implementation:
+     * - Checks config.visibility or _config.visibility for conditions (if not provided)
+     * - Sets up appropriate listeners based on condition types
+     * - Calls _updateVisibility() or _updateElement() when conditions change
+     *
+     * Override this method to customize behavior (e.g., filter conditions first)
+     * and call super.setupConditionalListeners(customConditions) to reuse the base implementation
+     *
+     * @param conditions - Optional conditions array. If not provided, will check config.visibility or _config.visibility
+     */
+    protected setupConditionalListeners(conditions?: Condition[]): void {
+      const config = this.config || this._config;
+      const finalConditions = conditions || config?.visibility;
+
+      if (!finalConditions || !this.hass) {
+        return;
+      }
+
+      const onUpdate = (conditionsMet: boolean) => {
+        if (this._updateVisibility) {
+          this._updateVisibility(conditionsMet);
+        } else if (this._updateElement && config) {
+          this._updateElement(config);
+        }
+      };
+
+      setupMediaQueryListeners(
+        finalConditions,
+        this.hass,
+        (unsub) => this.addConditionalListener(unsub),
+        onUpdate
+      );
+
+      setupTimeListeners(
+        finalConditions,
+        this.hass,
+        (unsub) => this.addConditionalListener(unsub),
+        onUpdate
+      );
     }
   }
   return ConditionalListenerClass;

src/onboarding/onboarding-welcome-links.ts

@@ -4,6 +4,7 @@ import { LitElement, css, html, nothing } from "lit";
 import { customElement, property } from "lit/decorators";
 import type { LocalizeFunc } from "../common/translations/localize";
 import "../components/ha-card";
+import { documentationUrl } from "../util/documentation-url";
 import type { HomeAssistant } from "../types";
 import { showAppDialog } from "./dialogs/show-app-dialog";
 import { showCommunityDialog } from "./dialogs/show-community-dialog";
@@ -22,7 +23,10 @@ class OnboardingWelcomeLinks extends LitElement {
     return html`<a
         target="_blank"
         rel="noreferrer noopener"
-        href="https://www.home-assistant.io/blog/2016/01/19/perfect-home-automation/"
+        href=${documentationUrl(
+          this.hass,
+          "/blog/2016/01/19/perfect-home-automation/"
+        )}
       >
         <onboarding-welcome-link
           noninteractive

src/panels/calendar/dialog-calendar-event-detail.ts

@@ -80,10 +80,12 @@ class DialogCalendarEventDetail extends LitElement {
               ${this._data!.rrule
                 ? this._renderRRuleAsText(this._data.rrule)
                 : ""}
+              ${this._data.location
+                ? html`${this._data.location} <br />`
+                : nothing}
               ${this._data.description
                 ? html`<br />
-                    <div class="description">${this._data.description}</div>
-                    <br />`
+                    <div class="description">${this._data.description}</div>`
                 : nothing}
             </div>
           </div>
@@ -241,7 +243,7 @@ class DialogCalendarEventDetail extends LitElement {
       haStyleDialog,
       css`
         state-info {
-          line-height: 40px;
+          margin-top: 24px;
         }
         ha-svg-icon {
           width: 40px;

src/panels/calendar/dialog-calendar-event-editor.ts

@@ -63,6 +63,8 @@ class DialogCalendarEventEditor extends LitElement {
 
   @state() private _description? = "";
 
+  @state() private _location? = "";
+
   @state() private _rrule?: string;
 
   @state() private _allDay = false;
@@ -79,6 +81,8 @@ class DialogCalendarEventEditor extends LitElement {
   // timezone, but floating without a timezone.
   private _timeZone?: string;
 
+  private _hasLocation = false;
+
   public showDialog(params: CalendarEventEditDialogParams): void {
     this._error = undefined;
     this._info = undefined;
@@ -99,6 +103,10 @@ class DialogCalendarEventEditor extends LitElement {
       this._allDay = isDate(entry.dtstart);
       this._summary = entry.summary;
       this._description = entry.description;
+      if (entry.location) {
+        this._hasLocation = true;
+        this._location = entry.location;
+      }
       this._rrule = entry.rrule;
       if (this._allDay) {
         this._dtstart = new Date(entry.dtstart + "T00:00:00");
@@ -130,6 +138,8 @@ class DialogCalendarEventEditor extends LitElement {
     this._dtend = undefined;
     this._summary = "";
     this._description = "";
+    this._location = "";
+    this._hasLocation = false;
     this._rrule = undefined;
     fireEvent(this, "dialog-closed", { dialog: this.localName });
   }
@@ -181,6 +191,15 @@ class DialogCalendarEventEditor extends LitElement {
             .validationMessage=${this.hass.localize("ui.common.error_required")}
             dialogInitialFocus
           ></ha-textfield>
+          <ha-textfield
+            class="location"
+            name="location"
+            .label=${this.hass.localize(
+              "ui.components.calendar.event.location"
+            )}
+            .value=${this._location}
+            @change=${this._handleLocationChanged}
+          ></ha-textfield>
           <ha-textarea
             class="description"
             name="description"
@@ -326,6 +345,10 @@ class DialogCalendarEventEditor extends LitElement {
     this._description = ev.target.value;
   }
 
+  private _handleLocationChanged(ev: Event) {
+    this._location = (ev.target as HTMLInputElement).value;
+  }
+
   private _handleRRuleChanged(ev) {
     this._rrule = ev.detail.value;
   }
@@ -399,6 +422,7 @@ class DialogCalendarEventEditor extends LitElement {
     const data: CalendarEventMutableParams = {
       summary: this._summary,
       description: this._description,
+      location: this._location || (this._hasLocation ? "" : undefined),
       rrule: this._rrule || undefined,
       dtstart: "",
       dtend: "",

src/panels/climate/strategies/climate-view-strategy.ts

@@ -1,21 +1,17 @@
 import { ReactiveElement } from "lit";
 import { customElement } from "lit/decorators";
+import { getAreasFloorHierarchy } from "../../../common/areas/areas-floor-hierarchy";
 import {
   findEntities,
   generateEntityFilter,
   type EntityFilter,
 } from "../../../common/entity/entity_filter";
+import { floorDefaultIcon } from "../../../components/ha-floor-icon";
 import type { LovelaceCardConfig } from "../../../data/lovelace/config/card";
 import type { LovelaceSectionRawConfig } from "../../../data/lovelace/config/section";
 import type { LovelaceViewConfig } from "../../../data/lovelace/config/view";
 import type { HomeAssistant } from "../../../types";
-import {
-  computeAreaTileCardConfig,
-  getAreas,
-  getFloors,
-} from "../../lovelace/strategies/areas/helpers/areas-strategy-helper";
-import { getHomeStructure } from "../../lovelace/strategies/home/helpers/home-structure";
-import { floorDefaultIcon } from "../../../components/ha-floor-icon";
+import { computeAreaTileCardConfig } from "../../lovelace/strategies/areas/helpers/areas-strategy-helper";
 
 export interface ClimateViewStrategyConfig {
   type: "climate";
@@ -139,9 +135,9 @@ export class ClimateViewStrategy extends ReactiveElement {
     _config: ClimateViewStrategyConfig,
     hass: HomeAssistant
   ): Promise<LovelaceViewConfig> {
-    const areas = getAreas(hass.areas);
-    const floors = getFloors(hass.floors);
-    const home = getHomeStructure(floors, areas);
+    const areas = Object.values(hass.areas);
+    const floors = Object.values(hass.floors);
+    const hierarchy = getAreasFloorHierarchy(floors, areas);
 
     const sections: LovelaceSectionRawConfig[] = [];
 
@@ -153,10 +149,11 @@ export class ClimateViewStrategy extends ReactiveElement {
 
     const entities = findEntities(allEntities, climateFilters);
 
-    const floorCount = home.floors.length + (home.areas.length ? 1 : 0);
+    const floorCount =
+      hierarchy.floors.length + (hierarchy.areas.length ? 1 : 0);
 
     // Process floors
-    for (const floorStructure of home.floors) {
+    for (const floorStructure of hierarchy.floors) {
       const floorId = floorStructure.id;
       const areaIds = floorStructure.areas;
       const floor = hass.floors[floorId];
@@ -185,7 +182,7 @@ export class ClimateViewStrategy extends ReactiveElement {
     }
 
     // Process unassigned areas
-    if (home.areas.length > 0) {
+    if (hierarchy.areas.length > 0) {
       const section: LovelaceSectionRawConfig = {
         type: "grid",
         column_span: 2,
@@ -200,7 +197,7 @@ export class ClimateViewStrategy extends ReactiveElement {
         ],
       };
 
-      const areaCards = processAreasForClimate(home.areas, hass, entities);
+      const areaCards = processAreasForClimate(hierarchy.areas, hass, entities);
 
       if (areaCards.length > 0) {
         section.cards!.push(...areaCards);

src/panels/config/application_credentials/ha-config-application-credentials.ts

@@ -104,7 +104,6 @@ export class HaConfigApplicationCredentials extends LitElement {
           ),
           sortable: true,
           filterable: true,
-          direction: "asc",
         },
         actions: {
           title: "",

src/panels/config/areas/ha-config-areas-dashboard.ts

@@ -2,38 +2,47 @@ import type { ActionDetail } from "@material/mwc-list";
 import {
   mdiDelete,
   mdiDotsVertical,
+  mdiDragHorizontalVariant,
   mdiHelpCircle,
   mdiPencil,
   mdiPlus,
 } from "@mdi/js";
 import {
-  LitElement,
-  type PropertyValues,
-  type TemplateResult,
   css,
   html,
+  LitElement,
   nothing,
+  type PropertyValues,
+  type TemplateResult,
 } from "lit";
 import { customElement, property, state } from "lit/decorators";
 import { styleMap } from "lit/directives/style-map";
 import memoizeOne from "memoize-one";
+import {
+  getAreasFloorHierarchy,
+  getAreasOrder,
+  getFloorOrder,
+  type AreasFloorHierarchy,
+} from "../../../common/areas/areas-floor-hierarchy";
 import { formatListWithAnds } from "../../../common/string/format-list";
 import "../../../components/ha-fab";
 import "../../../components/ha-floor-icon";
 import "../../../components/ha-icon-button";
 import "../../../components/ha-list-item";
 import "../../../components/ha-sortable";
+import type { HaSortableOptions } from "../../../components/ha-sortable";
 import "../../../components/ha-svg-icon";
 import type { AreaRegistryEntry } from "../../../data/area_registry";
 import {
   createAreaRegistryEntry,
+  reorderAreaRegistryEntries,
   updateAreaRegistryEntry,
 } from "../../../data/area_registry";
 import type { FloorRegistryEntry } from "../../../data/floor_registry";
 import {
   createFloorRegistryEntry,
   deleteFloorRegistryEntry,
-  getFloorAreaLookup,
+  reorderFloorRegistryEntries,
   updateFloorRegistryEntry,
 } from "../../../data/floor_registry";
 import {
@@ -42,6 +51,7 @@ import {
 } from "../../../dialogs/generic/show-dialog-box";
 import "../../../layouts/hass-tabs-subpage";
 import type { HomeAssistant, Route } from "../../../types";
+import { showToast } from "../../../util/toast";
 import "../ha-config-section";
 import { configSections } from "../ha-panel-config";
 import {
@@ -52,7 +62,17 @@ import { showFloorRegistryDetailDialog } from "./show-dialog-floor-registry-deta
 
 const UNASSIGNED_FLOOR = "__unassigned__";
 
-const SORT_OPTIONS = { sort: false, delay: 500, delayOnTouchOnly: true };
+const SORT_OPTIONS: HaSortableOptions = {
+  sort: true,
+  delay: 500,
+  delayOnTouchOnly: true,
+};
+
+interface AreaStats {
+  devices: number;
+  services: number;
+  entities: number;
+}
 
 @customElement("ha-config-areas-dashboard")
 export class HaConfigAreasDashboard extends LitElement {
@@ -64,55 +84,50 @@ export class HaConfigAreasDashboard extends LitElement {
 
   @property({ attribute: false }) public route!: Route;
 
-  @state() private _areas: AreaRegistryEntry[] = [];
+  @state() private _hierarchy?: AreasFloorHierarchy;
 
-  private _processAreas = memoizeOne(
+  private _blockHierarchyUpdate = false;
+
+  private _blockHierarchyUpdateTimeout?: number;
+
+  private _processAreasStats = memoizeOne(
     (
-      areas: AreaRegistryEntry[],
+      areas: HomeAssistant["areas"],
       devices: HomeAssistant["devices"],
-      entities: HomeAssistant["entities"],
-      floors: HomeAssistant["floors"]
-    ) => {
-      const processArea = (area: AreaRegistryEntry) => {
-        let noDevicesInArea = 0;
-        let noServicesInArea = 0;
-        let noEntitiesInArea = 0;
+      entities: HomeAssistant["entities"]
+    ): Map<string, AreaStats> => {
+      const computeAreaStats = (area: AreaRegistryEntry) => {
+        let devicesCount = 0;
+        let servicesCount = 0;
+        let entitiesCount = 0;
 
         for (const device of Object.values(devices)) {
           if (device.area_id === area.area_id) {
             if (device.entry_type === "service") {
-              noServicesInArea++;
+              servicesCount++;
             } else {
-              noDevicesInArea++;
+              devicesCount++;
             }
           }
         }
 
         for (const entity of Object.values(entities)) {
           if (entity.area_id === area.area_id) {
-            noEntitiesInArea++;
+            entitiesCount++;
           }
         }
 
         return {
-          ...area,
-          devices: noDevicesInArea,
-          services: noServicesInArea,
-          entities: noEntitiesInArea,
+          devices: devicesCount,
+          services: servicesCount,
+          entities: entitiesCount,
         };
       };
-
-      const floorAreaLookup = getFloorAreaLookup(areas);
-      const unassignedAreas = areas.filter(
-        (area) => !area.floor_id || !floorAreaLookup[area.floor_id]
-      );
-      return {
-        floors: Object.values(floors).map((floor) => ({
-          ...floor,
-          areas: (floorAreaLookup[floor.floor_id] || []).map(processArea),
-        })),
-        unassignedAreas: unassignedAreas.map(processArea),
-      };
+      const areaStats = new Map<string, AreaStats>();
+      Object.values(areas).forEach((area) => {
+        areaStats.set(area.area_id, computeAreaStats(area));
+      });
+      return areaStats;
     }
   );
 
@@ -120,25 +135,32 @@ export class HaConfigAreasDashboard extends LitElement {
     super.willUpdate(changedProperties);
     if (changedProperties.has("hass")) {
       const oldHass = changedProperties.get("hass");
-      if (this.hass.areas !== oldHass?.areas) {
-        this._areas = Object.values(this.hass.areas);
+      if (
+        (this.hass.areas !== oldHass?.areas ||
+          this.hass.floors !== oldHass?.floors) &&
+        !this._blockHierarchyUpdate
+      ) {
+        this._computeHierarchy();
       }
     }
   }
 
-  protected render(): TemplateResult {
-    const areasAndFloors =
-      !this.hass.areas ||
-      !this.hass.devices ||
-      !this.hass.entities ||
-      !this.hass.floors
-        ? undefined
-        : this._processAreas(
-            this._areas,
-            this.hass.devices,
-            this.hass.entities,
-            this.hass.floors
-          );
+  private _computeHierarchy() {
+    this._hierarchy = getAreasFloorHierarchy(
+      Object.values(this.hass.floors),
+      Object.values(this.hass.areas)
+    );
+  }
+
+  protected render(): TemplateResult<1> | typeof nothing {
+    if (!this._hierarchy) {
+      return nothing;
+    }
+    const areasStats = this._processAreasStats(
+      this.hass.areas,
+      this.hass.devices,
+      this.hass.entities
+    );
 
     return html`
       <hass-tabs-subpage
@@ -157,81 +179,120 @@ export class HaConfigAreasDashboard extends LitElement {
           @click=${this._showHelp}
         ></ha-icon-button>
         <div class="container">
-          ${areasAndFloors?.floors.map(
-            (floor) =>
-              html`<div class="floor">
-                <div class="header">
-                  <h2>
-                    <ha-floor-icon .floor=${floor}></ha-floor-icon>
-                    ${floor.name}
-                  </h2>
-                  <ha-button-menu
-                    .floor=${floor}
-                    @action=${this._handleFloorAction}
+          <ha-sortable
+            handle-selector=".handle"
+            draggable-selector=".floor"
+            @item-moved=${this._floorMoved}
+            .options=${SORT_OPTIONS}
+            group="floors"
+            invert-swap
+          >
+            <div class="floors">
+              ${this._hierarchy.floors.map(({ areas, id }) => {
+                const floor = this.hass.floors[id];
+                if (!floor) {
+                  return nothing;
+                }
+                return html`
+                  <div class="floor">
+                    <div class="header">
+                      <h2>
+                        <ha-floor-icon .floor=${floor}></ha-floor-icon>
+                        ${floor.name}
+                      </h2>
+                      <div class="actions">
+                        <ha-svg-icon
+                          class="handle"
+                          .path=${mdiDragHorizontalVariant}
+                        ></ha-svg-icon>
+                        <ha-button-menu
+                          .floor=${floor}
+                          @action=${this._handleFloorAction}
+                        >
+                          <ha-icon-button
+                            slot="trigger"
+                            .path=${mdiDotsVertical}
+                          ></ha-icon-button>
+                          <ha-list-item graphic="icon"
+                            ><ha-svg-icon
+                              .path=${mdiPencil}
+                              slot="graphic"
+                            ></ha-svg-icon
+                            >${this.hass.localize(
+                              "ui.panel.config.areas.picker.floor.edit_floor"
+                            )}</ha-list-item
+                          >
+                          <ha-list-item class="warning" graphic="icon"
+                            ><ha-svg-icon
+                              class="warning"
+                              .path=${mdiDelete}
+                              slot="graphic"
+                            ></ha-svg-icon
+                            >${this.hass.localize(
+                              "ui.panel.config.areas.picker.floor.delete_floor"
+                            )}</ha-list-item
+                          >
+                        </ha-button-menu>
+                      </div>
+                    </div>
+                    <ha-sortable
+                      handle-selector="a"
+                      draggable-selector="a"
+                      @item-added=${this._areaAdded}
+                      @item-moved=${this._areaMoved}
+                      group="areas"
+                      .options=${SORT_OPTIONS}
+                      .floor=${floor.floor_id}
+                    >
+                      <div class="areas">
+                        ${areas.map((areaId) => {
+                          const area = this.hass.areas[areaId];
+                          if (!area) {
+                            return nothing;
+                          }
+                          const stats = areasStats.get(area.area_id);
+                          return this._renderArea(area, stats);
+                        })}
+                      </div>
+                    </ha-sortable>
+                  </div>
+                `;
+              })}
+            </div>
+          </ha-sortable>
+
+          ${this._hierarchy.areas.length
+            ? html`
+                <div class="floor">
+                  <div class="header">
+                    <h2>
+                      ${this.hass.localize(
+                        "ui.panel.config.areas.picker.unassigned_areas"
+                      )}
+                    </h2>
+                  </div>
+                  <ha-sortable
+                    handle-selector="a"
+                    draggable-selector="a"
+                    @item-added=${this._areaAdded}
+                    @item-moved=${this._areaMoved}
+                    group="areas"
+                    .options=${SORT_OPTIONS}
+                    .floor=${UNASSIGNED_FLOOR}
                   >
-                    <ha-icon-button
-                      slot="trigger"
-                      .path=${mdiDotsVertical}
-                    ></ha-icon-button>
-                    <ha-list-item graphic="icon"
-                      ><ha-svg-icon
-                        .path=${mdiPencil}
-                        slot="graphic"
-                      ></ha-svg-icon
-                      >${this.hass.localize(
-                        "ui.panel.config.areas.picker.floor.edit_floor"
-                      )}</ha-list-item
-                    >
-                    <ha-list-item class="warning" graphic="icon"
-                      ><ha-svg-icon
-                        class="warning"
-                        .path=${mdiDelete}
-                        slot="graphic"
-                      ></ha-svg-icon
-                      >${this.hass.localize(
-                        "ui.panel.config.areas.picker.floor.delete_floor"
-                      )}</ha-list-item
-                    >
-                  </ha-button-menu>
+                    <div class="areas">
+                      ${this._hierarchy.areas.map((areaId) => {
+                        const area = this.hass.areas[areaId];
+                        if (!area) {
+                          return nothing;
+                        }
+                        const stats = areasStats.get(area.area_id);
+                        return this._renderArea(area, stats);
+                      })}
+                    </div>
+                  </ha-sortable>
                 </div>
-                <ha-sortable
-                  handle-selector="a"
-                  draggable-selector="a"
-                  @item-added=${this._areaAdded}
-                  group="floor"
-                  .options=${SORT_OPTIONS}
-                  .floor=${floor.floor_id}
-                >
-                  <div class="areas">
-                    ${floor.areas.map((area) => this._renderArea(area))}
-                  </div>
-                </ha-sortable>
-              </div>`
-          )}
-          ${areasAndFloors?.unassignedAreas.length
-            ? html`<div class="floor">
-                <div class="header">
-                  <h2>
-                    ${this.hass.localize(
-                      "ui.panel.config.areas.picker.unassigned_areas"
-                    )}
-                  </h2>
-                </div>
-                <ha-sortable
-                  handle-selector="a"
-                  draggable-selector="a"
-                  @item-added=${this._areaAdded}
-                  group="floor"
-                  .options=${SORT_OPTIONS}
-                  .floor=${UNASSIGNED_FLOOR}
-                >
-                  <div class="areas">
-                    ${areasAndFloors?.unassignedAreas.map((area) =>
-                      this._renderArea(area)
-                    )}
-                  </div>
-                </ha-sortable>
-              </div>`
+              `
             : nothing}
         </div>
         <ha-fab
@@ -259,56 +320,60 @@ export class HaConfigAreasDashboard extends LitElement {
     `;
   }
 
-  private _renderArea(area) {
-    return html`<a
-      href=${`/config/areas/area/${area.area_id}`}
-      .sortableData=${area}
-    >
-      <ha-card outlined>
-        <div
-          style=${styleMap({
-            backgroundImage: area.picture ? `url(${area.picture})` : undefined,
-          })}
-          class="picture ${!area.picture ? "placeholder" : ""}"
-        >
-          ${!area.picture && area.icon
-            ? html`<ha-icon .icon=${area.icon}></ha-icon>`
-            : ""}
-        </div>
-        <div class="card-header">
-          ${area.name}
-          <ha-icon-button
-            .area=${area}
-            .path=${mdiPencil}
-            @click=${this._openAreaDetails}
-          ></ha-icon-button>
-        </div>
-        <div class="card-content">
-          <div>
-            ${formatListWithAnds(
-              this.hass.locale,
-              [
-                area.devices &&
-                  this.hass.localize(
-                    "ui.panel.config.integrations.config_entry.devices",
-                    { count: area.devices }
-                  ),
-                area.services &&
-                  this.hass.localize(
-                    "ui.panel.config.integrations.config_entry.services",
-                    { count: area.services }
-                  ),
-                area.entities &&
-                  this.hass.localize(
-                    "ui.panel.config.integrations.config_entry.entities",
-                    { count: area.entities }
-                  ),
-              ].filter((v): v is string => Boolean(v))
-            )}
+  private _renderArea(
+    area: AreaRegistryEntry,
+    stats: AreaStats | undefined
+  ): TemplateResult<1> {
+    return html`
+      <a href=${`/config/areas/area/${area.area_id}`} .sortableData=${area}>
+        <ha-card outlined>
+          <div
+            style=${styleMap({
+              backgroundImage: area.picture
+                ? `url(${area.picture})`
+                : undefined,
+            })}
+            class="picture ${!area.picture ? "placeholder" : ""}"
+          >
+            ${!area.picture && area.icon
+              ? html`<ha-icon .icon=${area.icon}></ha-icon>`
+              : ""}
           </div>
-        </div>
-      </ha-card>
-    </a>`;
+          <div class="card-header">
+            ${area.name}
+            <ha-icon-button
+              .area=${area}
+              .path=${mdiPencil}
+              @click=${this._openAreaDetails}
+            ></ha-icon-button>
+          </div>
+          <div class="card-content">
+            <div>
+              ${formatListWithAnds(
+                this.hass.locale,
+                [
+                  stats?.devices &&
+                    this.hass.localize(
+                      "ui.panel.config.integrations.config_entry.devices",
+                      { count: stats.devices }
+                    ),
+                  stats?.services &&
+                    this.hass.localize(
+                      "ui.panel.config.integrations.config_entry.services",
+                      { count: stats.services }
+                    ),
+                  stats?.entities &&
+                    this.hass.localize(
+                      "ui.panel.config.integrations.config_entry.entities",
+                      { count: stats.entities }
+                    ),
+                ].filter((v): v is string => Boolean(v))
+              )}
+            </div>
+          </div>
+        </ha-card>
+      </a>
+    `;
   }
 
   protected firstUpdated(changedProps) {
@@ -326,24 +391,170 @@ export class HaConfigAreasDashboard extends LitElement {
     });
   }
 
+  private async _floorMoved(ev) {
+    ev.stopPropagation();
+    if (!this.hass || !this._hierarchy) {
+      return;
+    }
+    const { oldIndex, newIndex } = ev.detail;
+
+    const reorderFloors = (
+      floors: AreasFloorHierarchy["floors"],
+      oldIdx: number,
+      newIdx: number
+    ) => {
+      const newFloors = [...floors];
+      const [movedFloor] = newFloors.splice(oldIdx, 1);
+      newFloors.splice(newIdx, 0, movedFloor);
+      return newFloors;
+    };
+
+    // Optimistically update UI
+    this._hierarchy = {
+      ...this._hierarchy,
+      floors: reorderFloors(this._hierarchy.floors, oldIndex, newIndex),
+    };
+
+    const areaOrder = getAreasOrder(this._hierarchy);
+    const floorOrder = getFloorOrder(this._hierarchy);
+
+    // Block hierarchy updates for 500ms to avoid flickering
+    // because of multiple async updates
+    this._blockHierarchyUpdateFor(500);
+
+    try {
+      await reorderAreaRegistryEntries(this.hass, areaOrder);
+      await reorderFloorRegistryEntries(this.hass, floorOrder);
+    } catch {
+      showToast(this, {
+        message: this.hass.localize(
+          "ui.panel.config.areas.picker.floor_reorder_failed"
+        ),
+      });
+      // Revert on error
+      this._computeHierarchy();
+    }
+  }
+
+  private async _areaMoved(ev) {
+    ev.stopPropagation();
+    if (!this.hass || !this._hierarchy) {
+      return;
+    }
+    const { floor } = ev.currentTarget;
+    const { oldIndex, newIndex } = ev.detail;
+
+    const floorId = floor === UNASSIGNED_FLOOR ? null : floor;
+
+    // Reorder areas within the same floor
+    const reorderAreas = (areas: string[], oldIdx: number, newIdx: number) => {
+      const newAreas = [...areas];
+      const [movedArea] = newAreas.splice(oldIdx, 1);
+      newAreas.splice(newIdx, 0, movedArea);
+      return newAreas;
+    };
+
+    // Optimistically update UI
+    this._hierarchy = {
+      ...this._hierarchy,
+      floors: this._hierarchy.floors.map((f) => {
+        if (f.id === floorId) {
+          return {
+            ...f,
+            areas: reorderAreas(f.areas, oldIndex, newIndex),
+          };
+        }
+        return f;
+      }),
+      areas:
+        floorId === null
+          ? reorderAreas(this._hierarchy.areas, oldIndex, newIndex)
+          : this._hierarchy.areas,
+    };
+
+    const areaOrder = getAreasOrder(this._hierarchy);
+
+    try {
+      await reorderAreaRegistryEntries(this.hass, areaOrder);
+    } catch {
+      showToast(this, {
+        message: this.hass.localize(
+          "ui.panel.config.areas.picker.area_move_failed"
+        ),
+      });
+      // Revert on error
+      this._computeHierarchy();
+    }
+  }
+
   private async _areaAdded(ev) {
     ev.stopPropagation();
+    if (!this.hass || !this._hierarchy) {
+      return;
+    }
     const { floor } = ev.currentTarget;
+    const { data: area, index } = ev.detail;
 
     const newFloorId = floor === UNASSIGNED_FLOOR ? null : floor;
 
-    const { data: area } = ev.detail;
+    // Insert area at the specified index
+    const insertAtIndex = (areas: string[], areaId: string, idx: number) => {
+      const newAreas = [...areas];
+      newAreas.splice(idx, 0, areaId);
+      return newAreas;
+    };
 
-    this._areas = this._areas.map<AreaRegistryEntry>((a) => {
-      if (a.area_id === area.area_id) {
-        return { ...a, floor_id: newFloorId };
-      }
-      return a;
-    });
+    // Optimistically update UI
+    this._hierarchy = {
+      ...this._hierarchy,
+      floors: this._hierarchy.floors.map((f) => {
+        if (f.id === newFloorId) {
+          return {
+            ...f,
+            areas: insertAtIndex(f.areas, area.area_id, index),
+          };
+        }
+        return {
+          ...f,
+          areas: f.areas.filter((id) => id !== area.area_id),
+        };
+      }),
+      areas:
+        newFloorId === null
+          ? insertAtIndex(this._hierarchy.areas, area.area_id, index)
+          : this._hierarchy.areas.filter((id) => id !== area.area_id),
+    };
 
-    await updateAreaRegistryEntry(this.hass, area.area_id, {
-      floor_id: newFloorId,
-    });
+    const areaOrder = getAreasOrder(this._hierarchy);
+
+    // Block hierarchy updates for 500ms to avoid flickering
+    // because of multiple async updates
+    this._blockHierarchyUpdateFor(500);
+
+    try {
+      await reorderAreaRegistryEntries(this.hass, areaOrder);
+      await updateAreaRegistryEntry(this.hass, area.area_id, {
+        floor_id: newFloorId,
+      });
+    } catch {
+      showToast(this, {
+        message: this.hass.localize(
+          "ui.panel.config.areas.picker.area_move_failed"
+        ),
+      });
+      // Revert on error
+      this._computeHierarchy();
+    }
+  }
+
+  private _blockHierarchyUpdateFor(time: number) {
+    this._blockHierarchyUpdate = true;
+    if (this._blockHierarchyUpdateTimeout) {
+      window.clearTimeout(this._blockHierarchyUpdateTimeout);
+    }
+    this._blockHierarchyUpdateTimeout = window.setTimeout(() => {
+      this._blockHierarchyUpdate = false;
+    }, time);
   }
 
   private _handleFloorAction(ev: CustomEvent<ActionDetail>) {
@@ -463,6 +674,10 @@ export class HaConfigAreasDashboard extends LitElement {
     .header ha-icon {
       margin-inline-end: 8px;
     }
+    .header .actions {
+      display: flex;
+      align-items: center;
+    }
     .areas {
       display: grid;
       grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
@@ -473,6 +688,10 @@ export class HaConfigAreasDashboard extends LitElement {
     .areas > * {
       max-width: 500px;
     }
+    .handle {
+      cursor: move; /* fallback if grab cursor is unsupported */
+      cursor: grab;
+    }
     ha-card {
       overflow: hidden;
     }

src/panels/config/automation/action/ha-automation-action.ts

@@ -14,11 +14,13 @@ import "../../../../components/ha-sortable";
 import "../../../../components/ha-svg-icon";
 import {
   ACTION_BUILDING_BLOCKS,
-  getService,
-  isService,
   VIRTUAL_ACTIONS,
 } from "../../../../data/action";
-import type { AutomationClipboard } from "../../../../data/automation";
+import {
+  getValueFromDynamic,
+  isDynamic,
+  type AutomationClipboard,
+} from "../../../../data/automation";
 import type { Action } from "../../../../data/script";
 import type { HomeAssistant } from "../../../../types";
 import {
@@ -217,9 +219,9 @@ export default class HaAutomationAction extends LitElement {
       actions = this.actions.concat(deepClone(this._clipboard!.action));
     } else if (action in VIRTUAL_ACTIONS) {
       actions = this.actions.concat(VIRTUAL_ACTIONS[action]);
-    } else if (isService(action)) {
+    } else if (isDynamic(action)) {
       actions = this.actions.concat({
-        action: getService(action),
+        action: getValueFromDynamic(action),
         metadata: {},
       });
     } else {