feat(mobile): offline downloads, persistent event queue and offline start (M5)

- Downloads queue (2 parallel, Wi-Fi only by default) stores files under
  the app's document directory and track metadata in SQLite; Collection
  gets a Downloads tab, album and player screens get download buttons.
- Player plays downloaded files and local covers; My Wave falls back to
  a shuffle of downloaded tracks when the server is unreachable.
- Playback events that fail on the network are kept in SQLite and sent
  when the connection returns.
- AuthSession can open offline with the cached user and fetches an
  access token before the first request once online.

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

apps/mobile/src/player/controller.ts

@@ -15,6 +15,9 @@ import TrackPlayer, {
   type Track as RntpTrack,
 } from 'react-native-track-player';
 
+import { downloads } from '../offline/downloads';
+import { PersistentEvents } from '../offline/events';
+
 export interface WaveInfo {
   sessionId: string;
   activity: string | null;
@@ -41,6 +44,17 @@ const WAVE_REFILL_AT = 2;
 const EARLY_SKIP_MS = 30_000;
 const SAVE_EVERY_MS = 10_000;
 
+/** Офлайн-волна: скачанные треки без дизлайков, лайкнутые чаще оказываются ближе к началу. */
+export function offlineWave(tracks: Track[], random: () => number = Math.random): Track[] {
+  return tracks
+    .filter((t) => t.reaction !== 'dislike')
+    .map((t) => ({ t, key: random() * (t.reaction === 'like' ? 0.5 : 1) }))
+    .sort((a, b) => a.key - b.key)
+    .map((x) => x.t);
+}
+
+const playable = (t: Track) => t.available && (!!t.stream_url || downloads.isDownloaded(t.id));
+
 /** Ссылки API относительные — для приложения нужен полный адрес сервера. */
 export function absolute(server: string, path: string | null | undefined): string | undefined {
   if (!path) return undefined;
@@ -66,6 +80,8 @@ class Controller {
   private session: AuthSession | null = null;
   private server = '';
   private events: EventBuffer | null = null;
+  private persistent: PersistentEvents | null = null;
+  private unsubscribeNet: (() => void) | null = null;
   private attempt: PlayAttempt | null = null;
   private lastPositionMs = 0;
   private lastSave = 0;
@@ -90,19 +106,19 @@ class Controller {
     for (const fn of this.listeners) fn();
   }
 
-  /** Привязка к вошедшему пользователю: события и реакции уходят на его сервер. */
-  attach(session: AuthSession | null, server: string) {
+  /** Привязка к вошедшему пользователю: события и реакции уходят на его сервер, без сети — копятся в SQLite. */
+  attach(session: AuthSession | null, server: string, userId: string | null) {
     if (this.session === session) return;
     void this.events?.flush();
     this.session = session;
     this.server = server;
-    this.events = session
-      ? new EventBuffer({
-          send: async (events) => {
-            unwrap(await session.client.POST('/api/v1/events', { body: { events } }));
-          },
-        })
-      : null;
+    this.persistent = session && userId ? new PersistentEvents(session, server, userId) : null;
+    const sink = this.persistent;
+    this.events = sink ? new EventBuffer({ send: sink.send }) : null;
+    void sink?.drain();
+    this.unsubscribeNet ??= NetInfo.addEventListener((st) => {
+      if (st.isConnected) void this.persistent?.drain();
+    });
     if (!session) void this.reset();
   }
 
@@ -181,28 +197,29 @@ class Controller {
 
   private async toRntp(tracks: Track[]): Promise<RntpTrack[]> {
     const q = await quality();
+    // Скачанный трек играется из файла (и без сети), остальные — стримом по качеству сети.
     return tracks.map((t) => ({
       id: t.id,
-      url: `${absolute(this.server, t.stream_url)}&q=${q}`,
+      url: downloads.localTrack(t.id) ?? `${absolute(this.server, t.stream_url)}&q=${q}`,
       title: t.title,
       artist: t.artists.map((a) => a.name).join(', '),
       album: t.album.title,
-      artwork: t.album.cover_url ? `${absolute(this.server, t.album.cover_url)}&size=300` : undefined,
+      artwork: downloads.localCover(t) ?? (t.album.cover_url ? `${absolute(this.server, t.album.cover_url)}&size=300` : undefined),
       duration: t.duration_ms / 1000,
     }));
   }
 
   async playList(tracks: Track[], index: number, context: PlayContext) {
-    const playable = tracks.filter((t) => t.available && t.stream_url);
+    const list = tracks.filter(playable);
     const target = tracks[index];
-    if (!target || !playable.length) return;
+    if (!target || !list.length) return;
     await this.setup();
     this.leaveWave();
     this.finishAttempt(this.lastPositionMs / 1000);
-    const start = Math.max(playable.indexOf(target), 0);
-    this.update({ queue: playable, context, index: start, track: playable[start] ?? null });
+    const start = Math.max(list.indexOf(target), 0);
+    this.update({ queue: list, context, index: start, track: list[start] ?? null });
     await TrackPlayer.reset();
-    await TrackPlayer.add(await this.toRntp(playable));
+    await TrackPlayer.add(await this.toRntp(list));
     await TrackPlayer.skip(start);
     await TrackPlayer.play();
   }
@@ -248,6 +265,7 @@ class Controller {
       apply(prev);
       throw e;
     }
+    if (reaction === 'like' && downloads.state.autoLikes) void downloads.enqueue([{ ...track, reaction }]);
     if (reaction) {
       this.noteWave(track.id, reaction);
       void this.refillWave(true);
@@ -261,8 +279,16 @@ class Controller {
     if (!this.session) return;
     await this.setup();
     this.leaveWave();
-    const res = unwrap(await this.session.client.POST('/api/v1/wave/sessions', { body: { activity, mood } }));
-    const tracks = res.tracks.filter((t) => t.available && t.stream_url);
+    let res;
+    try {
+      res = unwrap(await this.session.client.POST('/api/v1/wave/sessions', { body: { activity, mood } }));
+    } catch (e) {
+      // Нет связи с сервером — офлайн-волна из скачанного.
+      const local = offlineWave(downloads.downloaded());
+      if (!local.length) throw e;
+      return this.playList(local, 0, { type: 'collection', id: 'downloads' });
+    }
+    const tracks = res.tracks.filter(playable);
     if (!tracks.length) return;
     this.finishAttempt(this.lastPositionMs / 1000);
     this.update({
@@ -305,7 +331,7 @@ class Controller {
   private async replaceUpcoming(tracks: Track[]) {
     const keep = this.state.queue.slice(0, this.state.index + 1);
     await TrackPlayer.removeUpcomingTracks();
-    const add = tracks.filter((t) => t.available && t.stream_url);
+    const add = tracks.filter(playable);
     await TrackPlayer.add(await this.toRntp(add));
     this.update({ queue: [...keep, ...add] });
   }
@@ -328,7 +354,7 @@ class Controller {
       if (this.state.wave?.sessionId !== wave.sessionId) return;
       if (refresh) await this.replaceUpcoming(res.tracks);
       else {
-        const add = res.tracks.filter((t) => t.available && t.stream_url);
+        const add = res.tracks.filter(playable);
         await TrackPlayer.add(await this.toRntp(add));
         this.update({ queue: [...this.state.queue, ...add] });
       }
@@ -368,7 +394,7 @@ class Controller {
       const st = unwrap(await this.session.client.GET('/api/v1/me/playback-state'));
       if (!st.track_id || !st.queue.length) return;
       const res = unwrap(await this.session.client.POST('/api/v1/tracks/batch', { body: { ids: st.queue } }));
-      const tracks = res.items.filter((t) => t.available && t.stream_url);
+      const tracks = res.items.filter(playable);
       const idx = Math.max(tracks.findIndex((t) => t.id === st.track_id), 0);
       if (!tracks.length) return;
       this.update({ queue: tracks, index: idx, track: tracks[idx] ?? null, context: (st.context as PlayContext | null) ?? null });