refactor(player): E.38 — extract seek action (#602)

Move the ~63-LOC `seek` action body into `runSeek(set, get, progress)`
in `src/store/seekAction.ts`, following the helper-with-thin-wrapper
pattern from E.37 (updateReplayGain).

The action handles the full seek path: 0..1 fraction → bounded time,
100 ms debounce, hot-cache-rebind branch via playTrack, and the
recoverable-seek-error retry burst (visual target pin + restart on
"not seekable" + bounded retry window).

Pure code-move. playerStore.ts: 938 → 868 LOC (−70).

src/store/seekAction.ts

@@ -0,0 +1,103 @@
+import { invoke } from '@tauri-apps/api/core';
+import { isRecoverableSeekError } from '../utils/seekErrors';
+import { useAuthStore } from './authStore';
+import { shouldRebindPlaybackToHotCache } from './playbackUrlRouting';
+import type { PlayerState } from './playerStoreTypes';
+import { armSeekDebounce } from './seekDebounce';
+import {
+  clearSeekFallbackRetry,
+  getSeekFallbackRestartAt,
+  getSeekFallbackTrackId,
+  scheduleSeekFallbackRetry,
+  setSeekFallbackRestartAt,
+  setSeekFallbackTrackId,
+  setSeekFallbackVisualTarget,
+} from './seekFallbackState';
+import {
+  clearSeekTarget,
+  setSeekTarget,
+} from './seekTargetState';
+
+type SetState = (
+  partial: Partial<PlayerState> | ((state: PlayerState) => Partial<PlayerState>),
+) => void;
+type GetState = () => PlayerState;
+
+/**
+ * Seek to a 0..1 fraction of the current track. 100 ms debounce
+ * collapses rapid slider drags into one actual engine seek; when the
+ * resolved playback source is about to be replaced by a hot-cache
+ * rebind, we re-issue `playTrack` with a visual target instead of
+ * a raw `audio_seek` (otherwise the seek would land in the old
+ * source and snap the progress UI back).
+ *
+ * Recoverable backend errors (streaming start not yet seekable / busy)
+ * are translated into a bounded retry burst: keep the UI's visual
+ * target pinned at the requested position, schedule another seek
+ * attempt, and on the "not seekable" subset restart the track from
+ * the same position via `playTrack`.
+ */
+export function runSeek(set: SetState, get: GetState, progress: number): void {
+  const { currentTrack } = get();
+  if (!currentTrack) return;
+  const dur = currentTrack.duration;
+  if (!dur || !isFinite(dur)) return;
+  const time = Math.max(0, Math.min(progress * dur, dur - 0.25));
+  set({ progress: time / dur, currentTime: time });
+  armSeekDebounce(100, () => {
+    const s0 = get();
+    if (!s0.currentTrack) return;
+    const authSeek = useAuthStore.getState();
+    const sidSeek = authSeek.activeServerId ?? '';
+    if (shouldRebindPlaybackToHotCache(s0.currentTrack.id, sidSeek)) {
+      setSeekFallbackVisualTarget({
+        trackId: s0.currentTrack.id,
+        seconds: time,
+        setAtMs: Date.now(),
+      });
+      clearSeekFallbackRetry();
+      s0.playTrack(s0.currentTrack, s0.queue, true);
+      return;
+    }
+    invoke('audio_seek', { seconds: time }).then(() => {
+      // Arm stale-progress guard only after backend acknowledged seek.
+      setSeekTarget(time);
+      setSeekFallbackVisualTarget(null);
+      clearSeekFallbackRetry();
+    }).catch((err: unknown) => {
+      // Release the progress-tick guard so the UI doesn't freeze
+      // waiting for a target the engine will never reach.
+      clearSeekTarget();
+      const msg = String(err ?? '');
+      if (!isRecoverableSeekError(msg)) {
+        console.error(err);
+        setSeekFallbackVisualTarget(null);
+        clearSeekFallbackRetry();
+        return;
+      }
+      // Streaming-start path can be temporarily non-seekable or busy.
+      // Keep UI at target and retry seek for a short bounded window.
+      const s = get();
+      if (!s.currentTrack) return;
+      const now = Date.now();
+      const sameBurst =
+        getSeekFallbackTrackId() === s.currentTrack.id
+        && now - getSeekFallbackRestartAt() < 600;
+      setSeekFallbackVisualTarget({
+        trackId: s.currentTrack.id,
+        seconds: time,
+        setAtMs: Date.now(),
+      });
+      // Keep stale progress ticks from snapping UI back to start while
+      // recoverable seek retries are still in flight.
+      setSeekTarget(time);
+      if (msg.includes('not seekable') && !sameBurst) {
+        setSeekFallbackTrackId(s.currentTrack.id);
+        setSeekFallbackRestartAt(now);
+        // Keep manual semantics (no crossfade) for seek recovery restarts.
+        s.playTrack(s.currentTrack, s.queue, true);
+      }
+      scheduleSeekFallbackRetry(s.currentTrack.id, time);
+    });
+  });
+}