refactor(utils): group utils/ files into topic folders (Phase L, part 1) (#689)

111 of 122 top-level src/utils/ files move into 16 topic folders (audio,
cache, cover, share, server, playback, playlist, deviceSync, waveform,
mix, format, export, changelog, ui, perf, componentHelpers). True
singletons with no cluster stay at the utils/ root.

Pure file-move: a path-aware codemod rewrote 539 relative-import
specifiers across 275 files; no logic touched. The hot-path coverage
gate list (.github/frontend-hot-path-files.txt) is updated to the new
paths for the 11 gated utils files — a mechanical consequence of the
move, not a CI change. tsc is green.

src/utils/componentHelpers/contextMenuActions.ts

@@ -0,0 +1,146 @@
+import { join } from '@tauri-apps/api/path';
+import { invoke } from '@tauri-apps/api/core';
+import { getSimilarSongs2, getSimilarSongs, getTopSongs } from '../../api/subsonicArtists';
+import { buildDownloadUrl } from '../../api/subsonicStreamUrl';
+import { useAuthStore } from '../../store/authStore';
+import { usePlayerStore } from '../../store/playerStore';
+import type { Track } from '../../store/playerStoreTypes';
+import { useZipDownloadStore } from '../../store/zipDownloadStore';
+import { useDownloadModalStore } from '../../store/downloadModalStore';
+import type { EntityShareKind } from '../share/shareLink';
+import { copyEntityShareLink } from '../share/copyEntityShareLink';
+import { sanitizeFilename, shuffleArray } from './contextMenuHelpers';
+import { songToTrack } from '../playback/songToTrack';
+import { showToast } from '../ui/toast';
+
+export async function copyShareLink(
+  kind: EntityShareKind,
+  id: string,
+  t: (key: string) => string,
+) {
+  const ok = await copyEntityShareLink(kind, id);
+  if (ok) showToast(t('contextMenu.shareCopied'));
+  else showToast(t('contextMenu.shareCopyFailed'), 4000, 'error');
+}
+
+export async function startRadio(
+  artistId: string,
+  artistName: string,
+  playTrack: (track: Track, queue: Track[]) => void,
+  seedTrack?: Track,
+) {
+  if (seedTrack) {
+    const state = usePlayerStore.getState();
+    if (state.currentTrack?.id === seedTrack.id) {
+      if (!state.isPlaying) state.resume();
+    } else {
+      playTrack(seedTrack, [seedTrack]);
+    }
+    try {
+      const [similar, top] = await Promise.all([getSimilarSongs2(artistId), getTopSongs(artistName)]);
+      const similarTracks = shuffleArray(
+        similar.map(songToTrack).filter(t => t.id !== seedTrack.id).map(t => ({ ...t, radioAdded: true as const })),
+      );
+      const radioTracks = similarTracks.length > 0
+        ? similarTracks
+        : shuffleArray(
+            top.map(songToTrack).filter(t => t.id !== seedTrack.id).map(t => ({ ...t, radioAdded: true as const })),
+          );
+      if (radioTracks.length > 0) usePlayerStore.getState().enqueueRadio(radioTracks, artistId);
+    } catch (e) {
+      console.error('Failed to load radio queue', e);
+    }
+    return;
+  }
+
+  // Artist radio without seed
+  const similarPromise = getSimilarSongs2(artistId).catch(() => [] as Awaited<ReturnType<typeof getSimilarSongs2>>);
+  try {
+    const top = await getTopSongs(artistName);
+    const topTracks = shuffleArray(
+      top.map(t => ({ ...songToTrack(t), radioAdded: true as const })),
+    );
+    if (topTracks.length === 0) {
+      const similar = await similarPromise;
+      const fallback = shuffleArray(
+        similar.map(t => ({ ...songToTrack(t), radioAdded: true as const })),
+      );
+      if (fallback.length === 0) return;
+      const state = usePlayerStore.getState();
+      if (state.currentTrack) {
+        state.enqueueRadio(fallback, artistId);
+      } else {
+        state.setRadioArtistId(artistId);
+        playTrack(fallback[0], fallback);
+      }
+      return;
+    }
+    const state = usePlayerStore.getState();
+    if (state.currentTrack) {
+      state.enqueueRadio([topTracks[0]], artistId);
+    } else {
+      state.setRadioArtistId(artistId);
+      playTrack(topTracks[0], [topTracks[0]]);
+    }
+    similarPromise.then(similar => {
+      const similarTracks = shuffleArray(
+        similar
+          .map(t => ({ ...songToTrack(t), radioAdded: true as const }))
+          .filter(t => t.id !== topTracks[0].id),
+      );
+      if (similarTracks.length === 0) return;
+      const { queue, queueIndex } = usePlayerStore.getState();
+      const pendingRadio = queue.slice(queueIndex + 1).filter(t => t.radioAdded);
+      usePlayerStore.getState().enqueueRadio([...pendingRadio, ...similarTracks], artistId);
+    });
+  } catch (e) {
+    console.error('Failed to start radio', e);
+  }
+}
+
+export async function startInstantMix(
+  song: Track,
+  t: (key: string) => string,
+) {
+  usePlayerStore.getState().reseedQueueForInstantMix(song);
+  const serverId = useAuthStore.getState().activeServerId;
+  try {
+    const similar = await getSimilarSongs(song.id, 50);
+    if (serverId) useAuthStore.getState().setAudiomuseNavidromeIssue(serverId, false);
+    const shuffled = shuffleArray(
+      similar
+        .filter(s => s.id !== song.id)
+        .map(s => ({ ...songToTrack(s), radioAdded: true as const })),
+    );
+    if (shuffled.length > 0) {
+      const aid = song.artistId?.trim() || undefined;
+      usePlayerStore.getState().enqueueRadio(shuffled, aid);
+    }
+  } catch (e) {
+    console.error('Instant mix failed', e);
+    if (serverId) useAuthStore.getState().setAudiomuseNavidromeIssue(serverId, true);
+    showToast(t('contextMenu.instantMixFailed'), 5000, 'error');
+  }
+}
+
+export async function downloadAlbum(albumName: string, albumId: string) {
+  const auth = useAuthStore.getState();
+  const requestDownloadFolder = useDownloadModalStore.getState().requestFolder;
+  const folder = auth.downloadFolder || await requestDownloadFolder();
+  if (!folder) return;
+
+  const filename = `${sanitizeFilename(albumName)}.zip`;
+  const destPath = await join(folder, filename);
+  const url = buildDownloadUrl(albumId);
+  const id = crypto.randomUUID();
+
+  const { start, complete, fail } = useZipDownloadStore.getState();
+  start(id, filename);
+  try {
+    await invoke('download_zip', { id, url, destPath });
+    complete(id);
+  } catch (e) {
+    fail(id);
+    console.error('ZIP download failed:', e);
+  }
+}