fix: address Copilot review feedback

- RetryManager offline short-circuit: add ErrorStore.hasAnyPanelOffline()
  so retries skip correctly under Favorites multi-panel watch (per-entity
  panel-offline keys), not just the legacy single-unnamed key.
- FavoritesCache / MonitoringStatusCache: track inflight generation so
  invalidate() supersedes pending requests; fetch() after invalidate()
  issues a fresh call instead of awaiting a stale in-flight promise.
- header-renderer buildSheddingLegendHTML: escape label / icon / color /
  textLabel via escapeHtml to match the escaping used elsewhere in the
  renderer and guard against stray markup in i18n strings.
- CHANGELOG: correct 'Persisted per device' wording — list-columns
  storage is a single localStorage key, global to the browser.

Author: cayossarian

CHANGELOG.md

@@ -6,8 +6,9 @@
 
 - **Compact expanded list rows** — Expanding a row in By Activity / By Area now shows only the chart. The gear icon and a real toggle-pill (arm-protected by the
   slide-to-confirm) moved onto the always-visible list row so expanding no longer duplicates information above the chart.
-- **Configurable list view columns** — 1 / 2 / 3 column grid for By Activity and By Area, set in Graph Settings → List View Columns. Persisted per device via
-  localStorage. Narrow viewports (< 600px) force single-column regardless. Expanded charts stay in their own column so row-to-chart association stays clear.
+- **Configurable list view columns** — 1 / 2 / 3 column grid for By Activity and By Area, set in Graph Settings → List View Columns. Persisted in localStorage
+  as a browser-wide preference (single key, not scoped per device). Narrow viewports (< 600px) force single-column regardless. Expanded charts stay in their own
+  column so row-to-chart association stays clear.
 - **Favorites per-panel status grid** — The Favorites view now renders a responsive grid of per-contributing-panel status cards (Site / Grid / Upstream /
   Downstream / Solar / Battery) below the slider + W/A row. One card per panel that contributes to the Favorites set; live values update on each tick.
 - **Slide-to-arm in Favorites** — Favorites view header now hosts the slide-confirm control so tappable ON/OFF toggles in list rows can actually fire. The

dist/span-panel-card.js

@@ -129,6 +129,20 @@ export class ErrorStore {
     return this._persistent.has(key);
   }
 
+  /**
+   * True when any watched panel is currently marked offline. Covers both
+   * the legacy single-unnamed key (``panel-offline``) used by per-panel
+   * views and the per-entity keys (``panel-offline:<entityId>``) used by
+   * the Favorites multi-panel watch. ``RetryManager`` uses this to
+   * short-circuit retries without needing to know the naming mode.
+   */
+  hasAnyPanelOffline(): boolean {
+    for (const key of this._persistent.keys()) {
+      if (key === "panel-offline" || key.startsWith("panel-offline:")) return true;
+    }
+    return false;
+  }
+
   /**
    * Subscribe to state changes. The callback is called after every `add`,
    * `remove`, `clear`, or transient auto-dismiss. Returns an unsubscribe fn.

dist/span-panel.js

@@ -83,7 +83,7 @@ export async function removeFavorite(hass: HomeAssistant, entityId: string): Pro
 export class FavoritesCache {
   private _map: FavoritesMap | null;
   private _lastFetch: number;
-  private _inflight: Promise<FavoritesMap> | null;
+  private _inflight: { gen: number; promise: Promise<FavoritesMap> } | null;
   private _generation: number;
   private _errorStore: ErrorStore | null = null;
   private _retry: RetryManager | null = null;
@@ -106,13 +106,16 @@ export class FavoritesCache {
 
   async fetch(hass: HomeAssistant): Promise<FavoritesMap> {
     const now = Date.now();
-    if (this._inflight) return this._inflight;
+    // Only dedupe onto an in-flight request from the current generation.
+    // Requests predating the last invalidate() must not be reused, or
+    // the caller would await a stale promise whose result is dropped.
+    if (this._inflight && this._inflight.gen === this._generation) return this._inflight.promise;
     if (this._map && now - this._lastFetch < FAVORITES_POLL_INTERVAL_MS) {
       return this._map;
     }
 
     const requestGen = this._generation;
-    this._inflight = (async () => {
+    const promise = (async (): Promise<FavoritesMap> => {
       try {
         const msg = {
           type: "call_service",
@@ -145,10 +148,16 @@ export class FavoritesCache {
         }
         return this._map ?? {};
       } finally {
-        this._inflight = null;
+        // Only clear the slot if it still points at this request; a
+        // later fetch() that ran after invalidate() may have replaced
+        // it with a newer in-flight promise we must not clobber.
+        if (this._inflight?.gen === requestGen) {
+          this._inflight = null;
+        }
       }
     })();
-    return this._inflight;
+    this._inflight = { gen: requestGen, promise };
+    return promise;
   }
 
   invalidate(): void {

src/core/error-store.ts

@@ -26,15 +26,20 @@ export function buildSheddingLegendHTML(): string {
     ${Object.entries(SHEDDING_PRIORITIES)
       .filter(([key]: [string, SheddingPriorityDef]) => key !== "unknown")
       .map(([, cfg]: [string, SheddingPriorityDef]) => {
+        const icon = escapeHtml(cfg.icon);
+        const color = escapeHtml(cfg.color);
+        const label = escapeHtml(cfg.label());
         let icons: string;
         if (cfg.icon2) {
-          icons = `<ha-icon icon="${cfg.icon}" style="color:${cfg.color}"></ha-icon><ha-icon class="shedding-legend-secondary" icon="${cfg.icon2}" style="color:${cfg.color}"></ha-icon>`;
+          const icon2 = escapeHtml(cfg.icon2);
+          icons = `<ha-icon icon="${icon}" style="color:${color}"></ha-icon><ha-icon class="shedding-legend-secondary" icon="${icon2}" style="color:${color}"></ha-icon>`;
         } else if (cfg.textLabel) {
-          icons = `<ha-icon icon="${cfg.icon}" style="color:${cfg.color}"></ha-icon><span class="shedding-legend-text" style="color:${cfg.color}">${cfg.textLabel}</span>`;
+          const textLabel = escapeHtml(cfg.textLabel);
+          icons = `<ha-icon icon="${icon}" style="color:${color}"></ha-icon><span class="shedding-legend-text" style="color:${color}">${textLabel}</span>`;
         } else {
-          icons = `<ha-icon icon="${cfg.icon}" style="color:${cfg.color}"></ha-icon>`;
+          icons = `<ha-icon icon="${icon}" style="color:${color}"></ha-icon>`;
         }
-        return `<div class="shedding-legend-item">${icons}<span class="shedding-legend-label">${cfg.label()}</span></div>`;
+        return `<div class="shedding-legend-item">${icons}<span class="shedding-legend-label">${label}</span></div>`;
       })
       .join("")}
   </div>`;

src/core/favorites-store.ts

@@ -17,7 +17,7 @@ interface CallServiceResponse {
 export class MonitoringStatusCache {
   private _status: MonitoringStatus | null = null;
   private _lastFetch: number = 0;
-  private _inflight: Promise<MonitoringStatus | null> | null = null;
+  private _inflight: { gen: number; promise: Promise<MonitoringStatus | null> } | null = null;
   private _generation: number = 0;
   private _errorStore: ErrorStore | null = null;
   private _retry: RetryManager | null = null;
@@ -41,13 +41,16 @@ export class MonitoringStatusCache {
    */
   async fetch(hass: HomeAssistant, configEntryId?: string | null): Promise<MonitoringStatus | null> {
     const now = Date.now();
-    if (this._inflight) return this._inflight;
+    // Only dedupe onto an in-flight request from the current generation.
+    // Requests predating the last invalidate() must not be reused, or the
+    // caller would await a stale promise whose result is silently dropped.
+    if (this._inflight && this._inflight.gen === this._generation) return this._inflight.promise;
     if (this._status && now - this._lastFetch < MONITORING_POLL_INTERVAL_MS) {
       return this._status;
     }
 
     const requestGen = this._generation;
-    this._inflight = (async () => {
+    const promise = (async (): Promise<MonitoringStatus | null> => {
       try {
         const serviceData: Record<string, string> = {};
         if (configEntryId) serviceData.config_entry_id = configEntryId;
@@ -85,10 +88,16 @@ export class MonitoringStatusCache {
         }
         return null;
       } finally {
-        this._inflight = null;
+        // Only clear the slot if it still points at this request; a
+        // later fetch() that ran after invalidate() may have replaced
+        // it with a newer in-flight promise we must not clobber.
+        if (this._inflight?.gen === requestGen) {
+          this._inflight = null;
+        }
       }
     })();
-    return this._inflight;
+    this._inflight = { gen: requestGen, promise };
+    return promise;
   }
 
   /** Force the next fetch() call to re-query the backend. */

src/core/header-renderer.ts

@@ -38,8 +38,11 @@ export class RetryManager {
   }
 
   private async _withRetry<T>(fn: () => Promise<T>, maxRetries: number, errorId: string, errorMessage?: string): Promise<T> {
-    // Short-circuit if panel is offline — single attempt, no retries
-    if (this._store.hasPersistent("panel-offline")) {
+    // Short-circuit if any watched panel is offline — single attempt,
+    // no retries. Uses ``hasAnyPanelOffline`` so it covers both the
+    // legacy single-unnamed key and the per-entity keys used by the
+    // Favorites multi-panel watch.
+    if (this._store.hasAnyPanelOffline()) {
       try {
         const result = await fn();
         this._store.remove(errorId);

src/core/monitoring-status.ts

@@ -58,6 +58,39 @@ describe("FavoritesCache", () => {
     expect(second).toEqual({ panelA: { circuits: ["c1"], sub_devices: [] } });
   });
 
+  it("fetch() after invalidate() issues a fresh request even while an earlier fetch is pending", async () => {
+    // Resolve manually so we can control the ordering: pre-toggle response
+    // stays pending until we release it.
+    let resolveFirst!: (resp: { response: { favorites: Record<string, { circuits: string[]; sub_devices: string[] }> } }) => void;
+    const firstPromise = new Promise<{ response: { favorites: Record<string, { circuits: string[]; sub_devices: string[] }> } }>(resolve => {
+      resolveFirst = resolve;
+    });
+    const secondResponse = { response: { favorites: { panelA: { circuits: ["c1", "c2"], sub_devices: [] } } } };
+
+    let i = 0;
+    const callWS = vi.fn(async () => {
+      const idx = i;
+      i += 1;
+      return idx === 0 ? firstPromise : secondResponse;
+    });
+    const hass = { states: {}, services: {}, language: "en", callWS } as unknown as HomeAssistant;
+
+    const first = cache.fetch(hass);
+    cache.invalidate();
+
+    // Second fetch arrives while first is still in flight but after
+    // invalidate(). It must not dedupe onto the stale request; it must
+    // issue a new backend call and return the post-invalidate data.
+    const second = cache.fetch(hass);
+    expect(callWS).toHaveBeenCalledTimes(2);
+
+    resolveFirst({ response: { favorites: { panelA: { circuits: ["c1"], sub_devices: [] } } } });
+
+    const [firstResult, secondResult] = await Promise.all([first, second]);
+    expect(firstResult).toEqual({ panelA: { circuits: ["c1"], sub_devices: [] } });
+    expect(secondResult).toEqual({ panelA: { circuits: ["c1", "c2"], sub_devices: [] } });
+  });
+
   it("clear() drops the cached map and bumps generation", async () => {
     const { hass } = makeHass([{ panelA: { circuits: ["c1"], sub_devices: [] } }, { panelA: { circuits: [], sub_devices: [] } }]);
     await cache.fetch(hass);

src/core/retry-manager.ts

@@ -225,4 +225,17 @@ describe("RetryManager — panel offline short-circuit", () => {
     // No transient error should be added since fn() succeeded
     expect(store.active.filter(e => !e.persistent)).toHaveLength(0);
   });
+
+  it("short-circuits on per-entity panel-offline keys (Favorites multi-panel watch)", async () => {
+    const hass = makeHass();
+    // Simulate the Favorites-mode watch: per-entity key, not the legacy unnamed key.
+    store.add({ key: "panel-offline:binary_sensor.span_panel_2_panel_on", level: "error", message: "Panel 2 unreachable", persistent: true });
+
+    vi.mocked(hass.callWS).mockRejectedValueOnce(new Error("offline"));
+
+    await expect(manager.callWS(hass, { type: "span/get_panel" }, { errorId: "test-offline-ws-named" })).rejects.toThrow("offline");
+
+    // Only 1 attempt — no retries, despite the key being per-entity rather than the legacy name.
+    expect(hass.callWS).toHaveBeenCalledTimes(1);
+  });
 });