Wire up playback reporting, fix duration flash, hide video from audio mini player

Playback reporting (position sync / resume-on-another-device):
- player_configure_jellyfin now builds a PlaybackReporter sharing the player
  controller's Arc, so Start/Progress/Stopped actually reach Jellyfin on every
  auth path (login/restore/reauth); previously they never did.
- The PlaybackReporterWrapper now shares the same Arc the controller and MPV
  progress loop report through, instead of a dead parallel Option.
- Android position callbacks now emit throttled progress reports (30s/item),
  mirroring the MPV backend.

Duration flash on pause:
- resolveDuration() prefers the live store duration for the already-loaded
  track over the runTimeTicks estimate, so pausing no longer clobbers the
  slider's max to 0 when runTimeTicks is missing.

Video leaking into audio mini player:
- isVideoItem() also checks the backend PlayerMediaItem mediaType
  discriminator, so a video started via player_play_item (no Jellyfin `type`,
  mediaType "video") no longer surfaces in the audio mini player.

Middle-truncation of long media names:
- New truncateMiddle util applied to track/episode/card/mini-player titles so
  distinguishing tails (episode numbers, suffixes) stay visible.

Adds regression tests for the duration and mini-player fixes.

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

src/lib/services/playerEvents.ts

@@ -10,7 +10,7 @@
 
 import { type UnlistenFn } from "@tauri-apps/api/event";
 import { commands, events, type PlayerStatusEvent, type SleepTimerMode } from "$lib/api/bindings";
-import { player, playbackPosition, currentMedia } from "$lib/stores/player";
+import { player, playbackPosition, playbackDuration, currentMedia } from "$lib/stores/player";
 import { queue, currentQueueItem } from "$lib/stores/queue";
 import { playbackMode } from "$lib/stores/playbackMode";
 import { sleepTimer } from "$lib/stores/sleepTimer";
@@ -142,6 +142,26 @@ function handlePositionUpdate(position: number, duration: number): void {
   // Note: Sleep timer logic is now handled entirely in the Rust backend
 }
 
+/**
+ * Resolve the duration to seed playing/paused state with.
+ *
+ * For the same track that is already loaded, the live store duration (kept
+ * fresh by media_loaded / position_update events) is authoritative and is
+ * preferred — falling back to the runTimeTicks estimate only when the store
+ * has no usable duration yet. This avoids clobbering a known-good duration
+ * with 0 when runTimeTicks is missing (which would zero the slider's max).
+ */
+function resolveDuration(currentItem: MediaItem, isSameTrack: boolean): number {
+  const estimate = currentItem.runTimeTicks ? currentItem.runTimeTicks / 10000000 : 0;
+  if (isSameTrack) {
+    const live = get(playbackDuration);
+    if (live > 0) {
+      return live;
+    }
+  }
+  return estimate;
+}
+
 /**
  * Handle state change events.
  *
@@ -171,7 +191,7 @@ async function handleStateChanged(state: string, _mediaId: string | null): Promi
         const previous = get(currentMedia);
         const isSameTrack = previous?.id === currentItem.id;
         const startPosition = isSameTrack ? get(playbackPosition) : 0;
-        const initialDuration = currentItem.runTimeTicks ? currentItem.runTimeTicks / 10000000 : 0;
+        const initialDuration = resolveDuration(currentItem, isSameTrack);
         player.setPlaying(currentItem, startPosition, initialDuration);
 
         // Trigger preloading of upcoming tracks in the background
@@ -180,9 +200,15 @@ async function handleStateChanged(state: string, _mediaId: string | null): Promi
           console.debug("[playerEvents] Preload failed (non-critical):", e);
         });
       } else if (state === "paused" && currentItem) {
-        // Keep current position from store
+        // Keep current position and duration from store. The same track is
+        // already loaded on pause, so its live duration (from media_loaded /
+        // position_update) is authoritative — recomputing from runTimeTicks
+        // would clobber it with 0 when runTimeTicks is missing, forcing the
+        // slider's max to 0 and flashing the thumb to the start.
+        const previous = get(currentMedia);
+        const isSameTrack = previous?.id === currentItem.id;
         const currentPosition = get(playbackPosition);
-        const initialDuration = currentItem.runTimeTicks ? currentItem.runTimeTicks / 10000000 : 0;
+        const initialDuration = resolveDuration(currentItem, isSameTrack);
         player.setPaused(currentItem, currentPosition, initialDuration);
       } else if (state === "loading" && currentItem) {
         player.setLoading(currentItem);