Test engine selection and the Leaflet fallback

jsdom has no WebGL2, so the existing ha-map tests only ever run Leaflet.
With the WebGL2 probe stubbed and the MapLibre engine replaced by a fake,
this covers the runtime choice: MapLibre with WebGL2, Leaflet without it,
Leaflet after MapLibre fails to start, and a rebuild on Leaflet with the
entities redrawn after a fatal engine event.

.agents/skills/ha-frontend-components/SKILL.md

@@ -7,6 +7,8 @@ description: Home Assistant frontend component patterns. Use when implementing o
 
 Use this skill when creating or reviewing Home Assistant UI components and common interaction patterns.
 
+Cross-load `ha-frontend-events` when component work includes event listener typing, custom event dispatch, or event-map declarations.
+
 ## Dialogs
 
 Open dialogs through the fire-event pattern:

.agents/skills/ha-frontend-events/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: ha-frontend-events
+description: Home Assistant frontend event patterns. Use when typing event handlers, using HASSDomEvent types, dispatching with fireEvent, or declaring HASSDomEvents and event maps.
+---
+
+# HA Frontend Events
+
+Use this skill when implementing or reviewing event listeners and custom event contracts. Cross-load `ha-frontend-components` when the work also involves dialogs, forms, alerts, shortcuts, tooltips, panels, Lovelace cards, or buttons.
+
+## Event Handling
+
+Use the event types from `src/common/dom/fire_event.ts` instead of plain `Event`, generic `CustomEvent`, or element casts when they express the handler contract:
+
+- Use `HASSDomCurrentTargetEvent<T>` to read the element on which the listener was registered through `ev.currentTarget`.
+- Use `HASSDomTargetEvent<T>` only to read the element that originated the event through `ev.target`.
+- Use `HASSDomEvent<T>` to read a custom event payload through `ev.detail`.
+- Use `ValueChangedEvent<T>` from `src/types.ts` for the standard `value-changed` event.
+- Prefer an event type exported by the component being listened to, such as `HaSelectSelectEvent<T, Clearable>` or `HaDropdownSelectEvent<TValue, TData>`, over reconstructing its detail type.
+- Use `ActionHandlerEvent` from `src/data/lovelace/action_handler.ts` for Lovelace tap, hold, and double-tap handlers.
+
+Import event and element types with `import type`:
+
+```ts
+import type {
+  HASSDomCurrentTargetEvent,
+  HASSDomEvent,
+  HASSDomTargetEvent,
+} from "../common/dom/fire_event";
+import type { HaCheckbox } from "../components/ha-checkbox";
+import type { HaEntityPicker } from "../components/entity/ha-entity-picker";
+import type { HaRadioGroup } from "../components/radio/ha-radio-group";
+import type { ValueChangedEvent } from "../types";
+```
+
+Type the handler so the selected property can be read directly. Do not cast `ev.currentTarget` or assign it to a single-use variable:
+
+```ts
+private _scopeChanged(ev: HASSDomCurrentTargetEvent<HaRadioGroup>): void {
+  this._scope = ev.currentTarget.value;
+}
+
+private _checkedChanged(ev: HASSDomTargetEvent<HaCheckbox>): void {
+  this._checked = ev.target.checked;
+}
+
+private _valueChanged(ev: ValueChangedEvent<string>): void {
+  this._value = ev.detail.value;
+}
+
+private _itemSelected(ev: HASSDomEvent<{ id: string }>): void {
+  this._selectedId = ev.detail.id;
+}
+```
+
+Use intersections when a handler needs more than one facet of an event. Keep the native event type when the handler reads native fields such as `key`, modifier keys, `dataTransfer`, or focus relationships:
+
+```ts
+private _entityChanged(
+  ev: ValueChangedEvent<string> & HASSDomCurrentTargetEvent<HaEntityPicker>
+): void {
+  ev.currentTarget.value = ev.detail.value;
+}
+
+private _keyDown(
+  ev: KeyboardEvent & HASSDomCurrentTargetEvent<HTMLInputElement>
+): void {
+  if (ev.key === "Enter") {
+    this._submit(ev.currentTarget.value);
+  }
+}
+```
+
+Dispatch Home Assistant component events with `fireEvent()` instead of constructing `Event` or `CustomEvent` directly. Register the event name and detail type by augmenting `HASSDomEvents`; use `undefined` when an event has no detail. `fireEvent()` constrains event names and supplied detail, and events bubble and cross shadow boundaries by default:
+
+```ts
+fireEvent(this, "item-selected", { id: item.id });
+fireEvent(this, "refresh-requested");
+```
+
+When an event is already registered, derive handler and listener types from its registration rather than repeating the payload shape:
+
+```ts
+private _itemSelected(
+  ev: HASSDomEvent<HASSDomEvents["item-selected"]>
+): void {
+  this._selectedId = ev.detail.id;
+}
+```
+
+`HASSDomEvents` types `fireEvent()` calls. Augment `HTMLElementEventMap` for typed listeners on HTML elements, or `GlobalEventHandlersEventMap` when the event is handled on global event targets.
+
+In component files, prefer placing global event declarations after the class at the bottom of the file. Preserve the existing placement when editing established files; foundational type, helper, and mixin files commonly keep declarations near the top before their consumers.
+
+```ts
+declare global {
+  interface HASSDomEvents {
+    "item-selected": { id: string };
+    "refresh-requested": undefined;
+  }
+
+  interface HTMLElementEventMap {
+    "item-selected": HASSDomEvent<HASSDomEvents["item-selected"]>;
+  }
+}
+```

.agents/skills/ha-frontend-lit/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: ha-frontend-lit
+description: Home Assistant frontend Lit conventions. Use when working with reactive properties, internal state, DOM queries, lifecycle methods, or render-derived state.
+---
+
+# HA Frontend Lit
+
+Use this skill when implementing or reviewing Lit component state, DOM access, lifecycle methods, or rendering behavior. Cross-load `ha-frontend-types` for Home Assistant data contracts, assertions, and lifecycle parameter types.
+
+## Reactive Fields
+
+This project currently uses Lit's TypeScript experimental decorators with `useDefineForClassFields: false`. Match existing declarations and do not introduce standard-decorator `accessor` syntax unless the project changes decorator mode.
+
+- Use `@property()` for public reactive API and `@state()` for private reactive state.
+- Prefer inferred types for initialized reactive fields when inference preserves the intended type; annotate when widening or an external contract requires it.
+
+## DOM Queries
+
+Prefer Lit's `@query()` or `@queryAll()` decorators for fixed selectors in the component's render root.
+
+- Type the decorated field with the narrowest useful DOM or component interface.
+- Keep the field optional when it may be absent at the point of access, including conditional rendering or pre-render lifecycle access.
+- Use a definite assignment assertion only when every call site runs after the node is guaranteed to exist.
+- The optional second argument to `@query()`, as in `@query("#target", true)`, caches the first query result. Use it only when later renders cannot replace the queried node.
+- Use a direct query when the selector is dynamic or the target is outside the component's render root. Before querying a child, consider whether the required value belongs in parent state or data flow.
+
+## Render-Derived State
+
+- Prefer render-local values for inexpensive structures used only by that render.
+- Assign a render-local value once when repeated evaluation is non-trivial or a local name improves clarity.
+- Keep purely presentational derivations in `render()`. Use stored state or `willUpdate()` when the value must participate in lifecycle work, reflection, CSS, or non-render consumers.
+- Use `memoizeOne` for pure, argument-derived transforms when stable input identity avoids meaningful repeated work. Keep inputs explicit and limited, and do not add caching without a credible benefit over computing the value directly.
+
+## References
+
+- [Reactive properties](https://lit.dev/docs/components/properties/)
+- [Decorators](https://lit.dev/docs/components/decorators/)
+- [Shadow DOM queries](https://lit.dev/docs/components/shadow-dom/#query)
+- [Reactive update cycle](https://lit.dev/docs/components/lifecycle/)

.agents/skills/ha-frontend-review/SKILL.md

@@ -22,7 +22,7 @@ When creating a pull request, use `.github/PULL_REQUEST_TEMPLATE.md` as the body
 
 - `yarn lint` passes when practical for the scope.
 - `yarn test` or focused relevant tests are green when practical for the scope.
-- Tests are added or updated for new data processing and utilities where applicable.
+- Each test added by the change protects real logic, not the look of a component.
 - User-facing text is localized and follows `ha-frontend-user-facing-text` guidance.
 - Components handle loading, error, unavailable, and missing-entity states.
 - Entity existence is checked before property access.
@@ -31,6 +31,33 @@ When creating a pull request, use `.github/PULL_REQUEST_TEMPLATE.md` as the body
 
 ## Recurring Review Issues
 
+Scope and public surface:
+
+- Keep changes independently reviewable and limited to the requested area.
+- Prefer existing Home Assistant helpers, Lit primitives, and component seams over parallel implementations.
+- Challenge new public properties and optional feature surface when transient options or existing seams meet the requirement with less lifecycle and consistency cost.
+
+Stateful and asynchronous UI:
+
+- Review transitions in both directions, not only individual rendered states.
+- When controls reappear, restore valid defaults instead of retaining state that was only valid while they were hidden.
+- Establish immutable dirty-state baselines before asynchronous work, guard against stale responses, and preserve unsaved state in mounted editors.
+- Determine an action's current meaning before applying dirty-state checks, especially when an action can change between Save and Close.
+
+Readiness and invalidation:
+
+- Treat readiness as the first displayable terminal result, including stable empty and error states.
+- Register child readiness before resolving the parent, do not treat fallback work as terminal, and replay readiness correctly for cached or reused panels.
+- Ensure every value read by memoized output participates in its invalidation.
+
+Repository-owned contracts:
+
+- Consult the public [frontend developer documentation](https://developers.home-assistant.io/docs/frontend/) for documented architecture, data flow, design, and development workflows.
+- For new leaf components, load `ha-frontend-contexts` and verify they consume narrow contexts instead of introducing a broad `hass` property; containers and external APIs may still require `hass`.
+- Verify backend assumptions against the owning Core, Supervisor, or WebSocket implementation, and component assumptions against the exported component contract.
+- Prefer canonical repository helpers and test setup over duplicate local implementations.
+- Promote AI-review concerns into durable guidance only when supported by code evidence, reproduced behavior, an accepted corrective commit, or human-maintainer validation.
+
 User experience and accessibility:
 
 - Forms need proper labels, helper text, and validation feedback.
@@ -70,4 +97,4 @@ Configuration and props:
 - Identify behavioral regressions, bugs, accessibility issues, and missing tests first.
 - Keep style-only comments secondary unless they affect maintainability or user experience.
 - Prefer small, direct fixes over large refactors during review follow-up.
-- Cross-load `ha-frontend-contexts`, `ha-frontend-components`, `ha-frontend-styling`, `ha-frontend-testing`, or `ha-frontend-user-facing-text` when a finding falls in that area.
+- Load the matching `ha-frontend-*` skill when a finding falls within its area.

.agents/skills/ha-frontend-testing/SKILL.md

@@ -20,6 +20,7 @@ yarn lint          # ESLint + Prettier + TypeScript + Lit
 yarn format        # Auto-fix ESLint + Prettier
 yarn lint:types    # TypeScript compiler, run without file arguments
 yarn test          # Vitest
+yarn build         # Full production build
 yarn dev           # App dev server
 yarn dev:serve     # Local serving dev server
 ```
@@ -28,12 +29,33 @@ Never run `tsc` or `yarn lint:types` with file arguments. File arguments make `t
 
 For focused type feedback on one file, use editor diagnostics instead of a file-scoped `tsc` command.
 
-## Unit And Utility Tests
+## Production Builds
 
-- Add or update Vitest tests for data processing, utility code, and behavior that can be tested without a browser.
-- Mock WebSocket connections and API calls at boundaries.
-- Cover loading, error, unavailable, and missing-entity states where relevant.
-- Test accessibility-sensitive behavior when it can be asserted without brittle DOM internals.
+Production builds support foreground and managed background execution:
+
+```bash
+yarn build                         # Full foreground build
+yarn build --background            # Full managed background build
+yarn build --modern                # Modern frontend_latest bundle only
+yarn build --modern --background   # Modern managed background build
+yarn build --status
+yarn build --logs [--follow]
+yarn build --stop
+```
+
+Use `yarn build --modern --background` for production bundle-size or browser performance comparisons that only need modern browser output. It runs the normal metadata and static preparation, minifies and compresses the modern `frontend_latest` bundle and shared static assets, and generates modern-only entry pages and service workers. It deliberately skips the legacy bundle and its service worker.
+
+Do not pass `--help`, `--background`, or `--modern` to `script/build_frontend`; that raw script does not parse arguments and always starts the full foreground build. Use `yarn build` for managed builds. App builds and development servers keep exclusive ownership of `hass_frontend/` for their lifetime.
+
+Managed app, demo, gallery, and E2E app workflows share one lifetime lock, so only one build or development server can run at a time.
+
+## When To Add Tests
+
+- Write tests for code that computes something: data processing, utility functions, config validation, and what happens when the user interacts with a component.
+- Do not write tests that check what a component looks like: its text, CSS classes, styles, or slots. Do not write tests that check the default value of an option.
+- A component that only takes data from contexts and helpers and puts it in a template does not need a test.
+- If you are not sure a test is useful, describe the test and what it would catch, and let the user decide.
+- Tests never talk to a real Home Assistant. Replace `callWS`, `callApi`, and the connection with fakes.
 
 ## Dev Servers
 
@@ -41,7 +63,7 @@ For focused type feedback on one file, use editor diagnostics instead of a file-
 
 `yarn dev:serve` also serves locally and supports `-c` for the core URL and `-p` for the port. The default is 8124, or 8123 in a devcontainer.
 
-Dev server commands support `--background`, `--status`, `--stop`, and `--logs [--follow]`. Prefer managed background mode while iterating so the watcher stays available across test runs without occupying the terminal.
+Dev server commands support `--background`, `--status`, `--stop`, and `--logs [--follow]`. `yarn dev`, `yarn dev:serve`, `yarn dev:demo`, and `yarn dev:gallery` also support `--fetch-translations`; this runs translation fetching, including first-time GitHub device authentication, under the workflow lock before starting the watcher. It works in foreground and background modes. Prefer managed background mode while iterating so the watcher stays available across test runs without occupying the terminal. `yarn dev` and `yarn dev:serve` share one managed process slot because both write the app output.
 
 ## Playwright E2E
 
@@ -59,7 +81,7 @@ The custom development wrappers use `/__ha_dev_status` to identify and manage th
 
 Local runs against a watched development server do not always match CI's clean build artifacts, environment, sharding, or worker configuration. Use background servers for the fast iteration loop, but confirm the relevant CI jobs complete successfully before considering E2E changes verified.
 
-Use `-g "<title>" --project=chromium` to narrow a run. `yarn test:e2e` runs all three suites in parallel when every managed server is available, otherwise it runs them sequentially to prevent cold builds racing over shared generated assets. Run suites directly; piping through output truncation hides progress and failures.
+Use `-g "<title>" --project=chromium` to narrow a run. `yarn test:e2e` runs suites sequentially when managed servers are unavailable to prevent cold builds racing over shared generated assets. Run suites directly; piping through output truncation hides progress and failures.
 
 The app suite uses a stripped-down harness for e2e. Demo and gallery use their normal dev servers.
 

.agents/skills/ha-frontend-types/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: ha-frontend-types
+description: Home Assistant frontend TypeScript conventions. Use when defining or reviewing backend data contracts, optional schemas, shared types, assertions, or Lit lifecycle types.
+---
+
+# HA Frontend Types
+
+Use this skill for Home Assistant-specific TypeScript contracts and type choices.
+
+## Home Assistant Data Contracts
+
+Verify data contracts against the source that owns them, such as Home Assistant Core, Supervisor, a WebSocket handler, or an exported component type. Do not shape a type around assumptions made by its current frontend consumers.
+
+- Match required, optional, nullable, and defaulted fields to the producer and runtime contract. Preserve optional configuration fields when omission is supported and has defined behavior.
+- Use distinct request and response types when their wire shapes differ.
+- When changing a shared contract, check affected consumers, tests, fixtures, and mocks.
+
+## Reuse Home Assistant Contracts
+
+- Reuse the canonical Home Assistant type when one exists. Define shared contract types in the data or API module that owns them.
+- Reuse types exported by components and helpers rather than reconstructing their payloads. For event types, follow `ha-frontend-events`.
+- When one domain contract is used across modules, define and export it from the module that owns that contract.
+
+Prefer an existing owning contract. Introduce a frontend-specific type when the frontend shape or boundary genuinely differs.
+
+## Assertions
+
+Prefer accurate types and runtime narrowing. Use assertions or TypeScript suppressions at boundaries where the runtime invariant is understood but cannot be expressed cleanly; keep them narrow and explain non-obvious invariants.
+
+## Lit Lifecycle Types
+
+For Lit lifecycle methods that receive changed properties, use `PropertyValues<this>` when the method only needs public reactive properties:
+
+```ts
+protected willUpdate(changedProperties: PropertyValues<this>) {
+  // ...
+}
+```
+
+Use unparameterized `PropertyValues` when the method inspects private or protected reactive properties, which are not keys of `this`. Do not add assertions solely to retain `PropertyValues<this>`.
+
+## Enforced Baseline
+
+Use `import type` for type-only imports. This is enforced by the repository ESLint configuration.

.browserslistrc

@@ -1,36 +1,52 @@
 [modern]
 # Modern builds target recent browsers supporting the latest features to minimize transpilation, polyfills, etc.
 # It is served to browsers meeting the following requirements:
-# - released in the last year + current alpha/beta versions
-# - Firefox extended support release (ESR)
-# - with global utilization at or above 0.5%
+# - released in the last 2 years + current alpha/beta versions
 # - exclude dead browsers (no security maintenance for 2+ years)
-# - exclude KaiOS, QQ, and UC browsers due to lack of sufficient feature support data
+# - exclude QQ, and UC browsers due to lack of sufficient feature support data
 unreleased versions
-last 1 year
-Firefox ESR
->= 0.5%
+last 2 years
 not dead
-not KaiOS > 0
 not QQAndroid > 0
 not UCAndroid > 0
 
 [legacy]
-# Legacy builds are served when modern requirements are not met and support browsers:
-# - released in the last 7 years + current alpha/beta versionss
-# - with global utilization at or above 0.05%
-# - exclude dead browsers (no security maintenance for 2+ years)
-# - exclude Opera Mini which does not support web sockets
-unreleased versions
-last 7 years
->= 0.05%
-not dead
-not op_mini all
+# Legacy builds are served when modern requirements are not met.
+# Floors are pinned explicitly (not usage-based) so the support policy is
+# deliberate and does not drift with global usage statistics, which do not
+# represent old tablets and wall displays used as Home Assistant dashboards:
+# - iOS/Safari >= 12: iPad Air 1 / mini 2 / mini 3 (last supported iOS).
+#   Older iPads (iPad 2/3/mini 1 on iOS 9.3, iPad 4 on iOS 10.3) cannot run
+#   the app: their engines lack custom elements, shadow DOM, and/or CSS grid.
+# - Chrome >= 59: Fire OS 5 tablets (Fire 7/HD 8/HD 10 through ~2017) have
+#   their system WebView pinned at Chromium 59 and commonly run Fully Kiosk;
+#   also covers old kiosk browsers and no-longer-updating webviews above it.
+# - Edge >= 79: all Chromium-based Edge. Costs nothing (above the Chrome
+#   floor); mainly catches Edge 109 on Windows 7/8.1 and update-frozen
+#   enterprise installs, whose engines can run the legacy build fine.
+# - Firefox >= 94: the zero-cost floor, not a chased population — pinning it
+#   adds no babel transforms, core-js modules, or Lightning CSS prefixes to
+#   the output. Mozilla-supported Firefox (incl. current ESR) always matches
+#   [modern]; Firefox on old OSes is not supported (use Chrome 109 instead).
+#   If Firefox ever becomes the pin forcing extra output, raise it first.
+# - Samsung >= 9: Samsung Internet on old Galaxy tablets
+Chrome >= 59
+ChromeAndroid >= 59
+Edge >= 79
+Firefox >= 94
+FirefoxAndroid >= 94
+iOS >= 12
+Safari >= 12
+Samsung >= 9
 
 [legacy-sw]
-# Same as legacy plus supports service workers
-unreleased versions
-last 7 years
->= 0.05% and supports serviceworkers
-not dead
-not op_mini all
+# Same as legacy, restricted to browsers that support service workers
+# (currently resolves to the same set; guards the service worker build if the legacy floor ever drops below them)
+Chrome >= 59 and supports serviceworkers
+ChromeAndroid >= 59 and supports serviceworkers
+Edge >= 79 and supports serviceworkers
+Firefox >= 94 and supports serviceworkers
+FirefoxAndroid >= 94 and supports serviceworkers
+iOS >= 12 and supports serviceworkers
+Safari >= 12 and supports serviceworkers
+Samsung >= 9 and supports serviceworkers

.github/actions/build/action.yml

@@ -11,6 +11,9 @@ inputs:
   is-test:
     description: Set IS_TEST for the build (skips source maps and compression)
     default: "false"
+  rspack-cache:
+    description: rspack persistent cache mode ("readwrite", "readonly", or "" to disable)
+    default: ""
 
 runs:
   using: composite
@@ -21,3 +24,4 @@ runs:
       env:
         GITHUB_TOKEN: ${{ inputs.github-token }}
         IS_TEST: ${{ inputs.is-test }}
+        RSPACK_CACHE: ${{ inputs.rspack-cache }}

.github/workflows/ci.yaml

@@ -97,10 +97,12 @@ jobs:
         run: yarn run test
   build:
     name: Build frontend
-    needs:
-      - prepare-dependencies
-      - lint
-      - test
+    # Runs alongside lint and test rather than after them: the build only needs
+    # the dependency tree, and with the rspack cache it is no longer expensive
+    # enough to be worth serialising behind the other checks. The
+    # cancel-on-failure job below stops the run as soon as a check fails, so a
+    # broken pull request does not finish building.
+    needs: prepare-dependencies
     runs-on: ubuntu-latest
     steps:
       - name: Check out files from GitHub
@@ -111,12 +113,26 @@ jobs:
         uses: ./.github/actions/setup
         with:
           node-modules-cache: true
+      # Read-only reuse of the rspack cache written by the nightly (see
+      # nightly.yaml). rspack itself decides what is still valid (version +
+      # buildDependencies + node_modules snapshot), so the GHA key just restores
+      # the latest nightly cache; no fingerprint, and no save step (CI never
+      # writes the shared cache).
+      - name: Restore rspack cache
+        continue-on-error: true
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .rspack-cache
+          key: rspack-cache-${{ runner.os }}-${{ github.run_id }}
+          restore-keys: |
+            rspack-cache-${{ runner.os }}-
       - name: Build Application
         uses: ./.github/actions/build
         with:
           target: build-app
           github-token: ${{ secrets.GITHUB_TOKEN }}
           is-test: true
+          rspack-cache: readonly
       - name: Upload bundle stats
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
@@ -132,3 +148,54 @@ jobs:
           path: hass_frontend/
           if-no-files-found: error
           retention-days: 7
+
+  # Now that the checks run in parallel, a failing lint or test no longer stops
+  # the build from finishing on its own, so this watches them and cancels the
+  # whole run on the first failure.
+  #
+  # It is a separate job on purpose. Cancelling needs `actions: write`, and the
+  # other jobs check out the pull request and run its build scripts — handing
+  # them that scope would give PR-controlled code (or a compromised dependency)
+  # write access to Actions. This job never checks out the repository, so the
+  # elevated token stays away from PR code. It also cannot be a job that
+  # `needs` the checks: that would only start once they have all finished, which
+  # is exactly too late to cancel anything.
+  cancel-on-failure:
+    name: Cancel run on failure
+    needs: prepare-dependencies
+    runs-on: ubuntu-latest
+    permissions:
+      actions: write
+    timeout-minutes: 30
+    steps:
+      - name: Cancel the run when a check fails
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          RUN_ID: ${{ github.run_id }}
+        run: |
+          watched='^(Lint and check format|Run tests|Build frontend)$'
+          while :; do
+            jobs=$(gh api "repos/$REPO/actions/runs/$RUN_ID/jobs?per_page=100" \
+              --paginate --jq '.jobs[] | [.name, .status, (.conclusion // "")] | @tsv' \
+              2>/dev/null || true)
+
+            failed=$(printf '%s\n' "$jobs" | awk -F'\t' -v w="$watched" \
+              '$1 ~ w && ($3 == "failure" || $3 == "timed_out") { print $1 }')
+            if [ -n "$failed" ]; then
+              echo "Cancelling the run, these checks failed:"
+              printf '%s\n' "$failed"
+              gh run cancel "$RUN_ID" --repo "$REPO" || true
+              exit 0
+            fi
+
+            found=$(printf '%s\n' "$jobs" | awk -F'\t' -v w="$watched" '$1 ~ w' | wc -l)
+            running=$(printf '%s\n' "$jobs" | awk -F'\t' -v w="$watched" \
+              '$1 ~ w && $2 != "completed" { print $1 }')
+            if [ "$found" -ge 3 ] && [ -z "$running" ]; then
+              echo "All checks finished without failure"
+              exit 0
+            fi
+
+            sleep 15
+          done

.github/workflows/codeql-analysis.yaml

@@ -32,12 +32,12 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@7188fc363630916deb702c7fdcf4e481b751f97a # v4.37.1
+        uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
         with:
           languages: javascript-typescript
           build-mode: none
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@7188fc363630916deb702c7fdcf4e481b751f97a # v4.37.1
+        uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
         with:
           category: "/language:javascript-typescript"

.github/workflows/e2e.yaml

@@ -38,7 +38,7 @@ jobs:
     name: Prepare container dependencies
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.62.0-noble
+      image: mcr.microsoft.com/playwright:v1.62.1-noble
       options: --user 1001
     defaults:
       run:
@@ -137,6 +137,7 @@ jobs:
         with:
           target: build-gallery
           github-token: ${{ secrets.GITHUB_TOKEN }}
+          is-test: true
 
       - name: Upload gallery build
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
@@ -154,7 +155,7 @@ jobs:
       - prepare-container-dependencies
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.62.0-noble
+      image: mcr.microsoft.com/playwright:v1.62.1-noble
       options: --user 1001 --ipc=host
     defaults:
       run:
@@ -206,7 +207,7 @@ jobs:
       - prepare-container-dependencies
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.62.0-noble
+      image: mcr.microsoft.com/playwright:v1.62.1-noble
       options: --user 1001 --ipc=host
     defaults:
       run:
@@ -260,7 +261,7 @@ jobs:
       - prepare-container-dependencies
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.62.0-noble
+      image: mcr.microsoft.com/playwright:v1.62.1-noble
       options: --user 1001 --ipc=host
     defaults:
       run:

.github/workflows/nightly.yaml

@@ -38,11 +38,44 @@ jobs:
         run: ./script/translations_download
         env:
           LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
+          # The wheel only builds the app (build-app), which does not merge
+          # backend translations. Skipping the whole-project backend export (as
+          # the release does) keeps this off the build's critical path; the full
+          # translations artifact is produced in parallel by the job below.
+          SKIP_BACKEND_TRANSLATIONS: "1"
 
       - name: Bump version
         run: script/version_bump.js nightly
 
+      # Warm the shared compression cache so releases reuse it (see release.yaml).
+      - name: Restore compression cache
+        id: compress-cache
+        continue-on-error: true
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .compress-cache
+          key: compress-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: |
+            compress-cache-${{ runner.os }}-
+
+      # The nightly writes the rspack persistent cache; CI reads it read-only
+      # (see ci.yaml). rspack invalidates internally (version + buildDependencies
+      # + node_modules snapshot), so the cache rolls forward daily and a single
+      # dependency bump keeps most of it warm instead of dropping the lineage.
+      - name: Restore rspack cache
+        id: rspack-cache
+        continue-on-error: true
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .rspack-cache
+          key: rspack-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: |
+            rspack-cache-${{ runner.os }}-
+
       - name: Build nightly Python wheels
+        env:
+          COMPRESS_CACHE_DIR: ${{ github.workspace }}/.compress-cache
+          RSPACK_CACHE: readwrite
         run: |
           pip install build
           yarn install
@@ -51,8 +84,23 @@ jobs:
           rm -rf dist home_assistant_frontend.egg-info
           python3 -m build
 
-      - name: Archive translations
-        run: tar -czvf translations.tar.gz translations
+      # Not gated on the restore steps: a transient restore failure (they are
+      # continue-on-error) must not stop us persisting a freshly built cache.
+      - name: Save compression cache
+        if: success()
+        continue-on-error: true
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .compress-cache
+          key: compress-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
+
+      - name: Save rspack cache
+        if: success()
+        continue-on-error: true
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .rspack-cache
+          key: rspack-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
 
       - name: Upload build artifacts
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
@@ -61,6 +109,31 @@ jobs:
           path: dist/home_assistant_frontend*.whl
           if-no-files-found: error
 
+  # The full translations (including the slow backend/core export) are only
+  # needed for the uploaded artifact, not the wheel, so they are downloaded in
+  # parallel here instead of blocking the build above.
+  translations:
+    name: Translations
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Setup Node and install
+        uses: ./.github/actions/setup
+        with:
+          immutable: false
+
+      - name: Download translations
+        run: ./script/translations_download
+        env:
+          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
+
+      - name: Archive translations
+        run: tar -czvf translations.tar.gz translations
+
       - name: Upload translations
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:

.github/workflows/release-drafter.yaml

@@ -18,6 +18,6 @@ jobs:
       pull-requests: read
     runs-on: ubuntu-latest
     steps:
-      - uses: release-drafter/release-drafter@eada3c96a64734dd381cfbda23511034e328ddb0 # v7.6.0
+      - uses: release-drafter/release-drafter@34d80673e067bdc0c24568d3af899c216adcfaa9 # v7.7.0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yaml

@@ -36,7 +36,7 @@ jobs:
           python-version: ${{ env.PYTHON_VERSION }}
 
       - name: Verify version
-        uses: home-assistant/actions/helpers/verify-version@e3fb68ebda13d88a0d695082f471ba2c83d025fb # master
+        uses: home-assistant/actions/helpers/verify-version@a7c616ce81ccda50150bf1595786c71b1883fabb # master
 
       - name: Setup Node and install
         uses: ./.github/actions/setup
@@ -48,15 +48,44 @@ jobs:
         run: ./script/translations_download
         env:
           LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
+          # The app fetches core (backend) translations live from HA, so the
+          # release build does not need Lokalise's backend project.
+          SKIP_BACKEND_TRANSLATIONS: "1"
+
+      # Restore the content-addressed compression cache. Unchanged chunks and
+      # static assets are then reused instead of re-run through brotli/zopfli.
+      - name: Restore compression cache
+        id: compress-cache
+        continue-on-error: true
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .compress-cache
+          key: compress-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: |
+            compress-cache-${{ runner.os }}-
 
       - name: Build and release package
+        env:
+          COMPRESS_CACHE_DIR: ${{ github.workspace }}/.compress-cache
         run: |
           python3 -m pip install build
           export SKIP_FETCH_NIGHTLY_TRANSLATIONS=1
           script/release
 
+      # The build keeps the cache under its size budget, so saving stays bounded.
+      # A unique key always writes; restore-keys picks the newest on the next
+      # run. Not gated on the restore step: a transient restore failure (it is
+      # continue-on-error) must not stop us persisting a freshly built cache.
+      - name: Save compression cache
+        if: success()
+        continue-on-error: true
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: .compress-cache
+          key: compress-cache-${{ runner.os }}-${{ github.run_id }}-${{ github.run_attempt }}
+
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247 # v1.14.1
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
         with:
           skip-existing: true
 
@@ -76,19 +105,21 @@ jobs:
           GITHUB_REF: ${{ github.ref }}
         run: |
           version=$(echo "$GITHUB_REF" | awk -F"/" '{print $NF}' )
-          # Wait for the package to become available on PyPI
-          echo "Waiting for home-assistant-frontend==$version to appear on PyPI..."
+          # Wait for the exact wheel to appear on the simple index (the surface
+          # the wheels build's pip uses). The JSON API can report a version as
+          # available before it propagates here, which fails the wheels build.
+          wheel="home_assistant_frontend-${version}-py3-none-any.whl"
+          echo "Waiting for $wheel to appear on the PyPI simple index..."
           for i in $(seq 1 30); do
-            status=$(curl -s -o /dev/null -w "%{http_code}" "https://pypi.org/pypi/home-assistant-frontend/$version/json")
-            if [ "$status" = "200" ]; then
-              echo "Package is available on PyPI!"
+            if curl -sf "https://pypi.org/simple/home-assistant-frontend/" | grep -qF "$wheel"; then
+              echo "Package is available on the PyPI simple index!"
               break
             fi
             if [ "$i" = "30" ]; then
               echo "Timed out waiting for package to appear on PyPI"
               exit 1
             fi
-            echo "Not available yet (HTTP $status), retrying in 30 seconds... ($i/30)"
+            echo "Not available yet, retrying in 30 seconds... ($i/30)"
             sleep 30
           done
           echo "home-assistant-frontend==$version" > ./requirements.txt
@@ -123,6 +154,8 @@ jobs:
         run: ./script/translations_download
         env:
           LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
+          # The landing-page build does not merge backend translations.
+          SKIP_BACKEND_TRANSLATIONS: "1"
       - name: Build landing-page
         run: landing-page/script/build_landing_page
       - name: Tar folder

.github/workflows/stale.yaml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 90 days stale policy
-        uses: actions/stale@1e223db275d687790206a7acac4d1a11bd6fe629 # v10.4.0
+        uses: actions/stale@4391f3da665fdf50b6810c1a66712fb9ba21aa93 # v11.0.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 90

.github/workflows/sync-device-classes.yaml

@@ -0,0 +1,47 @@
+name: Sync device class constants
+
+# Mirrors the device class constants for Home Assistant Core's into the
+# build-time default in src/data/devce_classes.ts and opens a PR
+# when it drifts. Reads homeassistant/generated/device_classes.json from core.
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 4 * * *" # Daily, 04:00 UTC
+
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    name: Sync
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Setup Node and install
+        uses: ./.github/actions/setup
+
+      - name: Regenerate device class constants
+        run: ./script/gen_device_classes
+
+      - name: Format
+        run: yarn prettier --write src/data/sensor_numeric_device_classes.ts
+
+      - name: Create pull request
+        uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
+        with:
+          branch: chore/sync-numeric-device-classes
+          commit-message: Update numeric sensor device classes
+          title: Update numeric sensor device classes
+          body: |
+            Regenerated `SENSOR_NUMERIC_DEVICE_CLASSES` from Home Assistant Core's
+            `SensorDeviceClass`.
+
+            Automated by `.github/workflows/sync-numeric-device-classes.yaml`.

.github/workflows/sync-sensor-entity-constants.yaml

@@ -1,7 +1,8 @@
-name: Sync numeric device classes
+name: Sync sensor entity constants
 
-# Mirrors Home Assistant Core's numeric `SensorDeviceClass` list into the
-# build-time default in src/data/sensor_numeric_device_classes.ts and opens a PR
+# Mirrors Home Assistant Core's numeric `SensorDeviceClass`, `SensorStateClass`,
+# units and related device and state classes arrays into the
+# build-time default in src/data/sensor_entity_constants.ts and opens a PR
 # when it drifts. Reads homeassistant/generated/sensor.json from core.
 
 on:
@@ -28,8 +29,8 @@ jobs:
       - name: Setup Node and install
         uses: ./.github/actions/setup
 
-      - name: Regenerate numeric device classes
-        run: ./script/gen_numeric_device_classes
+      - name: Regenerate sensor entity constants
+        run: ./script/gen_sensor_entity_constants
 
       - name: Format
         run: yarn prettier --write src/data/sensor_numeric_device_classes.ts

.gitignore

@@ -6,6 +6,8 @@ build/
 dist/
 /hass_frontend/
 /translations/
+/.compress-cache/
+/.rspack-cache/
 # Composite action source, not build output
 !/.github/actions/build/
 
@@ -72,3 +74,4 @@ test/e2e/app/dist/
 .serena
 
 test/benchmarks/results/
+

.nvmrc

@@ -1 +1 @@
-24.18.0
+24.20.0

.yarnrc.yml

@@ -13,4 +13,4 @@ nodeLinker: node-modules
 
 npmMinimalAgeGate: 3d
 
-yarnPath: .yarn/releases/yarn-4.17.1.cjs
+yarnPath: .yarn/releases/yarn-4.18.0.cjs

AGENTS.md

@@ -33,6 +33,7 @@ Never run `tsc` or `yarn lint:types` with file arguments. When `tsc` receives fi
 - Do not query or manipulate DOM manually when Lit decorators, component refs, or render state are appropriate.
 - Scope styles to components, use theme custom properties, and keep layouts mobile-first and RTL-safe.
 - All user-facing text must be localized through the translation system.
+- Do not write tests just because you changed some code. Write a test when there is real logic that could break without anyone noticing, and explain what the test protects.
 
 ## Project Skills
 
@@ -40,6 +41,9 @@ Detailed guidance lives in project skills under `.agents/skills/`. Load the matc
 
 - `ha-frontend-contexts`: Lit contexts, `hass` migration, and rerender-sensitive state access.
 - `ha-frontend-components`: dialogs, forms, alerts, shortcuts, tooltips, panels, and Lovelace cards.
+- `ha-frontend-events`: event handler typing, custom event dispatch, and event-map declarations.
+- `ha-frontend-types`: backend data contracts, optional schemas, shared types, assertions, and lifecycle types.
+- `ha-frontend-lit`: reactive fields, DOM queries, lifecycle behavior, and render-derived state.
 - `ha-frontend-styling`: theme variables, spacing tokens, responsive layout, RTL, and view transitions.
 - `ha-frontend-testing`: lint, typecheck, Vitest, Playwright e2e dev servers, and benchmarks.
 - `ha-frontend-user-facing-text`: localization, terminology, sentence case, and Home Assistant text style.

README.md

@@ -12,7 +12,7 @@ This is the repository for the official [Home Assistant](https://home-assistant.
 
 - Initial setup: `script/setup`
 - Development: [Instructions](https://developers.home-assistant.io/docs/frontend/development/)
-- Production build: `script/build_frontend`
+- Production build: `yarn build`
 - Gallery: `cd gallery && script/develop_gallery`
 
 ## Frontend development

build-scripts/README.md

@@ -34,6 +34,14 @@ In production, the following responsibilities are added:
 
 - Minify HTML
 - Bundle multiple imports so that the browser can fetch less files
-- Generate a second version that is ES5 compatible
+- Generate a second version that is compatible with older browsers (legacy build)
 
 Configuration for all these steps are specified in [bundle.js](bundle.js).
+
+## Auditing browser support changes
+
+`node build-scripts/list-plugins-and-polyfills.js` prints, per browserslist
+environment (modern/legacy), the Babel transforms preset-env enables and the
+Core-JS polyfills that may be injected — as collapsible markdown ready to
+paste into a PR. Use it to show the bundle impact when changing
+`.browserslistrc` or the Babel configuration.

build-scripts/brotli.mjs

@@ -0,0 +1,56 @@
+// Gulp transform that brotli-compresses files, several at a time.
+//
+// Drop-in replacement for gulp-brotli. zlib already does the work off the main
+// thread, but that plugin wraps it in through2, which waits for each file
+// before starting the next, so only one compression is ever in flight. The
+// compressed bytes are unchanged; only how many run at once differs.
+//
+// The real ceiling is libuv's threadpool, which zlib runs on. It sizes itself
+// from UV_THREADPOOL_SIZE before any JavaScript runs, so it can only be raised
+// from the environment, never from inside the build.
+
+import { availableParallelism } from "node:os";
+import { buffer as readStream } from "node:stream/consumers";
+import { promisify } from "node:util";
+import { brotliCompress, constants } from "node:zlib";
+import { withCache } from "./compress-cache.mjs";
+import { ParallelTransform } from "./parallel-transform.mjs";
+
+const EXTENSION = ".br";
+
+const compress = promisify(brotliCompress);
+
+/**
+ * @param {object} [options]
+ * @param {boolean} [options.skipLarger] Drop files that compression grows.
+ * @param {object} [options.params] Brotli parameters, passed to zlib as-is.
+ */
+export default ({ skipLarger = false, params } = {}) => {
+  // Isolate cache entries by anything that changes the output bytes: the brotli
+  // quality, and the node major that produced them.
+  const quality = params?.[constants.BROTLI_PARAM_QUALITY] ?? "default";
+  const namespace = `brotli-q${quality}-node${process.versions.node.split(".")[0]}`;
+
+  return new ParallelTransform(availableParallelism(), async (file) => {
+    if (file.isNull()) {
+      return file;
+    }
+    if (file.isStream()) {
+      file.contents = await readStream(file.contents);
+    }
+
+    const compressed = await withCache(namespace, file.contents, async () => {
+      const out = await compress(file.contents, { params });
+      // Dropped rather than passed through, as gulp-brotli did: the
+      // uncompressed file is already in the output directory.
+      return skipLarger && out.length >= file.contents.length ? undefined : out;
+    });
+    if (compressed === undefined) {
+      return undefined;
+    }
+
+    file.contents = compressed;
+    file.path += EXTENSION;
+    return file;
+  });
+};

build-scripts/build-manager.mjs

@@ -0,0 +1,311 @@
+// Manage a Home Assistant frontend production build with an agent-friendly
+// interface, matching build-scripts/dev-server.mjs.
+//
+//   node build-scripts/build-manager.mjs [--modern] [mode]
+//
+//   (no mode)          Run in the foreground.
+//   --background       Start detached, print the pid, then exit and leave it
+//                      running.
+//   --status           Report whether a managed build is running.
+//   --stop             Stop a managed build.
+//   --logs [--follow]  Print (or follow) the background build log.
+//
+//   --modern           Build only the modern frontend_latest bundle.
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  LIFECYCLE_MODE_FLAGS,
+  acquireProcessRecord,
+  isProcessRecordAlive,
+  outputLog,
+  offerToStopProcessRecord,
+  processStartTime,
+  readProcessRecord,
+  releaseProcessRecord,
+  runCli,
+  spawnDetachedToLog,
+  spawnForeground,
+  terminateDetachedProcess,
+  terminateProcess,
+  waitFor,
+  writeProcessRecord,
+} from "./managed-process.mjs";
+import {
+  buildCacheDir,
+  describeOutputOwner,
+  workflowLockEnv,
+  workflowLockFile,
+} from "./output-lock.mjs";
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const gulpBin = path.join(repoRoot, "node_modules", ".bin", "gulp");
+const stateDir = path.join(buildCacheDir, "ha-build");
+const logFile = path.join(stateDir, "build.log");
+const lockFile = workflowLockFile;
+
+const usage = () => {
+  process.stderr.write(
+    "Usage: node build-scripts/build-manager.mjs [--modern] " +
+      "[--background | --status | --stop | --logs [--follow]]\n"
+  );
+};
+
+const parseArgs = (argv) => {
+  const args = {
+    mode: "foreground",
+    modes: [],
+    follow: false,
+    modern: false,
+    unknown: [],
+  };
+  for (const arg of argv) {
+    if (LIFECYCLE_MODE_FLAGS.has(arg)) {
+      args.mode = LIFECYCLE_MODE_FLAGS.get(arg);
+      args.modes.push(arg);
+    } else if (arg === "--modern") {
+      args.modern = true;
+    } else if (arg === "--follow") {
+      args.follow = true;
+    } else {
+      args.unknown.push(arg);
+    }
+  }
+  return args;
+};
+
+const hints = () =>
+  "  Stop:   yarn build --stop\n" +
+  "  Status: yarn build --status\n" +
+  "  Logs:   yarn build --logs\n";
+
+const devCommand = (suite) => {
+  switch (suite) {
+    case "app-serve":
+      return "dev:serve";
+    case "demo":
+      return "dev:demo";
+    case "gallery":
+      return "dev:gallery";
+    case "e2e-app":
+      return "test:e2e:app:dev";
+    default:
+      return "dev";
+  }
+};
+
+const readBuild = () => readProcessRecord(lockFile);
+
+const releaseBuild = (token) => releaseProcessRecord(lockFile, token);
+
+const stopCommandFor = (owner) =>
+  owner?.kind === "build"
+    ? "yarn build --stop"
+    : owner?.kind === "dev"
+      ? `yarn ${devCommand(owner.suite)} --stop`
+      : undefined;
+
+const acquireBuild = async (modern, foreground) => {
+  const token = `${process.pid}-${Date.now()}-${Math.random()}`;
+  const record = {
+    pid: process.pid,
+    startTime: processStartTime(process.pid),
+    processGroup: false,
+    foreground,
+    kind: "build",
+    modern,
+    starting: true,
+    token,
+  };
+  const result = acquireProcessRecord(lockFile, record);
+  if (result.acquired) {
+    return { token };
+  }
+  reportExisting(result.existing);
+  return (await offerToStopProcessRecord({
+    file: lockFile,
+    owner: result.existing,
+    ownerDescription: describeOutputOwner(result.existing),
+    stopCommand: stopCommandFor(result.existing),
+  }))
+    ? acquireBuild(modern, foreground)
+    : { existing: result.existing };
+};
+
+const updateBuild = (token, child, processGroup) => {
+  const existing = readBuild();
+  if (existing?.token !== token) {
+    throw Error("Frontend build lock ownership was lost during startup.");
+  }
+  writeProcessRecord(lockFile, {
+    ...existing,
+    pid: child.pid,
+    startTime: processStartTime(child.pid),
+    processGroup,
+    starting: false,
+  });
+};
+
+const taskFor = (modern) => (modern ? "build-app-modern" : "build-app");
+
+const reportExisting = (existing) => {
+  if (existing?.kind === "output") {
+    process.stdout.write(
+      `${describeOutputOwner(existing)} already owns the build and development workflow` +
+        `${existing.pid ? ` (pid ${existing.pid})` : ""}.\n`
+    );
+    return;
+  }
+  if (existing?.kind === "dev") {
+    const command = devCommand(existing.suite);
+    process.stdout.write(
+      `Dev server (${existing.suite}) already running` +
+        `${existing.pid ? ` (pid ${existing.pid})` : ""}.\n` +
+        `  Stop:   yarn ${command} --stop\n` +
+        `  Status: yarn ${command} --status\n` +
+        `  Logs:   yarn ${command} --logs\n`
+    );
+    return;
+  }
+  process.stdout.write(
+    `Frontend ${existing?.modern ? "modern " : ""}build already running` +
+      `${existing?.pid ? ` (pid ${existing.pid})` : ""}.\n${hints()}`
+  );
+};
+
+const runForeground = async (modern) => {
+  const lock = await acquireBuild(modern, true);
+  if (!lock.token) {
+    return 1;
+  }
+  try {
+    return await spawnForeground({
+      cmd: gulpBin,
+      args: [taskFor(modern)],
+      cwd: repoRoot,
+      env: workflowLockEnv(lock.token),
+      processGroup: true,
+      onSpawn: (child) => updateBuild(lock.token, child, true),
+    });
+  } finally {
+    releaseBuild(lock.token);
+  }
+};
+
+const runBackground = async (modern) => {
+  const lock = await acquireBuild(modern, false);
+  if (!lock.token) {
+    return 1;
+  }
+  let child;
+  try {
+    child = await spawnDetachedToLog({
+      cmd: gulpBin,
+      args: [taskFor(modern)],
+      cwd: repoRoot,
+      env: workflowLockEnv(lock.token),
+      logFile,
+    });
+    updateBuild(lock.token, child, true);
+    process.stdout.write(
+      `Started ${modern ? "modern " : ""}frontend build (pid ${child.pid})\n` +
+        hints()
+    );
+    return 0;
+  } catch (err) {
+    if (child) {
+      await terminateDetachedProcess(child);
+    }
+    releaseBuild(lock.token);
+    throw err;
+  }
+};
+
+const runStatus = () => {
+  const existing = readBuild();
+  if (existing?.kind === "build" && isProcessRecordAlive(existing)) {
+    process.stdout.write(
+      `Frontend ${existing.modern ? "modern " : ""}build running (pid ${existing.pid}).\n`
+    );
+  } else {
+    if (existing?.kind === "build") {
+      releaseBuild(existing.token);
+    }
+    process.stdout.write("Frontend build not running.\n");
+  }
+  return 0;
+};
+
+const runStop = async () => {
+  let existing = readBuild();
+  if (existing?.kind !== "build") {
+    process.stdout.write("Frontend build not running.\n");
+    return 0;
+  }
+  if (existing?.starting) {
+    const token = existing.token;
+    await waitFor(
+      () => {
+        const current = readBuild();
+        return !current?.starting || current.token !== token;
+      },
+      100,
+      5000
+    );
+    existing = readBuild();
+  }
+  if (
+    !existing ||
+    existing.kind !== "build" ||
+    !isProcessRecordAlive(existing)
+  ) {
+    if (existing) releaseBuild(existing.token);
+    process.stdout.write("Frontend build not running.\n");
+    return 0;
+  }
+  if (
+    !(await terminateProcess({
+      pid: existing.pid,
+      processGroup: existing.processGroup,
+      isStopped: () => !isProcessRecordAlive(existing),
+    }))
+  ) {
+    process.stderr.write(
+      `Failed to stop frontend build (pid ${existing.pid}). Stop it manually.\n`
+    );
+    return 1;
+  }
+  releaseBuild(existing.token);
+  process.stdout.write(`Stopped frontend build (pid ${existing.pid}).\n`);
+  return 0;
+};
+
+const runLogs = (follow) =>
+  outputLog(logFile, follow, `No frontend build log yet (${logFile}).\n`);
+
+const main = async () => {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.unknown.length) {
+    process.stderr.write(`Unknown arguments: ${args.unknown.join(" ")}\n`);
+    usage();
+    return 1;
+  }
+  if (args.modes.length > 1 || (args.follow && args.mode !== "logs")) {
+    process.stderr.write("Invalid combination of build arguments.\n");
+    usage();
+    return 1;
+  }
+  const handlers = {
+    foreground: () => runForeground(args.modern),
+    background: () => runBackground(args.modern),
+    status: runStatus,
+    stop: runStop,
+    logs: () => runLogs(args.follow),
+  };
+  return handlers[args.mode]();
+};
+
+runCli(main);

build-scripts/bundle-budget.json

@@ -1,15 +1,15 @@
 {
   "_comment": "Initial JS budget (raw/uncompressed bytes) for the cold-load critical entrypoints. Enforced by build-scripts/check-bundle-size.cjs in CI. Re-seed after an intentional change with `--update --headroom=<percent>`.",
   "frontend-modern": {
-    "app": 595204,
-    "core": 57741,
-    "authorize": 576928,
-    "onboarding": 685964
+    "app": 576583,
+    "core": 54790,
+    "authorize": 543547,
+    "onboarding": 655556
   },
   "frontend-legacy": {
-    "app": 861452,
-    "core": 258557,
-    "authorize": 834356,
-    "onboarding": 1001360
+    "app": 717124,
+    "core": 181583,
+    "authorize": 699175,
+    "onboarding": 816133
   }
 }

build-scripts/bundle.cjs

@@ -63,8 +63,10 @@ module.exports.htmlMinifierOptions = {
 };
 
 module.exports.terserOptions = ({ latestBuild, isTestBuild }) => ({
-  safari10: !latestBuild,
-  ecma: latestBuild ? 2015 : 5,
+  // Highest syntax the minifier may emit; it never downlevels. Every browser
+  // in [modern] is well past ES2020 (universal since spring 2020); the
+  // [legacy] floors (Chrome 59 / Safari 12) top out at ES2017.
+  ecma: latestBuild ? 2020 : 2017,
   module: latestBuild,
   format: { comments: false },
   sourceMap: !isTestBuild,
@@ -119,7 +121,7 @@ module.exports.babelOptions = ({ latestBuild, isTestBuild, sw }) => ({
         ignoreModuleNotFound: true,
       },
     ],
-    // Import helpers and regenerator from runtime package.
+    // Import helpers from runtime package.
     // `moduleName` is pinned so helpers resolve from `@babel/runtime`: the
     // corejs3 polyfill provider above otherwise redirects them to the
     // (uninstalled) `@babel/runtime-corejs3`, which preset-env used to suppress
@@ -153,8 +155,6 @@ module.exports.babelOptions = ({ latestBuild, isTestBuild, sw }) => ({
           "@lit-labs/virtualizer/polyfills",
           "@webcomponents/scoped-custom-element-registry",
           "element-internals-polyfill",
-          "proxy-polyfill",
-          "unfetch",
         ].map((p) => new RegExp(`/node_modules/${p}/`)),
       ],
     },
@@ -277,7 +277,7 @@ module.exports.config = {
     };
   },
 
-  gallery({ isProdBuild, latestBuild }) {
+  gallery({ isProdBuild, latestBuild, isTestBuild }) {
     return {
       name: "gallery" + nameSuffix(latestBuild),
       entry: {
@@ -287,6 +287,7 @@ module.exports.config = {
       publicPath: publicPath(latestBuild),
       isProdBuild,
       latestBuild,
+      isTestBuild,
       defineOverlay: {
         __DEMO__: true,
       },
@@ -311,7 +312,15 @@ module.exports.config = {
     return {
       name: "e2e-test-app" + nameSuffix(latestBuild),
       entry: {
+        dashboard: path.resolve(
+          paths.e2eTestApp_dir,
+          "src/dashboard-entrypoint.ts"
+        ),
         main: path.resolve(paths.e2eTestApp_dir, "src/entrypoint.ts"),
+        onboarding: path.resolve(
+          paths.e2eTestApp_dir,
+          "src/onboarding-entrypoint.ts"
+        ),
       },
       outputPath: outputPath(paths.e2eTestApp_output_root, latestBuild),
       publicPath: publicPath(latestBuild),

build-scripts/compress-cache.mjs

@@ -0,0 +1,212 @@
+// Content-addressed cache for compression output.
+//
+// brotli (quality 11) and zopfli are the slowest part of a production build,
+// and they redo every file from scratch on every run. But production chunks are
+// content-hashed in their filenames, so a chunk that didn't change produces
+// byte-identical input here. Keying the compressed output by a hash of the
+// input bytes lets an unchanged file skip compression entirely, and lets a
+// nightly build warm the cache a release reuses the next day.
+//
+// Disabled unless COMPRESS_CACHE_DIR points at a directory. Local builds set
+// nothing and behave exactly as before. The compressed bytes are unchanged
+// either way; only whether they were recomputed differs.
+
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+  utimes,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+
+const rootDir = process.env.COMPRESS_CACHE_DIR;
+export const cacheEnabled = Boolean(rootDir);
+
+// Total cache size to keep across builds, least-recently-used first when over.
+// The cache is shared between branches (a dev nightly warms it for a release,
+// which builds from rc/master), so pruning must NOT drop everything the current
+// build didn't touch — that would make each branch evict the other's
+// branch-specific files every run. Instead the current build is pinned and the
+// rest is kept up to this budget, so nothing is dropped unless the cache is
+// genuinely too large. Override with COMPRESS_CACHE_MAX_BYTES.
+const DEFAULT_MAX_BYTES = 1024 * 1024 * 1024; // 1 GiB
+const maxBytes = () => {
+  // A valid, explicit budget wins — including 0, which keeps only the current
+  // build (evict everything else). An unset or invalid value uses the default.
+  const configured = Number(process.env.COMPRESS_CACHE_MAX_BYTES);
+  return Number.isFinite(configured) && configured >= 0
+    ? configured
+    : DEFAULT_MAX_BYTES;
+};
+
+// Every cache key touched this build, hits and writes alike, so a prune can pin
+// the current dist and never evict a file this build depends on.
+const touched = new Set();
+
+// Per-namespace directory, created lazily and only once.
+const dirs = new Map();
+
+let tmpCounter = 0;
+
+const sha256 = (contents) =>
+  createHash("sha256").update(contents).digest("hex");
+
+const namespaceDir = (namespace) => {
+  let dir = dirs.get(namespace);
+  if (!dir) {
+    const dirPath = path.join(rootDir, namespace);
+    dir = { path: dirPath, ready: undefined };
+    dirs.set(namespace, dir);
+  }
+  return dir;
+};
+
+const ensureDir = (dir) => {
+  dir.ready ??= mkdir(dir.path, { recursive: true });
+  return dir.ready;
+};
+
+// Written via a unique temp file and renamed into place so a concurrent reader
+// in the same build never sees a half-written entry (rename is atomic on the
+// same filesystem).
+const writeAtomic = async (dir, name, contents) => {
+  await ensureDir(dir);
+  tmpCounter += 1;
+  const tmp = path.join(dir.path, `.${process.pid}-${tmpCounter}.tmp`);
+  const dest = path.join(dir.path, name);
+  await writeFile(tmp, contents);
+  try {
+    await rename(tmp, dest);
+  } catch (error) {
+    // Two files with identical contents can miss and write the same entry at
+    // once. On POSIX the rename just overwrites, but Windows rejects a rename
+    // onto an existing path. Either way the destination already holds the same
+    // bytes (content-addressed), so drop our temp and treat it as done.
+    if (existsSync(dest)) {
+      await rm(tmp, { force: true });
+    } else {
+      throw error;
+    }
+  }
+};
+
+/**
+ * Return the cached compression result for `contents`, or run `compute` and
+ * cache what it returns. `compute` resolves to a Buffer for compressed output,
+ * or `undefined` when the file should be dropped (brotli skipLarger); both
+ * outcomes are cached, so a dropped file is not recompressed on the next build.
+ *
+ * @param {string} namespace Isolates entries by algorithm, parameters and tool
+ *   version, so a change to any of them can never return a stale result.
+ * @param {Buffer} contents Uncompressed input bytes, used as the cache key.
+ * @param {() => Promise<Buffer | undefined>} compute Runs on a cache miss.
+ * @returns {Promise<Buffer | undefined>}
+ */
+export const withCache = async (namespace, contents, compute) => {
+  if (!cacheEnabled) {
+    return compute();
+  }
+
+  const dir = namespaceDir(namespace);
+  const hash = sha256(contents);
+  touched.add(`${namespace}/${hash}`);
+
+  const dataPath = path.join(dir.path, hash);
+  const dropName = `${hash}.drop`;
+
+  try {
+    return await readFile(dataPath);
+  } catch {
+    // Miss (or unreadable) — fall through and compute.
+  }
+  if (existsSync(path.join(dir.path, dropName))) {
+    return undefined;
+  }
+
+  const result = await compute();
+  if (result === undefined) {
+    await writeAtomic(dir, dropName, "");
+  } else {
+    await writeAtomic(dir, hash, result);
+  }
+  return result;
+};
+
+/**
+ * Keep the cache under `maxBytes`, evicting least-recently-used entries first.
+ * Files this build touched are always kept (and their timestamp refreshed, so
+ * shared files stay warm across branches); the remainder — including another
+ * branch's entries — is kept up to the budget. No-op when the cache is disabled
+ * or nothing was compressed, so it never wipes a warm cache on a build that
+ * skipped compression.
+ */
+export const pruneCache = async () => {
+  if (!cacheEnabled || touched.size === 0 || !existsSync(rootDir)) {
+    return;
+  }
+
+  const now = new Date();
+  const pinned = [];
+  const others = [];
+
+  // Scan every namespace on disk, not just the ones this build used, so entries
+  // from an old tool version (a different namespace) are eligible for eviction.
+  const namespaces = await readdir(rootDir, { withFileTypes: true });
+  await Promise.all(
+    namespaces.map(async (ns) => {
+      if (!ns.isDirectory()) {
+        return;
+      }
+      const nsDir = path.join(rootDir, ns.name);
+      const entries = await readdir(nsDir);
+      await Promise.all(
+        entries.map(async (entry) => {
+          const entryPath = path.join(nsDir, entry);
+          // Stray temp files from an interrupted write are never valid entries.
+          if (entry.endsWith(".tmp")) {
+            await rm(entryPath, { force: true });
+            return;
+          }
+          const hash = entry.endsWith(".drop") ? entry.slice(0, -5) : entry;
+          const info = await stat(entryPath);
+          if (touched.has(`${ns.name}/${hash}`)) {
+            pinned.push({ entryPath, size: info.size });
+          } else {
+            others.push({ entryPath, size: info.size, mtimeMs: info.mtimeMs });
+          }
+        })
+      );
+    })
+  );
+
+  // Pinned files stay and are refreshed so they rank as most-recently-used for
+  // future prunes; they always count against the budget first.
+  let kept = 0;
+  await Promise.all(
+    pinned.map(async ({ entryPath, size }) => {
+      kept += size;
+      // A failed timestamp refresh only affects future LRU ordering, not
+      // correctness, so it is safe to ignore.
+      await utimes(entryPath, now, now).catch(() => undefined);
+    })
+  );
+
+  // Keep the most-recently-used others until the budget is spent; drop the rest.
+  others.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const budget = maxBytes();
+  const toDelete = [];
+  for (const entry of others) {
+    if (kept + entry.size <= budget) {
+      kept += entry.size;
+    } else {
+      toDelete.push(entry.entryPath);
+    }
+  }
+  await Promise.all(toDelete.map((p) => rm(p, { force: true })));
+};

build-scripts/gulp/app.js

@@ -1,5 +1,6 @@
 import gulp from "gulp";
 import env from "../env.cjs";
+import { createWorkflowLockTask } from "../output-lock.mjs";
 import "./clean.js";
 import "./compress.js";
 import "./entry-html.js";
@@ -17,6 +18,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "development";
     },
+    createWorkflowLockTask("develop-app"),
     "clean",
     gulp.parallel(
       "gen-service-worker-app-dev",
@@ -36,6 +38,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "production";
     },
+    createWorkflowLockTask("build-app"),
     "clean",
     gulp.parallel(
       "gen-icons-json",
@@ -47,6 +50,32 @@ gulp.task(
     "rspack-prod-app",
     gulp.parallel("gen-pages-app-prod", "gen-service-worker-app-prod"),
     // Don't compress running tests
+    ...(env.isTestBuild() || env.isStatsBuild()
+      ? []
+      : ["compress-app", "prune-compress-cache"])
+  )
+);
+
+gulp.task(
+  "build-app-modern",
+  gulp.series(
+    async function setEnv() {
+      process.env.NODE_ENV = "production";
+    },
+    createWorkflowLockTask("build-app-modern"),
+    "clean",
+    gulp.parallel(
+      "gen-icons-json",
+      "build-translations",
+      "build-locale-data",
+      "gen-licenses"
+    ),
+    "copy-static-app",
+    "rspack-prod-app-modern",
+    gulp.parallel(
+      "gen-pages-app-prod-modern",
+      "gen-service-worker-app-prod-modern"
+    ),
     ...(env.isTestBuild() || env.isStatsBuild() ? [] : ["compress-app"])
   )
 );

build-scripts/gulp/compress.js

@@ -2,9 +2,10 @@
 
 import { constants } from "node:zlib";
 import gulp from "gulp";
-import brotli from "gulp-brotli";
-import zopfli from "gulp-zopfli-green";
+import brotli from "../brotli.mjs";
+import { pruneCache } from "../compress-cache.mjs";
 import paths from "../paths.cjs";
+import zopfli from "../zopfli.mjs";
 
 const filesGlob = "*.{js,json,css,svg,xml}";
 const brotliOptions = {
@@ -57,3 +58,7 @@ gulp.task(
     compressAppOtherZopfli
   )
 );
+
+// Keep the compression cache under its size budget (LRU, this build pinned).
+// No-op unless COMPRESS_CACHE_DIR is set.
+gulp.task("prune-compress-cache", () => pruneCache());

build-scripts/gulp/demo.js

@@ -1,4 +1,5 @@
 import gulp from "gulp";
+import { createWorkflowLockTask } from "../output-lock.mjs";
 import "./clean.js";
 import "./entry-html.js";
 import "./gather-static.js";
@@ -13,6 +14,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "development";
     },
+    createWorkflowLockTask("develop-demo"),
     "clean-demo",
     "translations-enable-merge-backend",
     gulp.parallel(
@@ -32,6 +34,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "production";
     },
+    createWorkflowLockTask("build-demo"),
     "clean-demo",
     // Cast needs to be backwards compatible and older HA has no translations
     "translations-enable-merge-backend",

build-scripts/gulp/download-translations.js

@@ -155,8 +155,22 @@ gulp.task("fetch-lokalise", async function () {
     fs.mkdir(inDirBackend, { recursive: true }),
   ]);
 
+  // The backend project only provides entity_component translations, which are
+  // merged into the demo, gallery, cast and e2e builds. The shipped app fetches
+  // them live from core, so builds that only produce the app (release, release
+  // landing-page) can skip this second, whole-project export to save time.
+  const projects = Object.entries(lokaliseProjects).filter(
+    ([project]) =>
+      !(project === "backend" && process.env.SKIP_BACKEND_TRANSLATIONS)
+  );
+  if (projects.length !== Object.keys(lokaliseProjects).length) {
+    console.log(
+      "Skipping backend translations download (SKIP_BACKEND_TRANSLATIONS)"
+    );
+  }
+
   await Promise.all(
-    Object.entries(lokaliseProjects).map(async ([project, projectId]) => {
+    projects.map(async ([project, projectId]) => {
       try {
         const exportProcess = await lokaliseApi
           .files()

build-scripts/gulp/e2e-test-app.js

@@ -1,4 +1,5 @@
 import gulp from "gulp";
+import { createWorkflowLockTask } from "../output-lock.mjs";
 import "./clean.js";
 import "./entry-html.js";
 import "./gather-static.js";
@@ -12,6 +13,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "development";
     },
+    createWorkflowLockTask("develop-e2e-test-app"),
     "clean-e2e-test-app",
     "translations-enable-merge-backend",
     gulp.parallel(
@@ -31,6 +33,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "production";
     },
+    createWorkflowLockTask("build-e2e-test-app"),
     "clean-e2e-test-app",
     "translations-enable-merge-backend",
     gulp.parallel("gen-icons-json", "build-translations", "build-locale-data"),

build-scripts/gulp/entry-html.js

@@ -25,7 +25,7 @@ const SAFARI_TO_MACOS = {
   16: [11, 0, 0],
   17: [12, 0, 0],
   18: [13, 0, 0],
-  26: [26, 0, 0],
+  26: [14, 6, 0],
 };
 
 const getCommonTemplateVars = () => {
@@ -58,6 +58,12 @@ const getCommonTemplateVars = () => {
   return {
     modernRegex: compileRegex(browserRegexes.concat(haMacOSRegex)).toString(),
     hassUrl: process.env.HASS_URL || "",
+    // Single source for the stale-build recovery patterns, shared with the
+    // bundled src/util/recover-stale-build.ts and injected into the inline
+    // boot guard (_bootstrap_recovery.html.template).
+    staleBuildPatterns: fs.readJsonSync(
+      resolve(paths.root_dir, "src/util/stale-build-patterns.json")
+    ),
   };
 };
 
@@ -83,7 +89,7 @@ const minifyHtml = (content, ext) => {
     ...htmlMinifierOptions,
     conservativeCollapse: false,
     minifyJS: terserOptions({
-      latestBuild: false, // Shared scripts should be ES5
+      latestBuild: false, // Shared scripts must satisfy the legacy targets
       isTestBuild: true, // Don't need source maps
     }),
   }).then((wrapped) =>
@@ -107,6 +113,9 @@ const genPagesDevTask =
         resolve(inputRoot, inputSub, `${page}.template`),
         {
           ...commonVars,
+          // Dev entries are unhashed, so the stale-index recovery guard has
+          // nothing to key off and rebuild churn could cause spurious reloads.
+          useCacheRecovery: false,
           latestEntryJS: entries.map(
             (entry) => `${publicRoot}/frontend_latest/${entry}.js`
           ),
@@ -146,10 +155,15 @@ const genPagesProdTask =
         resolve(inputRoot, inputSub, `${page}.template`),
         {
           ...commonVars,
+          // Recover from a stale index.html that pins deleted hashed entry
+          // bundles (see _bootstrap_recovery.html.template).
+          useCacheRecovery: true,
           latestEntryJS: entries.map((entry) => latestManifest[`${entry}.js`]),
-          es5EntryJS: entries.map((entry) => es5Manifest[`${entry}.js`]),
+          es5EntryJS: outputES5
+            ? entries.map((entry) => es5Manifest[`${entry}.js`])
+            : [],
           latestCustomPanelJS: latestManifest["custom-panel.js"],
-          es5CustomPanelJS: es5Manifest["custom-panel.js"],
+          es5CustomPanelJS: outputES5 ? es5Manifest["custom-panel.js"] : "",
         }
       );
       minifiedHTML.push(
@@ -184,6 +198,17 @@ gulp.task(
   )
 );
 
+gulp.task(
+  "gen-pages-app-prod-modern",
+  genPagesProdTask(
+    APP_PAGE_ENTRIES,
+    paths.root_dir,
+    paths.app_output_root,
+    paths.app_output_latest,
+    undefined
+  )
+);
+
 const CAST_PAGE_ENTRIES = {
   "faq.html": ["launcher"],
   "index.html": ["launcher"],
@@ -278,7 +303,11 @@ gulp.task(
   )
 );
 
-const E2E_TEST_APP_PAGE_ENTRIES = { "index.html": ["main"] };
+const E2E_TEST_APP_PAGE_ENTRIES = {
+  "index.html": ["main"],
+  "dashboard.html": ["dashboard"],
+  "onboarding.html": ["onboarding"],
+};
 
 gulp.task(
   "gen-pages-e2e-test-app-dev",

build-scripts/gulp/gallery.js

@@ -4,6 +4,7 @@ import gulp from "gulp";
 import { load as loadYaml } from "js-yaml";
 import { marked } from "marked";
 import path from "path";
+import { createWorkflowLockTask } from "../output-lock.mjs";
 import paths from "../paths.cjs";
 import "./clean.js";
 import "./entry-html.js";
@@ -164,6 +165,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "development";
     },
+    createWorkflowLockTask("develop-gallery"),
     "clean-gallery",
     "translations-enable-merge-backend",
     gulp.parallel(
@@ -195,6 +197,7 @@ gulp.task(
     async function setEnv() {
       process.env.NODE_ENV = "production";
     },
+    createWorkflowLockTask("build-gallery"),
     "clean-gallery",
     "translations-enable-merge-backend",
     gulp.parallel(

build-scripts/gulp/gather-static.js

@@ -4,6 +4,7 @@ import fs from "fs-extra";
 import gulp from "gulp";
 import path from "path";
 import paths from "../paths.cjs";
+import { ensureMapAssets, mapAssetsDir } from "./map-assets.js";
 
 const npmPath = (...parts) =>
   path.resolve(paths.root_dir, "node_modules", ...parts);
@@ -41,37 +42,6 @@ function copyMdiIcons(staticDir) {
   fs.copySync(polyPath("build/mdi"), staticPath("mdi"));
 }
 
-function copyPolyfills(staticDir) {
-  const staticPath = genStaticPath(staticDir);
-
-  // For custom panels using ES5 builds that don't use Babel 7+
-  copyFileDir(
-    npmPath("@webcomponents/webcomponentsjs/custom-elements-es5-adapter.js"),
-    staticPath("polyfills/")
-  );
-
-  // Web Component polyfills and adapters
-  copyFileDir(
-    npmPath("@webcomponents/webcomponentsjs/webcomponents-bundle.js"),
-    staticPath("polyfills/")
-  );
-  copyFileDir(
-    npmPath("@webcomponents/webcomponentsjs/webcomponents-bundle.js.map"),
-    staticPath("polyfills/")
-  );
-  // Lit polyfill support
-  fs.copySync(
-    npmPath("lit/polyfill-support.js"),
-    path.join(staticPath("polyfills/"), "lit-polyfill-support.js")
-  );
-
-  // dialog-polyfill css
-  copyFileDir(
-    npmPath("dialog-polyfill/dialog-polyfill.css"),
-    staticPath("polyfills/")
-  );
-}
-
 function copyFonts(staticDir) {
   const staticPath = genStaticPath(staticDir);
   // Local fonts
@@ -89,7 +59,7 @@ function copyQrScannerWorker(staticDir) {
   copyFileDir(npmPath("qr-scanner/qr-scanner-worker.min.js"), staticPath("js"));
 }
 
-function copyMapPanel(staticDir) {
+async function copyMapPanel(staticDir) {
   const staticPath = genStaticPath(staticDir);
   copyFileDir(
     npmPath("leaflet/dist/leaflet.css"),
@@ -103,6 +73,16 @@ function copyMapPanel(staticDir) {
     npmPath("leaflet/dist/images"),
     staticPath("images/leaflet/images/")
   );
+
+  // Style, glyphs and sprites for the vector base map
+  await ensureMapAssets();
+  fs.copySync(mapAssetsDir, staticPath("map/"));
+  copyFileDir(
+    npmPath("@mapbox/mapbox-gl-rtl-text/dist/mapbox-gl-rtl-text.js"),
+    staticPath("map/")
+  );
+  // Controls and popups of the native MapLibre engine
+  copyFileDir(npmPath("maplibre-gl/dist/maplibre-gl.css"), staticPath("map/"));
 }
 
 function copyZXingWasm(staticDir) {
@@ -132,14 +112,13 @@ gulp.task("copy-static-app", async () => {
   const staticDir = paths.app_output_static;
   // Basic static files
   fs.copySync(polyPath("public"), paths.app_output_root);
-  copyPolyfills(staticDir);
   copyFonts(staticDir);
   copyTranslations(staticDir);
   copyLocaleData(staticDir);
   copyMdiIcons(staticDir);
 
   // Panel assets
-  copyMapPanel(staticDir);
+  await copyMapPanel(staticDir);
 
   // Qr Scanner assets
   copyZXingWasm(staticDir);
@@ -154,8 +133,7 @@ gulp.task("copy-static-demo", async () => {
   );
   // Copy demo static files
   fs.copySync(path.resolve(paths.demo_dir, "public"), paths.demo_output_root);
-  copyPolyfills(paths.demo_output_static);
-  copyMapPanel(paths.demo_output_static);
+  await copyMapPanel(paths.demo_output_static);
   copyFonts(paths.demo_output_static);
   copyTranslations(paths.demo_output_static);
   copyLocaleData(paths.demo_output_static);
@@ -167,8 +145,7 @@ gulp.task("copy-static-cast", async () => {
   fs.copySync(polyPath("public/static"), paths.cast_output_static);
   // Copy cast static files
   fs.copySync(path.resolve(paths.cast_dir, "public"), paths.cast_output_root);
-  copyPolyfills(paths.cast_output_static);
-  copyMapPanel(paths.cast_output_static);
+  await copyMapPanel(paths.cast_output_static);
   copyFonts(paths.cast_output_static);
   copyTranslations(paths.cast_output_static);
   copyLocaleData(paths.cast_output_static);
@@ -184,7 +161,7 @@ gulp.task("copy-static-gallery", async () => {
     paths.gallery_output_root
   );
 
-  copyMapPanel(paths.gallery_output_static);
+  await copyMapPanel(paths.gallery_output_static);
   copyFonts(paths.gallery_output_static);
   copyTranslations(paths.gallery_output_static);
   copyLocaleData(paths.gallery_output_static);
@@ -214,8 +191,7 @@ gulp.task("copy-static-e2e-test-app", async () => {
     fs.copySync(e2ePublic, paths.e2eTestApp_output_root);
   }
 
-  copyPolyfills(paths.e2eTestApp_output_static);
-  copyMapPanel(paths.e2eTestApp_output_static);
+  await copyMapPanel(paths.e2eTestApp_output_static);
   copyFonts(paths.e2eTestApp_output_static);
   copyTranslations(paths.e2eTestApp_output_static);
   copyLocaleData(paths.e2eTestApp_output_static);

build-scripts/gulp/gen-device-classes.js

@@ -0,0 +1,40 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import gulp from "gulp";
+import paths from "../paths.cjs";
+
+const SOURCE_URL =
+  process.env.SENSOR_METADATA_URL ||
+  "https://raw.githubusercontent.com/home-assistant/core/refs/heads/dev/homeassistant/generated/device_classes.json";
+
+const TARGET = join(paths.root_dir, "src", "data", "device_classes.ts");
+
+gulp.task("gen-device-classes", async () => {
+  const response = await fetch(SOURCE_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${SOURCE_URL}: ${response.status}`);
+  }
+
+  const data = await response.json();
+  const domainDeviceClasses = data ?? {};
+  if (!Object.keys(domainDeviceClasses).length) {
+    throw new Error(`No device classes found in ${SOURCE_URL}`);
+  }
+
+  const content = `// This file is auto-generated from Home Assistant Core's
+// entity platform device classes. Do not edit by hand.
+// Regenerate with \`script/gen_device_classes\`.
+
+export const DOMAIN_DEVICE_CLASSES: Record<string, string[]> = {
+${Object.entries(domainDeviceClasses)
+  .map(
+    ([domain, deviceClasses]) =>
+      `  "${domain}": [${deviceClasses.map((deviceClass) => `"${deviceClass}"`).join(", ")}],`
+  )
+  .join("\n")}
+};
+`;
+
+  await writeFile(TARGET, content);
+});

build-scripts/gulp/gen-numeric-device-classes.js

@@ -1,40 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import process from "node:process";
-import gulp from "gulp";
-import paths from "../paths.cjs";
-
-const SOURCE_URL =
-  process.env.SENSOR_METADATA_URL ||
-  "https://raw.githubusercontent.com/home-assistant/core/dev/homeassistant/generated/sensor.json";
-
-const TARGET = join(
-  paths.root_dir,
-  "src",
-  "data",
-  "sensor_numeric_device_classes.ts"
-);
-
-gulp.task("gen-numeric-device-classes", async () => {
-  const response = await fetch(SOURCE_URL);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${SOURCE_URL}: ${response.status}`);
-  }
-
-  const data = await response.json();
-  const classes = [...(data.numeric_device_classes ?? [])].sort();
-  if (!classes.length) {
-    throw new Error(`No numeric_device_classes found in ${SOURCE_URL}`);
-  }
-
-  const content = `// This file is auto-generated from Home Assistant Core's \`SensorDeviceClass\`
-// (all values minus \`NON_NUMERIC_DEVICE_CLASSES\`). Do not edit by hand.
-// Regenerate with \`script/gen_numeric_device_classes\`.
-
-export const SENSOR_NUMERIC_DEVICE_CLASSES: string[] = [
-${classes.map((deviceClass) => `  "${deviceClass}",`).join("\n")}
-];
-`;
-
-  await writeFile(TARGET, content);
-});

build-scripts/gulp/gen-sensor-entity-constants.js

@@ -0,0 +1,83 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import gulp from "gulp";
+import paths from "../paths.cjs";
+
+const SOURCE_URL =
+  process.env.SENSOR_METADATA_URL ||
+  "https://raw.githubusercontent.com/home-assistant/core/dev/homeassistant/generated/sensor.json";
+
+const TARGET = join(
+  paths.root_dir,
+  "src",
+  "data",
+  "sensor_entity_constants.ts"
+);
+
+gulp.task("gen-sensor-entity-constants", async () => {
+  const response = await fetch(SOURCE_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${SOURCE_URL}: ${response.status}`);
+  }
+
+  const data = await response.json();
+  const numericDeviceClasses = [...(data.numeric_device_classes ?? [])].sort();
+  const deviceClassUnits = data.device_class_units ?? {};
+  const convertibleClassUnits = data.convertible_units ?? {};
+  const stateClasses = data.state_classes ?? [];
+  const stateClassUnits = data.state_class_units ?? {};
+  if (
+    !numericDeviceClasses.length ||
+    !stateClasses.length ||
+    !Object.keys(deviceClassUnits).length ||
+    !Object.keys(stateClassUnits).length
+  ) {
+    throw new Error(
+      `No sensor device classes, state classes or units found in ${SOURCE_URL}`
+    );
+  }
+
+  const content = `// This file is auto-generated from Home Assistant Core's \`DEVICE_CLASS_UNITS\`
+// and \`STATE_CLASS_UNITS\`) and \`SensorDeviceClass\`
+// (all values minus \`NON_NUMERIC_DEVICE_CLASSES\`). Do not edit by hand.
+// Regenerate with \`script/gen_sensor_entity_constants\`.
+
+export const SENSOR_NUMERIC_DEVICE_CLASSES: string[] = [
+${numericDeviceClasses.map((deviceClass) => `  "${deviceClass}",`).join("\n")}
+];
+
+export const SENSOR_DEVICE_CLASS_UNITS: Record<string, (string | null)[]> = {
+${Object.entries(deviceClassUnits)
+  .map(
+    ([deviceClass, units]) =>
+      `  ${deviceClass}: [${units.map((u) => (u === null ? "null" : `"${u}"`)).join(", ")}],`
+  )
+  .join("\n")}
+};
+
+export const SENSOR_DEVICE_CLASS_CONVERTIBLE_UNITS: Record<string, (string | null)[]> = {
+${Object.entries(convertibleClassUnits)
+  .map(
+    ([deviceClass, units]) =>
+      `  ${deviceClass}: [${units.map((u) => (u === null ? "null" : `"${u}"`)).join(", ")}],`
+  )
+  .join("\n")}
+};
+
+export const SENSOR_STATE_CLASSES: string[] = [
+${stateClasses.map((stateClass) => `  "${stateClass}",`).join("\n")}
+];
+
+export const SENSOR_STATE_CLASS_UNITS: Record<string, string[]> = {
+${Object.entries(stateClassUnits)
+  .map(
+    ([stateClass, units]) =>
+      `  ${stateClass}: [${units.map((u) => (u === null ? "null" : `"${u}"`)).join(", ")}],`
+  )
+  .join("\n")}
+};
+`;
+
+  await writeFile(TARGET, content);
+});

build-scripts/gulp/index.mjs

@@ -9,10 +9,12 @@ import "./entry-html.js";
 import "./fetch-nightly-translations.js";
 import "./gallery.js";
 import "./gather-static.js";
+import "./gen-device-classes.js";
 import "./gen-icons-json.js";
-import "./gen-numeric-device-classes.js";
+import "./gen-sensor-entity-constants.js";
 import "./landing-page.js";
 import "./locale-data.js";
+import "./map-assets.js";
 import "./rspack.js";
 import "./service-worker.js";
 import "./translations.js";

build-scripts/gulp/map-assets.js

@@ -0,0 +1,86 @@
+// Generates the MapLibre styles for the vector base map.
+//
+// Only the styles. Glyphs, sprites and tiles are served by core's proxy, which
+// is what lets them be requested with an application User-Agent and without a
+// referrer. The styles stay here because they come from @versatiles/style and
+// core has no node toolchain to regenerate them with.
+
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { colorful, eclipse } from "@versatiles/style";
+import fs from "fs-extra";
+import gulp from "gulp";
+import paths from "../paths.cjs";
+import { addLatinLabels } from "./map-labels.js";
+
+const PROXY_PATH = "/api/map_tiles";
+const TILEJSON_URL = `${PROXY_PATH}/tilejson.json`;
+
+const outputDir = path.resolve(paths.build_dir, "map");
+
+// MapLibre extends the fetched TileJSON with the style's source options, so
+// anything left here wins and freezes at build time. Dropping them is what lets
+// the proxy move the attribution and zoom range too, not just the URLs.
+const TILEJSON_FIELDS = [
+  "tiles",
+  "attribution",
+  "bounds",
+  "minzoom",
+  "maxzoom",
+  "scheme",
+];
+
+// The builder can only write a tile URL, so the source is repointed afterwards.
+// Keyed on there being exactly one source: any other shape means the builder's
+// own default host would ship unnoticed.
+const useTileJson = (name, style) => {
+  const sources = Object.values(style.sources);
+
+  if (sources.length !== 1) {
+    throw new Error(
+      `Style "${name}" has ${sources.length} sources, expected exactly one to ` +
+        `point at the TileJSON. Check what @versatiles/style emits.`
+    );
+  }
+
+  for (const field of TILEJSON_FIELDS) {
+    delete sources[0][field];
+  }
+  sources[0].url = TILEJSON_URL;
+  return style;
+};
+
+const styleOptions = {
+  // Keeps the generated URLs origin relative.
+  baseUrl: "",
+  glyphs: `${PROXY_PATH}/fonts/{fontstack}/{range}.pbf`,
+  sprite: [{ id: "basics", url: `${PROXY_PATH}/sprites/basics/sprites` }],
+};
+
+const buildMapAssets = async () => {
+  await fs.emptyDir(outputDir);
+
+  await Promise.all(
+    // Both themes up front: dark is a real cartography, not an inverted raster.
+    [
+      ["light", colorful],
+      ["dark", eclipse],
+    ].map(([name, builder]) =>
+      writeFile(
+        path.join(outputDir, `${name}.json`),
+        JSON.stringify(addLatinLabels(useTileJson(name, builder(styleOptions))))
+      )
+    )
+  );
+};
+
+// Shared so it does not have to be wired into every pipeline separately.
+let pending;
+export const ensureMapAssets = () => {
+  pending ??= buildMapAssets();
+  return pending;
+};
+
+gulp.task("build-map-assets", ensureMapAssets);
+
+export const mapAssetsDir = outputDir;

build-scripts/gulp/map-labels.js

@@ -0,0 +1,42 @@
+// Adds the English name to labels whose local name is not in Latin script.
+// Shortbread tiles carry `name`, `name_en` and `name_de` only.
+
+const NAME = ["get", "name"];
+const NAME_EN = ["get", "name_en"];
+
+// Strings compare by code point: anything from Basic Latin up to Latin
+// Extended-B, digits and punctuation included.
+const IS_LATIN = ["<", NAME, "ɐ"];
+
+const ENGLISH_SCALE = 0.8;
+
+// Streets are line-placed and cannot break lines.
+const withEnglish = (placement) =>
+  placement === "line"
+    ? ["concat", NAME, " (", NAME_EN, ")"]
+    : ["format", NAME, {}, "\n", {}, NAME_EN, { "font-scale": ENGLISH_SCALE }];
+
+const isNameLabel = (layer) =>
+  JSON.stringify(layer.layout?.["text-field"]) === JSON.stringify(NAME);
+
+export const addLatinLabels = (style) => ({
+  ...style,
+  layers: style.layers.map((layer) =>
+    isNameLabel(layer)
+      ? {
+          ...layer,
+          layout: {
+            ...layer.layout,
+            "text-field": [
+              "case",
+              IS_LATIN,
+              NAME,
+              ["!", ["has", "name_en"]],
+              NAME,
+              withEnglish(layer.layout["symbol-placement"]),
+            ],
+          },
+        }
+      : layer
+  ),
+});

build-scripts/gulp/merge-translations.js

@@ -0,0 +1,45 @@
+import merge from "lodash.merge";
+
+const isMergeableObject = (value) =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+// Keys that must never be written to, to avoid prototype pollution when the
+// overlay comes from an untrusted source (JSON.parse can produce an own
+// `__proto__` key from `{"__proto__": ...}`).
+const FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+// Deep-merge `overlay` onto `base`, keeping only keys that already exist as own
+// properties of `base`. Overlay keys with no counterpart in the base - e.g.
+// translations for source strings that have since been removed from or renamed
+// in en.json but still linger in Lokalise - are dropped so we don't ship stale
+// keys. `base` is mutated and returned.
+export const restrictedMerge = (base, overlay) => {
+  for (const key of Object.keys(overlay)) {
+    // Own-property check (not `in`) so inherited keys like `__proto__` or
+    // `toString` from the overlay are ignored rather than merged.
+    if (FORBIDDEN_KEYS.has(key) || !Object.hasOwn(base, key)) {
+      continue;
+    }
+    const baseValue = base[key];
+    const overlayValue = overlay[key];
+    if (isMergeableObject(baseValue) && isMergeableObject(overlayValue)) {
+      restrictedMerge(baseValue, overlayValue);
+    } else if (
+      !isMergeableObject(baseValue) &&
+      !isMergeableObject(overlayValue)
+    ) {
+      base[key] = overlayValue;
+    }
+    // Mismatched shapes keep the base (English) value as a safe fallback.
+  }
+  return base;
+};
+
+// Merge translation `objects` onto `startObj`. When `prune` is set, the result
+// is restricted to the key shape of `startObj` (the English master), so keys
+// that no longer exist in en.json are not shipped. Otherwise keys are merged
+// additively (used when building the English master itself, which starts empty).
+export const mergeTranslations = (startObj, objects, prune = false) =>
+  prune
+    ? objects.reduce(restrictedMerge, startObj)
+    : merge(startObj, ...objects);

build-scripts/gulp/rspack.js

@@ -108,7 +108,7 @@ const runDevServer = async ({
   }
 };
 
-const doneHandler = (done) => (err, stats) => {
+const doneHandler = () => (err, stats) => {
   if (err) {
     log.error(err.stack || err);
     if (err.details) {
@@ -122,18 +122,26 @@ const doneHandler = (done) => (err, stats) => {
   }
 
   log(`Build done @ ${new Date().toLocaleTimeString()}`);
-
-  if (done) {
-    done();
-  }
 };
 
 const prodBuild = (conf) =>
-  new Promise((resolve) => {
+  new Promise((resolve, reject) => {
     rspack(
       conf,
       // Resolve promise when done. Because we pass a callback, rspack closes itself
-      doneHandler(resolve)
+      (err, stats) => {
+        if (err) {
+          reject(err);
+        } else if (stats.hasErrors()) {
+          reject(Error(stats.toString("errors-only")));
+        } else {
+          if (stats.hasWarnings()) {
+            console.log(stats.toString("minimal"));
+          }
+          log(`Build done @ ${new Date().toLocaleTimeString()}`);
+          resolve();
+        }
+      }
     );
   });
 
@@ -160,6 +168,17 @@ gulp.task("rspack-prod-app", () =>
   )
 );
 
+gulp.task("rspack-prod-app-modern", () =>
+  prodBuild(
+    createAppConfig({
+      isProdBuild: true,
+      isStatsBuild: env.isStatsBuild(),
+      isTestBuild: env.isTestBuild(),
+      latestBuild: true,
+    })
+  )
+);
+
 gulp.task("rspack-dev-server-demo", () =>
   runDevServer({
     compiler: rspack(
@@ -233,6 +252,7 @@ gulp.task("rspack-prod-gallery", () =>
     createGalleryConfig({
       isProdBuild: true,
       latestBuild: true,
+      isTestBuild: env.isTestBuild(),
     })
   )
 );

build-scripts/gulp/service-worker.js

@@ -34,9 +34,9 @@ gulp.task("gen-service-worker-app-dev", async () => {
   );
 });
 
-gulp.task("gen-service-worker-app-prod", () =>
+const genServiceWorker = (builds) =>
   Promise.all(
-    Object.entries(SW_MAP).map(async ([outPath, build]) => {
+    builds.map(async ([outPath, build]) => {
       const manifest = JSON.parse(
         await readFile(join(outPath, "manifest.json"), "utf-8")
       );
@@ -83,5 +83,12 @@ gulp.task("gen-service-worker-app-prod", () =>
         await symlink(basename(swDest), swOld);
       }
     })
-  )
+  );
+
+gulp.task("gen-service-worker-app-prod", () =>
+  genServiceWorker(Object.entries(SW_MAP))
+);
+
+gulp.task("gen-service-worker-app-prod-modern", () =>
+  genServiceWorker([[paths.app_output_latest, "modern"]])
 );

build-scripts/gulp/translations.js

@@ -1,10 +1,7 @@
-/* eslint-disable max-classes-per-file */
-
 import { deleteAsync } from "del";
 import { glob } from "glob";
 import gulp from "gulp";
 import rename from "gulp-rename";
-import merge from "lodash.merge";
 import { createHash } from "node:crypto";
 import { mkdir, readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
@@ -12,6 +9,7 @@ import { PassThrough, Transform } from "node:stream";
 import { finished } from "node:stream/promises";
 import env from "../env.cjs";
 import paths from "../paths.cjs";
+import { mergeTranslations } from "./merge-translations.js";
 import "./fetch-nightly-translations.js";
 
 const inFrontendDir = "translations/frontend";
@@ -58,11 +56,12 @@ class CustomJSON extends Transform {
 class MergeJSON extends Transform {
   _objects = [];
 
-  constructor(stem, startObj = {}, reviver = null) {
+  constructor(stem, startObj = {}, reviver = null, prune = false) {
     super({ objectMode: true, allowHalfOpen: false });
     this._stem = stem;
     this._startObj = structuredClone(startObj);
     this._reviver = reviver;
+    this._prune = prune;
   }
 
   // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -74,7 +73,11 @@ class MergeJSON extends Transform {
 
   // eslint-disable-next-line @typescript-eslint/naming-convention
   async _flush(callback) {
-    const mergedObj = merge(this._startObj, ...this._objects);
+    const mergedObj = mergeTranslations(
+      this._startObj,
+      this._objects,
+      this._prune
+    );
     this._outFile.contents = Buffer.from(JSON.stringify(mergedObj));
     this._outFile.stem = this._stem;
     callback(null, this._outFile);
@@ -259,7 +262,7 @@ const createTranslations = async () => {
     }
     const mergeStream = gulp
       .src(mergeFiles, { allowEmpty: true })
-      .pipe(new MergeJSON(locale, enMaster, emptyReviver));
+      .pipe(new MergeJSON(locale, enMaster, emptyReviver, true));
     mergesFinished.push(finished(mergeStream));
     mergeStream.pipe(hashStream, { end: false });
   }

build-scripts/list-plugins-and-polyfills.js

@@ -1,38 +1,55 @@
 #!/usr/bin/env node
 // Script to print Babel plugins and Core JS polyfills that will be used by browserslist environments
 
-import { version as babelVersion } from "@babel/core";
-import presetEnv from "@babel/preset-env";
-import compilationTargets from "@babel/helper-compilation-targets";
+import { transformSync } from "@babel/core";
+import compilationTargets, {
+  getInclusionReasons,
+} from "@babel/helper-compilation-targets";
 import coreJSCompat from "core-js-compat";
-import { logPlugin } from "@babel/preset-env/lib/debug.js";
-import shippedPolyfills from "../node_modules/babel-plugin-polyfill-corejs3/lib/shipped-proposals.js";
 import { babelOptions } from "./bundle.cjs";
 
 const detailsOpen = (heading) =>
   `<details>\n<summary><h4>${heading}</h4></summary>\n`;
 const detailsClose = "</details>\n";
 
-const dummyAPI = {
-  version: babelVersion,
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  assertVersion: () => {},
-  caller: (callback) =>
-    callback({
-      name: "Dummy Bundler",
-      supportsStaticESM: true,
-      supportsDynamicImport: true,
-      supportsTopLevelAwait: true,
-      supportsExportNamespaceFrom: true,
-    }),
-  targets: () => ({}),
+// Copied from @babel/preset-env's internal `logPlugin`, which Babel 8 no
+// longer exposes (the package rolls up into lib/index.js and exports nothing
+// but the preset). Prints an item with the targets that require it.
+const logPlugin = (item, targetVersions, list) => {
+  const filteredList = getInclusionReasons(item, targetVersions, list);
+  const support = list[item];
+  if (!support) {
+    console.log(`  ${item}`);
+    return;
+  }
+  let formattedTargets = `{`;
+  let first = true;
+  for (const target of Object.keys(filteredList)) {
+    if (!first) formattedTargets += `,`;
+    first = false;
+    formattedTargets += ` ${target}`;
+    if (support[target]) formattedTargets += ` < ${support[target]}`;
+  }
+  formattedTargets += ` }`;
+  console.log(`  ${item} ${formattedTargets}`);
 };
 
+// Copied from babel-plugin-polyfill-corejs3's generated
+// corejs3ShippedProposalsList, which v1 no longer exposes (it is inlined in
+// the package's rolled-up bundle).
+const shippedProposalsList = new Set([
+  "esnext.array.group",
+  "esnext.array.group-to-map",
+  "esnext.iterator.zip",
+  "esnext.iterator.zip-keyed",
+  "esnext.symbol.metadata",
+]);
+
 // Generate filter function based on proposal/method inputs
 // Copied and adapted from babel-plugin-polyfill-corejs3/esm/index.mjs
 const polyfillFilter = (method, proposals, shippedProposals) => (name) => {
   if (proposals || method === "entry-global") return true;
-  if (shippedProposals && shippedPolyfills.default.has(name)) {
+  if (shippedProposals && shippedProposalsList.has(name)) {
     return true;
   }
   if (name.startsWith("esnext.")) {
@@ -47,7 +64,9 @@ const polyfillFilter = (method, proposals, shippedProposals) => (name) => {
 for (const buildType of ["Modern", "Legacy"]) {
   const browserslistEnv = buildType.toLowerCase();
   const babelOpts = babelOptions({ latestBuild: browserslistEnv === "modern" });
-  const presetEnvOpts = babelOpts.presets[0][1];
+  const presetEnvOpts = babelOpts.presets.find(
+    (preset) => Array.isArray(preset) && preset[0] === "@babel/preset-env"
+  )?.[1];
   // Core-JS polyfills are injected by babel-plugin-polyfill-corejs3 (Babel 8
   // removed preset-env's `useBuiltIns`), so read its options here.
   const corejsOpts = babelOpts.plugins.find(
@@ -55,22 +74,38 @@ for (const buildType of ["Modern", "Legacy"]) {
       Array.isArray(plugin) && plugin[0] === "babel-plugin-polyfill-corejs3"
   )?.[1];
 
-  // Invoking preset-env in debug mode will log the included plugins
+  // Transforming an empty file with preset-env in debug mode logs the included
+  // plugins. The caller declares the same capabilities babel-loader does, so
+  // plugins gated on bundler support (e.g. transform-export-namespace-from)
+  // match the build.
+  presetEnvOpts.debug = true;
   console.log(detailsOpen(`${buildType} Build Babel Plugins`));
-  presetEnv.default(dummyAPI, {
-    ...presetEnvOpts,
-    browserslistEnv,
-    debug: true,
+  transformSync("", {
+    ...babelOpts,
+    configFile: false,
+    filename: "audit.js",
+    caller: {
+      name: "list-plugins-and-polyfills",
+      supportsStaticESM: true,
+      supportsDynamicImport: true,
+      supportsTopLevelAwait: true,
+      supportsExportNamespaceFrom: true,
+    },
   });
   console.log(detailsClose);
 
   // Manually log the Core-JS polyfills using the same technique
   if (corejsOpts) {
     console.log(detailsOpen(`${buildType} Build Core-JS Polyfills`));
-    const targets = compilationTargets.default(babelOpts?.targets, {
+    const targets = compilationTargets(babelOpts.targets, {
       browserslistEnv,
     });
-    const polyfillList = coreJSCompat({ targets }).list.filter(
+    // `version` limits the list to modules the installed core-js ships,
+    // mirroring the provider's own filtering.
+    const polyfillList = coreJSCompat({
+      targets,
+      version: corejsOpts.version,
+    }).list.filter(
       polyfillFilter(
         corejsOpts.method,
         corejsOpts.proposals,

build-scripts/managed-process.mjs

@@ -0,0 +1,552 @@
+import { spawn, execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+
+export const LIFECYCLE_MODE_FLAGS = new Map([
+  ["--background", "background"],
+  ["--status", "status"],
+  ["--stop", "stop"],
+  ["--logs", "logs"],
+]);
+
+const AGENT_PROVIDERS = [
+  {
+    id: "opencode",
+    env: [
+      "OPENCODE",
+      "OPENCODE_BIN_PATH",
+      "OPENCODE_SERVER",
+      "OPENCODE_APP_INFO",
+      "OPENCODE_MODES",
+    ],
+    processes: ["opencode"],
+  },
+  {
+    id: "claude-code",
+    env: ["CLAUDECODE"],
+    processes: ["claude"],
+  },
+  {
+    id: "cursor",
+    env: ["CURSOR_TRACE_ID"],
+    processes: [],
+  },
+  {
+    id: "github-copilot",
+    matchesEnv: (env) =>
+      env.TERM_PROGRAM === "vscode" && env.GIT_PAGER === "cat",
+    processes: [],
+  },
+  {
+    id: "generic",
+    env: ["AGENT", "AI_AGENT"],
+    processes: [],
+  },
+];
+const MAX_ANCESTRY_HOPS = 24;
+
+const readProcessParent = (pid) => {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+    const commandEnd = stat.lastIndexOf(")");
+    const commandStart = stat.indexOf("(");
+    if (commandStart === -1 || commandEnd === -1) {
+      return undefined;
+    }
+    const parentPid = Number.parseInt(
+      stat.slice(commandEnd + 2).split(" ")[1] ?? "",
+      10
+    );
+    return Number.isFinite(parentPid)
+      ? {
+          command: stat.slice(commandStart + 1, commandEnd).toLowerCase(),
+          parentPid,
+        }
+      : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+export const detectCodingAgent = (env = process.env, pid = process.pid) => {
+  if (env.HA_CODING_AGENT === "0") {
+    return undefined;
+  }
+  const envMatch = AGENT_PROVIDERS.find(
+    (provider) =>
+      provider.matchesEnv?.(env) || provider.env?.some((name) => env[name])
+  );
+  if (envMatch) {
+    return envMatch.id;
+  }
+  if (env.HA_CODING_AGENT === "1") {
+    return "unknown";
+  }
+  let currentPid = pid;
+  for (let hop = 0; hop < MAX_ANCESTRY_HOPS; hop++) {
+    const processInfo = readProcessParent(currentPid);
+    if (!processInfo) {
+      return undefined;
+    }
+    const processMatch = AGENT_PROVIDERS.find((provider) =>
+      provider.processes.some((name) => processInfo.command.includes(name))
+    );
+    if (processMatch) {
+      return processMatch.id;
+    }
+    if (processInfo.parentPid <= 1) {
+      return undefined;
+    }
+    currentPid = processInfo.parentPid;
+  }
+  return undefined;
+};
+
+const canPromptForConflict = () =>
+  Boolean(process.stdin.isTTY && process.stderr.isTTY && !detectCodingAgent());
+
+const formatCommand = (command) =>
+  !("NO_COLOR" in process.env)
+    ? `\u001b[1;36m${command}\u001b[0m`
+    : `\`${command}\``;
+
+const confirmStopConflict = async (ownerDescription, stopCommand) => {
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 30_000);
+  try {
+    process.stderr.write(
+      `${ownerDescription} can be stopped with ${formatCommand(stopCommand)}.\n`
+    );
+    const answer = await readline.question("Stop it and continue? [y/N] ", {
+      signal: controller.signal,
+    });
+    return ["y", "yes"].includes(answer.trim().toLowerCase());
+  } catch (err) {
+    if (err?.name !== "AbortError") {
+      throw err;
+    }
+    process.stderr.write("\n");
+    return false;
+  } finally {
+    clearTimeout(timeout);
+    readline.close();
+  }
+};
+
+export const sleep = (ms) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+export const waitFor = async (predicate, intervalMs, timeoutMs) => {
+  const deadline = Date.now() + timeoutMs;
+  const poll = async () => {
+    if (await predicate()) {
+      return true;
+    }
+    if (Date.now() >= deadline) {
+      return false;
+    }
+    await sleep(intervalMs);
+    return poll();
+  };
+  return poll();
+};
+
+export const isProcessAlive = (pid) => {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM means the process exists but is owned by someone else.
+    return err.code === "EPERM";
+  }
+};
+
+export const processStartTime = (pid) => {
+  if (!isProcessAlive(pid)) {
+    return undefined;
+  }
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+    return stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19];
+  } catch {
+    try {
+      return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+    } catch {
+      return undefined;
+    }
+  }
+};
+
+export const isProcessRecordAlive = ({ pid, startTime }) =>
+  Boolean(startTime) && processStartTime(pid) === startTime;
+
+export const readProcessRecord = (file) => {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, "utf8"));
+    return data && Number.isInteger(data.pid) ? data : undefined;
+  } catch (err) {
+    if (err.code === "ENOENT" || err instanceof SyntaxError) {
+      return undefined;
+    }
+    throw err;
+  }
+};
+
+export const writeProcessRecord = (file, data) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(data));
+    fs.renameSync(temporary, file);
+  } finally {
+    removeFileIfExists(temporary);
+  }
+};
+
+export const removeProcessRecord = (file) => {
+  removeFileIfExists(file);
+};
+
+export const acquireProcessRecord = (file, data) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs.openSync(file, "wx");
+      try {
+        fs.writeFileSync(fd, JSON.stringify(data));
+      } finally {
+        fs.closeSync(fd);
+      }
+      return { acquired: true };
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+      const existing = readProcessRecord(file);
+      if (existing && isProcessRecordAlive(existing)) {
+        return { acquired: false, existing };
+      }
+      if (!existing && isRecentFile(file)) {
+        return { acquired: false };
+      }
+      const removed = withExclusiveFileLockSync(`${file}.cleanup`, () => {
+        const current = readProcessRecord(file);
+        if (
+          current &&
+          (current.token !== existing?.token || isProcessRecordAlive(current))
+        ) {
+          return false;
+        }
+        removeProcessRecord(file);
+        return true;
+      });
+      if (!removed.acquired || !removed.value) {
+        return { acquired: false, existing: readProcessRecord(file) };
+      }
+    }
+  }
+  return { acquired: false, existing: readProcessRecord(file) };
+};
+
+export const releaseProcessRecord = (file, token, onRelease) => {
+  if (!token) {
+    return;
+  }
+  withExclusiveFileLockSync(`${file}.cleanup`, () => {
+    const existing = readProcessRecord(file);
+    if (!existing || existing.token === token) {
+      onRelease?.();
+      if (existing) {
+        removeProcessRecord(file);
+      }
+    }
+  });
+};
+
+const removeFileIfExists = (file) => {
+  try {
+    fs.rmSync(file);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+};
+
+const isRecentFile = (file) => {
+  try {
+    return Date.now() - fs.statSync(file).mtimeMs < 5000;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  }
+};
+
+export const withExclusiveFileLockSync = (file, operation) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    let fd;
+    try {
+      fd = fs.openSync(file, "wx");
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+      const owner = readProcessRecord(file);
+      if (owner && isProcessRecordAlive(owner)) {
+        return { acquired: false };
+      }
+      if (!owner && isRecentFile(file)) {
+        return { acquired: false };
+      }
+      removeFileIfExists(file);
+      continue;
+    }
+    try {
+      fs.writeFileSync(
+        fd,
+        JSON.stringify({
+          pid: process.pid,
+          startTime: processStartTime(process.pid),
+        })
+      );
+      return { acquired: true, value: operation() };
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } finally {
+        removeFileIfExists(file);
+      }
+    }
+  }
+  return { acquired: false };
+};
+
+export const spawnForeground = ({
+  cmd,
+  args,
+  cwd,
+  env,
+  processGroup = false,
+  onSpawn,
+}) =>
+  new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      detached: processGroup,
+      env,
+      stdio: "inherit",
+    });
+    let settled = false;
+    const forwardSigint = () =>
+      signalProcess(child.pid, "SIGINT", processGroup);
+    const forwardSigterm = () =>
+      signalProcess(child.pid, "SIGTERM", processGroup);
+    const forwardSighup = () =>
+      signalProcess(child.pid, "SIGHUP", processGroup);
+    const removeSignalHandlers = () => {
+      process.off("SIGINT", forwardSigint);
+      process.off("SIGTERM", forwardSigterm);
+      process.off("SIGHUP", forwardSighup);
+    };
+    if (processGroup) {
+      process.on("SIGINT", forwardSigint);
+      process.on("SIGTERM", forwardSigterm);
+      process.on("SIGHUP", forwardSighup);
+    }
+    child.once("spawn", () => {
+      try {
+        onSpawn?.(child);
+      } catch (err) {
+        settled = true;
+        signalProcess(child.pid, "SIGTERM", processGroup);
+        removeSignalHandlers();
+        reject(err);
+      }
+    });
+    child.once("error", (err) => {
+      if (!settled) {
+        settled = true;
+        removeSignalHandlers();
+        process.stderr.write(`Failed to start ${cmd}: ${err.message}\n`);
+        resolve(1);
+      }
+    });
+    child.once("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        removeSignalHandlers();
+        resolve(code ?? 1);
+      }
+    });
+  });
+
+export const spawnDetachedToLog = ({ cmd, args, cwd, env, logFile }) =>
+  new Promise((resolve, reject) => {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    const fd = fs.openSync(logFile, "w");
+    let child;
+    try {
+      child = spawn(cmd, args, {
+        cwd,
+        detached: true,
+        env,
+        stdio: ["ignore", fd, fd],
+      });
+    } finally {
+      fs.closeSync(fd);
+    }
+    child.once("spawn", () => {
+      child.unref();
+      resolve(child);
+    });
+    child.once("error", reject);
+  });
+
+const signalProcess = (pid, signal, processGroup) => {
+  if (processGroup) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+      // Fall back to the process itself.
+    }
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {
+    // Already gone.
+  }
+};
+
+export const terminateProcess = async ({
+  pid,
+  isStopped,
+  processGroup = true,
+  graceMs = 10_000,
+}) => {
+  signalProcess(pid, "SIGTERM", processGroup);
+  if (await waitFor(isStopped, 300, graceMs)) {
+    return true;
+  }
+  signalProcess(pid, "SIGKILL", processGroup);
+  await sleep(300);
+  return await isStopped();
+};
+
+const sameProcessRecord = (current, expected) =>
+  Boolean(expected?.token) && current?.token === expected.token;
+
+const stopProcessRecord = async (file, owner) => {
+  let current = readProcessRecord(file);
+  if (!current) {
+    return true;
+  }
+  if (!sameProcessRecord(current, owner)) {
+    return false;
+  }
+  if (!isProcessRecordAlive(current)) {
+    releaseProcessRecord(file, current.token);
+    return true;
+  }
+  const stopped = await terminateProcess({
+    pid: current.pid,
+    processGroup: current.processGroup ?? false,
+    isStopped: () => {
+      const latest = readProcessRecord(file);
+      return (
+        !sameProcessRecord(latest, owner) ||
+        !latest ||
+        !isProcessRecordAlive(latest)
+      );
+    },
+  });
+  current = readProcessRecord(file);
+  if (current && !sameProcessRecord(current, owner)) {
+    return false;
+  }
+  if (!stopped && current) {
+    return false;
+  }
+  releaseProcessRecord(file, owner.token);
+  return true;
+};
+
+export const offerToStopProcessRecord = async ({
+  file,
+  owner,
+  ownerDescription,
+  stopCommand,
+}) => {
+  if (
+    !owner ||
+    !stopCommand ||
+    !canPromptForConflict() ||
+    !(await confirmStopConflict(ownerDescription, stopCommand))
+  ) {
+    return false;
+  }
+  return stopProcessRecord(file, owner);
+};
+
+export const terminateDetachedProcess = (child) =>
+  terminateProcess({
+    pid: child.pid,
+    processGroup: true,
+    isStopped: () => !isProcessAlive(child.pid),
+  });
+
+export const outputLog = (logFile, follow, missingMessage) => {
+  if (!fs.existsSync(logFile)) {
+    process.stdout.write(missingMessage);
+    return Promise.resolve(0);
+  }
+  if (!follow) {
+    process.stdout.write(fs.readFileSync(logFile, "utf8"));
+    return Promise.resolve(0);
+  }
+  return new Promise((resolve) => {
+    const tail = spawn("tail", ["-f", logFile], { stdio: "inherit" });
+    let settled = false;
+    tail.once("error", () => {
+      if (!settled) {
+        settled = true;
+        process.stdout.write(fs.readFileSync(logFile, "utf8"));
+        resolve(0);
+      }
+    });
+    tail.once("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        resolve(code ?? 1);
+      }
+    });
+  });
+};
+
+export const runCli = (main) => {
+  main().then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (err) => {
+      process.stderr.write(`${err?.stack || err}\n`);
+      process.exitCode = 1;
+    }
+  );
+};

build-scripts/output-lock.mjs

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  acquireProcessRecord,
+  processStartTime,
+  readProcessRecord,
+  releaseProcessRecord,
+} from "./managed-process.mjs";
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+export const buildCacheDir =
+  process.env.HA_BUILD_CACHE_DIR ??
+  path.join(repoRoot, "node_modules", ".cache");
+
+const WORKFLOW_LOCK_TOKEN_ENV = "HA_WORKFLOW_LOCK_TOKEN";
+const signalCleanups = new Set();
+const cleanupSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+
+const handleSignal = (signal) => {
+  for (const cleanup of signalCleanups) {
+    cleanup();
+  }
+  for (const cleanupSignal of cleanupSignals) {
+    process.off(cleanupSignal, handleSignal);
+  }
+  process.kill(process.pid, signal);
+};
+
+const registerSignalCleanup = (cleanup) => {
+  if (signalCleanups.size === 0) {
+    for (const signal of cleanupSignals) {
+      process.on(signal, handleSignal);
+    }
+  }
+  signalCleanups.add(cleanup);
+};
+
+const unregisterSignalCleanup = (cleanup) => {
+  signalCleanups.delete(cleanup);
+  if (signalCleanups.size === 0) {
+    for (const signal of cleanupSignals) {
+      process.off(signal, handleSignal);
+    }
+  }
+};
+
+export const workflowLockFile = path.join(buildCacheDir, "ha-workflow.lock");
+
+export const workflowLockEnv = (token) => ({
+  ...process.env,
+  [WORKFLOW_LOCK_TOKEN_ENV]: token,
+});
+
+export const describeOutputOwner = (owner) => {
+  if (owner?.kind === "build") {
+    return `frontend ${owner.modern ? "modern " : ""}build`;
+  }
+  if (owner?.kind === "dev") {
+    return `dev server (${owner.suite ?? "app"})`;
+  }
+  return owner?.target ? `Gulp task ${owner.target}` : "another process";
+};
+
+const createLockTask = ({ file, inheritedTokenEnv, kind, label, target }) => {
+  let exitToken;
+
+  const cleanup = () => {
+    if (!exitToken) {
+      return;
+    }
+    releaseProcessRecord(file, exitToken);
+    exitToken = undefined;
+    process.off("exit", cleanup);
+    unregisterSignalCleanup(cleanup);
+  };
+  const acquire = async () => {
+    const inheritedToken = process.env[inheritedTokenEnv];
+    if (inheritedToken) {
+      if (readProcessRecord(file)?.token !== inheritedToken) {
+        throw Error(
+          `${label} lock ownership was lost before ${target} started.`
+        );
+      }
+      exitToken = inheritedToken;
+      process.once("exit", cleanup);
+      registerSignalCleanup(cleanup);
+      return;
+    }
+
+    const token = `${process.pid}-${Date.now()}-${Math.random()}`;
+    const record = {
+      pid: process.pid,
+      startTime: processStartTime(process.pid),
+      processGroup: false,
+      kind,
+      target,
+      token,
+    };
+    const result = acquireProcessRecord(file, record);
+    if (!result.acquired) {
+      const pid = result.existing?.pid;
+      throw Error(
+        `Cannot run ${target}: ${describeOutputOwner(result.existing)} ` +
+          `already owns ${label}${pid ? ` (pid ${pid})` : ""}.`
+      );
+    }
+
+    exitToken = token;
+    process.once("exit", cleanup);
+    registerSignalCleanup(cleanup);
+  };
+
+  acquire.displayName = `lock-${label}:${target}`;
+  return acquire;
+};
+
+export const createWorkflowLockTask = (target) =>
+  createLockTask({
+    file: workflowLockFile,
+    inheritedTokenEnv: WORKFLOW_LOCK_TOKEN_ENV,
+    kind: "output",
+    label: "build and development workflow",
+    target,
+  });

build-scripts/parallel-transform.mjs

@@ -0,0 +1,64 @@
+// Object-mode transform that keeps several files in flight at once.
+//
+// through2 and node's Transform both wait for the previous callback before
+// handling the next file, which serialises asynchronous work down to one file
+// at a time. This keeps `limit` files in flight and applies backpressure beyond
+// that. Files are emitted in completion order rather than input order.
+
+import { Transform } from "node:stream";
+
+export class ParallelTransform extends Transform {
+  #limit;
+
+  #handle;
+
+  #inFlight = 0;
+
+  #resume;
+
+  #finish;
+
+  constructor(limit, handle) {
+    super({ objectMode: true, highWaterMark: limit });
+    this.#limit = limit;
+    this.#handle = handle;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- node's Transform API
+  _transform(file, _encoding, callback) {
+    this.#inFlight += 1;
+    this.#handle(file)
+      .then((result) => {
+        if (result) {
+          this.push(result);
+        }
+      })
+      .catch((error) => this.destroy(error))
+      .finally(() => {
+        this.#inFlight -= 1;
+        const resume = this.#resume;
+        this.#resume = undefined;
+        resume?.();
+        if (this.#inFlight === 0) {
+          const finish = this.#finish;
+          this.#finish = undefined;
+          finish?.();
+        }
+      });
+
+    if (this.#inFlight < this.#limit) {
+      callback();
+    } else {
+      this.#resume = callback;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- node's Transform API
+  _flush(callback) {
+    if (this.#inFlight === 0) {
+      callback();
+    } else {
+      this.#finish = callback;
+    }
+  }
+}

build-scripts/rspack.cjs

@@ -1,4 +1,6 @@
-const { existsSync } = require("fs");
+const fs = require("fs");
+
+const { existsSync } = fs;
 const path = require("path");
 const rspack = require("@rspack/core");
 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -16,6 +18,61 @@ const SafeWebpackBar = require("./safe-webpackbar.cjs");
 const paths = require("./paths.cjs");
 const bundle = require("./bundle.cjs");
 
+// Build-toolchain packages whose version changes the emitted bytes but which
+// are loader/compiler machinery, not modules in the build graph — so rspack's
+// node_modules snapshot cannot see them. Their versions are folded into the
+// persistent cache `version` so a toolchain upgrade invalidates the cache,
+// while ordinary runtime-dependency bumps (handled by the snapshot) do not.
+const TOOLCHAIN_PACKAGES = [
+  "@rspack/core",
+  "@babel/core",
+  "@babel/preset-env",
+  "babel-plugin-polyfill-corejs3",
+  "@babel/plugin-transform-runtime",
+  "@babel/plugin-transform-class-properties",
+  "@babel/plugin-transform-private-methods",
+  "@babel/runtime",
+  "babel-loader",
+  "core-js",
+  "terser",
+  "terser-webpack-plugin",
+  "browserslist",
+  "caniuse-lite",
+];
+
+// Our own build logic — the config, loaders and babel plugins. Their contents
+// (not their paths) go into the cache version, so a change invalidates the
+// cache the same way `buildDependencies` would, but without tying validity to
+// absolute paths — rspack compares buildDependencies by path, which breaks a
+// cache reused on another machine/checkout (a different workspace path).
+const CONFIG_FILES = [
+  __filename,
+  path.join(__dirname, "bundle.cjs"),
+  path.join(__dirname, "minify-template-literals-loader.cjs"),
+  path.join(__dirname, "lit-disable-dev-mode-loader.cjs"),
+  path.join(__dirname, "babel-plugins", "custom-polyfill-plugin.js"),
+  path.join(__dirname, "babel-plugins", "inline-constants-plugin.cjs"),
+];
+
+// Content hash of the toolchain versions and our own build files, used as the
+// persistent cache `version`. Everything here is path-independent so the cache
+// stays valid when reused on a different machine or checkout path.
+const cacheVersion = () => {
+  const parts = [
+    ...TOOLCHAIN_PACKAGES.map(
+      (pkg) => `${pkg}@${require(`${pkg}/package.json`).version}`
+    ),
+    ...CONFIG_FILES.map(
+      (file) => `${path.basename(file)}:${fs.readFileSync(file, "utf8")}`
+    ),
+  ];
+  return require("crypto")
+    .createHash("sha256")
+    .update(parts.join("\n"))
+    .digest("hex")
+    .slice(0, 16);
+};
+
 class LogStartCompilePlugin {
   ignoredFirst = false;
 
@@ -288,10 +345,7 @@ const createRspackConfig = ({
         "lit/directives/join$": "lit/directives/join.js",
         "lit/directives/repeat$": "lit/directives/repeat.js",
         "lit/directives/live$": "lit/directives/live.js",
-        "lit/directives/keyed$": latestBuild
-          ? "lit/directives/keyed.js"
-          : path.resolve(__dirname, "../src/common/lit/keyed-es5.ts"),
-        "lit/polyfill-support$": "lit/polyfill-support.js",
+        "lit/directives/keyed$": "lit/directives/keyed.js",
         "@lit-labs/virtualizer/layouts/grid":
           "@lit-labs/virtualizer/layouts/grid.js",
         "@lit-labs/virtualizer/polyfills/resize-observer-polyfill/ResizeObserver":
@@ -376,6 +430,33 @@ const createRspackConfig = ({
         ])
       ),
     },
+    // Persistent filesystem cache for production builds, opt-in per environment
+    // via RSPACK_CACHE ("readwrite" writes it, "readonly" only reads a warm
+    // cache — e.g. CI reusing the nightly-written one). Unset (releases, local,
+    // tests) = no cache.
+    ...(isProdBuild && process.env.RSPACK_CACHE
+      ? {
+          cache: {
+            type: "persistent",
+            // `name` is already unique per variant (frontend-modern/-legacy).
+            name,
+            // Content-based version (node major + toolchain versions + our own
+            // build files). Everything is path-independent, so the cache stays
+            // valid when reused on another machine/checkout. Runtime deps are
+            // deliberately absent — rspack's node_modules snapshot invalidates
+            // their modules per-package, so a single unrelated bump keeps the
+            // rest warm. buildDependencies is intentionally not used: rspack
+            // compares it by absolute path, which breaks cross-machine reuse.
+            version: `node${process.versions.node.split(".")[0]}-${cacheVersion()}`,
+            storage: {
+              type: "filesystem",
+              directory: path.resolve(paths.root_dir, ".rspack-cache"),
+            },
+            // CI reads the nightly-written cache but must not modify it.
+            readonly: process.env.RSPACK_CACHE === "readonly",
+          },
+        }
+      : {}),
     experiments: {
       outputModule: true,
     },
@@ -405,8 +486,10 @@ const createDemoConfig = ({
 const createCastConfig = ({ isProdBuild, latestBuild }) =>
   createRspackConfig(bundle.config.cast({ isProdBuild, latestBuild }));
 
-const createGalleryConfig = ({ isProdBuild, latestBuild }) =>
-  createRspackConfig(bundle.config.gallery({ isProdBuild, latestBuild }));
+const createGalleryConfig = ({ isProdBuild, latestBuild, isTestBuild }) =>
+  createRspackConfig(
+    bundle.config.gallery({ isProdBuild, latestBuild, isTestBuild })
+  );
 
 const createLandingPageConfig = ({ isProdBuild, latestBuild }) =>
   createRspackConfig(bundle.config.landingPage({ isProdBuild, latestBuild }));

build-scripts/zopfli-worker.mjs

@@ -0,0 +1,18 @@
+// Worker side of the zopfli pool. @gfx/zopfli is a synchronous WASM build, so
+// compressing on the main thread blocks the event loop; one instance per worker
+// is what makes the work parallel.
+
+import { parentPort } from "node:worker_threads";
+import zopfli from "@gfx/zopfli";
+
+parentPort.on("message", ({ contents, options }) => {
+  zopfli.gzip(contents, options, (error, result) => {
+    if (error) {
+      parentPort.postMessage({ error: error.message ?? String(error) });
+      return;
+    }
+    // `result` is a fresh Uint8Array copied out of the WASM heap, so it owns
+    // its ArrayBuffer and can be transferred instead of cloned.
+    parentPort.postMessage({ result }, [result.buffer]);
+  });
+});

build-scripts/zopfli.mjs

@@ -0,0 +1,148 @@
+// Gulp transform that gzips files with zopfli across a pool of worker threads.
+//
+// Drop-in replacement for gulp-zopfli-green. That plugin compresses on the main
+// thread, and @gfx/zopfli is synchronous WASM, so it pins a single core and
+// blocks the event loop for the whole compression step. Running one WASM
+// instance per worker parallelises it; the output bytes are unchanged.
+
+import { createRequire } from "node:module";
+import { availableParallelism } from "node:os";
+import { buffer as readStream } from "node:stream/consumers";
+import { Worker } from "node:worker_threads";
+import { withCache } from "./compress-cache.mjs";
+import { ParallelTransform } from "./parallel-transform.mjs";
+
+const WORKER_URL = new URL("./zopfli-worker.mjs", import.meta.url);
+const EXTENSION = ".gz";
+
+// Cache namespace tied to the zopfli version, since a different version can
+// produce different bytes for the same input.
+const ZOPFLI_VERSION = createRequire(import.meta.url)(
+  "@gfx/zopfli/package.json"
+).version;
+const NAMESPACE = `gzip-zopfli${ZOPFLI_VERSION}`;
+
+// Left empty on purpose: @gfx/zopfli then applies its own defaults, which is
+// what gulp-zopfli-green did, so compressed output stays byte-identical.
+const ZOPFLI_OPTIONS = {};
+
+const poolSize = () => {
+  const configured = Number(process.env.ZOPFLI_WORKERS);
+  return Number.isInteger(configured) && configured > 0
+    ? configured
+    : availableParallelism();
+};
+
+// One job per worker at a time, so the worker itself is the job slot.
+const createPool = (size) => {
+  const live = new Set();
+  const idle = [];
+  const waiting = [];
+  const inFlight = new Map();
+
+  // A dead worker must leave the pool, or it gets handed a job that never
+  // completes and the build hangs instead of failing.
+  const retire = (worker, error) => {
+    if (!live.delete(worker)) {
+      return;
+    }
+    const index = idle.indexOf(worker);
+    if (index !== -1) {
+      idle.splice(index, 1);
+    }
+    const job = inFlight.get(worker);
+    inFlight.delete(worker);
+    job?.reject(error);
+    waiting.shift()?.();
+  };
+
+  const spawn = () => {
+    const worker = new Worker(WORKER_URL);
+    live.add(worker);
+    // Idle workers must not hold the process open. Each job refs its worker for
+    // as long as it runs, so a pending compression always keeps the event loop
+    // alive.
+    worker.unref();
+
+    worker.on("message", ({ error, result }) => {
+      const job = inFlight.get(worker);
+      if (!job) {
+        return;
+      }
+      inFlight.delete(worker);
+      worker.unref();
+      idle.push(worker);
+      if (error) {
+        job.reject(new Error(error));
+      } else {
+        job.resolve(
+          Buffer.from(result.buffer, result.byteOffset, result.byteLength)
+        );
+      }
+      waiting.shift()?.();
+    });
+
+    worker.on("error", (error) => retire(worker, error));
+    worker.on("exit", () =>
+      retire(worker, new Error("zopfli worker exited unexpectedly"))
+    );
+
+    return worker;
+  };
+
+  return (contents) =>
+    new Promise((resolve, reject) => {
+      const start = () => {
+        const worker = idle.pop() ?? (live.size < size ? spawn() : undefined);
+        if (!worker) {
+          waiting.push(start);
+          return;
+        }
+        inFlight.set(worker, { resolve, reject });
+        worker.ref();
+        // `contents` is cloned rather than transferred: buffers read by vinyl
+        // can share a pooled ArrayBuffer with unrelated buffers, and
+        // transferring would detach those too.
+        worker.postMessage({ contents, options: ZOPFLI_OPTIONS });
+      };
+      start();
+    });
+};
+
+// Shared by every transform this module hands out, so the worker count is a
+// property of the process rather than of how many streams happen to run.
+let pool;
+
+const sharedPool = () => {
+  if (!pool) {
+    const size = poolSize();
+    pool = { size, compress: createPool(size) };
+  }
+  return pool;
+};
+
+/**
+ * @param {object} [options]
+ * @param {number} [options.threshold] Skip files smaller than this many bytes.
+ */
+export default ({ threshold = 0 } = {}) => {
+  const { size, compress } = sharedPool();
+
+  return new ParallelTransform(size, async (file) => {
+    if (file.isNull()) {
+      return file;
+    }
+    if (file.isStream()) {
+      file.contents = await readStream(file.contents);
+    }
+    if (threshold && file.contents.length < threshold) {
+      // Passed through unrenamed and uncompressed, as gulp-zopfli-green did.
+      return file;
+    }
+    file.contents = await withCache(NAMESPACE, file.contents, () =>
+      compress(file.contents)
+    );
+    file.path += EXTENSION;
+    return file;
+  });
+};

cast/src/launcher/layout/hc-cast.ts

@@ -15,7 +15,6 @@ import {
   saveTokens,
 } from "../../../../src/common/auth/token_storage";
 import { atLeastVersion } from "../../../../src/common/config/version";
-import { toggleAttribute } from "../../../../src/common/dom/toggle_attribute";
 import "../../../../src/components/ha-button";
 import "../../../../src/components/ha-icon";
 import "../../../../src/components/ha-list";
@@ -197,8 +196,7 @@ class HcCast extends LitElement {
 
   protected updated(changedProps: PropertyValues<this>) {
     super.updated(changedProps);
-    toggleAttribute(
-      this,
+    this.toggleAttribute(
       "hide-icons",
       this.lovelaceViews ? !this.lovelaceViews.some((view) => view.icon) : true
     );

demo/src/cloud/cloud-demo-controls.ts

@@ -1,304 +0,0 @@
-import { mdiClose, mdiFlaskOutline } from "@mdi/js";
-import { css, html, LitElement, nothing } from "lit";
-import { customElement, state } from "lit/decorators";
-import { fireEvent } from "../../../src/common/dom/fire_event";
-import { mainWindow } from "../../../src/common/dom/get_main_window";
-import { navigate } from "../../../src/common/navigate";
-import "../../../src/components/ha-button";
-import "../../../src/components/ha-card";
-import "../../../src/components/ha-icon-button";
-import "../../../src/components/ha-svg-icon";
-import "../../../src/components/ha-switch";
-import type { HaSwitch } from "../../../src/components/ha-switch";
-import type { CloudDemoScenario } from "../stubs/cloud-demo-state";
-import {
-  getCloudDemoScenario,
-  setCloudDemoScenario,
-  subscribeCloudDemoScenario,
-} from "../stubs/cloud-demo-state";
-
-// Walk the DOM, descending into shadow roots, to find the first matching
-// element. Used to reach <ha-panel-config> (which owns the cloud status) so we
-// can ask it to re-fetch after a scenario change.
-const deepQuery = (
-  selector: string,
-  root: Document | ShadowRoot = document
-): Element | null => {
-  const direct = root.querySelector(selector);
-  if (direct) {
-    return direct;
-  }
-  const elements = root.querySelectorAll("*");
-  for (const element of elements) {
-    const shadow = element.shadowRoot;
-    if (shadow) {
-      const found = deepQuery(selector, shadow);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return null;
-};
-
-/**
- * Demo-only floating panel that flips the mocked Home Assistant Cloud state so
- * reviewers can preview every UI state of the cloud account page. It writes to
- * the shared {@link CloudDemoScenario} (which the cloud/backup mocks read) and
- * then nudges the page to re-read it. Lives entirely under demo/.
- */
-@customElement("cloud-demo-controls")
-export class CloudDemoControls extends LitElement {
-  @state() private _open = true;
-
-  @state() private _visible = false;
-
-  @state() private _scenario: CloudDemoScenario = getCloudDemoScenario();
-
-  private _unsub?: () => void;
-
-  // The demo uses hash-based routing (navigate() sets location.hash), so the
-  // active route lives in the hash, not the pathname.
-  private get _currentPath(): string {
-    const hash = mainWindow.location.hash;
-    return hash.startsWith("#/") ? hash.slice(1) : mainWindow.location.pathname;
-  }
-
-  private _locationChanged = () => {
-    this._visible = this._currentPath.startsWith("/config/cloud");
-  };
-
-  public connectedCallback(): void {
-    super.connectedCallback();
-    this._locationChanged();
-    mainWindow.addEventListener("location-changed", this._locationChanged);
-    mainWindow.addEventListener("popstate", this._locationChanged);
-    mainWindow.addEventListener("hashchange", this._locationChanged);
-    this._unsub = subscribeCloudDemoScenario((scenario) => {
-      this._scenario = { ...scenario };
-    });
-  }
-
-  public disconnectedCallback(): void {
-    super.disconnectedCallback();
-    mainWindow.removeEventListener("location-changed", this._locationChanged);
-    mainWindow.removeEventListener("popstate", this._locationChanged);
-    mainWindow.removeEventListener("hashchange", this._locationChanged);
-    this._unsub?.();
-  }
-
-  protected render() {
-    if (!this._visible) {
-      return nothing;
-    }
-    if (!this._open) {
-      return html`
-        <ha-icon-button
-          class="fab"
-          label="Cloud demo controls"
-          .path=${mdiFlaskOutline}
-          @click=${this._toggleOpen}
-        ></ha-icon-button>
-      `;
-    }
-    return html`
-      <ha-card>
-        <div class="header">
-          <ha-svg-icon .path=${mdiFlaskOutline}></ha-svg-icon>
-          <span class="title">Cloud demo controls</span>
-          <ha-icon-button
-            label="Close"
-            .path=${mdiClose}
-            @click=${this._toggleOpen}
-          ></ha-icon-button>
-        </div>
-        <p class="note">
-          Demo only. Flips the mocked cloud state shown on this page.
-        </p>
-        <div class="controls">
-          ${this._segment("Subscription", "account", [
-            ["active", "Active"],
-            ["trialing", "Trialing"],
-            ["canceled", "Canceled"],
-            ["expired", "Expired"],
-            ["unknown", "Unknown"],
-          ])}
-          ${this._toggle("Onboarded", "onboarded")}
-          ${this._toggle("Onboarding postponed", "postponed")}
-          ${this._toggle("Remote access", "remote")}
-          ${this._segment("Remote status", "remoteStatus", [
-            ["ready", "Ready"],
-            ["generating", "Preparing"],
-            ["loading", "Loading"],
-            ["loaded", "Loaded"],
-            ["error", "Error"],
-          ])}
-          ${this._segment("Backups", "backup", [
-            ["fresh", "Recent"],
-            ["stale", "Old"],
-            ["failed", "Failed"],
-            ["local", "Local only"],
-            ["none", "None"],
-          ])}
-          ${this._toggle("Alexa linked", "alexa")}
-          ${this._toggle("Google linked", "google")}
-          ${this._toggle("Cameras (WebRTC)", "webrtc")}
-          ${this._toggle("Has webhooks", "webhooks")}
-        </div>
-      </ha-card>
-    `;
-  }
-
-  private _segment(
-    label: string,
-    field: keyof CloudDemoScenario,
-    options: [string, string][]
-  ) {
-    return html`
-      <div class="row">
-        <span>${label}</span>
-        <div class="segment">
-          ${options.map(
-            ([value, text]) => html`
-              <ha-button
-                size="s"
-                appearance=${
-                  this._scenario[field] === value ? "filled" : "plain"
-                }
-                data-field=${field}
-                data-value=${value}
-                @click=${this._segmentClick}
-              >
-                ${text}
-              </ha-button>
-            `
-          )}
-        </div>
-      </div>
-    `;
-  }
-
-  private _toggle(label: string, field: keyof CloudDemoScenario) {
-    return html`
-      <div class="row">
-        <span>${label}</span>
-        <ha-switch
-          .checked=${this._scenario[field] as boolean}
-          data-field=${field}
-          @change=${this._toggleChange}
-        ></ha-switch>
-      </div>
-    `;
-  }
-
-  private _toggleOpen() {
-    this._open = !this._open;
-  }
-
-  private _segmentClick(ev: Event) {
-    const target = ev.currentTarget as HTMLElement;
-    this._set(
-      target.dataset.field as keyof CloudDemoScenario,
-      target.dataset.value!
-    );
-  }
-
-  private _toggleChange(ev: Event) {
-    const target = ev.target as HaSwitch;
-    this._set(target.dataset.field as keyof CloudDemoScenario, target.checked);
-  }
-
-  private _set(field: keyof CloudDemoScenario, value: string | boolean) {
-    setCloudDemoScenario({ [field]: value } as Partial<CloudDemoScenario>);
-    this._refresh();
-  }
-
-  private _refresh() {
-    // Refresh the shared cloud status so login-state changes (signed out) and
-    // status-derived fields update.
-    const panel = deepQuery("ha-panel-config");
-    if (panel) {
-      fireEvent(panel as HTMLElement, "ha-refresh-cloud-status");
-    }
-    // cloud-account fetches its subscription/backup/webhook data once on mount
-    // and is not cached by the router, so bounce through a sibling cloud route
-    // to force a clean remount that re-reads the updated mocks.
-    const path = this._currentPath;
-    if (path.startsWith("/config/cloud") && path !== "/config/cloud/login") {
-      const sibling =
-        path === "/config/cloud/remote"
-          ? "/config/cloud/account"
-          : "/config/cloud/remote";
-      navigate(sibling, { replace: true });
-      window.setTimeout(() => navigate(path, { replace: true }), 0);
-    }
-  }
-
-  static styles = css`
-    :host {
-      position: fixed;
-      right: 16px;
-      bottom: 16px;
-      z-index: 9999;
-    }
-    .fab {
-      --mdc-icon-button-size: 48px;
-      --mdc-icon-size: 24px;
-      background-color: var(--primary-color);
-      color: var(--text-primary-color, #fff);
-      border-radius: 50%;
-      box-shadow: 0 2px 6px rgba(0, 0, 0, 0.3);
-    }
-    ha-card {
-      display: block;
-      width: 320px;
-      max-height: 80vh;
-      overflow: auto;
-      box-shadow: 0 2px 12px rgba(0, 0, 0, 0.3);
-    }
-    .header {
-      display: flex;
-      align-items: center;
-      gap: 8px;
-      padding: 8px 8px 8px 16px;
-      border-bottom: 1px solid var(--divider-color);
-    }
-    .header .title {
-      flex: 1;
-      font-weight: var(--ha-font-weight-medium, 500);
-    }
-    .header ha-svg-icon {
-      color: var(--secondary-text-color);
-    }
-    .note {
-      margin: 8px 16px;
-      color: var(--secondary-text-color);
-      font-size: var(--ha-font-size-s, 0.875rem);
-    }
-    .controls {
-      display: flex;
-      flex-direction: column;
-      gap: 8px;
-      padding: 0 16px 16px;
-    }
-    .row {
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      gap: 12px;
-      min-height: 36px;
-    }
-    .segment {
-      display: flex;
-      gap: 4px;
-      flex-wrap: wrap;
-      justify-content: flex-end;
-    }
-  `;
-}
-
-declare global {
-  interface HTMLElementTagNameMap {
-    "cloud-demo-controls": CloudDemoControls;
-  }
-}

demo/src/configs/demo-configs.ts

@@ -3,6 +3,7 @@ import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
 import type { Lovelace } from "../../../src/panels/lovelace/types";
 import { setDemoAreas } from "../stubs/area_registry";
 import { energyEntities } from "../stubs/entities";
+import { connectivityEntities } from "../stubs/connectivity/fixtures";
 import { setDemoFloors } from "../stubs/floor_registry";
 import { getDemoTheme } from "../stubs/frontend";
 import type { DemoConfig, DemoTheme } from "./types";
@@ -53,6 +54,9 @@ export const setDemoConfig = async (
   setDemoAreas(hass, config.areas);
   hass.addEntities(config.entities(hass.localize), true);
   hass.addEntities(energyEntities());
+  // Replaced the whole state map above, so the entities that do not belong to a
+  // demo config have to be added back.
+  hass.addEntities(connectivityEntities());
 
   // Let the new registries and entities reach the dashboard before saving the
   // config, so dashboard strategies generate against them

demo/src/ha-demo.ts

@@ -7,6 +7,12 @@ import { HomeAssistantAppEl } from "../../src/layouts/home-assistant";
 import type { HomeAssistant } from "../../src/types";
 import { applyDemoTheme, selectedDemoConfig } from "./configs/demo-configs";
 import { mockAreaRegistry, setDemoAreas } from "./stubs/area_registry";
+import {
+  connectivityCommands,
+  connectivityComponents,
+  connectivityEntities,
+  connectivityEntityRegistryEntries,
+} from "./stubs/connectivity/fixtures";
 import { mockAuth } from "./stubs/auth";
 import { demoDevices } from "./stubs/devices";
 import { mockDeviceRegistry } from "./stubs/device_registry";
@@ -32,7 +38,6 @@ import { mockTemplate } from "./stubs/template";
 import { mockTodo } from "./stubs/todo";
 import { mockTranslations } from "./stubs/translations";
 import { mockUsagePrediction } from "./stubs/usage_prediction";
-import "./cloud/cloud-demo-controls";
 
 // WS command / REST path prefixes whose mocks live in the lazily imported
 // config-panel chunk (see ./stubs/config-panel). Must stay in sync with it.
@@ -59,6 +64,9 @@ const CONFIG_PANEL_COMMANDS = [
   "search/related",
   "tag/list",
   "assist_pipeline/",
+  "config/entity_registry/settings/",
+  "slugify",
+  ...connectivityCommands,
 ];
 
 @customElement("ha-demo")
@@ -86,15 +94,11 @@ export class HaDemo extends HomeAssistantAppEl {
           "assist_pipeline",
           "hassio",
           "hardware",
+          ...connectivityComponents,
         ],
       },
     });
 
-    // Demo-only floating panel to flip the mocked cloud state. Mounted once at
-    // the document level; it shows itself only on the cloud panel.
-    if (!document.querySelector("cloud-demo-controls")) {
-      document.body.appendChild(document.createElement("cloud-demo-controls"));
-    }
     const localizePromise =
       // @ts-ignore
       this._loadFragmentTranslations(hass.language, "page-demo").then(
@@ -103,7 +107,7 @@ export class HaDemo extends HomeAssistantAppEl {
 
     mockLovelace(hass, localizePromise);
     mockAuth(hass);
-    mockTranslations(hass);
+    mockTranslations(hass, localizePromise);
     mockHistory(hass);
     mockRecorder(hass);
     mockTodo(hass);
@@ -176,9 +180,11 @@ export class HaDemo extends HomeAssistantAppEl {
         created_at: 0,
         modified_at: 0,
       },
+      ...connectivityEntityRegistryEntries,
     ]);
 
     hass.addEntities(energyEntities());
+    hass.addEntities(connectivityEntities());
 
     // Once config is loaded AND localize, set registries, entities and theme.
     Promise.all([selectedDemoConfig, localizePromise]).then(

demo/src/stubs/backup.ts

@@ -7,31 +7,43 @@ import type {
 import { BackupScheduleRecurrence } from "../../../src/data/backup";
 import type { ManagerStateEvent } from "../../../src/data/backup_manager";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
-import type { DemoCloudBackup } from "./cloud-demo-state";
-import {
-  getCloudDemoScenario,
-  setCloudDemoScenario,
-  subscribeCloudDemoScenario,
-} from "./cloud-demo-state";
 
 const CLOUD_AGENT = "cloud.cloud";
 
+// Fixed "recent" backup state: an automatic backup completed 12h ago to both the
+// local and cloud agents, with the next run scheduled for tomorrow. This is the
+// healthy state the cloud overview status line and backup sub-page render.
+const now = Date.now();
+const recent = new Date(now - 12 * 3600 * 1000).toISOString();
+const future = new Date(now + 86400000).toISOString();
+
 const backupInfo: BackupInfo = {
-  backups: [],
+  backups: [
+    {
+      backup_id: "demo-backup-1",
+      name: "Automatic backup DEMO",
+      date: recent,
+      with_automatic_settings: true,
+      agents: {
+        "backup.local": { size: 1024 * 1024 * 512, protected: true },
+        "cloud.cloud": { size: 1024 * 1024 * 512, protected: true },
+      },
+    } as BackupContent,
+  ],
   agent_errors: {},
-  last_attempted_automatic_backup: null,
-  last_completed_automatic_backup: null,
+  last_attempted_automatic_backup: recent,
+  last_completed_automatic_backup: recent,
   last_action_event: { manager_state: "idle" },
-  next_automatic_backup: null,
+  next_automatic_backup: future,
   next_automatic_backup_additional: false,
   state: "idle",
 };
 
 const backupConfig: BackupConfig = {
   automatic_backups_configured: true,
-  last_attempted_automatic_backup: null,
-  last_completed_automatic_backup: null,
-  next_automatic_backup: null,
+  last_attempted_automatic_backup: recent,
+  last_completed_automatic_backup: recent,
+  next_automatic_backup: future,
   next_automatic_backup_additional: false,
   create_backup: {
     agent_ids: ["backup.local", CLOUD_AGENT],
@@ -61,88 +73,6 @@ const agentsInfo: BackupAgentsInfo = {
   ],
 };
 
-// Map the demo "Backups" scenario onto the mutable backup config/info, so the
-// cloud overview status line and the backup sub-page reflect the chosen state.
-const applyScenario = () => {
-  const kind = getCloudDemoScenario().backup;
-  const now = Date.now();
-  const recent = new Date(now - 12 * 3600 * 1000).toISOString();
-  const old = new Date(now - 5 * 86400000).toISOString();
-  const future = new Date(now + 86400000).toISOString();
-  // Comfortably past BACKUP_OVERDUE_MARGIN_HOURS (3h) so the "stale" scenario
-  // actually reads as overdue rather than slipping under the margin.
-  const overdue = new Date(now - 6 * 3600 * 1000).toISOString();
-
-  // The cloud agent is a backup target for the cloud-backed states only. For
-  // "local" a backup exists but is stored locally (no cloud copy), and for
-  // "none" there are no automatic backups at all.
-  const cloudEnabled =
-    kind === "fresh" || kind === "stale" || kind === "failed";
-  backupConfig.create_backup.agent_ids = cloudEnabled
-    ? ["backup.local", CLOUD_AGENT]
-    : ["backup.local"];
-
-  switch (kind) {
-    case "fresh":
-      backupConfig.automatic_backups_configured = true;
-      backupConfig.last_completed_automatic_backup = recent;
-      backupConfig.last_attempted_automatic_backup = recent;
-      backupConfig.next_automatic_backup = future;
-      break;
-    case "local":
-      // Automatic backups run, but only to the local agent.
-      backupConfig.automatic_backups_configured = true;
-      backupConfig.last_completed_automatic_backup = recent;
-      backupConfig.last_attempted_automatic_backup = recent;
-      backupConfig.next_automatic_backup = future;
-      break;
-    case "stale":
-      backupConfig.automatic_backups_configured = true;
-      backupConfig.last_completed_automatic_backup = old;
-      backupConfig.last_attempted_automatic_backup = old;
-      // Next scheduled backup is in the past, so it reads as overdue.
-      backupConfig.next_automatic_backup = overdue;
-      break;
-    case "failed":
-      backupConfig.automatic_backups_configured = true;
-      backupConfig.last_completed_automatic_backup = old;
-      // Most recent attempt is newer than the last success, so it failed.
-      backupConfig.last_attempted_automatic_backup = recent;
-      backupConfig.next_automatic_backup = future;
-      break;
-    case "none":
-      backupConfig.automatic_backups_configured = false;
-      backupConfig.last_completed_automatic_backup = null;
-      backupConfig.last_attempted_automatic_backup = null;
-      backupConfig.next_automatic_backup = null;
-      break;
-  }
-
-  backupInfo.last_completed_automatic_backup =
-    backupConfig.last_completed_automatic_backup;
-  backupInfo.last_attempted_automatic_backup =
-    backupConfig.last_attempted_automatic_backup;
-  backupInfo.next_automatic_backup = backupConfig.next_automatic_backup;
-  backupInfo.backups =
-    cloudEnabled && backupConfig.last_completed_automatic_backup
-      ? [
-          {
-            backup_id: "demo-backup-1",
-            name: "Automatic backup DEMO",
-            date: backupConfig.last_completed_automatic_backup,
-            with_automatic_settings: true,
-            agents: {
-              "backup.local": { size: 1024 * 1024 * 512, protected: true },
-              "cloud.cloud": { size: 1024 * 1024 * 512, protected: true },
-            },
-          } as BackupContent,
-        ]
-      : [];
-};
-
-applyScenario();
-subscribeCloudDemoScenario(applyScenario);
-
 export const mockBackup = (hass: MockHomeAssistant) => {
   // Fresh objects each fetch so re-reading after a mutation actually re-renders
   // (Lit change detection is identity-based; the real WS API returns new
@@ -171,20 +101,6 @@ export const mockBackup = (hass: MockHomeAssistant) => {
     if (update.agents) {
       backupConfig.agents = { ...backupConfig.agents, ...update.agents };
     }
-    // Reflect the UI-driven backup change into the demo scenario so the demo
-    // controls panel stays in sync with the mocked state.
-    const cloudNow = backupConfig.create_backup.agent_ids.includes(CLOUD_AGENT);
-    const current = getCloudDemoScenario().backup;
-    const next: DemoCloudBackup = !backupConfig.automatic_backups_configured
-      ? "none"
-      : cloudNow
-        ? current === "fresh" || current === "stale" || current === "failed"
-          ? current
-          : "fresh"
-        : "local";
-    if (next !== current) {
-      setCloudDemoScenario({ backup: next });
-    }
     return null;
   });
   hass.mockWS(

demo/src/stubs/cloud-demo-state.ts

@@ -1,89 +0,0 @@
-// Demo-only switchable Home Assistant Cloud scenario.
-//
-// The redesigned cloud account page (src/panels/config/cloud/account) renders
-// purely from real WS data. To let reviewers preview every UI state without a
-// real cloud account, this module holds a mutable "scenario" that the cloud and
-// backup mocks read from, plus the floating <cloud-demo-controls> panel writes
-// to. It is persisted to localStorage so the choice survives the data the page
-// fetches once per visit (subscription, backup config, webhooks).
-//
-// This lives entirely under demo/ — no production code imports it.
-
-import type { RemoteCertificateStatus } from "../../../src/data/cloud";
-
-// The five PaymentSubscriptionState values.
-export type DemoCloudAccount =
-  "active" | "trialing" | "canceled" | "expired" | "unknown";
-
-// "local": automatic backups are configured, but not to the cloud agent
-// (a backup exists, just no cloud copy). "none": no automatic backups at all.
-export type DemoCloudBackup = "fresh" | "stale" | "failed" | "local" | "none";
-
-export interface CloudDemoScenario {
-  account: DemoCloudAccount;
-  onboarded: boolean;
-  // Onboarding postponed server-side (maps to onboarding_postponed); hides
-  // the onboarding UI without marking it completed.
-  postponed: boolean;
-  remote: boolean;
-  remoteStatus: RemoteCertificateStatus;
-  backup: DemoCloudBackup;
-  alexa: boolean;
-  google: boolean;
-  webrtc: boolean;
-  webhooks: boolean;
-}
-
-export const DEFAULT_CLOUD_DEMO_SCENARIO: CloudDemoScenario = {
-  account: "active",
-  onboarded: true,
-  postponed: false,
-  remote: true,
-  remoteStatus: "ready",
-  backup: "fresh",
-  alexa: true,
-  google: true,
-  webrtc: true,
-  webhooks: true,
-};
-
-const STORAGE_KEY = "cloudDemoScenario";
-
-const readScenario = (): CloudDemoScenario => {
-  try {
-    const raw = window.localStorage.getItem(STORAGE_KEY);
-    if (raw) {
-      return { ...DEFAULT_CLOUD_DEMO_SCENARIO, ...JSON.parse(raw) };
-    }
-  } catch (_err) {
-    // Ignore malformed or unavailable storage and fall back to the default.
-  }
-  return { ...DEFAULT_CLOUD_DEMO_SCENARIO };
-};
-
-let scenario: CloudDemoScenario = readScenario();
-
-const listeners = new Set<(scenario: CloudDemoScenario) => void>();
-
-export const getCloudDemoScenario = (): CloudDemoScenario => scenario;
-
-export const subscribeCloudDemoScenario = (
-  listener: (scenario: CloudDemoScenario) => void
-): (() => void) => {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-};
-
-export const setCloudDemoScenario = (
-  partial: Partial<CloudDemoScenario>
-): void => {
-  scenario = { ...scenario, ...partial };
-  try {
-    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(scenario));
-  } catch (_err) {
-    // Ignore storage failures (e.g. private mode); state still applies in-memory.
-  }
-  listeners.forEach((listener) => listener(scenario));
-};

demo/src/stubs/cloud.ts

@@ -6,11 +6,6 @@ import { ONBOARDING_ITEMS } from "../../../src/data/cloud";
 import type { CloudTTSInfo } from "../../../src/data/cloud/tts";
 import type { Webhook } from "../../../src/data/webhook";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
-import {
-  getCloudDemoScenario,
-  setCloudDemoScenario,
-  subscribeCloudDemoScenario,
-} from "./cloud-demo-state";
 
 const emptyFilter = () => ({
   include_domains: [],
@@ -34,14 +29,30 @@ const demoWebhooks: Webhook[] = [
   },
 ];
 
-// A single mutable status object so that preference changes made in the demo
-// (both via the real UI and the demo scenario controls) are reflected back.
+const demoCloudhooks = Object.fromEntries(
+  demoWebhooks.map((webhook) => [
+    webhook.webhook_id,
+    {
+      webhook_id: webhook.webhook_id,
+      cloudhook_id: `demo-${webhook.webhook_id}`,
+      cloudhook_url: `https://hooks.nabu.casa/demo-${webhook.webhook_id}`,
+      managed: false,
+    },
+  ])
+);
+
+// A single mutable status object seeded to one fixed demo state: an active cloud
+// subscription with remote ready, cloud backups recent, webhooks set up and voice
+// set up (Alexa linked), but cameras (WebRTC) off, so onboarding is still in
+// progress (streaming is the remaining step) and not postponed. Page-driven
+// changes (connect remote, postpone onboarding, add/delete webhooks) mutate this
+// object directly and reset on reload.
 const cloudStatus: CloudStatusLoggedIn = {
   logged_in: true,
   cloud: "connected",
   cloud_last_disconnect_reason: null,
   email: "[email protected]",
-  google_registered: true,
+  google_registered: false,
   google_entities: emptyFilter(),
   google_domains: ["light", "switch", "climate", "cover"],
   alexa_registered: true,
@@ -58,20 +69,20 @@ const cloudStatus: CloudStatusLoggedIn = {
   http_use_ssl: false,
   active_subscription: true,
   onboarding_postponed: false,
-  onboarding_completed: true,
+  onboarding_completed: false,
   prefs: {
-    google_enabled: true,
+    google_enabled: false,
     alexa_enabled: true,
     remote_enabled: true,
     remote_allow_remote_enable: true,
     strict_connection: "disabled",
     google_secure_devices_pin: undefined,
-    cloudhooks: {},
+    cloudhooks: demoCloudhooks,
     alexa_report_state: true,
     google_report_state: true,
     tts_default_voice: ["en-US", "JennyNeural"],
-    cloud_ice_servers_enabled: true,
-    onboarded_items: [...ONBOARDING_ITEMS],
+    cloud_ice_servers_enabled: false,
+    onboarded_items: [],
     onboarding_postponed_until: null,
   },
 };
@@ -93,94 +104,6 @@ const ttsInfo: CloudTTSInfo = {
   ],
 };
 
-// Map the high-level demo scenario onto the mutable cloud status / subscription.
-const applyScenario = () => {
-  const scenario = getCloudDemoScenario();
-
-  switch (scenario.account) {
-    case "trialing":
-      cloudStatus.active_subscription = true;
-      subscription.subscription = { status: "trialing" };
-      break;
-    case "canceled":
-      cloudStatus.active_subscription = false;
-      subscription.subscription = { status: "canceled" };
-      break;
-    case "expired":
-      cloudStatus.active_subscription = false;
-      subscription.subscription = { status: "expired" };
-      break;
-    case "unknown":
-      cloudStatus.active_subscription = true;
-      subscription.subscription = { status: "unknown" };
-      break;
-    default:
-      // "active"
-      cloudStatus.active_subscription = true;
-      subscription.subscription = { status: "active" };
-  }
-
-  cloudStatus.prefs.onboarded_items = scenario.onboarded
-    ? [...ONBOARDING_ITEMS]
-    : [];
-  cloudStatus.onboarding_completed = scenario.onboarded;
-  cloudStatus.onboarding_postponed = scenario.postponed;
-  cloudStatus.prefs.onboarding_postponed_until = scenario.postponed
-    ? new Date(Date.now() + 24 * 3600 * 1000).toISOString()
-    : null;
-  cloudStatus.prefs.remote_enabled = scenario.remote;
-  cloudStatus.remote_connected = scenario.remote;
-  cloudStatus.remote_certificate_status = scenario.remoteStatus;
-  cloudStatus.alexa_registered = scenario.alexa;
-  cloudStatus.google_registered = scenario.google;
-  cloudStatus.prefs.cloud_ice_servers_enabled = scenario.webrtc;
-
-  const hasCloudhooks = Object.keys(cloudStatus.prefs.cloudhooks).length > 0;
-  if (scenario.webhooks && !hasCloudhooks) {
-    cloudStatus.prefs.cloudhooks = Object.fromEntries(
-      demoWebhooks.map((webhook) => [
-        webhook.webhook_id,
-        {
-          webhook_id: webhook.webhook_id,
-          cloudhook_id: `demo-${webhook.webhook_id}`,
-          cloudhook_url: `https://hooks.nabu.casa/demo-${webhook.webhook_id}`,
-          managed: false,
-        },
-      ])
-    );
-  } else if (!scenario.webhooks && hasCloudhooks) {
-    cloudStatus.prefs.cloudhooks = {};
-  }
-};
-
-applyScenario();
-subscribeCloudDemoScenario(applyScenario);
-
-// Reflect UI-driven changes (onboarding toggles, remote connect/disconnect)
-// back into the demo scenario so the demo controls panel stays in sync with the
-// mocked state. Only writes when a value actually changed, to avoid needless
-// re-projection. `applyScenario` re-applies the (now matching) scenario, so
-// this stays idempotent and does not fight the direct mutation above.
-const syncScenarioFromStatus = () => {
-  const scenario = getCloudDemoScenario();
-  const next = {
-    onboarded: cloudStatus.onboarding_completed,
-    postponed: cloudStatus.onboarding_postponed,
-    remote: cloudStatus.prefs.remote_enabled,
-    webrtc: cloudStatus.prefs.cloud_ice_servers_enabled,
-    webhooks: Object.keys(cloudStatus.prefs.cloudhooks).length > 0,
-  };
-  if (
-    scenario.onboarded !== next.onboarded ||
-    scenario.postponed !== next.postponed ||
-    scenario.remote !== next.remote ||
-    scenario.webrtc !== next.webrtc ||
-    scenario.webhooks !== next.webhooks
-  ) {
-    setCloudDemoScenario(next);
-  }
-};
-
 export const mockCloud = (hass: MockHomeAssistant) => {
   hass.mockWS("cloud/status", () => ({
     ...cloudStatus,
@@ -193,7 +116,6 @@ export const mockCloud = (hass: MockHomeAssistant) => {
   hass.mockWS("cloud/update_prefs", (msg) => {
     const { type, ...prefs } = msg;
     cloudStatus.prefs = { ...cloudStatus.prefs, ...prefs };
-    syncScenarioFromStatus();
     return { success: true };
   });
 
@@ -202,7 +124,6 @@ export const mockCloud = (hass: MockHomeAssistant) => {
       Date.now() + 24 * 3600 * 1000
     ).toISOString();
     cloudStatus.onboarding_postponed = true;
-    syncScenarioFromStatus();
     // Backend returns the full logged-in status object.
     return { ...cloudStatus, prefs: { ...cloudStatus.prefs } };
   });
@@ -222,7 +143,6 @@ export const mockCloud = (hass: MockHomeAssistant) => {
       (onboardingItem) =>
         cloudStatus.prefs.onboarded_items.includes(onboardingItem)
     );
-    syncScenarioFromStatus();
     // Backend returns the full logged-in status object.
     return { ...cloudStatus, prefs: { ...cloudStatus.prefs } };
   });
@@ -245,20 +165,17 @@ export const mockCloud = (hass: MockHomeAssistant) => {
     const cloudhooks = { ...cloudStatus.prefs.cloudhooks };
     delete cloudhooks[msg.webhook_id];
     cloudStatus.prefs.cloudhooks = cloudhooks;
-    syncScenarioFromStatus();
     return null;
   });
 
   hass.mockWS("cloud/remote/connect", () => {
     cloudStatus.remote_connected = true;
     cloudStatus.prefs.remote_enabled = true;
-    syncScenarioFromStatus();
     return null;
   });
   hass.mockWS("cloud/remote/disconnect", () => {
     cloudStatus.remote_connected = false;
     cloudStatus.prefs.remote_enabled = false;
-    syncScenarioFromStatus();
     return null;
   });
 

demo/src/stubs/config-panel.ts

@@ -7,13 +7,16 @@ import { mockBlueprint } from "./blueprint";
 import { mockCloud } from "./cloud";
 import { mockConfig } from "./config";
 import { mockConfigEntries } from "./config_entries";
+import { mockConnectivity } from "./connectivity";
 import { mockDeviceAutomation } from "./device_automation";
+import { mockEntityRegistrySettings } from "./entity_registry_settings";
 import { mockEntitySources } from "./entity_sources";
 import { mockExpose } from "./expose";
 import { mockNetwork } from "./network";
 import { mockPerson } from "./person";
 import { mockScene } from "./scene";
 import { mockSearch } from "./search";
+import { mockSlugify } from "./slugify";
 import { mockSystemHealth } from "./system_health";
 import { mockTags } from "./tags";
 import { mockZone } from "./zone";
@@ -24,6 +27,7 @@ export const mockConfigPanel = (hass: MockHomeAssistant) => {
   mockCloud(hass);
   mockConfig(hass);
   mockConfigEntries(hass);
+  mockConnectivity(hass);
   mockDeviceAutomation(hass);
   mockEntitySources(hass);
   mockBlueprint(hass);
@@ -39,4 +43,12 @@ export const mockConfigPanel = (hass: MockHomeAssistant) => {
   mockSearch(hass);
   mockTags(hass);
   mockAssist(hass);
+  mockEntityRegistrySettings(hass);
+  mockSlugify(hass);
+  hass.mockWS("llm/api/list", () => ({
+    apis: [
+      { id: "assist", name: "Assist" },
+      { id: "music_assistant", name: "Music Assistant" },
+    ],
+  }));
 };

demo/src/stubs/config_entries.ts

@@ -5,6 +5,7 @@ import type {
 import type { ConfigFlowInProgressMessage } from "../../../src/data/config_flow";
 import type { IntegrationType } from "../../../src/data/integration";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
+import { connectivityConfigEntries } from "./connectivity/fixtures";
 
 const baseEntry = {
   source: "user",
@@ -19,6 +20,7 @@ const baseEntry = {
   pref_disable_polling: false,
   disabled_by: null,
   reason: null,
+  error_reason_translation_domain: null,
   error_reason_translation_key: null,
   error_reason_translation_placeholders: null,
 };
@@ -79,6 +81,17 @@ export const demoConfigEntries: {
       title: "Comfort level",
     },
   },
+  {
+    type: "service",
+    entry: {
+      ...baseEntry,
+      entry_id: "mock-mcp-server",
+      domain: "mcp_server",
+      title: "Assist, Music Assistant",
+      supports_options: true,
+    },
+  },
+  ...connectivityConfigEntries,
 ];
 
 const filterEntries = (filters?: {

demo/src/stubs/connectivity/bluetooth/fixtures.ts

@@ -0,0 +1,71 @@
+import { manifest } from "../../manifest";
+import { configEntry, device } from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+export const LOCAL_SOURCE = "00:1A:7D:DA:71:11";
+export const PROXY_SOURCE = "E8:DB:84:A1:C2:30";
+export const SHED_SOURCE = "A4:CF:12:9B:44:70";
+
+const ADAPTER_ENTRY_ID = "mock-bluetooth";
+const PROXY_LIVING_ENTRY_ID = "mock-bluetooth-proxy-living";
+const PROXY_SHED_ENTRY_ID = "mock-bluetooth-proxy-shed";
+
+export const bluetoothFixtures: ConnectivityFixtures = {
+  components: ["bluetooth"],
+  commands: ["bluetooth/"],
+  manifests: [manifest("bluetooth", "Bluetooth", { integration_type: "hub" })],
+  configEntries: [
+    {
+      type: "hub",
+      entry: configEntry(
+        ADAPTER_ENTRY_ID,
+        "bluetooth",
+        `hci0 (${LOCAL_SOURCE})`,
+        { source: "usb", supports_options: true }
+      ),
+    },
+    {
+      type: "hub",
+      entry: configEntry(
+        PROXY_LIVING_ENTRY_ID,
+        "bluetooth",
+        "Living room proxy",
+        { source: "esphome" }
+      ),
+    },
+    {
+      type: "hub",
+      entry: configEntry(PROXY_SHED_ENTRY_ID, "bluetooth", "Shed proxy", {
+        source: "esphome",
+      }),
+    },
+  ],
+  // Adapters and proxies are matched to their scanner by the bluetooth
+  // connection tuple, see ./mock.
+  devices: [
+    device(
+      "bluetooth-hci0",
+      "hci0",
+      "Home Assistant",
+      "Home Assistant Green",
+      ADAPTER_ENTRY_ID,
+      { connections: [["bluetooth", LOCAL_SOURCE]] }
+    ),
+    device(
+      "bluetooth-proxy-living",
+      "Living room proxy",
+      "Espressif",
+      "ESP32-C3",
+      PROXY_LIVING_ENTRY_ID,
+      { area_id: "living_room", connections: [["bluetooth", PROXY_SOURCE]] }
+    ),
+    device(
+      "bluetooth-proxy-shed",
+      "Shed proxy",
+      "Espressif",
+      "ESP32",
+      PROXY_SHED_ENTRY_ID,
+      { connections: [["bluetooth", SHED_SOURCE]] }
+    ),
+  ],
+};

demo/src/stubs/connectivity/bluetooth/mock.ts

@@ -0,0 +1,193 @@
+import type {
+  BluetoothAllocationsData,
+  BluetoothDeviceData,
+  BluetoothScannerDetails,
+  BluetoothScannerState,
+} from "../../../../../src/data/bluetooth";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { emitInitial } from "../subscription";
+import { LOCAL_SOURCE, PROXY_SOURCE, SHED_SOURCE } from "./fixtures";
+
+const SCANNERS: BluetoothScannerDetails[] = [
+  {
+    source: LOCAL_SOURCE,
+    connectable: true,
+    name: "hci0 (Home Assistant Green)",
+    adapter: "hci0",
+    scanner_type: "usb",
+  },
+  {
+    source: PROXY_SOURCE,
+    connectable: true,
+    name: "Living room proxy",
+    adapter: "esp32",
+    scanner_type: "remote",
+  },
+  {
+    source: SHED_SOURCE,
+    connectable: false,
+    name: "Shed proxy",
+    adapter: "esp32",
+    scanner_type: "remote",
+  },
+];
+
+const SCANNER_STATES: BluetoothScannerState[] = [
+  {
+    source: LOCAL_SOURCE,
+    adapter: "hci0",
+    current_mode: "active",
+    requested_mode: "active",
+  },
+  {
+    source: PROXY_SOURCE,
+    adapter: "esp32",
+    current_mode: "active",
+    requested_mode: "active",
+  },
+  {
+    // A proxy configured for passive scanning: it reports advertisements but
+    // cannot connect, matching its `connectable: false` scanner details.
+    source: SHED_SOURCE,
+    adapter: "esp32",
+    current_mode: "passive",
+    requested_mode: "passive",
+  },
+];
+
+const ALLOCATIONS: BluetoothAllocationsData[] = [
+  {
+    source: LOCAL_SOURCE,
+    slots: 5,
+    free: 3,
+    allocated: ["A4:C1:38:11:22:33", "E7:2E:00:B1:9A:1C"],
+  },
+  {
+    source: PROXY_SOURCE,
+    slots: 3,
+    free: 2,
+    allocated: ["FC:58:FA:12:34:56"],
+  },
+];
+
+interface DemoAdvertisement {
+  address: string;
+  name: string;
+  rssi: number;
+  source: string;
+  connectable?: boolean;
+  tx_power?: number;
+  manufacturer_data?: Record<number, string>;
+  service_data?: Record<string, string>;
+  service_uuids?: string[];
+}
+
+const ADVERTISEMENTS: DemoAdvertisement[] = [
+  {
+    address: "A4:C1:38:11:22:33",
+    name: "Govee H5075",
+    rssi: -58,
+    source: LOCAL_SOURCE,
+    manufacturer_data: { 60552: "000104a10b64" },
+    service_uuids: ["0000ec88-0000-1000-8000-00805f9b34fb"],
+  },
+  {
+    address: "E7:2E:00:B1:9A:1C",
+    name: "SwitchBot Meter",
+    rssi: -71,
+    source: LOCAL_SOURCE,
+    service_data: { "0000fd3d-0000-1000-8000-00805f9b34fb": "5400648c14" },
+    service_uuids: ["cba20d00-224d-11e6-9fb8-0002a5d5c51b"],
+  },
+  {
+    address: "FC:58:FA:12:34:56",
+    name: "Xiaomi LYWSD03MMC",
+    rssi: -64,
+    source: PROXY_SOURCE,
+    service_data: { "0000fe95-0000-1000-8000-00805f9b34fb": "3058590e" },
+  },
+  {
+    address: "C4:7C:8D:6A:5B:20",
+    name: "Flower care",
+    rssi: -88,
+    source: SHED_SOURCE,
+    connectable: false,
+    service_uuids: ["0000fe95-0000-1000-8000-00805f9b34fb"],
+  },
+  {
+    address: "D0:36:9A:7F:11:80",
+    name: "Tile Mate",
+    rssi: -79,
+    source: PROXY_SOURCE,
+    connectable: false,
+    service_uuids: ["0000feed-0000-1000-8000-00805f9b34fb"],
+  },
+  {
+    address: "5C:C7:C1:04:9E:2A",
+    name: "Nut Find 3",
+    rssi: -93,
+    source: SHED_SOURCE,
+    connectable: false,
+  },
+];
+
+const buildAdvertisement = (
+  advertisement: DemoAdvertisement
+): BluetoothDeviceData => ({
+  address: advertisement.address,
+  name: advertisement.name,
+  rssi: advertisement.rssi,
+  source: advertisement.source,
+  connectable: advertisement.connectable ?? true,
+  manufacturer_data: advertisement.manufacturer_data ?? {},
+  service_data: advertisement.service_data ?? {},
+  service_uuids: advertisement.service_uuids ?? [],
+  tx_power: advertisement.tx_power ?? -59,
+  time: Date.now() / 1000,
+  raw: null,
+});
+
+// Nudge the signal strength a little on every tick so the monitors and the
+// network map look alive without the rows jumping around.
+const jitter = (rssi: number) =>
+  Math.max(-99, Math.min(-30, rssi + Math.round(Math.random() * 4) - 2));
+
+export const mockBluetooth = (hass: MockHomeAssistant) => {
+  hass.mockWS("bluetooth/subscribe_scanner_details", (_msg, _hass, onChange) =>
+    emitInitial(() => onChange?.({ add: SCANNERS }))
+  );
+
+  hass.mockWS("bluetooth/subscribe_scanner_state", (_msg, _hass, onChange) =>
+    emitInitial(() => SCANNER_STATES.forEach((state) => onChange?.(state)))
+  );
+
+  hass.mockWS(
+    "bluetooth/subscribe_connection_allocations",
+    (msg: { config_entry_id?: string }, _hass, onChange) =>
+      emitInitial(() =>
+        onChange?.(
+          msg.config_entry_id
+            ? ALLOCATIONS.filter((a) => a.source === LOCAL_SOURCE)
+            : ALLOCATIONS
+        )
+      )
+  );
+
+  hass.mockWS("bluetooth/subscribe_advertisements", (_msg, _hass, onChange) => {
+    let advertisements = ADVERTISEMENTS;
+    const stopInitial = emitInitial(() =>
+      onChange?.({ add: advertisements.map(buildAdvertisement) })
+    );
+    const interval = window.setInterval(() => {
+      advertisements = advertisements.map((advertisement) => ({
+        ...advertisement,
+        rssi: jitter(advertisement.rssi),
+      }));
+      onChange?.({ change: advertisements.map(buildAdvertisement) });
+    }, 5000);
+    return () => {
+      stopInitial();
+      clearInterval(interval);
+    };
+  });
+};

demo/src/stubs/connectivity/fixtures.ts

@@ -0,0 +1,60 @@
+import { bluetoothFixtures } from "./bluetooth/fixtures";
+import { infraredFixtures } from "./infrared/fixtures";
+import { matterFixtures } from "./matter/fixtures";
+import { mqttFixtures } from "./mqtt/fixtures";
+import { radioFrequencyFixtures } from "./radio_frequency/fixtures";
+import { serialFixtures } from "./serial/fixtures";
+import { tagsFixtures } from "./tags/fixtures";
+import { threadFixtures } from "./thread/fixtures";
+import type { ConnectivityFixtures } from "./types";
+import { zhaFixtures } from "./zha/fixtures";
+import { zwaveJsFixtures } from "./zwave_js/fixtures";
+
+// Every integration reachable from Settings > Connectivity that has frontend
+// data to mock. Each owns its own fixtures, so they can be added and removed
+// one at a time.
+const INTEGRATIONS: ConnectivityFixtures[] = [
+  bluetoothFixtures,
+  serialFixtures,
+  mqttFixtures,
+  matterFixtures,
+  infraredFixtures,
+  zwaveJsFixtures,
+  zhaFixtures,
+  radioFrequencyFixtures,
+  tagsFixtures,
+  threadFixtures,
+];
+
+const collect = <T>(
+  pick: (fixtures: ConnectivityFixtures) => T[] | undefined
+) => INTEGRATIONS.flatMap((fixtures) => pick(fixtures) ?? []);
+
+export const connectivityComponents = collect((f) => f.components);
+
+export const connectivityCommands = collect((f) => f.commands);
+
+export const connectivityConfigEntries = collect((f) => f.configEntries);
+
+export const connectivityManifests = collect((f) => f.manifests);
+
+export const connectivityDevices = collect((f) => f.devices);
+
+export const connectivityEntityRegistryEntries = collect(
+  (f) => f.entityRegistryEntries
+);
+
+export const connectivityEntities = () =>
+  INTEGRATIONS.flatMap((fixtures) => fixtures.entities?.() ?? []);
+
+/** Backend translation resources, merged per category. */
+export const connectivityBackendTranslations = INTEGRATIONS.reduce<
+  Record<string, Record<string, string>>
+>((resources, fixtures) => {
+  for (const [category, keys] of Object.entries(
+    fixtures.backendTranslations ?? {}
+  )) {
+    resources[category] = { ...resources[category], ...keys };
+  }
+  return resources;
+}, {});

demo/src/stubs/connectivity/helpers.ts

@@ -0,0 +1,129 @@
+import type { ConfigEntry } from "../../../../src/data/config_entries";
+import type { DeviceRegistryEntry } from "../../../../src/data/device/device_registry";
+import type { EntityRegistryEntry } from "../../../../src/data/entity/entity_registry";
+import type { EntityInput } from "../../../../src/fake_data/entities/types";
+
+// Builders for the registry fixtures, so each integration only spells out what
+// makes its own entries different.
+
+const BASE_CONFIG_ENTRY = {
+  source: "user",
+  state: "loaded" as const,
+  supports_options: false,
+  supports_remove_device: false,
+  supports_unload: true,
+  supports_reconfigure: true,
+  supported_subentry_types: {},
+  num_subentries: 0,
+  pref_disable_new_entities: false,
+  pref_disable_polling: false,
+  disabled_by: null,
+  reason: null,
+  error_reason_translation_domain: null,
+  error_reason_translation_key: null,
+  error_reason_translation_placeholders: null,
+};
+
+export const configEntry = (
+  entryId: string,
+  domain: string,
+  title: string,
+  extra: Partial<ConfigEntry> = {}
+): ConfigEntry => ({
+  ...BASE_CONFIG_ENTRY,
+  entry_id: entryId,
+  domain,
+  title,
+  ...extra,
+});
+
+const BASE_DEVICE = {
+  config_entries_subentries: {},
+  connections: [] as [string, string][],
+  identifiers: [] as [string, string][],
+  model_id: null,
+  labels: [] as string[],
+  sw_version: null,
+  hw_version: null,
+  serial_number: null,
+  via_device_id: null,
+  area_id: null,
+  name_by_user: null,
+  disabled_by: null,
+  configuration_url: null,
+  parent_device_id: null,
+  entry_type: null,
+  created_at: 0,
+  modified_at: 0,
+};
+
+export const device = (
+  id: string,
+  name: string,
+  manufacturer: string,
+  model: string,
+  entryId: string,
+  extra: Partial<DeviceRegistryEntry> = {}
+): DeviceRegistryEntry => ({
+  ...BASE_DEVICE,
+  id,
+  name,
+  manufacturer,
+  model,
+  config_entries: [entryId],
+  primary_config_entry: entryId,
+  ...extra,
+});
+
+const BASE_REGISTRY_ENTRY = {
+  config_subentry_id: null,
+  area_id: null,
+  disabled_by: null,
+  icon: null,
+  labels: [] as string[],
+  categories: {},
+  hidden_by: null,
+  entity_category: null,
+  options: null,
+  created_at: 0,
+  modified_at: 0,
+};
+
+export const registryEntry = (
+  entityId: string,
+  deviceId: string,
+  entryId: string,
+  platform: string,
+  name?: string
+): EntityRegistryEntry => ({
+  ...BASE_REGISTRY_ENTRY,
+  entity_id: entityId,
+  id: entityId,
+  unique_id: entityId,
+  device_id: deviceId,
+  config_entry_id: entryId,
+  platform,
+  name: name ?? null,
+  has_entity_name: name === undefined,
+});
+
+/**
+ * The demo's `addEntities` builds the display entity registry from the entity
+ * inputs, so mirror each state's registry entry onto it. Panels count entities
+ * per device and per integration.
+ */
+export const withRegistryLinks = (
+  entries: EntityRegistryEntry[],
+  states: Record<string, EntityInput>
+): EntityInput[] =>
+  Object.values(states).map((state) => {
+    const entry = entries.find(
+      (candidate) => candidate.entity_id === state.entity_id
+    );
+    return entry
+      ? { ...state, device_id: entry.device_id!, platform: entry.platform }
+      : state;
+  });
+
+export const minutesAgo = (minutes: number) =>
+  new Date(Date.now() - minutes * 60000).toISOString();

demo/src/stubs/connectivity/index.ts

@@ -0,0 +1,25 @@
+import type { MockHomeAssistant } from "../../../../src/fake_data/provide_hass";
+import { mockBluetooth } from "./bluetooth/mock";
+import { mockMatter } from "./matter/mock";
+import { mockMqtt } from "./mqtt/mock";
+import { mockRadioFrequency } from "./radio_frequency/mock";
+import { mockSerial } from "./serial/mock";
+import { mockThread } from "./thread/mock";
+import { mockZha } from "./zha/mock";
+import { mockZwaveJs } from "./zwave_js/mock";
+
+// The WebSocket mocks, code-split into the config panel chunk.
+const MOCKS = [
+  mockBluetooth,
+  mockSerial,
+  mockMatter,
+  mockMqtt,
+  mockZwaveJs,
+  mockZha,
+  mockRadioFrequency,
+  mockThread,
+];
+
+export const mockConnectivity = (hass: MockHomeAssistant) => {
+  MOCKS.forEach((mock) => mock(hass));
+};

demo/src/stubs/connectivity/infrared/fixtures.ts

@@ -0,0 +1,107 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  minutesAgo,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-broadlink";
+
+const DEVICES = [
+  device(
+    "broadlink-living-room",
+    "Living room blaster",
+    "Broadlink",
+    "RM4 pro",
+    ENTRY_ID,
+    { area_id: "living_room" }
+  ),
+  device(
+    "broadlink-bedroom",
+    "Bedroom blaster",
+    "Broadlink",
+    "RM mini 3",
+    ENTRY_ID,
+    { area_id: "bedroom" }
+  ),
+];
+
+// The infrared panel is entity driven: the proxy entities live in the
+// `infrared` domain while their registry platform stays the integration that
+// provides them.
+const REGISTRY_ENTRIES = [
+  registryEntry(
+    "infrared.living_room_blaster_emitter",
+    "broadlink-living-room",
+    ENTRY_ID,
+    "broadlink",
+    "Emitter"
+  ),
+  registryEntry(
+    "infrared.living_room_blaster_receiver",
+    "broadlink-living-room",
+    ENTRY_ID,
+    "broadlink",
+    "Receiver"
+  ),
+  registryEntry(
+    "infrared.bedroom_blaster_emitter",
+    "broadlink-bedroom",
+    ENTRY_ID,
+    "broadlink",
+    "Emitter"
+  ),
+];
+
+export const infraredFixtures: ConnectivityFixtures = {
+  components: ["infrared"],
+  manifests: [
+    manifest("broadlink", "Broadlink", {
+      integration_type: "hub",
+      iot_class: "local_polling",
+    }),
+  ],
+  configEntries: [
+    { type: "hub", entry: configEntry(ENTRY_ID, "broadlink", "RM4 pro") },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  // A proxy entity's state is the timestamp it was last used.
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "infrared.living_room_blaster_emitter": {
+        entity_id: "infrared.living_room_blaster_emitter",
+        state: minutesAgo(12),
+        attributes: {
+          friendly_name: "Living room blaster Emitter",
+          device_class: "emitter",
+        },
+      },
+      "infrared.living_room_blaster_receiver": {
+        entity_id: "infrared.living_room_blaster_receiver",
+        state: minutesAgo(3),
+        attributes: {
+          friendly_name: "Living room blaster Receiver",
+          device_class: "receiver",
+        },
+      },
+      "infrared.bedroom_blaster_emitter": {
+        entity_id: "infrared.bedroom_blaster_emitter",
+        state: minutesAgo(1440),
+        attributes: {
+          friendly_name: "Bedroom blaster Emitter",
+          device_class: "emitter",
+        },
+      },
+    }),
+  backendTranslations: {
+    entity_component: {
+      // The emitter is the default device class, stored under the "_" key.
+      "component.infrared.entity_component._.name": "Emitter",
+      "component.infrared.entity_component.receiver.name": "Receiver",
+    },
+  },
+};

demo/src/stubs/connectivity/matter/fixtures.ts

@@ -0,0 +1,119 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-matter";
+
+const DEVICES = [
+  device(
+    "matter-kitchen-light",
+    "Kitchen ceiling",
+    "Nanoleaf",
+    "Essentials A19",
+    ENTRY_ID,
+    { area_id: "kitchen", sw_version: "3.5.7" }
+  ),
+  device(
+    "matter-side-door-lock",
+    "Side door lock",
+    "Aqara",
+    "Smart Lock U100",
+    ENTRY_ID,
+    { sw_version: "1.2.0" }
+  ),
+  device("matter-office-plug", "Office plug", "Eve", "Energy", ENTRY_ID, {
+    area_id: "office",
+    sw_version: "3.2.0",
+  }),
+  device("matter-patio-sensor", "Patio sensor", "Eve", "Weather", ENTRY_ID, {
+    area_id: "garden",
+    sw_version: "3.2.1",
+  }),
+];
+
+const REGISTRY_ENTRIES = [
+  registryEntry(
+    "light.kitchen_ceiling",
+    "matter-kitchen-light",
+    ENTRY_ID,
+    "matter"
+  ),
+  registryEntry("lock.side_door", "matter-side-door-lock", ENTRY_ID, "matter"),
+  registryEntry("switch.office_plug", "matter-office-plug", ENTRY_ID, "matter"),
+  registryEntry(
+    "sensor.office_plug_power",
+    "matter-office-plug",
+    ENTRY_ID,
+    "matter"
+  ),
+  registryEntry(
+    "sensor.patio_temperature",
+    "matter-patio-sensor",
+    ENTRY_ID,
+    "matter"
+  ),
+];
+
+export const matterFixtures: ConnectivityFixtures = {
+  components: ["matter"],
+  commands: ["matter/"],
+  manifests: [manifest("matter", "Matter", { integration_type: "hub" })],
+  configEntries: [
+    {
+      type: "hub",
+      entry: configEntry(ENTRY_ID, "matter", "Matter", {
+        supports_remove_device: true,
+      }),
+    },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "light.kitchen_ceiling": {
+        entity_id: "light.kitchen_ceiling",
+        state: "on",
+        attributes: {
+          friendly_name: "Kitchen ceiling",
+          supported_color_modes: ["color_temp"],
+          color_mode: "color_temp",
+          brightness: 204,
+        },
+      },
+      "lock.side_door": {
+        entity_id: "lock.side_door",
+        state: "locked",
+        attributes: { friendly_name: "Side door lock" },
+      },
+      "switch.office_plug": {
+        entity_id: "switch.office_plug",
+        state: "on",
+        attributes: { friendly_name: "Office plug" },
+      },
+      "sensor.office_plug_power": {
+        entity_id: "sensor.office_plug_power",
+        state: "42.5",
+        attributes: {
+          friendly_name: "Office plug power",
+          device_class: "power",
+          state_class: "measurement",
+          unit_of_measurement: "W",
+        },
+      },
+      "sensor.patio_temperature": {
+        entity_id: "sensor.patio_temperature",
+        state: "14.2",
+        attributes: {
+          friendly_name: "Patio temperature",
+          device_class: "temperature",
+          state_class: "measurement",
+          unit_of_measurement: "°C",
+        },
+      },
+    }),
+};

demo/src/stubs/connectivity/matter/mock.ts

@@ -0,0 +1,404 @@
+import type {
+  MatterCommissioningParameters,
+  MatterFabricData,
+  MatterNetworkTopology,
+  MatterNetworkTopologyConnection,
+  MatterNetworkTopologyNode,
+  MatterNodeDiagnostics,
+} from "../../../../../src/data/matter";
+import { NetworkType, NodeType } from "../../../../../src/data/matter";
+import type {
+  MatterLockInfo,
+  MatterLockUser,
+  MatterLockUsersResponse,
+  SetMatterLockCredentialResult,
+} from "../../../../../src/data/matter-lock";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { emitInitial } from "../subscription";
+
+const EXT_PAN_ID = "dead00beef00cafe";
+const THREAD_NETWORK = "ha-thread";
+
+const NODES: MatterNetworkTopologyNode[] = [
+  {
+    id: "otbr",
+    kind: "border_router",
+    network_type: "thread",
+    ha_device_id: null,
+    role: "leader",
+    available: true,
+    ext_address: "f6a1c30d2b4e5f61",
+    rloc16: 0x4000,
+    ext_pan_id: EXT_PAN_ID,
+    network_name: THREAD_NETWORK,
+    host_name: "homeassistant",
+    vendor_name: "Home Assistant",
+    model_name: "OpenThread Border Router",
+  },
+  {
+    id: "wifi-ap",
+    kind: "wifi_ap",
+    network_type: "wifi",
+    ha_device_id: null,
+    available: true,
+    ssid: "Home",
+    bssid: "3c:37:86:11:22:33",
+    vendor_name: "Ubiquiti",
+    model_name: "U6 Pro",
+  },
+  {
+    id: "node-1",
+    kind: "matter",
+    network_type: "thread",
+    node_id: 1,
+    ha_device_id: "matter-kitchen-light",
+    available: true,
+    role: "router",
+    ext_address: "10a2b3c4d5e6f708",
+    rloc16: 0x8401,
+    ext_pan_id: EXT_PAN_ID,
+    network_name: THREAD_NETWORK,
+    vendor_name: "Nanoleaf",
+    model_name: "Essentials A19",
+  },
+  {
+    id: "node-2",
+    kind: "matter",
+    network_type: "thread",
+    node_id: 2,
+    ha_device_id: "matter-side-door-lock",
+    available: true,
+    role: "sleepy_end_device",
+    ext_address: "20b3c4d5e6f70819",
+    rloc16: 0x8402,
+    ext_pan_id: EXT_PAN_ID,
+    network_name: THREAD_NETWORK,
+    vendor_name: "Aqara",
+    model_name: "Smart Lock U100",
+  },
+  {
+    id: "node-3",
+    kind: "matter",
+    network_type: "wifi",
+    node_id: 3,
+    ha_device_id: "matter-office-plug",
+    available: true,
+    ssid: "Home",
+    vendor_name: "Eve",
+    model_name: "Energy",
+  },
+  {
+    id: "node-4",
+    kind: "matter",
+    network_type: "thread",
+    node_id: 4,
+    ha_device_id: "matter-patio-sensor",
+    available: false,
+    role: "end_device",
+    ext_address: "30c4d5e6f708192a",
+    rloc16: 0x8403,
+    ext_pan_id: EXT_PAN_ID,
+    network_name: THREAD_NETWORK,
+    vendor_name: "Eve",
+    model_name: "Weather",
+  },
+  {
+    id: "thread-unknown-1",
+    kind: "thread_unknown",
+    network_type: "thread",
+    available: true,
+    role: "end_device",
+    ext_address: "40d5e6f708192a3b",
+    rloc16: 0x8404,
+    ext_pan_id: EXT_PAN_ID,
+    network_name: THREAD_NETWORK,
+  },
+];
+
+const connection = (
+  source: string,
+  target: string,
+  network: string,
+  strength: MatterNetworkTopologyConnection["strength"],
+  lqi?: number,
+  rssi?: number
+): MatterNetworkTopologyConnection => ({
+  source,
+  target,
+  network,
+  strength,
+  source_to_target: { strength, lqi: lqi ?? null, rssi: rssi ?? null },
+  target_to_source: { strength, lqi: lqi ?? null, rssi: rssi ?? null },
+  via_route_table: false,
+  path_cost: null,
+});
+
+const CONNECTIONS: MatterNetworkTopologyConnection[] = [
+  connection("otbr", "node-1", "thread", "strong", 245, -42),
+  connection("otbr", "node-2", "thread", "medium", 160, -68),
+  connection("node-1", "node-4", "thread", "weak", 84, -86),
+  connection("node-1", "thread-unknown-1", "thread", "medium", 172, -63),
+  connection("wifi-ap", "node-3", "wifi", "strong", undefined, -47),
+];
+
+const TOPOLOGY: MatterNetworkTopology = {
+  collected_at: Date.now() / 1000,
+  nodes: NODES,
+  connections: CONNECTIONS,
+};
+
+const buildTopology = (): MatterNetworkTopology => ({
+  ...TOPOLOGY,
+  collected_at: Date.now() / 1000,
+});
+
+const FABRICS: MatterFabricData[] = [
+  {
+    fabric_id: 1,
+    vendor_id: 4939,
+    fabric_index: 1,
+    fabric_label: "Home Assistant",
+    vendor_name: "Home Assistant",
+  },
+];
+
+const NODE_TYPE_BY_ROLE: Record<string, NodeType> = {
+  router: NodeType.ROUTING_END_DEVICE,
+  sleepy_end_device: NodeType.SLEEPY_END_DEVICE,
+  end_device: NodeType.END_DEVICE,
+};
+
+const NODES_BY_DEVICE_ID = new Map(
+  NODES.filter((node) => node.ha_device_id).map((node) => [
+    node.ha_device_id!,
+    node,
+  ])
+);
+
+const nodeIpAddress = (node: MatterNetworkTopologyNode): string =>
+  node.network_type === "thread"
+    ? `fd11:2233:4455:6677::${(node.node_id ?? 0).toString(16)}`
+    : `192.168.1.${100 + (node.node_id ?? 0)}`;
+
+// Diagnostics are derived from the topology so a device's transport,
+// availability and node type match the map. The device page reads them per
+// device, and gates its actions on `available` and `network_type`.
+const buildNodeDiagnostics = (
+  node: MatterNetworkTopologyNode
+): MatterNodeDiagnostics => ({
+  node_id: node.node_id!,
+  network_type:
+    node.network_type === "thread" ? NetworkType.THREAD : NetworkType.WIFI,
+  node_type: node.is_bridge
+    ? NodeType.BRIDGE
+    : (NODE_TYPE_BY_ROLE[node.role ?? ""] ?? NodeType.END_DEVICE),
+  network_name: node.network_name ?? node.ssid ?? undefined,
+  ip_adresses: [nodeIpAddress(node)],
+  mac_address: node.ext_address?.match(/.{2}/g)?.join(":"),
+  available: node.available !== false,
+  active_fabrics: FABRICS,
+  active_fabric_index: 1,
+});
+
+// The backend resolves the device before acting, so both node commands answer
+// the same way when it cannot.
+const nodeNotFound = (deviceId: string) =>
+  Promise.reject({
+    code: "node_not_found",
+    message: `No Matter node for device ${deviceId}`,
+  });
+
+// The manual and QR codes below are the Matter test payload for passcode
+// 20202021 with discriminator 3840; the three have to agree.
+const COMMISSIONING_PARAMETERS: MatterCommissioningParameters = {
+  setup_pin_code: 20202021,
+  setup_manual_code: "34970112332",
+  setup_qr_code: "MT:Y.K9042C00KA0648G00",
+};
+
+const LOCK_INFO: MatterLockInfo = {
+  supports_user_management: true,
+  supported_credential_types: ["pin"],
+  max_users: 10,
+  max_pin_users: 10,
+  max_rfid_users: null,
+  max_credentials_per_user: 2,
+  min_pin_length: 4,
+  max_pin_length: 8,
+  min_rfid_length: null,
+  max_rfid_length: null,
+};
+
+const initialLockUsers = (): MatterLockUser[] => [
+  {
+    user_index: 1,
+    user_name: "Anne",
+    user_unique_id: 1,
+    user_status: "occupied_enabled",
+    user_type: "unrestricted_user",
+    credential_rule: "single",
+    credentials: [{ type: "pin", index: 1 }],
+    next_user_index: 2,
+  },
+  {
+    user_index: 2,
+    user_name: "Cleaner",
+    user_unique_id: 2,
+    user_status: "occupied_disabled",
+    user_type: "week_day_schedule_user",
+    credential_rule: "single",
+    credentials: [{ type: "pin", index: 2 }],
+    next_user_index: null,
+  },
+];
+
+// The manage dialog reloads the list after every add, edit and delete, so the
+// mocked services keep the lock's users rather than answering from a constant,
+// which would make every change look like it was reverted.
+const lockUsers = new Map<string, MatterLockUser[]>();
+
+const usersFor = (entityId: string): MatterLockUser[] => {
+  let users = lockUsers.get(entityId);
+  if (!users) {
+    users = initialLockUsers();
+    lockUsers.set(entityId, users);
+  }
+  return users;
+};
+
+// Lowest free slot, the way a lock hands out user and credential indexes.
+const nextFreeIndex = (taken: number[]): number => {
+  let index = 1;
+  while (taken.includes(index)) {
+    index += 1;
+  }
+  return index;
+};
+
+export const mockMatter = (hass: MockHomeAssistant) => {
+  hass.mockWS("matter/network_topology", () => buildTopology());
+
+  hass.mockWS("matter/subscribe_network_topology", (_msg, _hass, onChange) =>
+    emitInitial(() => onChange?.(buildTopology()))
+  );
+
+  hass.mockWS("matter/node_diagnostics", (msg: { device_id: string }) => {
+    const node = NODES_BY_DEVICE_ID.get(msg.device_id);
+    return node ? buildNodeDiagnostics(node) : nodeNotFound(msg.device_id);
+  });
+
+  hass.mockWS("matter/ping_node", (msg: { device_id: string }) => {
+    const node = NODES_BY_DEVICE_ID.get(msg.device_id);
+    return node
+      ? { [nodeIpAddress(node)]: node.available !== false }
+      : nodeNotFound(msg.device_id);
+  });
+
+  hass.mockWS("matter/interview_node", () => undefined);
+
+  // Actions the device page offers for an available node. Without these the
+  // dialogs behind them fail with `command_not_mocked`.
+  hass.mockWS(
+    "matter/open_commissioning_window",
+    () => COMMISSIONING_PARAMETERS
+  );
+  hass.mockWS("matter/remove_matter_fabric", () => undefined);
+  hass.mockWS("matter/set_wifi_credentials", () => undefined);
+  hass.mockWS("matter/set_thread", () => undefined);
+
+  // The lock device exposes "Manage lock", whose dialog reads back the response
+  // of these services.
+  hass.mockService("matter", "get_lock_info", (_data, target) => ({
+    [target!.entity_id]: LOCK_INFO,
+  }));
+  hass.mockService("matter", "get_lock_users", (_data, target) => ({
+    // Copied, the way a real response would be: the dialog assigns the list to
+    // reactive state, so handing back the same array leaves it unchanged and
+    // the list never rerenders.
+    [target!.entity_id]: {
+      max_users: LOCK_INFO.max_users!,
+      users: usersFor(target!.entity_id).map((user) => ({
+        ...user,
+        credentials: user.credentials.map((credential) => ({ ...credential })),
+      })),
+    } satisfies MatterLockUsersResponse,
+  }));
+
+  // Renames the user the credential below created, or edits an existing one.
+  hass.mockService("matter", "set_lock_user", (data, target) => {
+    const user = usersFor(target!.entity_id).find(
+      (candidate) => candidate.user_index === data?.user_index
+    );
+    if (user) {
+      if (data?.user_name !== undefined) {
+        user.user_name = data.user_name;
+      }
+      if (data?.user_type !== undefined) {
+        user.user_type = data.user_type;
+      }
+      if (data?.credential_rule !== undefined) {
+        user.credential_rule = data.credential_rule;
+      }
+    }
+    return {};
+  });
+
+  hass.mockService("matter", "clear_lock_user", (data, target) => {
+    const users = usersFor(target!.entity_id);
+    const index = users.findIndex(
+      (candidate) => candidate.user_index === data?.user_index
+    );
+    if (index !== -1) {
+      users.splice(index, 1);
+    }
+    return {};
+  });
+
+  // Adding a user starts here: the credential creates it, and the dialog reads
+  // the assigned index straight back to name it.
+  hass.mockService("matter", "set_lock_credential", (data, target) => {
+    const users = usersFor(target!.entity_id);
+    const userIndex =
+      (data?.user_index as number | null | undefined) ??
+      nextFreeIndex(
+        users
+          .map((user) => user.user_index)
+          .filter((i): i is number => i !== null)
+      );
+    const credentialIndex =
+      (data?.credential_index as number | null | undefined) ??
+      nextFreeIndex(
+        users.flatMap((user) =>
+          user.credentials
+            .map((credential) => credential.index)
+            .filter((i): i is number => i !== null)
+        )
+      );
+    const credential = {
+      type: (data?.credential_type as string) ?? "pin",
+      index: credentialIndex,
+    };
+    const user = users.find((candidate) => candidate.user_index === userIndex);
+    if (user) {
+      user.credentials = [...user.credentials, credential];
+    } else {
+      users.push({
+        user_index: userIndex,
+        user_name: null,
+        user_unique_id: userIndex,
+        user_status: data?.user_status ?? "occupied_enabled",
+        user_type: data?.user_type ?? "unrestricted_user",
+        credential_rule: "single",
+        credentials: [credential],
+        next_user_index: null,
+      });
+    }
+    return {
+      [target!.entity_id]: {
+        credential_index: credentialIndex,
+        user_index: userIndex,
+        next_credential_index: null,
+      } satisfies SetMatterLockCredentialResult,
+    };
+  });
+};

demo/src/stubs/connectivity/mqtt/fixtures.ts

@@ -0,0 +1,90 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-mqtt";
+
+const DEVICES = [
+  device(
+    "mqtt-fridge-sensor",
+    "Fridge sensor",
+    "Xiaomi",
+    "LYWSD03MMC",
+    ENTRY_ID,
+    { area_id: "kitchen" }
+  ),
+  device(
+    "mqtt-garage-door",
+    "Garage door",
+    "Shelly",
+    "Shelly Plus 1",
+    ENTRY_ID
+  ),
+];
+
+const REGISTRY_ENTRIES = [
+  registryEntry(
+    "sensor.fridge_temperature",
+    "mqtt-fridge-sensor",
+    ENTRY_ID,
+    "mqtt"
+  ),
+  registryEntry(
+    "sensor.fridge_battery",
+    "mqtt-fridge-sensor",
+    ENTRY_ID,
+    "mqtt"
+  ),
+  registryEntry("cover.garage_door", "mqtt-garage-door", ENTRY_ID, "mqtt"),
+];
+
+export const mqttFixtures: ConnectivityFixtures = {
+  components: ["mqtt"],
+  // `execute_script` too: the panel publishes through a script action.
+  commands: ["mqtt/", "execute_script"],
+  manifests: [manifest("mqtt", "MQTT", { integration_type: "hub" })],
+  configEntries: [
+    {
+      type: "hub",
+      entry: configEntry(ENTRY_ID, "mqtt", "core-mosquitto", {
+        supports_options: true,
+        supports_remove_device: true,
+      }),
+    },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "sensor.fridge_temperature": {
+        entity_id: "sensor.fridge_temperature",
+        state: "21.4",
+        attributes: {
+          friendly_name: "Fridge temperature",
+          device_class: "temperature",
+          state_class: "measurement",
+          unit_of_measurement: "°C",
+        },
+      },
+      "sensor.fridge_battery": {
+        entity_id: "sensor.fridge_battery",
+        state: "92",
+        attributes: {
+          friendly_name: "Fridge battery",
+          device_class: "battery",
+          state_class: "measurement",
+          unit_of_measurement: "%",
+        },
+      },
+      "cover.garage_door": {
+        entity_id: "cover.garage_door",
+        state: "closed",
+        attributes: { friendly_name: "Garage door", device_class: "garage" },
+      },
+    }),
+};

demo/src/stubs/connectivity/mqtt/mock.ts

@@ -0,0 +1,192 @@
+import type {
+  MQTTDeviceDebugInfo,
+  MQTTMessage,
+} from "../../../../../src/data/mqtt";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { emitInitial } from "../subscription";
+
+const PAYLOADS: Record<string, () => string> = {
+  "homeassistant/status": () => "online",
+  "zigbee2mqtt/bridge/state": () => '{"state":"online"}',
+  default: () =>
+    JSON.stringify({
+      battery: 92,
+      linkquality: 120,
+      // Built from whole tenths, so the payload never carries the noise a
+      // float sum leaves behind, like 21.599999999999998.
+      temperature: (214 + Math.floor(Math.random() * 11)) / 10,
+    }),
+};
+
+// Subscriptions take a topic filter, but a message carries the topic it was
+// actually published on, so a filter has to be resolved to one concrete topic
+// before it can be echoed back.
+const resolveFilter = (filter: string): string =>
+  filter
+    .split("/")
+    .flatMap((level) => {
+      if (level === "+") {
+        return ["kitchen"];
+      }
+      if (level === "#") {
+        return ["kitchen", "temperature"];
+      }
+      return [level];
+    })
+    .join("/") || "homeassistant/status";
+
+const buildMessage = (topic: string, qos: number): MQTTMessage => ({
+  topic,
+  payload: (PAYLOADS[topic] ?? PAYLOADS.default)(),
+  qos,
+  retain: 0,
+  time: new Date().toISOString(),
+});
+
+// A filter matches a topic level by level: "+" stands for one level, "#" for
+// the rest of them.
+const filterMatches = (filter: string, topic: string): boolean => {
+  const filterLevels = filter.split("/");
+  const topicLevels = topic.split("/");
+  for (let index = 0; index < filterLevels.length; index += 1) {
+    if (filterLevels[index] === "#") {
+      return true;
+    }
+    if (index >= topicLevels.length) {
+      return false;
+    }
+    if (
+      filterLevels[index] !== "+" &&
+      filterLevels[index] !== topicLevels[index]
+    ) {
+      return false;
+    }
+  }
+  return filterLevels.length === topicLevels.length;
+};
+
+// The panel's listen card and its publish button talk to each other through
+// the broker, so the mock keeps the subscriptions and delivers to them.
+const subscriptions = new Set<{
+  filter: string;
+  qos: number;
+  deliver: (message: MQTTMessage) => void;
+}>();
+
+const topicDebug = (topic: string) => ({
+  topic,
+  messages: [buildMessage(topic, 0)],
+});
+
+// Keyed by device, the way the backend builds this per requested device.
+const DEBUG_INFO: Record<string, MQTTDeviceDebugInfo> = {
+  "mqtt-fridge-sensor": {
+    entities: [
+      {
+        entity_id: "sensor.fridge_temperature",
+        discovery_data: {
+          topic: "homeassistant/sensor/fridge/temperature/config",
+          payload: {
+            name: "Temperature",
+            state_topic: "zigbee2mqtt/fridge",
+            unit_of_measurement: "°C",
+            device_class: "temperature",
+          },
+        },
+        subscriptions: [topicDebug("zigbee2mqtt/fridge")],
+        transmitted: [],
+      },
+      {
+        entity_id: "sensor.fridge_battery",
+        discovery_data: {
+          topic: "homeassistant/sensor/fridge/battery/config",
+          payload: {
+            name: "Battery",
+            state_topic: "zigbee2mqtt/fridge",
+            unit_of_measurement: "%",
+            device_class: "battery",
+          },
+        },
+        subscriptions: [topicDebug("zigbee2mqtt/fridge")],
+        transmitted: [],
+      },
+    ],
+    triggers: [],
+  },
+  "mqtt-garage-door": {
+    entities: [
+      {
+        entity_id: "cover.garage_door",
+        discovery_data: {
+          topic: "homeassistant/cover/garage/config",
+          payload: {
+            name: "Garage door",
+            state_topic: "shellyplus1/status/cover:0",
+            command_topic: "shellyplus1/command/cover:0",
+            device_class: "garage",
+          },
+        },
+        subscriptions: [topicDebug("shellyplus1/status/cover:0")],
+        transmitted: [topicDebug("shellyplus1/command/cover:0")],
+      },
+    ],
+    triggers: [],
+  },
+};
+
+export const mockMqtt = (hass: MockHomeAssistant) => {
+  hass.mockWS(
+    "mqtt/subscribe",
+    (msg: { topic: string; qos?: number }, _hass, onChange) => {
+      // Echo a message on the subscribed topic every few seconds so the
+      // listen card in the MQTT panel shows traffic.
+      const qos = msg.qos ?? 0;
+      const topic = resolveFilter(msg.topic);
+      const deliver = (message: MQTTMessage) => onChange?.(message);
+      const subscription = { filter: msg.topic, qos, deliver };
+      subscriptions.add(subscription);
+      const send = () => deliver(buildMessage(topic, qos));
+      const stopInitial = emitInitial(send);
+      const interval = window.setInterval(send, 3000);
+      return () => {
+        stopInitial();
+        clearInterval(interval);
+        subscriptions.delete(subscription);
+      };
+    }
+  );
+
+  // The panel publishes through a script action rather than a `mqtt/` command,
+  // so without this the publish button only ever reports a failure. Delivering
+  // to the matching subscriptions is what makes the two halves of the panel
+  // work together.
+  hass.mockWS(
+    "execute_script",
+    (msg: { sequence: { action?: string; data?: Record<string, any> }[] }) => {
+      msg.sequence
+        ?.filter((action) => action.action === "mqtt.publish")
+        .forEach((action) => {
+          const topic = String(action.data?.topic ?? "");
+          const message: MQTTMessage = {
+            topic,
+            payload: String(action.data?.payload ?? ""),
+            qos: Number(action.data?.qos ?? 0),
+            retain: action.data?.retain ? 1 : 0,
+            time: new Date().toISOString(),
+          };
+          subscriptions.forEach((subscription) => {
+            if (filterMatches(subscription.filter, topic)) {
+              subscription.deliver(message);
+            }
+          });
+        });
+      return { context: { id: "mock-context" }, response: {} };
+    }
+  );
+
+  hass.mockWS(
+    "mqtt/device/debug_info",
+    (msg: { device_id: string }): MQTTDeviceDebugInfo =>
+      DEBUG_INFO[msg.device_id] ?? { entities: [], triggers: [] }
+  );
+};

demo/src/stubs/connectivity/radio_frequency/fixtures.ts

@@ -0,0 +1,69 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  minutesAgo,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-rf-bridge";
+
+const DEVICES = [
+  device(
+    "rf-bridge-garage",
+    "Garage bridge",
+    "Sonoff",
+    "RF Bridge R2",
+    ENTRY_ID,
+    { area_id: "garden" }
+  ),
+  device("rf-bridge-shed", "Shed bridge", "Sonoff", "RF Bridge R2", ENTRY_ID),
+];
+
+const REGISTRY_ENTRIES = [
+  registryEntry(
+    "radio_frequency.garage_bridge",
+    "rf-bridge-garage",
+    ENTRY_ID,
+    "esphome",
+    "Transceiver"
+  ),
+  registryEntry(
+    "radio_frequency.shed_bridge",
+    "rf-bridge-shed",
+    ENTRY_ID,
+    "esphome",
+    "Transceiver"
+  ),
+];
+
+export const radioFrequencyFixtures: ConnectivityFixtures = {
+  components: ["radio_frequency"],
+  commands: ["radio_frequency/"],
+  manifests: [manifest("esphome", "ESPHome", { integration_type: "device" })],
+  configEntries: [
+    { type: "device", entry: configEntry(ENTRY_ID, "esphome", "RF Bridge") },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "radio_frequency.garage_bridge": {
+        entity_id: "radio_frequency.garage_bridge",
+        state: minutesAgo(47),
+        attributes: { friendly_name: "Garage bridge Transceiver" },
+      },
+      "radio_frequency.shed_bridge": {
+        entity_id: "radio_frequency.shed_bridge",
+        state: "unknown",
+        attributes: { friendly_name: "Shed bridge Transceiver" },
+      },
+    }),
+  backendTranslations: {
+    entity_component: {
+      "component.radio_frequency.entity_component._.name": "Transceiver",
+    },
+  },
+};

demo/src/stubs/connectivity/radio_frequency/mock.ts

@@ -0,0 +1,25 @@
+import type { RadioFrequencyTransmitter } from "../../../../../src/data/radio_frequency";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+
+const TRANSMITTERS: RadioFrequencyTransmitter[] = [
+  {
+    entity_id: "radio_frequency.garage_bridge",
+    device_id: "rf-bridge-garage",
+    config_entry_id: "mock-rf-bridge",
+    supported_frequency_ranges: [[433920000, 433920000]],
+    supported_modulations: ["OOK"],
+  },
+  {
+    entity_id: "radio_frequency.shed_bridge",
+    device_id: "rf-bridge-shed",
+    config_entry_id: "mock-rf-bridge",
+    supported_frequency_ranges: [[433920000, 433920000]],
+    supported_modulations: ["OOK"],
+  },
+];
+
+export const mockRadioFrequency = (hass: MockHomeAssistant) => {
+  hass.mockWS("radio_frequency/list", () => ({
+    transmitters: TRANSMITTERS,
+  }));
+};

demo/src/stubs/connectivity/serial/fixtures.ts

@@ -0,0 +1,6 @@
+import type { ConnectivityFixtures } from "../types";
+
+export const serialFixtures: ConnectivityFixtures = {
+  components: ["usb"],
+  commands: ["usb/"],
+};

demo/src/stubs/connectivity/serial/mock.ts

@@ -0,0 +1,107 @@
+import type { SerialPortUsage } from "../../../../../src/data/usb";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+
+const PORTS: SerialPortUsage[] = [
+  {
+    device: "/dev/ttyUSB0",
+    resolved_device:
+      "/dev/serial/by-id/usb-Nabu_Casa_ZBT-1_9e2adbd75b8beb119fe564a0f320645d-if00-port0",
+    serial_number: "9e2adbd75b8beb119fe564a0f320645d",
+    manufacturer: "Nabu Casa",
+    description: "Home Assistant Connect ZBT-1",
+    interface_description: "Connect ZBT-1",
+    interface_num: 0,
+    vid: "10C4",
+    pid: "EA60",
+    bcd_device: 256,
+    matching_integrations: ["zha"],
+    present: true,
+    consumers: [
+      {
+        kind: "config_entry",
+        title: "Home Assistant Connect ZBT-1",
+        active: true,
+        domain: "zha",
+        config_entry_id: "mock-zha",
+        slug: null,
+      },
+    ],
+    discovery_flows: [],
+  },
+  {
+    device: "/dev/ttyACM0",
+    resolved_device:
+      "/dev/serial/by-id/usb-Zooz_800_Z-Wave_Stick_533D004242-if00",
+    serial_number: "533D004242",
+    manufacturer: "Zooz",
+    description: "800 Series Z-Wave Long Range",
+    interface_description: null,
+    interface_num: 0,
+    vid: "10C4",
+    pid: "EA60",
+    bcd_device: 256,
+    matching_integrations: ["zwave_js"],
+    present: true,
+    consumers: [
+      {
+        kind: "config_entry",
+        title: "Z-Wave",
+        active: true,
+        domain: "zwave_js",
+        config_entry_id: "mock-zwave-js",
+        slug: null,
+      },
+    ],
+    discovery_flows: [],
+  },
+  {
+    device: "/dev/ttyUSB1",
+    resolved_device:
+      "/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A50285BI-if00-port0",
+    serial_number: "A50285BI",
+    manufacturer: "FTDI",
+    description: "FT232R USB UART",
+    interface_description: null,
+    interface_num: 0,
+    vid: "0403",
+    pid: "6001",
+    bcd_device: 1536,
+    matching_integrations: [],
+    present: true,
+    consumers: [],
+    discovery_flows: [],
+  },
+  {
+    // A port that is configured but not currently plugged in. Its add-on icon
+    // is requested straight from /api/hassio/addons/<slug>/icon, which the
+    // demo has no backend for, so the icon stays blank here.
+    device: "/dev/ttyUSB2",
+    resolved_device: null,
+    serial_number: "0001",
+    manufacturer: "Silicon Labs",
+    description: "CP2102 USB to UART Bridge Controller",
+    interface_description: null,
+    interface_num: 0,
+    vid: "10C4",
+    pid: "EA60",
+    bcd_device: null,
+    matching_integrations: [],
+    present: false,
+    consumers: [
+      {
+        kind: "app",
+        title: "ESPHome Device Builder",
+        active: false,
+        domain: null,
+        config_entry_id: null,
+        slug: "esphome",
+      },
+    ],
+    discovery_flows: [],
+  },
+];
+
+export const mockSerial = (hass: MockHomeAssistant) => {
+  hass.mockWS("usb/list_serial_ports", () => PORTS);
+  hass.mockWS("usb/scan", () => undefined);
+};

demo/src/stubs/connectivity/subscription.ts

@@ -0,0 +1,10 @@
+// Mocked WebSocket subscriptions are registered synchronously, so a callback
+// invoked straight away can land before the subscriber is ready for it: pages
+// that ignore messages received before their first render drop it, and
+// `createCollection` overwrites it with the empty initial fetch. Emitting the
+// first message from a timeout matches the real backend, which always answers
+// asynchronously.
+export const emitInitial = (send: () => void): (() => void) => {
+  const timeout = window.setTimeout(send, 0);
+  return () => clearTimeout(timeout);
+};

demo/src/stubs/connectivity/tags/fixtures.ts

@@ -0,0 +1,6 @@
+import type { ConnectivityFixtures } from "../types";
+
+export const tagsFixtures: ConnectivityFixtures = {
+  components: ["tag"],
+  commands: ["tag/"],
+};

demo/src/stubs/connectivity/thread/fixtures.ts

@@ -0,0 +1,31 @@
+import { manifest } from "../../manifest";
+import { configEntry } from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const THREAD_ENTRY_ID = "mock-thread";
+const OTBR_ENTRY_ID = "mock-otbr";
+
+export const threadFixtures: ConnectivityFixtures = {
+  components: ["thread", "otbr"],
+  commands: ["thread/", "otbr/"],
+  manifests: [
+    manifest("thread", "Thread", {
+      integration_type: "service",
+      iot_class: "local_polling",
+    }),
+    manifest("otbr", "Open Thread Border Router", {
+      integration_type: "service",
+      iot_class: "local_polling",
+    }),
+  ],
+  configEntries: [
+    {
+      type: "service",
+      entry: configEntry(THREAD_ENTRY_ID, "thread", "Thread"),
+    },
+    {
+      type: "service",
+      entry: configEntry(OTBR_ENTRY_ID, "otbr", "Open Thread Border Router"),
+    },
+  ],
+};

demo/src/stubs/connectivity/thread/mock.ts

@@ -0,0 +1,441 @@
+import type { OTBRInfoDict } from "../../../../../src/data/otbr";
+import type {
+  ThreadDataSet,
+  ThreadRouter,
+} from "../../../../../src/data/thread";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { emitInitial } from "../subscription";
+
+const HA_EXT_PAN_ID = "DEAD00BEEF00CAFE";
+const AMAZON_EXT_PAN_ID = "0011223344556677";
+
+const OTBR_EXT_ADDRESS = "f6a1c30d2b4e5f61";
+const OTBR_BORDER_AGENT_ID = "230c6a1ac57f6f4be262acf32e5ef52c";
+
+const ROUTERS: ThreadRouter[] = [
+  {
+    instance_name: "HomeAssistant OpenThreadBorderRouter",
+    addresses: ["192.168.1.10"],
+    border_agent_id: OTBR_BORDER_AGENT_ID,
+    brand: "homeassistant",
+    extended_address: OTBR_EXT_ADDRESS,
+    extended_pan_id: HA_EXT_PAN_ID,
+    model_name: "OpenThread Border Router",
+    network_name: "ha-thread",
+    server: "core-openthread-border-router.local.",
+    thread_version: "1.3.0",
+    unconfigured: null,
+    vendor_name: "Home Assistant",
+  },
+  {
+    instance_name: "HomePod mini",
+    addresses: ["192.168.1.24"],
+    border_agent_id: "6a1ac57f6f4be262acf32e5ef52c230c",
+    brand: "apple",
+    extended_address: "aabbccddeeff0011",
+    extended_pan_id: HA_EXT_PAN_ID,
+    model_name: "HomePod mini",
+    network_name: "ha-thread",
+    server: "homepod-mini.local.",
+    thread_version: "1.3.0",
+    unconfigured: null,
+    vendor_name: "Apple Inc.",
+  },
+  {
+    instance_name: "Nest Hub",
+    addresses: ["192.168.1.31"],
+    border_agent_id: "ac57f6f4be262acf32e5ef52c230c6a1",
+    brand: "google",
+    extended_address: "bbccddeeff001122",
+    extended_pan_id: HA_EXT_PAN_ID,
+    model_name: "Google Nest Hub",
+    network_name: "ha-thread",
+    server: "nest-hub.local.",
+    thread_version: "1.3.0",
+    unconfigured: null,
+    vendor_name: "Google Inc.",
+  },
+  {
+    instance_name: "Echo (4th Gen)",
+    addresses: ["192.168.1.42"],
+    border_agent_id: "57f6f4be262acf32e5ef52c230c6a1ac",
+    brand: "amazon",
+    extended_address: "ccddeeff00112233",
+    extended_pan_id: AMAZON_EXT_PAN_ID,
+    model_name: "Echo",
+    network_name: "AmazonThread",
+    server: "amazon-echo.local.",
+    thread_version: "1.3.0",
+    unconfigured: null,
+    vendor_name: "Amazon",
+  },
+];
+
+const decodeUtf8 = (value: string): string | undefined => {
+  const bytes = Uint8Array.from(
+    (value.match(/../g) ?? []).map((byte) => parseInt(byte, 16))
+  );
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return undefined;
+  }
+};
+
+const tlv = (type: number, value: string) =>
+  type.toString(16).padStart(2, "0").toUpperCase() +
+  (value.length / 2).toString(16).padStart(2, "0").toUpperCase() +
+  value.toUpperCase();
+
+const textToHex = (text: string) =>
+  Array.from(text)
+    .map((character) => character.charCodeAt(0).toString(16).padStart(2, "0"))
+    .join("")
+    .toUpperCase();
+
+const replaceTlvField = (value: string, type: number, replacement: string) => {
+  let index = 0;
+  let out = "";
+  let replaced = false;
+  while (index + 4 <= value.length) {
+    const fieldType = parseInt(value.slice(index, index + 2), 16);
+    const length = parseInt(value.slice(index + 2, index + 4), 16);
+    const end = index + 4 + length * 2;
+    out +=
+      fieldType === type ? tlv(type, replacement) : value.slice(index, end);
+    replaced = replaced || fieldType === type;
+    index = end;
+  }
+  return replaced ? out : out + tlv(type, replacement);
+};
+
+const buildDatasetTlv = (dataset: ThreadDataSet) =>
+  [
+    tlv(0x0e, "0000000000010000"),
+    tlv(0x00, `00${(dataset.channel ?? 15).toString(16).padStart(4, "0")}`),
+    tlv(0x35, "000040010200"),
+    tlv(0x02, dataset.extended_pan_id),
+    tlv(0x07, "FD11220000000000"),
+    tlv(0x05, "00112233445566778899AABBCCDDEEFF"),
+    dataset.network_name === null
+      ? ""
+      : tlv(0x03, textToHex(dataset.network_name)),
+    tlv(0x01, (dataset.pan_id ?? "1234").padStart(4, "0")),
+    tlv(0x04, "1035060004001FFFE00C0402A0F7F800"),
+    tlv(0x0c, "02A0F7F8"),
+  ].join("");
+
+const parseDatasetTlv = (value: string) => {
+  if (value.length % 2 !== 0 || !/^[0-9A-Fa-f]*$/.test(value)) {
+    return undefined;
+  }
+  const fields = new Map<number, string>();
+  let index = 0;
+  while (index < value.length) {
+    if (index + 4 > value.length) {
+      return undefined;
+    }
+    const type = parseInt(value.slice(index, index + 2), 16);
+    const length = parseInt(value.slice(index + 2, index + 4), 16);
+    const start = index + 4;
+    const end = start + length * 2;
+    if (end > value.length) {
+      return undefined;
+    }
+    if (fields.has(type)) {
+      return undefined;
+    }
+    fields.set(type, value.slice(start, end).toUpperCase());
+    index = end;
+  }
+  const extendedPanId = fields.get(0x02);
+  const networkName = fields.get(0x03);
+  const activeTimestamp = fields.get(0x0e);
+  if (
+    !extendedPanId ||
+    extendedPanId.length !== 16 ||
+    !activeTimestamp ||
+    activeTimestamp.length !== 16
+  ) {
+    return undefined;
+  }
+  const decodedName =
+    networkName === undefined ? null : decodeUtf8(networkName);
+  if (decodedName === undefined) {
+    return undefined;
+  }
+  const channel = fields.get(0x00);
+  const channelNumber = channel ? parseInt(channel.slice(2), 16) : null;
+  if (channelNumber === 0) {
+    return undefined;
+  }
+  return {
+    activeTimestamp,
+    extendedPanId,
+    networkName: decodedName,
+    panId: fields.get(0x01) ?? null,
+    channel: channelNumber,
+  };
+};
+
+const DATASETS: ThreadDataSet[] = [
+  {
+    channel: 15,
+    created: new Date(Date.now() - 86400000 * 30).toISOString(),
+    dataset_id: "ha-thread-dataset",
+    extended_pan_id: HA_EXT_PAN_ID,
+    network_name: "ha-thread",
+    pan_id: "1234",
+    preferred_border_agent_id: OTBR_BORDER_AGENT_ID,
+    preferred_extended_address: OTBR_EXT_ADDRESS,
+    preferred: true,
+    source: "otbr",
+  },
+];
+
+const DATASET_TLVS: Record<string, string> = Object.fromEntries(
+  DATASETS.map((dataset) => [dataset.dataset_id, buildDatasetTlv(dataset)])
+);
+
+const OTBR_INFO: OTBRInfoDict = {
+  [OTBR_EXT_ADDRESS]: {
+    active_dataset_tlvs: DATASET_TLVS["ha-thread-dataset"],
+    border_agent_id: OTBR_BORDER_AGENT_ID,
+    channel: 15,
+    extended_address: OTBR_EXT_ADDRESS,
+    extended_pan_id: HA_EXT_PAN_ID,
+    url: "http://core-openthread-border-router:8081",
+  },
+};
+
+let added = 0;
+let created = 0;
+
+const randomExtendedPanId = () =>
+  Array.from({ length: 8 }, () =>
+    Math.floor(Math.random() * 256)
+      .toString(16)
+      .padStart(2, "0")
+  )
+    .join("")
+    .toUpperCase();
+
+const moveRouter = (
+  extendedAddress: string,
+  extendedPanId: string,
+  networkName: string | null,
+  datasetId: string
+) => {
+  const info = OTBR_INFO[extendedAddress];
+  const moved = DATASETS.find((item) => item.dataset_id === datasetId);
+  if (info) {
+    info.extended_pan_id = extendedPanId;
+    info.active_dataset_tlvs =
+      DATASET_TLVS[datasetId] ?? info.active_dataset_tlvs;
+    info.channel = moved?.channel ?? info.channel;
+  }
+  const router = ROUTERS.find(
+    (candidate) => candidate.extended_address === extendedAddress
+  );
+  if (router) {
+    router.extended_pan_id = extendedPanId;
+    router.network_name = networkName;
+    announce(router);
+  }
+};
+
+type RouterListener = (event: {
+  key: string;
+  type: "router_discovered" | "router_removed";
+  data: ThreadRouter;
+}) => void;
+
+const listeners = new Set<RouterListener>();
+
+const announce = (router: ThreadRouter) =>
+  listeners.forEach((listener) =>
+    listener({
+      key: router.extended_address,
+      type: "router_discovered",
+      data: router,
+    })
+  );
+
+export const mockThread = (hass: MockHomeAssistant) => {
+  hass.mockWS("thread/discover_routers", (_msg, _hass, onChange) => {
+    const listener = onChange as RouterListener | undefined;
+    if (listener) {
+      listeners.add(listener);
+    }
+    const stopInitial = emitInitial(() => ROUTERS.forEach(announce));
+    return () => {
+      stopInitial();
+      if (listener) {
+        listeners.delete(listener);
+      }
+    };
+  });
+
+  hass.mockWS("thread/list_datasets", () => ({
+    datasets: DATASETS.map((dataset) => ({ ...dataset })),
+  }));
+  hass.mockWS("thread/get_dataset_tlv", (msg: { dataset_id: string }) => {
+    const value = DATASET_TLVS[msg.dataset_id];
+    if (!value) {
+      throw new Error(`Dataset ${msg.dataset_id} not found`);
+    }
+    return { tlv: value };
+  });
+
+  hass.mockWS("otbr/info", () => OTBR_INFO);
+
+  hass.mockWS(
+    "thread/add_dataset_tlv",
+    (msg: { source: string; tlv: string }) => {
+      const parsed = parseDatasetTlv(msg.tlv);
+      if (!parsed) {
+        throw new Error("Invalid dataset");
+      }
+      const existing = DATASETS.find(
+        (candidate) => candidate.extended_pan_id === parsed.extendedPanId
+      );
+      if (existing) {
+        const current = parseDatasetTlv(DATASET_TLVS[existing.dataset_id]);
+        if (current && parsed.activeTimestamp <= current.activeTimestamp) {
+          return undefined;
+        }
+        existing.channel = parsed.channel;
+        existing.network_name = parsed.networkName;
+        existing.pan_id = parsed.panId;
+        DATASET_TLVS[existing.dataset_id] = msg.tlv.toUpperCase();
+        return undefined;
+      }
+      added += 1;
+      const dataset: ThreadDataSet = {
+        channel: parsed.channel,
+        created: new Date().toISOString(),
+        dataset_id: `added-dataset-${added}`,
+        extended_pan_id: parsed.extendedPanId,
+        network_name: parsed.networkName,
+        pan_id: parsed.panId,
+        preferred_border_agent_id: null,
+        preferred_extended_address: null,
+        preferred: false,
+        source: msg.source,
+      };
+      DATASETS.push(dataset);
+      DATASET_TLVS[dataset.dataset_id] = msg.tlv.toUpperCase();
+      return undefined;
+    }
+  );
+
+  hass.mockWS("thread/delete_dataset", (msg: { dataset_id: string }) => {
+    const index = DATASETS.findIndex(
+      (dataset) => dataset.dataset_id === msg.dataset_id
+    );
+    if (index === -1) {
+      throw new Error(`Dataset ${msg.dataset_id} not found`);
+    }
+    if (DATASETS[index].preferred) {
+      throw new Error("Preferred dataset cannot be deleted");
+    }
+    DATASETS.splice(index, 1);
+    delete DATASET_TLVS[msg.dataset_id];
+    return undefined;
+  });
+
+  hass.mockWS("thread/set_preferred_dataset", (msg: { dataset_id: string }) => {
+    DATASETS.forEach((dataset) => {
+      dataset.preferred = dataset.dataset_id === msg.dataset_id;
+    });
+    return undefined;
+  });
+
+  hass.mockWS(
+    "thread/set_preferred_border_agent",
+    (msg: {
+      dataset_id: string;
+      border_agent_id: string | null;
+      extended_address: string;
+    }) => {
+      const dataset = DATASETS.find(
+        (candidate) => candidate.dataset_id === msg.dataset_id
+      );
+      if (dataset) {
+        dataset.preferred_border_agent_id = msg.border_agent_id;
+        dataset.preferred_extended_address = msg.extended_address;
+      }
+      return undefined;
+    }
+  );
+
+  hass.mockWS("otbr/create_network", (msg: { extended_address: string }) => {
+    created += 1;
+    const dataset: ThreadDataSet = {
+      channel: 15,
+      created: new Date().toISOString(),
+      dataset_id: `created-dataset-${created}`,
+      extended_pan_id: randomExtendedPanId(),
+      network_name: `ha-thread-${created}`,
+      pan_id: "1234",
+      preferred_border_agent_id: null,
+      preferred_extended_address: null,
+      preferred: false,
+      source: "otbr",
+    };
+    DATASETS.push(dataset);
+    DATASET_TLVS[dataset.dataset_id] = buildDatasetTlv(dataset);
+    moveRouter(
+      msg.extended_address,
+      dataset.extended_pan_id,
+      dataset.network_name,
+      dataset.dataset_id
+    );
+    return undefined;
+  });
+
+  hass.mockWS(
+    "otbr/set_network",
+    (msg: { extended_address: string; dataset_id: string }) => {
+      const dataset = DATASETS.find(
+        (candidate) => candidate.dataset_id === msg.dataset_id
+      );
+      if (dataset) {
+        const info = OTBR_INFO[msg.extended_address];
+        if (info) {
+          info.channel = dataset.channel ?? info.channel;
+        }
+        moveRouter(
+          msg.extended_address,
+          dataset.extended_pan_id,
+          dataset.network_name,
+          dataset.dataset_id
+        );
+      }
+      return undefined;
+    }
+  );
+
+  hass.mockWS(
+    "otbr/set_channel",
+    (msg: { extended_address: string; channel: number }) => {
+      const info = OTBR_INFO[msg.extended_address];
+      if (info) {
+        info.channel = msg.channel;
+        const dataset = DATASETS.find(
+          (candidate) => candidate.extended_pan_id === info.extended_pan_id
+        );
+        if (dataset) {
+          dataset.channel = msg.channel;
+          DATASET_TLVS[dataset.dataset_id] = replaceTlvField(
+            DATASET_TLVS[dataset.dataset_id],
+            0x00,
+            `00${msg.channel.toString(16).padStart(4, "0")}`
+          );
+          info.active_dataset_tlvs = DATASET_TLVS[dataset.dataset_id];
+        }
+      }
+      return { delay: 120 };
+    }
+  );
+};

demo/src/stubs/connectivity/types.ts

@@ -0,0 +1,38 @@
+import type { ConfigEntry } from "../../../../src/data/config_entries";
+import type { DeviceRegistryEntry } from "../../../../src/data/device/device_registry";
+import type { EntityRegistryEntry } from "../../../../src/data/entity/entity_registry";
+import type {
+  IntegrationManifest,
+  IntegrationType,
+} from "../../../../src/data/integration";
+import type { TranslationCategory } from "../../../../src/data/translation";
+import type { EntityInput } from "../../../../src/fake_data/entities/types";
+
+export interface DemoConfigEntry {
+  entry: ConfigEntry;
+  type: IntegrationType;
+}
+
+/**
+ * Everything one connectivity integration contributes to the demo besides its
+ * WebSocket mocks. This is loaded eagerly, together with the registries, so it
+ * must not pull in the mocks (which are code-split into the config panel
+ * chunk). Each integration owns one of these, so they stay independent.
+ */
+export interface ConnectivityFixtures {
+  /** Components to load, so the integration's panel is reachable. */
+  components: string[];
+  /** WS command prefixes served by the integration's mock, if it has one. */
+  commands?: string[];
+  configEntries?: DemoConfigEntry[];
+  /** Manifests for the domains above, so their integration pages open. */
+  manifests?: IntegrationManifest[];
+  devices?: DeviceRegistryEntry[];
+  entityRegistryEntries?: EntityRegistryEntry[];
+  /** States for the entities above; built lazily so timestamps stay fresh. */
+  entities?: () => EntityInput[];
+  /** Backend translations the panel looks up, by category. */
+  backendTranslations?: Partial<
+    Record<TranslationCategory, Record<string, string>>
+  >;
+}

demo/src/stubs/connectivity/zha/fixtures.ts

@@ -0,0 +1,232 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-zha";
+
+export const COORDINATOR_IEEE = "00:12:4b:00:24:c2:e1:00";
+export const PORCH_IEEE = "84:2e:14:ff:fe:11:22:33";
+export const MOTION_IEEE = "cc:cc:cc:ff:fe:44:55:66";
+export const PLUG_IEEE = "00:15:8d:00:03:aa:bb:cc";
+export const KITCHEN_IEEE = "84:2e:14:ff:fe:aa:bb:01";
+export const LANDING_IEEE = "00:15:8d:00:03:aa:bb:02";
+export const GARAGE_IEEE = "00:15:8d:00:03:aa:bb:03";
+export const OFFICE_IEEE = "00:15:8d:00:03:aa:bb:04";
+
+const DEVICES = [
+  device(
+    "zha-coordinator",
+    "Home Assistant Connect ZBT-1",
+    "Nabu Casa",
+    "Connect ZBT-1",
+    ENTRY_ID,
+    {
+      sw_version: "7.4.4.0",
+      connections: [["zigbee", COORDINATOR_IEEE]],
+      identifiers: [["zha", COORDINATOR_IEEE]],
+    }
+  ),
+  device(
+    "zha-porch-light",
+    "Porch light",
+    "IKEA of Sweden",
+    "TRADFRI bulb E27 CWS 806lm",
+    ENTRY_ID,
+    {
+      connections: [["zigbee", PORCH_IEEE]],
+      identifiers: [["zha", PORCH_IEEE]],
+    }
+  ),
+  device(
+    "zha-hall-motion",
+    "Hall motion",
+    "IKEA of Sweden",
+    "TRADFRI motion sensor",
+    ENTRY_ID,
+    {
+      connections: [["zigbee", MOTION_IEEE]],
+      identifiers: [["zha", MOTION_IEEE]],
+    }
+  ),
+  device("zha-tv-plug", "TV plug", "Innr", "SP 220", ENTRY_ID, {
+    area_id: "living_room",
+    connections: [["zigbee", PLUG_IEEE]],
+    identifiers: [["zha", PLUG_IEEE]],
+  }),
+  device(
+    "zha-kitchen-switch",
+    "Kitchen switch",
+    "IKEA of Sweden",
+    "TRADFRI on/off switch",
+    ENTRY_ID,
+    {
+      area_id: "kitchen",
+      connections: [["zigbee", KITCHEN_IEEE]],
+      identifiers: [["zha", KITCHEN_IEEE]],
+    }
+  ),
+  device(
+    "zha-landing-sensor",
+    "Landing sensor",
+    "Aqara",
+    "WSDCGQ11LM",
+    ENTRY_ID,
+    {
+      connections: [["zigbee", LANDING_IEEE]],
+      identifiers: [["zha", LANDING_IEEE]],
+    }
+  ),
+  device(
+    "zha-garage-contact",
+    "Garage contact",
+    "Aqara",
+    "MCCGQ11LM",
+    ENTRY_ID,
+    {
+      connections: [["zigbee", GARAGE_IEEE]],
+      identifiers: [["zha", GARAGE_IEEE]],
+    }
+  ),
+  device("zha-office-plug", "Office plug", "Innr", "SP 240", ENTRY_ID, {
+    area_id: "office",
+    connections: [["zigbee", OFFICE_IEEE]],
+    identifiers: [["zha", OFFICE_IEEE]],
+  }),
+];
+
+const REGISTRY_ENTRIES = [
+  registryEntry("light.porch", "zha-porch-light", ENTRY_ID, "zha"),
+  registryEntry(
+    "binary_sensor.hall_motion",
+    "zha-hall-motion",
+    ENTRY_ID,
+    "zha"
+  ),
+  registryEntry("switch.tv_plug", "zha-tv-plug", ENTRY_ID, "zha"),
+  registryEntry(
+    "sensor.kitchen_switch_battery",
+    "zha-kitchen-switch",
+    ENTRY_ID,
+    "zha"
+  ),
+  registryEntry(
+    "sensor.landing_temperature",
+    "zha-landing-sensor",
+    ENTRY_ID,
+    "zha"
+  ),
+  registryEntry(
+    "binary_sensor.garage_contact",
+    "zha-garage-contact",
+    ENTRY_ID,
+    "zha"
+  ),
+  registryEntry("switch.office_desk", "zha-office-plug", ENTRY_ID, "zha"),
+];
+
+export const AREA_BY_IEEE: Record<string, string> = Object.fromEntries(
+  DEVICES.flatMap((entry) => {
+    const areaId = entry.area_id;
+    return areaId
+      ? entry.connections
+          .filter(([type]) => type === "zigbee")
+          .map(([, ieee]) => [ieee, areaId])
+      : [];
+  })
+);
+
+export const zhaFixtures: ConnectivityFixtures = {
+  components: ["zha"],
+  commands: ["zha/"],
+  manifests: [
+    manifest("zha", "Zigbee Home Automation", {
+      integration_type: "hub",
+      iot_class: "local_polling",
+    }),
+  ],
+  configEntries: [
+    {
+      type: "hub",
+      entry: configEntry(ENTRY_ID, "zha", "Home Assistant Connect ZBT-1", {
+        supports_options: true,
+        supports_remove_device: true,
+      }),
+    },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "light.porch": {
+        entity_id: "light.porch",
+        state: "off",
+        attributes: {
+          friendly_name: "Porch light",
+          supported_color_modes: ["hs"],
+        },
+      },
+      "binary_sensor.hall_motion": {
+        entity_id: "binary_sensor.hall_motion",
+        state: "off",
+        attributes: { friendly_name: "Hall motion", device_class: "motion" },
+      },
+      "switch.tv_plug": {
+        entity_id: "switch.tv_plug",
+        state: "unavailable",
+        attributes: { friendly_name: "TV plug" },
+      },
+      "sensor.kitchen_switch_battery": {
+        entity_id: "sensor.kitchen_switch_battery",
+        state: "78",
+        attributes: {
+          friendly_name: "Kitchen switch battery",
+          device_class: "battery",
+          state_class: "measurement",
+          unit_of_measurement: "%",
+        },
+      },
+      "sensor.landing_temperature": {
+        entity_id: "sensor.landing_temperature",
+        state: "19.6",
+        attributes: {
+          friendly_name: "Landing temperature",
+          device_class: "temperature",
+          state_class: "measurement",
+          unit_of_measurement: "°C",
+        },
+      },
+      "binary_sensor.garage_contact": {
+        entity_id: "binary_sensor.garage_contact",
+        state: "off",
+        attributes: { friendly_name: "Garage contact", device_class: "door" },
+      },
+      "switch.office_desk": {
+        entity_id: "switch.office_desk",
+        state: "on",
+        attributes: { friendly_name: "Office desk" },
+      },
+    }),
+  backendTranslations: {
+    config_panel: {
+      "component.zha.config_panel.zha_options.title": "Global options",
+      "component.zha.config_panel.zha_options.default_light_transition":
+        "Default light transition time (seconds)",
+      "component.zha.config_panel.zha_options.enhanced_light_transition":
+        "Enable enhanced light color/temperature transition from an off state",
+      "component.zha.config_panel.zha_options.always_prefer_xy_color_mode":
+        "Always prefer XY color mode",
+      "component.zha.config_panel.zha_alarm_options.title": "Alarm options",
+      "component.zha.config_panel.zha_alarm_options.alarm_master_code":
+        "Alarm master code",
+      "component.zha.config_panel.zha_alarm_options.alarm_failed_tries":
+        "Failed authentication attempts before restart",
+      "component.zha.config_panel.zha_alarm_options.alarm_arm_requires_code":
+        "Code required for arming",
+    },
+  },
+};

demo/src/stubs/connectivity/zha/mock.ts

@@ -0,0 +1,793 @@
+import type {
+  Attribute,
+  AttributeConfigurationStatus,
+  Cluster,
+  ClusterConfigurationEvent,
+  Command,
+  Neighbor,
+  ReadAttributeServiceData,
+  ZHAConfiguration,
+  ZHADevice,
+  ZHADeviceEndpoint,
+  ZHAGroup,
+  ZHAEntityReference,
+  ZHAGroupMember,
+  ZHANetworkBackup,
+  ZHANetworkSettings,
+} from "../../../../../src/data/zha";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { minutesAgo } from "../helpers";
+
+import {
+  AREA_BY_IEEE,
+  LANDING_IEEE,
+  COORDINATOR_IEEE,
+  GARAGE_IEEE,
+  KITCHEN_IEEE,
+  MOTION_IEEE,
+  OFFICE_IEEE,
+  PLUG_IEEE,
+  PORCH_IEEE,
+} from "./fixtures";
+
+const neighbor = (
+  ieee: string,
+  nwk: string,
+  lqi: string,
+  relationship: string,
+  depth = "1"
+): Neighbor => ({ ieee, nwk, lqi, depth, relationship });
+
+const DEVICES: ZHADevice[] = [
+  {
+    available: true,
+    name: "Nabu Casa Connect ZBT-1",
+    ieee: COORDINATOR_IEEE,
+    nwk: 0x0000,
+    lqi: 255,
+    rssi: "0",
+    last_seen: minutesAgo(0),
+    manufacturer: "Nabu Casa",
+    model: "Connect ZBT-1",
+    quirk_applied: false,
+    quirk_class: "zigpy.device.Device",
+    entities: [],
+    manufacturer_code: 4476,
+    device_reg_id: "zha-coordinator",
+    user_given_name: "Home Assistant Connect ZBT-1",
+    power_source: "Mains",
+    device_type: "Coordinator",
+    active_coordinator: true,
+    signature: {},
+    neighbors: [
+      neighbor(PORCH_IEEE, "0x1a2b", "224", "Child"),
+      neighbor(PLUG_IEEE, "0x3c4d", "198", "Child"),
+      neighbor(OFFICE_IEEE, "0x7a8b", "211", "Child"),
+    ],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "TRADFRI bulb E27 CWS 806lm",
+    ieee: PORCH_IEEE,
+    nwk: 0x1a2b,
+    lqi: 224,
+    rssi: "-58",
+    last_seen: minutesAgo(2),
+    manufacturer: "IKEA of Sweden",
+    model: "TRADFRI bulb E27 CWS 806lm",
+    quirk_applied: true,
+    quirk_class: "zhaquirks.ikea.bulb.IkeaBulb",
+    entities: [],
+    manufacturer_code: 4476,
+    device_reg_id: "zha-porch-light",
+    user_given_name: "Porch light",
+    power_source: "Mains",
+    device_type: "Router",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [
+      neighbor(COORDINATOR_IEEE, "0x0000", "224", "Parent", "0"),
+      neighbor(MOTION_IEEE, "0x5e6f", "142", "Child", "2"),
+      neighbor(KITCHEN_IEEE, "0x9c0d", "186", "Sibling", "1"),
+    ],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "TRADFRI motion sensor",
+    ieee: MOTION_IEEE,
+    nwk: 0x5e6f,
+    lqi: 142,
+    rssi: "-77",
+    last_seen: minutesAgo(9),
+    manufacturer: "IKEA of Sweden",
+    model: "TRADFRI motion sensor",
+    quirk_applied: false,
+    quirk_class: "zigpy.device.Device",
+    entities: [],
+    manufacturer_code: 4476,
+    device_reg_id: "zha-hall-motion",
+    user_given_name: "Hall motion",
+    power_source: "Battery",
+    device_type: "EndDevice",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [neighbor(PORCH_IEEE, "0x1a2b", "142", "Parent", "1")],
+    routes: [],
+  },
+  {
+    available: false,
+    name: "Innr SP 220",
+    ieee: PLUG_IEEE,
+    nwk: 0x3c4d,
+    lqi: 198,
+    rssi: "-64",
+    last_seen: minutesAgo(240),
+    manufacturer: "Innr",
+    model: "SP 220",
+    quirk_applied: false,
+    quirk_class: "zigpy.device.Device",
+    entities: [],
+    manufacturer_code: 4448,
+    device_reg_id: "zha-tv-plug",
+    user_given_name: "TV plug",
+    power_source: "Mains",
+    device_type: "Router",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [neighbor(COORDINATOR_IEEE, "0x0000", "198", "Parent", "0")],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "TRADFRI on/off switch",
+    ieee: KITCHEN_IEEE,
+    nwk: 0x9c0d,
+    lqi: 186,
+    rssi: "-69",
+    last_seen: minutesAgo(4),
+    manufacturer: "IKEA of Sweden",
+    model: "TRADFRI on/off switch",
+    quirk_applied: true,
+    quirk_class: "zhaquirks.ikea.onoffswitch.IkeaSwitch",
+    entities: [],
+    manufacturer_code: 4476,
+    device_reg_id: "zha-kitchen-switch",
+    user_given_name: "Kitchen switch",
+    power_source: "Battery",
+    device_type: "EndDevice",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [neighbor(PORCH_IEEE, "0x1a2b", "186", "Parent", "1")],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "Aqara temperature sensor",
+    ieee: LANDING_IEEE,
+    nwk: 0xab12,
+    lqi: 164,
+    rssi: "-74",
+    last_seen: minutesAgo(6),
+    manufacturer: "Aqara",
+    model: "WSDCGQ11LM",
+    quirk_applied: true,
+    quirk_class: "zhaquirks.xiaomi.aqara.weather.Weather",
+    entities: [],
+    manufacturer_code: 4447,
+    device_reg_id: "zha-landing-sensor",
+    user_given_name: "Landing sensor",
+    power_source: "Battery",
+    device_type: "EndDevice",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [neighbor(OFFICE_IEEE, "0x7a8b", "164", "Parent", "2")],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "Aqara door sensor",
+    ieee: GARAGE_IEEE,
+    nwk: 0xcd34,
+    lqi: 118,
+    rssi: "-83",
+    last_seen: minutesAgo(21),
+    manufacturer: "Aqara",
+    model: "MCCGQ11LM",
+    quirk_applied: true,
+    quirk_class: "zhaquirks.xiaomi.aqara.magnet.Magnet",
+    entities: [],
+    manufacturer_code: 4447,
+    device_reg_id: "zha-garage-contact",
+    user_given_name: "Garage contact",
+    power_source: "Battery",
+    device_type: "EndDevice",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [neighbor(OFFICE_IEEE, "0x7a8b", "118", "Parent", "2")],
+    routes: [],
+  },
+  {
+    available: true,
+    name: "Innr SP 240",
+    ieee: OFFICE_IEEE,
+    nwk: 0x7a8b,
+    lqi: 211,
+    rssi: "-61",
+    last_seen: minutesAgo(1),
+    manufacturer: "Innr",
+    model: "SP 240",
+    quirk_applied: false,
+    quirk_class: "zigpy.device.Device",
+    entities: [],
+    manufacturer_code: 4448,
+    device_reg_id: "zha-office-plug",
+    user_given_name: "Office plug",
+    power_source: "Mains",
+    device_type: "Router",
+    active_coordinator: false,
+    signature: {},
+    neighbors: [
+      neighbor(COORDINATOR_IEEE, "0x0000", "211", "Parent", "0"),
+      neighbor(LANDING_IEEE, "0xab12", "164", "Child", "2"),
+      neighbor(GARAGE_IEEE, "0xcd34", "118", "Child", "2"),
+    ],
+    routes: [],
+  },
+];
+
+DEVICES.forEach((zhaDevice) => {
+  zhaDevice.area_id = AREA_BY_IEEE[zhaDevice.ieee];
+});
+
+const deviceByIeee = (ieee: string): ZHADevice =>
+  DEVICES.find((d) => d.ieee === ieee)!;
+
+const ENDPOINT_ENTITIES: Record<string, { entity_id: string; name: string }[]> =
+  {
+    [PORCH_IEEE]: [{ entity_id: "light.porch", name: "Porch light" }],
+    [PLUG_IEEE]: [{ entity_id: "switch.tv_plug", name: "TV plug" }],
+    [OFFICE_IEEE]: [{ entity_id: "switch.office_desk", name: "Office desk" }],
+  };
+
+const member = (ieee: string, endpointId = 1): ZHADeviceEndpoint => ({
+  device: deviceByIeee(ieee),
+  endpoint_id: endpointId,
+  entities: (ENDPOINT_ENTITIES[ieee] ?? []).map(
+    (entity) =>
+      ({
+        ...entity,
+        original_name: entity.name,
+      }) as ZHAEntityReference
+  ),
+});
+
+const GROUPS: ZHAGroup[] = [
+  {
+    name: "Downstairs lights",
+    group_id: 1,
+    members: [member(PORCH_IEEE), member(OFFICE_IEEE)],
+  },
+  {
+    name: "Outdoor lights",
+    group_id: 2,
+    members: [member(PORCH_IEEE)],
+  },
+];
+
+const CONFIGURATION: ZHAConfiguration = {
+  data: {
+    zha_options: {
+      default_light_transition: 0,
+      enhanced_light_transition: false,
+      light_transitioning_flag: true,
+      always_prefer_xy_color_mode: true,
+      group_members_assume_state: true,
+      consider_unavailable_mains: 7200,
+      consider_unavailable_battery: 21600,
+    },
+    zha_alarm_options: {
+      alarm_master_code: "1234",
+      alarm_failed_tries: 3,
+      alarm_arm_requires_code: false,
+    },
+  },
+  schemas: {
+    zha_options: [
+      {
+        name: "default_light_transition",
+        required: true,
+        selector: { number: { min: 0, max: 2 ** 16 / 10, step: 0.1 } },
+      },
+      {
+        name: "enhanced_light_transition",
+        required: true,
+        selector: { boolean: {} },
+      },
+      {
+        name: "always_prefer_xy_color_mode",
+        required: true,
+        selector: { boolean: {} },
+      },
+    ],
+    zha_alarm_options: [
+      { name: "alarm_master_code", required: true, selector: { text: {} } },
+      {
+        name: "alarm_failed_tries",
+        required: true,
+        selector: { number: { min: 0, max: 2 ** 8, mode: "box" } },
+      },
+      {
+        name: "alarm_arm_requires_code",
+        required: true,
+        selector: { boolean: {} },
+      },
+    ],
+  },
+};
+
+const BACKUPS: ZHANetworkBackup[] = [];
+
+const NETWORK_SETTINGS: ZHANetworkSettings = {
+  radio_type: "ezsp",
+  device: { path: "/dev/ttyUSB0", baudrate: 115200, flow_control: "hardware" },
+  settings: {
+    backup_time: new Date(Date.now() - 3600000).toISOString(),
+    node_info: {
+      nwk: "0x0000",
+      ieee: COORDINATOR_IEEE,
+      logical_type: "coordinator",
+    },
+    network_info: {
+      extended_pan_id: "b0:23:2f:cc:aa:11:22:33",
+      pan_id: "0x1234",
+      nwk_update_id: 0,
+      nwk_manager_id: "0x0000",
+      channel: 15,
+      channel_mask: [15, 20, 25],
+      security_level: 5,
+      network_key: {
+        key: "aa:bb:cc:dd:ee:ff:00:11:22:33:44:55:66:77:88:99",
+        tx_counter: 138234,
+        rx_counter: 0,
+        seq: 0,
+        partner_ieee: "ff:ff:ff:ff:ff:ff:ff:ff",
+      },
+      tc_link_key: {
+        key: "5a:69:67:42:65:65:41:6c:6c:69:61:6e:63:65:30:39",
+        tx_counter: 0,
+        rx_counter: 0,
+        seq: 0,
+        partner_ieee: COORDINATOR_IEEE,
+      },
+      key_table: [],
+      children: [PORCH_IEEE, PLUG_IEEE, OFFICE_IEEE],
+      nwk_addresses: {
+        [PORCH_IEEE]: "0x1a2b",
+        [MOTION_IEEE]: "0x5e6f",
+        [PLUG_IEEE]: "0x3c4d",
+        [KITCHEN_IEEE]: "0x9c0d",
+        [LANDING_IEEE]: "0xab12",
+        [GARAGE_IEEE]: "0xcd34",
+        [OFFICE_IEEE]: "0x7a8b",
+      },
+      stack_specific: {},
+      metadata: { ezsp: { stack_version: "7.4.4.0" } },
+      source: "[email protected]",
+    },
+  },
+};
+
+interface ClusterDefinition {
+  name: string;
+  attributes: Attribute[];
+  commands: Command[];
+}
+
+const numberField = (name: string, max: number) => ({
+  name,
+  required: true,
+  selector: { number: { min: 0, max, mode: "box" as const } },
+});
+
+const CLUSTERS: Record<number, ClusterDefinition> = {
+  0: {
+    name: "Basic",
+    attributes: [
+      { name: "zcl_version", id: 0 },
+      { name: "app_version", id: 1 },
+      { name: "manufacturer", id: 4 },
+      { name: "model", id: 5 },
+    ],
+    commands: [],
+  },
+  1: {
+    name: "PowerConfiguration",
+    attributes: [
+      { name: "battery_voltage", id: 32 },
+      { name: "battery_percentage_remaining", id: 33 },
+    ],
+    commands: [],
+  },
+  3: {
+    name: "Identify",
+    attributes: [{ name: "identify_time", id: 0 }],
+    commands: [
+      {
+        name: "identify",
+        id: 0,
+        type: "server",
+        schema: [numberField("identify_time", 65535)],
+      },
+    ],
+  },
+  4: {
+    name: "Groups",
+    attributes: [{ name: "name_support", id: 0 }],
+    commands: [],
+  },
+  6: {
+    name: "OnOff",
+    attributes: [{ name: "on_off", id: 0 }],
+    commands: [
+      { name: "off", id: 0, type: "server", schema: [] },
+      { name: "on", id: 1, type: "server", schema: [] },
+      { name: "toggle", id: 2, type: "server", schema: [] },
+    ],
+  },
+  8: {
+    name: "LevelControl",
+    attributes: [{ name: "current_level", id: 0 }],
+    commands: [
+      {
+        name: "move_to_level",
+        id: 0,
+        type: "server",
+        schema: [
+          numberField("level", 254),
+          numberField("transition_time", 65535),
+        ],
+      },
+    ],
+  },
+  25: {
+    name: "Ota",
+    attributes: [{ name: "current_file_version", id: 2 }],
+    commands: [],
+  },
+  768: {
+    name: "ColorControl",
+    attributes: [
+      { name: "current_hue", id: 0 },
+      { name: "current_saturation", id: 1 },
+      { name: "color_temperature", id: 7 },
+    ],
+    commands: [
+      {
+        name: "move_to_color_temp",
+        id: 10,
+        type: "server",
+        schema: [
+          numberField("color_temp_mireds", 500),
+          numberField("transition_time", 65535),
+        ],
+      },
+    ],
+  },
+  1026: {
+    name: "TemperatureMeasurement",
+    attributes: [
+      { name: "measured_value", id: 0 },
+      { name: "min_measured_value", id: 1 },
+      { name: "max_measured_value", id: 2 },
+    ],
+    commands: [],
+  },
+  1280: {
+    name: "IasZone",
+    attributes: [
+      { name: "zone_state", id: 0 },
+      { name: "zone_type", id: 1 },
+      { name: "zone_status", id: 2 },
+    ],
+    commands: [],
+  },
+  2820: {
+    name: "ElectricalMeasurement",
+    attributes: [
+      { name: "rms_voltage", id: 1285 },
+      { name: "rms_current", id: 1288 },
+      { name: "active_power", id: 1291 },
+    ],
+    commands: [],
+  },
+};
+
+const clusterList = (inIds: number[], outIds: number[] = []): Cluster[] =>
+  [
+    ...inIds.map((id) => ({ id, type: "in" })),
+    ...outIds.map((id) => ({ id, type: "out" })),
+  ].map(({ id, type }) => ({
+    name: CLUSTERS[id].name,
+    id,
+    endpoint_id: 1,
+    type,
+  }));
+
+// A device binds from its client side, and group binding lists only those, so
+// the remotes carry the `out` clusters they would have on real hardware and
+// the mains-powered devices only their OTA one.
+const DEVICE_CLUSTERS: Record<string, Cluster[]> = {
+  [COORDINATOR_IEEE]: clusterList([0]),
+  [PORCH_IEEE]: clusterList([0, 3, 4, 6, 8, 768], [25]),
+  [MOTION_IEEE]: clusterList([0, 1, 3, 1280], [3, 6, 8]),
+  [PLUG_IEEE]: clusterList([0, 3, 4, 6, 2820], [25]),
+  [KITCHEN_IEEE]: clusterList([0, 1, 3], [3, 6, 8]),
+  [LANDING_IEEE]: clusterList([0, 1, 3, 1026]),
+  [GARAGE_IEEE]: clusterList([0, 1, 3, 1280]),
+  [OFFICE_IEEE]: clusterList([0, 3, 4, 6, 2820], [25]),
+};
+
+const DEFAULT_ATTRIBUTE_VALUES: Record<string, string> = {
+  "1:32": "30",
+  "1:33": "184",
+  "3:0": "0",
+  "4:0": "0",
+  "6:0": "1",
+  "8:0": "254",
+  "768:0": "42",
+  "768:1": "180",
+  "768:7": "370",
+  "1026:0": "2140",
+  "1026:1": "-2000",
+  "1026:2": "6000",
+  "1280:0": "1",
+  "1280:1": "21",
+  "1280:2": "0",
+  "2820:1285": "2300",
+  "2820:1288": "410",
+  "2820:1291": "94",
+};
+
+const writtenAttributes = new Map<string, string>();
+
+const attributeKey = (data: ReadAttributeServiceData) =>
+  `${data.ieee}:${data.endpoint_id}:${data.cluster_id}:${data.attribute}`;
+
+const attributeValue = (data: ReadAttributeServiceData): string => {
+  const written = writtenAttributes.get(attributeKey(data));
+  if (written !== undefined) {
+    return written;
+  }
+  if (data.cluster_id === 0) {
+    const device = DEVICES.find((candidate) => candidate.ieee === data.ieee);
+    if (data.attribute === 4) {
+      return device?.manufacturer ?? "";
+    }
+    if (data.attribute === 5) {
+      return device?.model ?? "";
+    }
+    return "3";
+  }
+  return (
+    DEFAULT_ATTRIBUTE_VALUES[`${data.cluster_id}:${data.attribute}`] ?? "0"
+  );
+};
+
+export const mockZha = (hass: MockHomeAssistant) => {
+  hass.mockWS("zha/devices", () => DEVICES);
+  hass.mockWS("zha/device", (msg: { ieee: string }) =>
+    DEVICES.find((device) => device.ieee === msg.ieee)
+  );
+  hass.mockWS("zha/groups", () => GROUPS);
+  hass.mockWS("zha/group", (msg: { group_id: number }) =>
+    GROUPS.find((group) => group.group_id === msg.group_id)
+  );
+  // Copied: both options editors mutate the fetched data as the user changes a
+  // control, so handing out the backing object would persist edits that were
+  // never saved. Only the update below writes to it.
+  hass.mockWS("zha/configuration", () => structuredClone(CONFIGURATION));
+  hass.mockWS("zha/network/settings", () => NETWORK_SETTINGS);
+  hass.mockWS("zha/topology/update", () => undefined);
+  hass.mockWS("zha/devices/bindable", (msg: { ieee: string }) =>
+    DEVICES.filter(
+      (candidate) =>
+        candidate.device_type === "Router" && candidate.ieee !== msg.ieee
+    )
+  );
+  hass.mockWS("zha/devices/bind", () => undefined);
+  hass.mockWS("zha/devices/unbind", () => undefined);
+  hass.mockWS("zha/groups/bind", () => undefined);
+  hass.mockWS("zha/groups/unbind", () => undefined);
+  hass.mockWS(
+    "zha/devices/clusters",
+    (msg: { ieee: string }) => DEVICE_CLUSTERS[msg.ieee] ?? []
+  );
+  hass.mockWS(
+    "zha/devices/clusters/attributes",
+    (msg: { cluster_id: number }) => CLUSTERS[msg.cluster_id]?.attributes ?? []
+  );
+  hass.mockWS(
+    "zha/devices/clusters/commands",
+    (msg: { cluster_id: number }) => CLUSTERS[msg.cluster_id]?.commands ?? []
+  );
+  hass.mockWS(
+    "zha/devices/clusters/attributes/value",
+    (msg: ReadAttributeServiceData) => attributeValue(msg)
+  );
+  hass.mockService("zha", "set_zigbee_cluster_attribute", (data) => {
+    const write = data as ReadAttributeServiceData & { value: unknown };
+    writtenAttributes.set(attributeKey(write), String(write.value));
+    return undefined;
+  });
+  hass.mockWS("zha/devices/groupable", () => [
+    member(PORCH_IEEE),
+    member(OFFICE_IEEE),
+    member(PLUG_IEEE),
+  ]);
+  hass.mockWS("zha/network/backups/list", () => BACKUPS);
+
+  hass.mockWS("zha/devices/permit", () => () => undefined);
+
+  hass.mockWS(
+    "zha/devices/reconfigure",
+    (msg: { ieee: string }, _hass, onChange) => {
+      const deviceClusters = DEVICE_CLUSTERS[msg.ieee] ?? [];
+      const timers: number[] = [];
+      let cancelled = false;
+      const emit = (event: ClusterConfigurationEvent, step: number) => {
+        timers.push(
+          window.setTimeout(() => {
+            if (!cancelled) {
+              onChange!(event);
+            }
+          }, step * 400)
+        );
+      };
+
+      deviceClusters.forEach((cluster, index) => {
+        emit(
+          {
+            type: "zha_channel_bind",
+            zha_channel_msg_data: {
+              cluster_name: cluster.name,
+              cluster_id: cluster.id,
+              success: true,
+            },
+          },
+          index + 1
+        );
+        const attributes: AttributeConfigurationStatus[] = CLUSTERS[
+          cluster.id
+        ].attributes.map((attribute) => ({
+          ...attribute,
+          status: "SUCCESS",
+          min: 30,
+          max: 900,
+          change: 1,
+        }));
+        if (attributes.length) {
+          emit(
+            {
+              type: "zha_channel_configure_reporting",
+              zha_channel_msg_data: {
+                cluster_name: cluster.name,
+                cluster_id: cluster.id,
+                attributes,
+              },
+            },
+            index + 1
+          );
+        }
+      });
+      emit({ type: "zha_channel_cfg_done" }, deviceClusters.length + 1);
+
+      return () => {
+        cancelled = true;
+        timers.forEach((timer) => clearTimeout(timer));
+      };
+    }
+  );
+
+  hass.mockWS(
+    "zha/configuration/update",
+    (msg: { data: ZHAConfiguration["data"] }) => {
+      Object.entries(msg.data ?? {}).forEach(([section, values]) => {
+        CONFIGURATION.data[section] = {
+          ...CONFIGURATION.data[section],
+          ...values,
+        };
+      });
+      return undefined;
+    }
+  );
+
+  hass.mockWS("zha/network/backups/create", () => {
+    const backup: ZHANetworkBackup = {
+      backup_time: new Date().toISOString(),
+      // Copied, or changing the channel afterwards would rewrite the backup
+      // too, which is the one thing a backup must not do.
+      network_info: structuredClone(NETWORK_SETTINGS.settings.network_info),
+      node_info: structuredClone(NETWORK_SETTINGS.settings.node_info),
+    };
+    BACKUPS.push(backup);
+    return { backup, is_complete: true };
+  });
+
+  hass.mockWS(
+    "zha/network/change_channel",
+    (msg: { new_channel: "auto" | number }) => {
+      NETWORK_SETTINGS.settings.network_info.channel =
+        msg.new_channel === "auto" ? 25 : msg.new_channel;
+      return undefined;
+    }
+  );
+
+  hass.mockWS(
+    "zha/group/add",
+    (msg: {
+      group_name: string;
+      group_id?: number;
+      members?: ZHAGroupMember[];
+    }) => {
+      const group: ZHAGroup = {
+        name: msg.group_name,
+        group_id:
+          msg.group_id ??
+          GROUPS.reduce(
+            (highest, item) => Math.max(highest, item.group_id),
+            0
+          ) + 1,
+        members: (msg.members ?? []).map((item) => member(item.ieee)),
+      };
+      GROUPS.push(group);
+      return group;
+    }
+  );
+
+  hass.mockWS("zha/group/remove", (msg: { group_ids: number[] }) => {
+    msg.group_ids.forEach((groupId) => {
+      const index = GROUPS.findIndex((group) => group.group_id === groupId);
+      if (index !== -1) {
+        GROUPS.splice(index, 1);
+      }
+    });
+    return GROUPS;
+  });
+
+  const findGroup = (groupId: number) => {
+    const group = GROUPS.find((candidate) => candidate.group_id === groupId);
+    if (!group) {
+      throw new Error(`Group ${groupId} not found`);
+    }
+    return group;
+  };
+
+  hass.mockWS(
+    "zha/group/members/add",
+    (msg: { group_id: number; members: ZHAGroupMember[] }) => {
+      const group = findGroup(msg.group_id);
+      const known = new Set(group.members.map((item) => item.device.ieee));
+      group.members = [
+        ...group.members,
+        ...msg.members
+          .filter((item) => !known.has(item.ieee))
+          .map((item) => member(item.ieee)),
+      ];
+      return group;
+    }
+  );
+
+  hass.mockWS(
+    "zha/group/members/remove",
+    (msg: { group_id: number; members: ZHAGroupMember[] }) => {
+      const group = findGroup(msg.group_id);
+      const dropped = new Set(msg.members.map((item) => item.ieee));
+      group.members = group.members.filter(
+        (item) => !dropped.has(item.device.ieee)
+      );
+      return group;
+    }
+  );
+};

demo/src/stubs/connectivity/zwave_js/fixtures.ts

@@ -0,0 +1,201 @@
+import { manifest } from "../../manifest";
+import {
+  configEntry,
+  device,
+  registryEntry,
+  withRegistryLinks,
+} from "../helpers";
+import type { ConnectivityFixtures } from "../types";
+
+const ENTRY_ID = "mock-zwave-js";
+export const HOME_ID = 3245146787;
+
+// Node IDs are carried in the `zwave_js` device identifiers, which is where the
+// panels read them back from.
+export const CONTROLLER_NODE_ID = 1;
+export const HALLWAY_NODE_ID = 7;
+export const DIMMER_NODE_ID = 12;
+export const MOTION_NODE_ID = 15;
+export const LOCK_NODE_ID = 18;
+export const THERMOSTAT_NODE_ID = 20;
+export const SENSOR_NODE_ID = 23;
+export const OUTLET_NODE_ID = 31;
+
+export const DEVICE_IDS_BY_NODE_ID: Record<number, string> = {
+  [CONTROLLER_NODE_ID]: "zwave-controller",
+  [HALLWAY_NODE_ID]: "zwave-hallway-switch",
+  [DIMMER_NODE_ID]: "zwave-dining-dimmer",
+  [MOTION_NODE_ID]: "zwave-garage-motion",
+  [LOCK_NODE_ID]: "zwave-back-door-lock",
+  [THERMOSTAT_NODE_ID]: "zwave-bedroom-thermostat",
+  [SENSOR_NODE_ID]: "zwave-basement-sensor",
+  [OUTLET_NODE_ID]: "zwave-porch-outlet",
+};
+
+const identifiers = (nodeId: number): [string, string][] => [
+  ["zwave_js", `${HOME_ID}-${nodeId}`],
+];
+
+const DEVICES = [
+  device(
+    "zwave-controller",
+    "Z-Wave stick",
+    "Zooz",
+    "800 Series Z-Wave Long Range",
+    ENTRY_ID,
+    { sw_version: "1.10", identifiers: identifiers(CONTROLLER_NODE_ID) }
+  ),
+  device(
+    "zwave-dining-dimmer",
+    "Dining room dimmer",
+    "Inovelli",
+    "LZW31-SN",
+    ENTRY_ID,
+    { identifiers: identifiers(DIMMER_NODE_ID) }
+  ),
+  device("zwave-back-door-lock", "Back door lock", "Yale", "YRD226", ENTRY_ID, {
+    identifiers: identifiers(LOCK_NODE_ID),
+  }),
+  device(
+    "zwave-basement-sensor",
+    "Basement sensor",
+    "Aeotec",
+    "ZWA005 TriSensor",
+    ENTRY_ID,
+    { identifiers: identifiers(SENSOR_NODE_ID) }
+  ),
+  device("zwave-hallway-switch", "Hallway switch", "Zooz", "ZEN76", ENTRY_ID, {
+    area_id: "entrance",
+    identifiers: identifiers(HALLWAY_NODE_ID),
+  }),
+  device(
+    "zwave-garage-motion",
+    "Garage motion",
+    "Aeotec",
+    "MultiSensor 7",
+    ENTRY_ID,
+    { identifiers: identifiers(MOTION_NODE_ID) }
+  ),
+  device(
+    "zwave-bedroom-thermostat",
+    "Bedroom thermostat",
+    "Honeywell",
+    "T6 Pro",
+    ENTRY_ID,
+    { area_id: "bedroom", identifiers: identifiers(THERMOSTAT_NODE_ID) }
+  ),
+  device("zwave-porch-outlet", "Porch outlet", "Zooz", "ZEN15", ENTRY_ID, {
+    identifiers: identifiers(OUTLET_NODE_ID),
+  }),
+];
+
+const REGISTRY_ENTRIES = [
+  registryEntry(
+    "light.dining_room",
+    "zwave-dining-dimmer",
+    ENTRY_ID,
+    "zwave_js"
+  ),
+  registryEntry("lock.back_door", "zwave-back-door-lock", ENTRY_ID, "zwave_js"),
+  registryEntry(
+    "sensor.basement_humidity",
+    "zwave-basement-sensor",
+    ENTRY_ID,
+    "zwave_js"
+  ),
+  registryEntry("light.hallway", "zwave-hallway-switch", ENTRY_ID, "zwave_js"),
+  registryEntry(
+    "binary_sensor.garage_motion",
+    "zwave-garage-motion",
+    ENTRY_ID,
+    "zwave_js"
+  ),
+  registryEntry(
+    "climate.bedroom",
+    "zwave-bedroom-thermostat",
+    ENTRY_ID,
+    "zwave_js"
+  ),
+  registryEntry(
+    "switch.porch_outlet",
+    "zwave-porch-outlet",
+    ENTRY_ID,
+    "zwave_js"
+  ),
+];
+
+export const zwaveJsFixtures: ConnectivityFixtures = {
+  components: ["zwave_js"],
+  commands: ["zwave_js/"],
+  manifests: [manifest("zwave_js", "Z-Wave", { integration_type: "hub" })],
+  configEntries: [
+    {
+      type: "hub",
+      entry: configEntry(ENTRY_ID, "zwave_js", "Z-Wave", {
+        supports_options: true,
+        supports_remove_device: true,
+      }),
+    },
+  ],
+  devices: DEVICES,
+  entityRegistryEntries: REGISTRY_ENTRIES,
+  entities: () =>
+    withRegistryLinks(REGISTRY_ENTRIES, {
+      "light.dining_room": {
+        entity_id: "light.dining_room",
+        state: "on",
+        attributes: {
+          friendly_name: "Dining room dimmer",
+          supported_color_modes: ["brightness"],
+          color_mode: "brightness",
+          brightness: 128,
+        },
+      },
+      "lock.back_door": {
+        entity_id: "lock.back_door",
+        state: "unlocked",
+        attributes: { friendly_name: "Back door lock" },
+      },
+      "sensor.basement_humidity": {
+        entity_id: "sensor.basement_humidity",
+        state: "58",
+        attributes: {
+          friendly_name: "Basement humidity",
+          device_class: "humidity",
+          state_class: "measurement",
+          unit_of_measurement: "%",
+        },
+      },
+      "light.hallway": {
+        entity_id: "light.hallway",
+        state: "off",
+        attributes: {
+          friendly_name: "Hallway switch",
+          supported_color_modes: ["onoff"],
+        },
+      },
+      "binary_sensor.garage_motion": {
+        entity_id: "binary_sensor.garage_motion",
+        state: "on",
+        attributes: { friendly_name: "Garage motion", device_class: "motion" },
+      },
+      "climate.bedroom": {
+        entity_id: "climate.bedroom",
+        state: "heat",
+        attributes: {
+          friendly_name: "Bedroom thermostat",
+          hvac_modes: ["off", "heat"],
+          current_temperature: 19.6,
+          temperature: 20.5,
+          min_temp: 7,
+          max_temp: 30,
+          supported_features: 1,
+        },
+      },
+      "switch.porch_outlet": {
+        entity_id: "switch.porch_outlet",
+        state: "off",
+        attributes: { friendly_name: "Porch outlet" },
+      },
+    }),
+};

demo/src/stubs/connectivity/zwave_js/mock.ts

@@ -0,0 +1,229 @@
+import type {
+  ZWaveJSController,
+  ZWaveJSNetwork,
+  ZWaveJSNodeStatisticsUpdatedMessage,
+  ZWaveJSNodeStatus,
+  ZwaveJSProvisioningEntry,
+} from "../../../../../src/data/zwave_js";
+import {
+  NodeStatus,
+  ProvisioningEntryStatus,
+  SecurityClass,
+} from "../../../../../src/data/zwave_js";
+import type { MockHomeAssistant } from "../../../../../src/fake_data/provide_hass";
+import { emitInitial } from "../subscription";
+
+import {
+  CONTROLLER_NODE_ID,
+  DEVICE_IDS_BY_NODE_ID,
+  DIMMER_NODE_ID,
+  HALLWAY_NODE_ID,
+  HOME_ID,
+  LOCK_NODE_ID,
+  MOTION_NODE_ID,
+  OUTLET_NODE_ID,
+  SENSOR_NODE_ID,
+  THERMOSTAT_NODE_ID,
+} from "./fixtures";
+
+const node = (
+  nodeId: number,
+  status: NodeStatus,
+  overrides: Partial<ZWaveJSNodeStatus> = {}
+): ZWaveJSNodeStatus => ({
+  node_id: nodeId,
+  ready: true,
+  status,
+  is_secure: true,
+  is_routing: true,
+  zwave_plus_version: 2,
+  highest_security_class: SecurityClass.S2_Authenticated,
+  is_controller_node: false,
+  has_firmware_update_cc: true,
+  ...overrides,
+});
+
+const NODES: ZWaveJSNodeStatus[] = [
+  node(CONTROLLER_NODE_ID, NodeStatus.Alive, {
+    is_controller_node: true,
+    highest_security_class: SecurityClass.S2_AccessControl,
+  }),
+  node(HALLWAY_NODE_ID, NodeStatus.Alive),
+  node(DIMMER_NODE_ID, NodeStatus.Alive),
+  node(MOTION_NODE_ID, NodeStatus.Asleep, { is_routing: false }),
+  node(LOCK_NODE_ID, NodeStatus.Asleep, {
+    is_routing: false,
+    highest_security_class: SecurityClass.S2_AccessControl,
+  }),
+  node(THERMOSTAT_NODE_ID, NodeStatus.Alive),
+  node(SENSOR_NODE_ID, NodeStatus.Dead, { is_routing: false }),
+  node(OUTLET_NODE_ID, NodeStatus.Alive),
+];
+
+const CONTROLLER: ZWaveJSController = {
+  home_id: HOME_ID,
+  sdk_version: "7.19.3",
+  type: 1,
+  own_node_id: CONTROLLER_NODE_ID,
+  rf_region: null,
+  is_primary: true,
+  is_using_home_id_from_other_network: false,
+  is_sis_present: true,
+  was_real_primary: true,
+  is_suc: true,
+  // NodeType.Controller; the enum itself is not exported from data/zwave_js.
+  node_type: 0 as ZWaveJSController["node_type"],
+  firmware_version: "1.10",
+  manufacturer_id: 634,
+  product_id: 4,
+  product_type: 3,
+  supported_function_types: [],
+  suc_node_id: CONTROLLER_NODE_ID,
+  supports_timers: false,
+  is_rebuilding_routes: false,
+  // InclusionState.Idle
+  inclusion_state: 0,
+  nodes: NODES,
+  supports_long_range: true,
+};
+
+const NETWORK: ZWaveJSNetwork = {
+  client: {
+    state: "connected",
+    ws_server_url: "ws://localhost:3000",
+    server_version: "1.40.1",
+    driver_version: "13.2.0",
+  },
+  controller: CONTROLLER,
+};
+
+const PROVISIONING_ENTRIES: ZwaveJSProvisioningEntry[] = [
+  {
+    dsk: "51590-27189-49239-34778-15304-59293-52843-45852",
+    securityClasses: [SecurityClass.S2_Authenticated],
+    status: ProvisioningEntryStatus.Active,
+    additionalProperties: {},
+    manufacturer: "Zooz",
+    label: "ZEN32 Scene Controller",
+  },
+];
+
+// Node IDs each node can reach directly. Only requested when the map's
+// neighbor overlay is toggled on.
+const NEIGHBORS: Record<number, number[]> = {
+  [CONTROLLER_NODE_ID]: [HALLWAY_NODE_ID, DIMMER_NODE_ID, OUTLET_NODE_ID],
+  [HALLWAY_NODE_ID]: [
+    CONTROLLER_NODE_ID,
+    DIMMER_NODE_ID,
+    LOCK_NODE_ID,
+    THERMOSTAT_NODE_ID,
+  ],
+  [DIMMER_NODE_ID]: [
+    CONTROLLER_NODE_ID,
+    HALLWAY_NODE_ID,
+    SENSOR_NODE_ID,
+    OUTLET_NODE_ID,
+  ],
+  [MOTION_NODE_ID]: [THERMOSTAT_NODE_ID],
+  [LOCK_NODE_ID]: [HALLWAY_NODE_ID],
+  [THERMOSTAT_NODE_ID]: [HALLWAY_NODE_ID, MOTION_NODE_ID],
+  [SENSOR_NODE_ID]: [DIMMER_NODE_ID],
+  [OUTLET_NODE_ID]: [CONTROLLER_NODE_ID, DIMMER_NODE_ID],
+};
+
+// Route each node reports as its last working route back to the controller,
+// so the map can draw the mesh instead of a star.
+const ROUTES: Record<number, { repeaters: number[]; rssi: number }> = {
+  [HALLWAY_NODE_ID]: { repeaters: [], rssi: -44 },
+  [DIMMER_NODE_ID]: { repeaters: [], rssi: -48 },
+  [OUTLET_NODE_ID]: { repeaters: [], rssi: -57 },
+  [LOCK_NODE_ID]: { repeaters: [HALLWAY_NODE_ID], rssi: -72 },
+  [THERMOSTAT_NODE_ID]: { repeaters: [HALLWAY_NODE_ID], rssi: -66 },
+  [MOTION_NODE_ID]: {
+    repeaters: [HALLWAY_NODE_ID, THERMOSTAT_NODE_ID],
+    rssi: -79,
+  },
+  [SENSOR_NODE_ID]: { repeaters: [DIMMER_NODE_ID], rssi: -81 },
+};
+
+const NODE_IDS_BY_DEVICE_ID: Record<string, number> = Object.fromEntries(
+  Object.entries(DEVICE_IDS_BY_NODE_ID).map(([nodeId, deviceId]) => [
+    deviceId,
+    Number(nodeId),
+  ])
+);
+
+const buildNodeStatistics = (
+  nodeId: number
+): ZWaveJSNodeStatisticsUpdatedMessage => {
+  const route = ROUTES[nodeId];
+  return {
+    event: "statistics updated",
+    source: "node",
+    nodeId,
+    node_id: nodeId,
+    commands_tx: 1200 + nodeId * 7,
+    commands_rx: 980 + nodeId * 5,
+    commands_dropped_tx: 0,
+    commands_dropped_rx: nodeId === SENSOR_NODE_ID ? 4 : 0,
+    timeout_response: 0,
+    rtt: 24 + nodeId,
+    rssi: route?.rssi ?? null,
+    lwr: route
+      ? {
+          protocol_data_rate: 3,
+          repeaters: route.repeaters.map(
+            (repeaterNodeId) => DEVICE_IDS_BY_NODE_ID[repeaterNodeId]
+          ),
+          rssi: route.rssi,
+          repeater_rssi: route.repeaters.map(() => -55),
+          route_failed_between: null,
+        }
+      : null,
+    nlwr: null,
+  };
+};
+
+export const mockZwaveJs = (hass: MockHomeAssistant) => {
+  hass.mockWS("zwave_js/network_status", () => NETWORK);
+  hass.mockWS("zwave_js/network_neighbors", () => NEIGHBORS);
+  hass.mockWS("zwave_js/get_provisioning_entries", () => PROVISIONING_ENTRIES);
+  hass.mockWS("zwave_js/data_collection_status", () => ({
+    enabled: false,
+    opted_in: false,
+  }));
+  hass.mockWS("zwave_js/subscribe_s2_inclusion", () => () => undefined);
+  hass.mockWS("zwave_js/node_status", (msg: { device_id: string }) => {
+    const nodeId = NODE_IDS_BY_DEVICE_ID[msg.device_id];
+    return NODES.find((n) => n.node_id === nodeId) ?? NODES[0];
+  });
+  hass.mockWS(
+    "zwave_js/subscribe_node_statistics",
+    (msg: { device_id: string }, _hass, onChange) => {
+      const nodeId = NODE_IDS_BY_DEVICE_ID[msg.device_id];
+      if (nodeId === undefined || nodeId === CONTROLLER_NODE_ID) {
+        return () => undefined;
+      }
+      return emitInitial(() => onChange?.(buildNodeStatistics(nodeId)));
+    }
+  );
+  hass.mockWS(
+    "zwave_js/subscribe_controller_statistics",
+    (_msg, _hass, onChange) =>
+      emitInitial(() =>
+        onChange?.({
+          event: "statistics updated",
+          source: "controller",
+          messages_tx: 18234,
+          messages_rx: 17980,
+          messages_dropped_tx: 2,
+          messages_dropped_rx: 5,
+          nak: 0,
+          can: 3,
+          timeout_ack: 1,
+          timeout_response: 0,
+          timeout_callback: 0,
+        })
+      )
+  );
+};

demo/src/stubs/devices.ts

@@ -1,4 +1,5 @@
 import type { DeviceRegistryEntry } from "../../../src/data/device/device_registry";
+import { connectivityDevices } from "./connectivity/fixtures";
 
 const baseDevice = {
   config_entries_subentries: {},
@@ -14,6 +15,7 @@ const baseDevice = {
   name_by_user: null,
   disabled_by: null,
   configuration_url: null,
+  parent_device_id: null,
   created_at: 0,
   modified_at: 0,
 };
@@ -50,4 +52,40 @@ export const demoDevices: DeviceRegistryEntry[] = [
     primary_config_entry: "mock-sonos",
     entry_type: null,
   },
+  {
+    ...baseDevice,
+    id: "power-strip",
+    name: "Power strip",
+    manufacturer: "Acme",
+    model: "Smart Power Strip",
+    config_entries: ["mock-hue"],
+    primary_config_entry: "mock-hue",
+    entry_type: null,
+  },
+  // Child devices (logical parts of the power strip). They carry the parent's
+  // inherited hardware fields, mirroring how resolveChildDevices fills them in
+  // from the WebSocket, and reference the parent via parent_device_id.
+  {
+    ...baseDevice,
+    id: "power-strip-outlet-1",
+    name: "Outlet 1",
+    manufacturer: "Acme",
+    model: "Smart Power Strip",
+    config_entries: ["mock-hue"],
+    primary_config_entry: "mock-hue",
+    entry_type: null,
+    parent_device_id: "power-strip",
+  },
+  {
+    ...baseDevice,
+    id: "power-strip-outlet-2",
+    name: "Outlet 2",
+    manufacturer: "Acme",
+    model: "Smart Power Strip",
+    config_entries: ["mock-hue"],
+    primary_config_entry: "mock-hue",
+    entry_type: null,
+    parent_device_id: "power-strip",
+  },
+  ...connectivityDevices,
 ];

demo/src/stubs/energy.ts

@@ -102,6 +102,11 @@ export const mockEnergy = (hass: MockHomeAssistant) => {
     cost_sensors: {},
     solar_forecast_domains: [],
   }));
+  hass.mockWS("energy/validate", () => ({
+    energy_sources: Array.from({ length: 6 }, () => []),
+    device_consumption: Array.from({ length: 6 }, () => []),
+    device_consumption_water: Array.from({ length: 2 }, () => []),
+  }));
   hass.mockWS(
     "energy/fossil_energy_consumption",
     ({ period }): FossilEnergyConsumption => ({

demo/src/stubs/entity_registry_settings.ts

@@ -0,0 +1,22 @@
+import type {
+  EntityRegistrySettings,
+  fetchEntityRegistrySettings,
+  updateEntityRegistrySettings,
+} from "../../../src/data/entity/entity_registry_settings";
+import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
+
+export const mockEntityRegistrySettings = (hass: MockHomeAssistant) => {
+  let settings: EntityRegistrySettings = { entity_id_parts: null };
+
+  hass.mockWS<typeof fetchEntityRegistrySettings>(
+    "config/entity_registry/settings/get",
+    () => settings
+  );
+  hass.mockWS<typeof updateEntityRegistrySettings>(
+    "config/entity_registry/settings/update",
+    (msg: Partial<EntityRegistrySettings>) => {
+      settings = { ...settings, ...msg };
+      return settings;
+    }
+  );
+};

demo/src/stubs/integration.ts

@@ -1,19 +1,7 @@
 import type { IntegrationManifest } from "../../../src/data/integration";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
-
-const manifest = (
-  domain: string,
-  name: string,
-  overrides: Partial<IntegrationManifest> = {}
-): IntegrationManifest => ({
-  is_built_in: true,
-  domain,
-  name,
-  config_flow: true,
-  documentation: `https://www.home-assistant.io/integrations/${domain}/`,
-  iot_class: "local_push",
-  ...overrides,
-});
+import { connectivityManifests } from "./connectivity/fixtures";
+import { manifest } from "./manifest";
 
 const manifests: IntegrationManifest[] = [
   manifest("co2signal", "Electricity Maps", { iot_class: "cloud_polling" }),
@@ -62,11 +50,18 @@ const manifests: IntegrationManifest[] = [
     integration_type: "helper",
     iot_class: "local_polling",
   }),
+  ...connectivityManifests,
 ];
 
 export const mockIntegration = (hass: MockHomeAssistant) => {
   hass.mockWS("manifest/list", () => manifests);
-  hass.mockWS("manifest/get", (msg: { integration: string }) =>
-    manifests.find((m) => m.domain === msg.integration)
+  // Never answer with undefined: the integration page reads the manifest it
+  // gets back without guarding, so an unlisted domain would throw. The real
+  // backend always has a manifest for a domain that has config entries.
+  hass.mockWS(
+    "manifest/get",
+    (msg: { integration: string }) =>
+      manifests.find((m) => m.domain === msg.integration) ??
+      manifest(msg.integration, msg.integration)
   );
 };

demo/src/stubs/manifest.ts

@@ -0,0 +1,20 @@
+import type { IntegrationManifest } from "../../../src/data/integration";
+
+/**
+ * Builds a demo integration manifest. Lives in its own module so both the
+ * manifest registry and the per-integration fixtures that feed it can use it
+ * without importing each other.
+ */
+export const manifest = (
+  domain: string,
+  name: string,
+  overrides: Partial<IntegrationManifest> = {}
+): IntegrationManifest => ({
+  is_built_in: true,
+  domain,
+  name,
+  config_flow: true,
+  documentation: `https://www.home-assistant.io/integrations/${domain}/`,
+  iot_class: "local_push",
+  ...overrides,
+});

demo/src/stubs/sensor.ts

@@ -1,6 +1,12 @@
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
 
 export const mockSensor = (hass: MockHomeAssistant) => {
+  hass.mockWS(
+    "sensor/device_class_convertible_units",
+    ({ device_class }: { device_class: string }) => ({
+      units: device_class === "energy" ? ["kWh"] : ["W"],
+    })
+  );
   hass.mockWS("sensor/numeric_device_classes", () => ({
     numeric_device_classes: [
       "volume_storage",

demo/src/stubs/slugify.ts

@@ -0,0 +1,9 @@
+import { slugify } from "../../../src/common/string/slugify";
+import type { fetchSlug } from "../../../src/data/ws-slugify";
+import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
+
+export const mockSlugify = (hass: MockHomeAssistant) => {
+  hass.mockWS<typeof fetchSlug>("slugify", (msg: { text: string }) => ({
+    slug: slugify(msg.text),
+  }));
+};

demo/src/stubs/tags.ts

@@ -1,6 +1,58 @@
-import type { Tag } from "../../../src/data/tag";
+import type { Tag, UpdateTagParams } from "../../../src/data/tag";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
 
 export const mockTags = (hass: MockHomeAssistant) => {
-  hass.mockWS("tag/list", () => [{ id: "my-tag", name: "My Tag" }] as Tag[]);
+  const tags: Tag[] = [{ id: "my-tag", name: "My Tag" }];
+  let created = 0;
+
+  const find = (tagId: string) => tags.find((tag) => tag.id === tagId);
+
+  hass.mockWS("tag/list", () => tags.map((tag) => ({ ...tag })));
+
+  hass.mockWS(
+    "tag/create",
+    (msg: UpdateTagParams & { tag_id?: string }): Tag => {
+      if (msg.tag_id && find(msg.tag_id)) {
+        throw new Error(`Tag ${msg.tag_id} already exists`);
+      }
+      let id = msg.tag_id;
+      while (!id) {
+        created += 1;
+        id = find(`tag-${created}`) ? undefined : `tag-${created}`;
+      }
+      const tag: Tag = {
+        id,
+        name: msg.name,
+        description: msg.description,
+      };
+      tags.push(tag);
+      return { ...tag };
+    }
+  );
+
+  hass.mockWS(
+    "tag/update",
+    (msg: UpdateTagParams & { tag_id: string }): Tag => {
+      const tag = find(msg.tag_id);
+      if (!tag) {
+        throw new Error(`Tag ${msg.tag_id} not found`);
+      }
+      if ("name" in msg) {
+        tag.name = msg.name;
+      }
+      if ("description" in msg) {
+        tag.description = msg.description;
+      }
+      return { ...tag };
+    }
+  );
+
+  hass.mockWS("tag/delete", (msg: { tag_id: string }) => {
+    const index = tags.findIndex((tag) => tag.id === msg.tag_id);
+    if (index === -1) {
+      throw new Error(`Tag ${msg.tag_id} not found`);
+    }
+    tags.splice(index, 1);
+    return undefined;
+  });
 };

demo/src/stubs/translations.ts

@@ -1,7 +1,26 @@
+import type { LocalizeFunc } from "../../../src/common/translations/localize";
 import type { MockHomeAssistant } from "../../../src/fake_data/provide_hass";
+import { connectivityBackendTranslations } from "./connectivity/fixtures";
 
-export const mockTranslations = (hass: MockHomeAssistant) => {
-  hass.mockWS("frontend/get_translations", (
-    /* msg: {language: string, category: string} */
-  ) => ({ resources: {} }));
+export const mockTranslations = (
+  hass: MockHomeAssistant,
+  localizePromise?: Promise<LocalizeFunc>
+) => {
+  hass.mockWS(
+    "frontend/get_translations",
+    (msg: { language: string; category?: string }) => ({
+      resources:
+        (msg.category && connectivityBackendTranslations[msg.category]) || {},
+    })
+  );
+
+  // `hass.loadBackendTranslation` is a no-op in the mocked hass, so categories
+  // that are only requested through it never reach the WebSocket mock above.
+  // Seed every category into the resources, after the fragment translations so
+  // this merges on top of them.
+  (localizePromise ?? Promise.resolve()).then(() =>
+    hass.addTranslations(
+      Object.assign({}, ...Object.values(connectivityBackendTranslations))
+    )
+  );
 };

eslint.config.mjs

@@ -17,6 +17,9 @@ const rspackConfigPath = fileURLToPath(
   new URL("./rspack.config.cjs", import.meta.url)
 );
 
+// Applies everywhere, including the files exempted from the history rule below.
+const restrictedSyntax = ["LabeledStatement", "WithStatement"];
+
 export default tseslint.config(
   js.configs.recommended,
   eslintConfigPrettier,
@@ -111,7 +114,16 @@ export default tseslint.config(
       "no-bitwise": "error",
       "no-console": "error",
       "no-restricted-globals": [2, "event"],
-      "no-restricted-syntax": ["error", "LabeledStatement", "WithStatement"],
+      "no-restricted-syntax": [
+        "error",
+        ...restrictedSyntax,
+        {
+          selector:
+            "CallExpression[callee.property.name=/^(push|replace)State$/]",
+          message:
+            "Use navigate(), updateHistoryState() or replaceCurrentUrl() from common/navigate. History entries carry the app's own bookkeeping, which a raw pushState/replaceState drops.",
+        },
+      ],
       "wc/no-self-class": "off",
 
       // import-x rules
@@ -222,6 +234,24 @@ export default tseslint.config(
       ],
     },
   },
+  {
+    // These own history entries themselves: the navigation helpers, the dialog
+    // stack, the boot paths that run before the app has any state to keep, and
+    // the tests that fabricate entries to simulate a document load.
+    files: [
+      "src/common/navigate.ts",
+      "src/dialogs/make-dialog-manager.ts",
+      "src/state/url-sync-mixin.ts",
+      "src/panels/config/automation/add-automation-element-dialog.ts",
+      "src/entrypoints/core.ts",
+      "src/onboarding/**/*.ts",
+      "cast/**/*.ts",
+      "test/**/*.ts",
+    ],
+    rules: {
+      "no-restricted-syntax": ["error", ...restrictedSyntax],
+    },
+  },
   {
     files: ["src/util/recorder-worklet.js"],
     languageOptions: {

gallery/sidebar.js

@@ -228,6 +228,7 @@ export default [
       "entity-state",
       "ha-markdown",
       "integration-card",
+      "cloud-account",
       "box-shadow",
       "util-long-press",
       "remove-delete-add-create",

gallery/src/common/validate-card-config.ts

@@ -0,0 +1,7 @@
+import type { LovelaceCardConfig } from "../../../src/data/lovelace/config/card";
+import { getCardElementClass } from "../../../src/panels/lovelace/create-element/create-card-element";
+
+export const validateCardConfig = async (config: LovelaceCardConfig) => {
+  const cardClass = await getCardElementClass(config.type);
+  new cardClass().setConfig(config);
+};