feat(offline): #427 S4a — Shuffle all + offline system-playlist gate

Headline of S4. "Shuffle all" is always present (home app-bar
shuffle icon); the pool degrades with reachability:
- online  → GET /api/library/shuffle?limit=N (new): N random
  library tracks server-side, per-user quarantine filtered
  (ListRandomTracksForUser, ORDER BY random()).
- offline → ShuffleSource shuffles the whole local cache index
  (audio_cache_index ∩ cached_tracks, names from cached_artists/
  albums) — a UNION over liked AND recently-played, since the
  two-bucket split is storage-only and never filters playback.

Offline gating: refreshable (singleton) system playlists need the
live build/shuffle endpoints, so their tile play is disabled when
offlineProvider is true — Shuffle all is the offline path. User
playlists still play from cache.

playlist_card now reads offlineProvider in build → wrapped the
direct-render widget test in ProviderScope (offlineProvider is
smoke-safe from S1: tracked timers, no connectivity mount).

S4b (offline Recently-played / Liked browsable surfaces over the
cache index) next.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

flutter_client/lib/cache/shuffle_source.dart

@@ -0,0 +1,68 @@
+// "Shuffle all" source (#427 S4). Always-present; the pool degrades
+// gracefully with reachability:
+//   online  → GET /api/library/shuffle (random over the whole library)
+//   offline → a client shuffle over the entire local cache index
+//
+// Offline is a UNION over every cached track regardless of storage
+// bucket — liked AND recently-played both included. The two-bucket
+// split (S2) is storage/eviction-only and never filters playback,
+// which is exactly the property this relies on.
+
+import 'dart:math';
+
+import 'package:drift/drift.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../library/library_providers.dart' show libraryApiProvider;
+import '../models/track.dart';
+import 'adapters.dart';
+import 'audio_cache_manager.dart' show appDbProvider;
+import 'offline_provider.dart';
+
+class ShuffleSource {
+  ShuffleSource(this._ref);
+  final Ref _ref;
+
+  /// Returns up to [limit] tracks to play as a shuffle-all. Online:
+  /// server-random. Offline: every cached track (liked + recent),
+  /// shuffled client-side. Empty offline → nothing is cached yet.
+  Future<List<TrackRef>> tracks({int limit = 100}) async {
+    if (_ref.read(offlineProvider)) {
+      return _offline(limit);
+    }
+    final api = await _ref.read(libraryApiProvider.future);
+    return api.shuffle(limit: limit);
+  }
+
+  Future<List<TrackRef>> _offline(int limit) async {
+    final db = _ref.read(appDbProvider);
+    final cachedIds =
+        (await db.select(db.audioCacheIndex).get()).map((r) => r.trackId).toSet();
+    if (cachedIds.isEmpty) return const [];
+
+    final meta = await (db.select(db.cachedTracks)
+          ..where((t) => t.id.isIn(cachedIds.toList())))
+        .get();
+    if (meta.isEmpty) return const [];
+
+    final artistName = {
+      for (final a in await db.select(db.cachedArtists).get()) a.id: a.name
+    };
+    final albumTitle = {
+      for (final a in await db.select(db.cachedAlbums).get()) a.id: a.title
+    };
+
+    final refs = [
+      for (final t in meta)
+        t.toRef(
+          artistName: artistName[t.artistId] ?? '',
+          albumTitle: albumTitle[t.albumId] ?? '',
+        )
+    ];
+    refs.shuffle(Random());
+    return refs.length > limit ? refs.sublist(0, limit) : refs;
+  }
+}
+
+final shuffleSourceProvider =
+    Provider<ShuffleSource>((ref) => ShuffleSource(ref));