feat(offline): make the web UI usable without a reachable backend

Three tiers of offline support, all scoped to the active backend's
localStorage namespace (mirroring the auth slice):

Tier 1 — persist client state. queue + player slices are saved (queue
entries/index/source; player track/position/volume/repeat/shuffle) and
rehydrated on load, so a reload with no backend restores where the user
left off. Playback never auto-resumes (browsers block autoplay). Retires
the DEMO_QUEUE and isQueueOpen:true stubs.

Tier 2 — persist the RTK Query cache. Last-seen library/albums/artists
are snapshotted (fulfilled queries only) and replayed via RTKQ's
extractRehydrationInfo at startup, so the library renders read-only when
the backend is down. ConnectionStatus tooltip flags cached data offline.
No server data is copied into a slice — the cache feeds itself back.

Tier 3 — service worker audio + cover cache (PWA). Audio streams are
cached keyed by content id (token stripped), range-aware (synthetic 206
slicing), with a 500MB LRU cap, so already-played tracks play fully
offline. Cover art uses stale-while-revalidate in its own bounded cache.
Module worker (ESM); pure helpers split into sw-core.js and unit-tested.
Web app manifest enables "Install app". Player source badge now reflects
real cached state.

tsc clean, lint clean, 19 new tests pass, production build verified.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/lib/sw.ts

@@ -0,0 +1,80 @@
+/*
+ * Service-worker client: registration + a typed bridge to the audio offline
+ * cache (Tier 3). The SW itself lives in `public/sw.js`; this is the app side.
+ *
+ * Messaging uses a MessageChannel — we hand the SW a port and await its reply —
+ * so each call resolves with that request's result rather than a global event.
+ */
+
+export interface AudioCacheStats {
+  count: number;
+  bytes: number;
+  maxBytes: number;
+}
+
+/** Register the service worker. No-op when unsupported (e.g. plain http host). */
+export function registerServiceWorker(): void {
+  if (typeof navigator === 'undefined' || !('serviceWorker' in navigator)) {
+    return;
+  }
+  window.addEventListener('load', () => {
+    // Module worker: sw.js uses ES imports (see public/sw.js + sw-core.js).
+    navigator.serviceWorker.register('/sw.js', { type: 'module' }).catch(() => {
+      /* SW unavailable (insecure origin, blocked, …) — app still works online */
+    });
+  });
+}
+
+function controller(): ServiceWorker | null {
+  if (typeof navigator === 'undefined' || !('serviceWorker' in navigator)) {
+    return null;
+  }
+  return navigator.serviceWorker.controller;
+}
+
+/** Round-trip a message to the SW; rejects if no controlling SW is present. */
+function send<T>(message: Record<string, unknown>): Promise<T> {
+  const sw = controller();
+  if (!sw) return Promise.reject(new Error('no-service-worker'));
+  return new Promise<T>((resolve, reject) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = (event) => resolve(event.data as T);
+    try {
+      sw.postMessage(message, [channel.port2]);
+    } catch (err) {
+      reject(err as Error);
+    }
+  });
+}
+
+/** Total size + count of cached audio, or null when the SW isn't controlling. */
+export async function getAudioCacheStats(): Promise<AudioCacheStats | null> {
+  try {
+    return await send<AudioCacheStats>({ type: 'STATS' });
+  } catch {
+    return null;
+  }
+}
+
+/** Whether a given stream URL is already cached for offline playback. */
+export async function isStreamCached(streamUrl: string): Promise<boolean> {
+  try {
+    const { cached } = await send<{ cached: boolean }>({
+      type: 'HAS',
+      url: streamUrl,
+    });
+    return cached;
+  } catch {
+    return false;
+  }
+}
+
+/** Drop the entire audio cache. Resolves false if the SW isn't controlling. */
+export async function clearAudioCache(): Promise<boolean> {
+  try {
+    const { ok } = await send<{ ok: boolean }>({ type: 'CLEAR' });
+    return ok;
+  } catch {
+    return false;
+  }
+}