merge: integrate pre-release blacklist feature with i18n fixes

src/lib/components/TrackRow.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
   import { onMount } from 'svelte';
-  import { Play, Pause, Heart, HardDrive, AlertCircle } from 'lucide-svelte';
+  import { Play, Pause, Heart, HardDrive, AlertCircle, Ban } from 'lucide-svelte';
   import TrackMenu from './TrackMenu.svelte';
   import DownloadButton from './DownloadButton.svelte';
   import {
@@ -26,6 +26,7 @@
     isLocal?: boolean; // Whether this is a local library track
     isUnavailable?: boolean; // Track removed from Qobuz or otherwise unavailable
     unavailableTooltip?: string; // Tooltip for unavailable indicator
+    isBlacklisted?: boolean; // Artist is blacklisted
     isFavoriteOverride?: boolean; // Optional override for favorite state
     downloadStatus?: OfflineCacheStatus;
     downloadProgress?: number;
@@ -73,6 +74,7 @@
     isUnavailable = false,
     unavailableTooltip,
     isFavoriteOverride,
+    isBlacklisted = false,
     downloadStatus = 'none',
     downloadProgress = 0,
     hideDownload = false,
@@ -136,19 +138,24 @@
 <div
   class="track-row"
   class:playing={isPlaying}
-  class:hovered={isHovered && !isPlaying}
+  class:hovered={isHovered && !isPlaying && !isBlacklisted}
   class:compact
+  class:blacklisted={isBlacklisted}
   data-track-id={trackId ?? undefined}
   onmouseenter={() => (isHovered = true)}
   onmouseleave={() => (isHovered = false)}
-  onclick={onPlay}
+  onclick={isBlacklisted ? undefined : onPlay}
   role="button"
-  tabindex="0"
-  onkeydown={(e) => e.key === 'Enter' && onPlay?.()}
+  tabindex={isBlacklisted ? -1 : 0}
+  onkeydown={(e) => e.key === 'Enter' && !isBlacklisted && onPlay?.()}
 >
   <!-- Track Number / Play Button / Unavailable Indicator -->
-  <div class="track-number" class:unavailable={isUnavailable}>
-    {#if isUnavailable}
+  <div class="track-number" class:unavailable={isUnavailable} class:blacklisted={isBlacklisted}>
+    {#if isBlacklisted}
+      <span class="blacklisted-icon" title="Artist is blacklisted">
+        <Ban size={14} />
+      </span>
+    {:else if isUnavailable}
       <span class="unavailable-icon" title={unavailableTooltip}>
         <AlertCircle size={16} />
       </span>
@@ -334,6 +341,27 @@
     cursor: help;
   }
 
+  /* Blacklisted track styles */
+  .track-row.blacklisted {
+    opacity: 0.4;
+    cursor: not-allowed;
+  }
+
+  .track-row.blacklisted:hover {
+    background: transparent;
+  }
+
+  .track-number.blacklisted {
+    color: var(--text-muted);
+  }
+
+  .blacklisted-icon {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-muted);
+  }
+
   .track-number :global(.play-icon) {
     color: white;
   }

src/lib/components/VirtualizedTrackList.svelte

@@ -2,6 +2,7 @@
   import { onMount, onDestroy } from 'svelte';
   import TrackRow from './TrackRow.svelte';
   import type { OfflineCacheStatus } from '$lib/stores/offlineCacheState';
+  import { isBlacklisted as isArtistBlacklisted } from '$lib/stores/artistBlacklistStore';
 
   // Use generic types to match whatever caller passes
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -315,6 +316,7 @@
           {@const albumId = getAlbumId?.(item.track)}
           {@const downloadInfo = getOfflineCacheStatus?.(trackId) ?? { status: 'none' as const, progress: 0 }}
           {@const isTrackDownloaded = downloadInfo.status === 'ready'}
+          {@const trackBlacklisted = !isLocal && artistId ? isArtistBlacklisted(artistId) : false}
           <TrackRow
             trackId={trackId}
             number={getTrackNumber(item.track, item.index)}
@@ -324,18 +326,24 @@
             duration={formatDuration(getTrackDuration(item.track))}
             quality={getQualityBadge(item.track)}
             isPlaying={isPlaybackActive && activeTrackId === trackId}
+            isBlacklisted={trackBlacklisted}
             {isLocal}
-            {hideDownload}
-            {hideFavorite}
+            hideDownload={hideDownload || trackBlacklisted}
+            hideFavorite={hideFavorite || trackBlacklisted}
             isFavoriteOverride={isFavoriteOverride}
             downloadStatus={downloadInfo.status}
             downloadProgress={downloadInfo.progress}
             onArtistClick={trackArtist && onArtistClick ? () => onArtistClick(trackArtist) : undefined}
             onAlbumClick={albumKey && onAlbumClick ? () => onAlbumClick(item.track) : undefined}
-            onPlay={() => onTrackPlay(item.track)}
-            onDownload={onDownload ? () => onDownload(item.track) : undefined}
+            onPlay={trackBlacklisted ? undefined : () => onTrackPlay(item.track)}
+            onDownload={onDownload && !trackBlacklisted ? () => onDownload(item.track) : undefined}
             onRemoveDownload={onRemoveDownload ? () => onRemoveDownload(trackId) : undefined}
-            menuActions={{
+            menuActions={trackBlacklisted ? {
+              // Only navigation actions for blacklisted tracks
+              onGoToAlbum: albumId && onGoToAlbum ? () => onGoToAlbum(albumId) : undefined,
+              onGoToArtist: artistId && onGoToArtist ? () => onGoToArtist(artistId) : undefined,
+              onShowInfo: !isLocal && onShowInfo ? () => onShowInfo(trackId) : undefined,
+            } : {
               onPlayNow: () => onTrackPlay(item.track),
               onPlayNext: onTrackPlayNext ? () => onTrackPlayNext(item.track) : undefined,
               onPlayLater: onTrackPlayLater ? () => onTrackPlayLater(item.track) : undefined,

src/lib/components/views/AlbumDetailView.svelte

@@ -13,12 +13,14 @@
     loadAlbumFavorites,
     toggleAlbumFavorite
   } from '$lib/stores/albumFavoritesStore';
+  import { isBlacklisted as isArtistBlacklisted } from '$lib/stores/artistBlacklistStore';
 
   interface Track {
     id: number;
     number: number;
     title: string;
     artist?: string;
+    artistId?: number;
     duration: string;
     durationSeconds: number;
     quality?: string;
@@ -416,6 +418,8 @@
       {#each album.tracks as track, trackIndex (`${track.id}-${downloadStateVersion}`)}
         {@const downloadInfo = getTrackOfflineCacheStatus?.(track.id) ?? { status: 'none' as const, progress: 0 }}
         {@const isTrackDownloaded = downloadInfo.status === 'ready'}
+        {@const trackArtistId = track.artistId ?? album.artistId}
+        {@const trackBlacklisted = trackArtistId ? isArtistBlacklisted(trackArtistId) : false}
         <TrackRow
           trackId={track.id}
           number={track.number}
@@ -424,14 +428,21 @@
           duration={track.duration}
           quality={track.quality}
           isPlaying={activeTrackId === track.id}
+          isBlacklisted={trackBlacklisted}
           downloadStatus={downloadInfo.status}
           downloadProgress={downloadInfo.progress}
-          onPlay={() => {
+          hideFavorite={trackBlacklisted}
+          hideDownload={trackBlacklisted}
+          onPlay={trackBlacklisted ? undefined : () => {
             onTrackPlay?.(track);
           }}
-          onDownload={onTrackDownload ? () => onTrackDownload(track) : undefined}
-          onRemoveDownload={onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
-          menuActions={{
+          onDownload={!trackBlacklisted && onTrackDownload ? () => onTrackDownload(track) : undefined}
+          onRemoveDownload={!trackBlacklisted && onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
+          menuActions={trackBlacklisted ? {
+            // Blacklisted: only navigation and info
+            onGoToArtist: album.artistId && onTrackGoToArtist ? () => onTrackGoToArtist(album.artistId!) : undefined,
+            onShowInfo: onTrackShowInfo ? () => onTrackShowInfo(track.id) : undefined
+          } : {
             onPlayNow: () => {
               onTrackPlay?.(track);
             },

src/lib/components/views/ArtistDetailView.svelte

@@ -1,6 +1,13 @@
 <script lang="ts">
   import { invoke } from '@tauri-apps/api/core';
-  import { ArrowLeft, User, ChevronDown, ChevronUp, Play, Music, Heart, Search, X, ChevronLeft, ChevronRight, Radio, MoreHorizontal, Info, Disc } from 'lucide-svelte';
+  import { ArrowLeft, User, ChevronDown, ChevronUp, Play, Music, Heart, Search, X, ChevronLeft, ChevronRight, Radio, MoreHorizontal, Info, Disc, Ban } from 'lucide-svelte';
+  import {
+    isBlacklisted,
+    addToBlacklist,
+    removeFromBlacklist,
+    subscribe as subscribeBlacklist
+  } from '$lib/stores/artistBlacklistStore';
+  import { showToast } from '$lib/stores/toastStore';
   import type { ArtistDetail, QobuzArtist } from '$lib/types';
   import AlbumCard from '../AlbumCard.svelte';
   import TrackMenu from '../TrackMenu.svelte';
@@ -121,19 +128,33 @@
   let isFavorite = $state(false);
   let isFavoriteLoading = $state(false);
   let isRadioLoading = $state(false);
+  let artistIsBlacklisted = $state(false);
+  let isBlacklistLoading = $state(false);
   let radioLoadingMessage = $state('');
   let radioJustCreated = $state(false);
   let showNetworkSidebar = $state(false);
   let unsubscribeSidebar: (() => void) | null = null;
+  let unsubscribeBlacklist: (() => void) | null = null;
+
+  function updateBlacklistState() {
+    artistIsBlacklisted = isBlacklisted(artist.id);
+  }
 
   onMount(() => {
     unsubscribeSidebar = subscribeContentSidebar((active: ContentSidebarType) => {
       showNetworkSidebar = active === 'network';
     });
+
+    // Initialize blacklist state and subscribe to changes
+    updateBlacklistState();
+    unsubscribeBlacklist = subscribeBlacklist(() => {
+      updateBlacklistState();
+    });
   });
 
   onDestroy(() => {
     unsubscribeSidebar?.();
+    unsubscribeBlacklist?.();
   });
   let similarArtists = $state<QobuzArtist[]>([]);
   let similarArtistsLoading = $state(false);
@@ -387,6 +408,31 @@
     }
   }
 
+  async function toggleBlacklist() {
+    if (isBlacklistLoading) return;
+
+    isBlacklistLoading = true;
+    const wasBlacklisted = artistIsBlacklisted;
+
+    try {
+      if (wasBlacklisted) {
+        await removeFromBlacklist(artist.id);
+        artistIsBlacklisted = false;
+        showToast(`${artist.name} removed from blacklist`, 'success');
+      } else {
+        await addToBlacklist(artist.id, artist.name);
+        artistIsBlacklisted = true;
+        showToast(`${artist.name} added to blacklist`, 'success');
+      }
+    } catch (err) {
+      console.error('Failed to toggle artist blacklist:', err);
+      artistIsBlacklisted = wasBlacklisted; // Rollback on error
+      showToast('Failed to update blacklist', 'error');
+    } finally {
+      isBlacklistLoading = false;
+    }
+  }
+
   async function createArtistRadio() {
     if (isRadioLoading) return;
 
@@ -1258,10 +1304,30 @@
         >
           <img src="/element-connect.svg" alt="Network" class="network-icon" />
         </button>
+        <button
+          class="blacklist-btn"
+          class:is-blacklisted={artistIsBlacklisted}
+          onclick={toggleBlacklist}
+          disabled={isBlacklistLoading}
+          title={artistIsBlacklisted ? 'Remove from blacklist' : 'Add to blacklist'}
+        >
+          <Ban size={24} />
+        </button>
       </div>
     </div>
   </div>
 
+  <!-- Blacklist Warning Banner -->
+  {#if artistIsBlacklisted}
+    <div class="blacklist-banner">
+      <Ban size={18} />
+      <span>This artist is blacklisted. Their music is hidden from search, radio, and suggestions.</span>
+      <button class="unblock-btn" onclick={toggleBlacklist} disabled={isBlacklistLoading}>
+        Unblock
+      </button>
+    </div>
+  {/if}
+
   {#if showJumpNav}
     <div class="jump-nav">
       <div class="jump-nav-left">
@@ -2529,6 +2595,74 @@
     filter: brightness(0) saturate(100%) invert(56%) sepia(63%) saturate(4848%) hue-rotate(230deg) brightness(102%) contrast(101%);
   }
 
+  .blacklist-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 44px;
+    height: 44px;
+    background: var(--bg-tertiary);
+    border: none;
+    border-radius: 50%;
+    cursor: pointer;
+    color: var(--text-muted);
+    transition: all 150ms ease;
+    flex-shrink: 0;
+  }
+
+  .blacklist-btn:hover:not(:disabled) {
+    background: var(--bg-hover);
+    color: var(--error);
+  }
+
+  .blacklist-btn.is-blacklisted {
+    background: rgba(239, 68, 68, 0.15);
+    color: var(--error);
+  }
+
+  .blacklist-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .blacklist-banner {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 20px;
+    background: rgba(239, 68, 68, 0.1);
+    border: 1px solid rgba(239, 68, 68, 0.3);
+    border-radius: 8px;
+    margin: 0 24px 16px 24px;
+    color: #ef4444;
+    font-size: 13px;
+  }
+
+  .blacklist-banner span {
+    flex: 1;
+  }
+
+  .unblock-btn {
+    padding: 6px 14px;
+    background: rgba(239, 68, 68, 0.2);
+    border: 1px solid rgba(239, 68, 68, 0.4);
+    border-radius: 6px;
+    color: #ef4444;
+    font-size: 12px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 150ms ease;
+  }
+
+  .unblock-btn:hover:not(:disabled) {
+    background: rgba(239, 68, 68, 0.3);
+  }
+
+  .unblock-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
   .floating-message {
     position: absolute;
     left: 50%;

src/lib/components/views/BlacklistManagerView.svelte

@@ -0,0 +1,659 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { ArrowLeft, Search, X, Trash2, Ban, ToggleLeft, ToggleRight, AlertCircle } from 'lucide-svelte';
+  import ViewTransition from '../ViewTransition.svelte';
+  import { showToast } from '$lib/stores/toastStore';
+  import {
+    subscribe,
+    loadBlacklist,
+    removeFromBlacklist,
+    clearBlacklist,
+    setEnabled,
+    isEnabled,
+    getCachedBlacklist,
+    getCount,
+    type BlacklistedArtist
+  } from '$lib/stores/artistBlacklistStore';
+
+  interface Props {
+    onBack?: () => void;
+    onArtistSelect?: (artistId: number) => void;
+  }
+
+  let { onBack, onArtistSelect }: Props = $props();
+
+  let artists = $state<BlacklistedArtist[]>([]);
+  let enabled = $state(true);
+  let loading = $state(true);
+  let searchQuery = $state('');
+  let confirmClearOpen = $state(false);
+
+  // Filtered artists based on search
+  const filteredArtists = $derived.by(() => {
+    if (!searchQuery.trim()) return artists;
+    const query = searchQuery.trim().toLowerCase();
+    return artists.filter(a => a.artist_name.toLowerCase().includes(query));
+  });
+
+  onMount(() => {
+    loadData();
+
+    const unsubscribe = subscribe(() => {
+      artists = getCachedBlacklist();
+      enabled = isEnabled();
+    });
+
+    return unsubscribe;
+  });
+
+  async function loadData() {
+    loading = true;
+    try {
+      await loadBlacklist();
+      artists = getCachedBlacklist();
+      enabled = isEnabled();
+    } catch (err) {
+      console.error('Failed to load blacklist:', err);
+    } finally {
+      loading = false;
+    }
+  }
+
+  async function handleRemove(artistId: number) {
+    const artist = artists.find(a => a.artist_id === artistId);
+    try {
+      await removeFromBlacklist(artistId);
+      showToast(`${artist?.artist_name || 'Artist'} removed from blacklist`, 'success');
+    } catch (err) {
+      console.error('Failed to remove artist from blacklist:', err);
+      showToast('Failed to remove artist', 'error');
+    }
+  }
+
+  async function handleToggleEnabled() {
+    try {
+      const newState = !enabled;
+      await setEnabled(newState);
+      showToast(`Blacklist ${newState ? 'enabled' : 'disabled'}`, 'info');
+    } catch (err) {
+      console.error('Failed to toggle blacklist:', err);
+      showToast('Failed to toggle blacklist', 'error');
+    }
+  }
+
+  async function handleClearAll() {
+    const count = artists.length;
+    try {
+      await clearBlacklist();
+      confirmClearOpen = false;
+      showToast(`Removed ${count} artists from blacklist`, 'success');
+    } catch (err) {
+      console.error('Failed to clear blacklist:', err);
+      showToast('Failed to clear blacklist', 'error');
+    }
+  }
+
+  function formatDate(timestamp: number): string {
+    return new Date(timestamp * 1000).toLocaleDateString(undefined, {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric'
+    });
+  }
+</script>
+
+<ViewTransition duration={200} distance={12} direction="down">
+<div class="blacklist-manager">
+  <!-- Header -->
+  <div class="header">
+    <button class="back-btn" onclick={onBack}>
+      <ArrowLeft size={16} />
+      <span>Back</span>
+    </button>
+    <div class="title-section">
+      <Ban size={24} class="title-icon" />
+      <h1>Artist Blacklist</h1>
+    </div>
+  </div>
+
+  <!-- Description -->
+  <p class="description">
+    Blacklisted artists are hidden from search results, radio, suggestions, and similar artists.
+  </p>
+
+  <!-- Controls -->
+  <div class="controls">
+    <!-- Enable/Disable Toggle -->
+    <button
+      class="toggle-btn"
+      class:enabled={enabled}
+      onclick={handleToggleEnabled}
+    >
+      {#if enabled}
+        <ToggleRight size={20} />
+        <span>Enabled</span>
+      {:else}
+        <ToggleLeft size={20} />
+        <span>Disabled</span>
+      {/if}
+    </button>
+
+    <!-- Search bar -->
+    <div class="search-container">
+      <Search size={16} class="search-icon" />
+      <input
+        type="text"
+        placeholder="Search blacklisted artists..."
+        bind:value={searchQuery}
+        class="search-input"
+      />
+      {#if searchQuery}
+        <button class="clear-search" onclick={() => searchQuery = ''}>
+          <X size={14} />
+        </button>
+      {/if}
+    </div>
+
+    <!-- Clear All Button -->
+    {#if artists.length > 0}
+      <button
+        class="clear-all-btn"
+        onclick={() => confirmClearOpen = true}
+      >
+        <Trash2 size={16} />
+        <span>Clear All</span>
+      </button>
+    {/if}
+
+    <span class="count">{getCount()} artists</span>
+  </div>
+
+  <!-- Disabled Warning -->
+  {#if !enabled}
+    <div class="warning-banner">
+      <AlertCircle size={16} />
+      <span>Blacklist is currently disabled. Artists below will appear in results.</span>
+    </div>
+  {/if}
+
+  <!-- Content -->
+  {#if loading}
+    <div class="loading">
+      <div class="spinner"></div>
+      <p>Loading blacklist...</p>
+    </div>
+  {:else if artists.length === 0}
+    <div class="empty">
+      <Ban size={48} class="empty-icon" />
+      <p>No blacklisted artists</p>
+      <span class="empty-hint">To blacklist an artist, go to their page and click the ban icon.</span>
+    </div>
+  {:else if filteredArtists.length === 0}
+    <div class="empty">
+      <Search size={48} class="empty-icon" />
+      <p>No results for "{searchQuery}"</p>
+    </div>
+  {:else}
+    <div class="list">
+      {#each filteredArtists as artist (artist.artist_id)}
+        <div class="list-item">
+          <div
+            class="artist-info"
+            role="button"
+            tabindex="0"
+            onclick={() => onArtistSelect?.(artist.artist_id)}
+            onkeydown={(e) => e.key === 'Enter' && onArtistSelect?.(artist.artist_id)}
+          >
+            <div class="artist-avatar">
+              <Ban size={20} />
+            </div>
+            <div class="artist-details">
+              <span class="artist-name">{artist.artist_name}</span>
+              <span class="artist-meta">Added {formatDate(artist.added_at)}</span>
+              {#if artist.notes}
+                <span class="artist-notes">{artist.notes}</span>
+              {/if}
+            </div>
+          </div>
+          <button
+            class="remove-btn"
+            onclick={() => handleRemove(artist.artist_id)}
+            title="Remove from blacklist"
+          >
+            <X size={18} />
+          </button>
+        </div>
+      {/each}
+    </div>
+  {/if}
+</div>
+</ViewTransition>
+
+<!-- Confirm Clear Modal -->
+{#if confirmClearOpen}
+  <div
+    class="modal-overlay"
+    role="button"
+    tabindex="0"
+    onclick={() => confirmClearOpen = false}
+    onkeydown={(e) => e.key === 'Escape' && (confirmClearOpen = false)}
+  >
+    <div
+      class="modal-content"
+      role="dialog"
+      aria-modal="true"
+      onclick={(e) => e.stopPropagation()}
+    >
+      <h2 class="modal-title">Clear Blacklist?</h2>
+      <p class="modal-text">
+        This will remove all {artists.length} artists from your blacklist. This action cannot be undone.
+      </p>
+      <div class="modal-actions">
+        <button class="modal-btn cancel" onclick={() => confirmClearOpen = false}>
+          Cancel
+        </button>
+        <button class="modal-btn danger" onclick={handleClearAll}>
+          Clear All
+        </button>
+      </div>
+    </div>
+  </div>
+{/if}
+
+<style>
+  .blacklist-manager {
+    padding: 24px;
+    padding-left: 18px;
+    padding-right: 8px;
+    padding-bottom: 100px;
+    height: 100%;
+    overflow-y: auto;
+  }
+
+  /* Custom scrollbar */
+  .blacklist-manager::-webkit-scrollbar {
+    width: 6px;
+  }
+
+  .blacklist-manager::-webkit-scrollbar-track {
+    background: transparent;
+  }
+
+  .blacklist-manager::-webkit-scrollbar-thumb {
+    background: var(--bg-tertiary);
+    border-radius: 3px;
+  }
+
+  .blacklist-manager::-webkit-scrollbar-thumb:hover {
+    background: var(--text-muted);
+  }
+
+  .header {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 12px;
+  }
+
+  .title-section {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+  }
+
+  .title-section :global(.title-icon) {
+    color: var(--text-muted);
+  }
+
+  .header h1 {
+    font-size: 24px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 0;
+  }
+
+  .back-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 16px;
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    font-size: 14px;
+    transition: color 150ms ease;
+  }
+
+  .back-btn:hover {
+    color: var(--text-primary);
+  }
+
+  .description {
+    color: var(--text-muted);
+    font-size: 14px;
+    margin: 0 0 20px 0;
+  }
+
+  .controls {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 16px;
+    flex-wrap: wrap;
+  }
+
+  .toggle-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 14px;
+    background: var(--bg-tertiary);
+    border: none;
+    border-radius: 6px;
+    color: var(--text-muted);
+    font-size: 13px;
+    cursor: pointer;
+    transition: all 150ms ease;
+  }
+
+  .toggle-btn:hover {
+    background: var(--bg-hover);
+  }
+
+  .toggle-btn.enabled {
+    color: var(--accent-primary);
+  }
+
+  .search-container {
+    position: relative;
+    display: flex;
+    align-items: center;
+    flex: 1;
+    max-width: 280px;
+  }
+
+  .search-container :global(.search-icon) {
+    position: absolute;
+    left: 10px;
+    color: var(--text-muted);
+    pointer-events: none;
+  }
+
+  .search-input {
+    width: 100%;
+    padding: 8px 32px 8px 34px;
+    background: var(--bg-tertiary);
+    border: 1px solid transparent;
+    border-radius: 6px;
+    color: var(--text-primary);
+    font-size: 13px;
+    outline: none;
+    transition: border-color 150ms ease;
+  }
+
+  .search-input:focus {
+    border-color: var(--accent-primary);
+  }
+
+  .search-input::placeholder {
+    color: var(--text-muted);
+  }
+
+  .clear-search {
+    position: absolute;
+    right: 6px;
+    padding: 4px;
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+    transition: all 150ms ease;
+  }
+
+  .clear-search:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+  }
+
+  .clear-all-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 14px;
+    background: var(--bg-tertiary);
+    border: none;
+    border-radius: 6px;
+    color: #ef4444;
+    font-size: 13px;
+    cursor: pointer;
+    transition: all 150ms ease;
+  }
+
+  .clear-all-btn:hover {
+    background: rgba(239, 68, 68, 0.15);
+  }
+
+  .count {
+    font-size: 13px;
+    color: var(--text-muted);
+    margin-left: auto;
+  }
+
+  .warning-banner {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 12px 16px;
+    background: rgba(251, 191, 36, 0.1);
+    border: 1px solid rgba(251, 191, 36, 0.3);
+    border-radius: 8px;
+    color: #fbbf24;
+    font-size: 13px;
+    margin-bottom: 16px;
+  }
+
+  .loading,
+  .empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 64px;
+    color: var(--text-muted);
+  }
+
+  .empty :global(.empty-icon) {
+    opacity: 0.3;
+    margin-bottom: 16px;
+  }
+
+  .empty p {
+    margin: 0 0 8px 0;
+    font-size: 16px;
+  }
+
+  .empty-hint {
+    font-size: 13px;
+    opacity: 0.7;
+    text-align: center;
+  }
+
+  .spinner {
+    width: 32px;
+    height: 32px;
+    border: 3px solid var(--bg-tertiary);
+    border-top-color: var(--accent-primary);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin-bottom: 16px;
+  }
+
+  @keyframes spin {
+    to { transform: rotate(360deg); }
+  }
+
+  .list {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+  }
+
+  .list-item {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    transition: background-color 150ms ease;
+  }
+
+  .list-item:hover {
+    background: var(--bg-tertiary);
+  }
+
+  .artist-info {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    cursor: pointer;
+    min-width: 0;
+  }
+
+  .artist-avatar {
+    width: 44px;
+    height: 44px;
+    border-radius: 50%;
+    background: var(--bg-tertiary);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-muted);
+    flex-shrink: 0;
+  }
+
+  .artist-details {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+  }
+
+  .artist-name {
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .artist-meta {
+    font-size: 12px;
+    color: var(--text-muted);
+  }
+
+  .artist-notes {
+    font-size: 12px;
+    color: var(--text-muted);
+    font-style: italic;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .remove-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 36px;
+    height: 36px;
+    background: transparent;
+    border: none;
+    border-radius: 6px;
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: all 150ms ease;
+    flex-shrink: 0;
+  }
+
+  .remove-btn:hover {
+    background: rgba(239, 68, 68, 0.15);
+    color: #ef4444;
+  }
+
+  /* Modal */
+  .modal-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.6);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 10000;
+  }
+
+  .modal-content {
+    background: var(--bg-secondary);
+    border-radius: 12px;
+    padding: 24px;
+    min-width: 320px;
+    max-width: 400px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+  }
+
+  .modal-title {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 0 0 12px 0;
+  }
+
+  .modal-text {
+    font-size: 14px;
+    color: var(--text-secondary);
+    margin: 0 0 20px 0;
+    line-height: 1.5;
+  }
+
+  .modal-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 12px;
+  }
+
+  .modal-btn {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 6px;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 150ms ease;
+  }
+
+  .modal-btn.cancel {
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+  }
+
+  .modal-btn.cancel:hover {
+    background: var(--bg-hover);
+  }
+
+  .modal-btn.danger {
+    background: #ef4444;
+    color: white;
+  }
+
+  .modal-btn.danger:hover {
+    background: #dc2626;
+  }
+</style>

src/lib/components/views/HomeView.svelte

@@ -9,6 +9,7 @@
   import HomeSettingsModal from '../HomeSettingsModal.svelte';
   import GenreFilterButton from '../GenreFilterButton.svelte';
   import { formatDuration, formatQuality, getQobuzImage } from '$lib/adapters/qobuzAdapters';
+  import { isBlacklisted as isArtistBlacklisted } from '$lib/stores/artistBlacklistStore';
   import {
     subscribe as subscribeHomeSettings,
     getSettings,
@@ -913,6 +914,7 @@
               {@const isActiveTrack = isPlaybackActive && activeTrackId === track.id}
               {@const cacheStatus = getTrackOfflineCacheStatus?.(track.id) ?? { status: 'none', progress: 0 }}
               {@const isTrackDownloaded = cacheStatus.status === 'ready'}
+              {@const trackBlacklisted = track.artistId ? isArtistBlacklisted(track.artistId) : false}
               <TrackRow
                 trackId={track.id}
                 number={index + 1}
@@ -922,13 +924,21 @@
                 duration={track.duration}
                 quality={getTrackQuality(track)}
                 isPlaying={isActiveTrack}
+                isBlacklisted={trackBlacklisted}
                 compact={true}
+                hideDownload={trackBlacklisted}
+                hideFavorite={trackBlacklisted}
                 downloadStatus={cacheStatus.status}
                 downloadProgress={cacheStatus.progress}
                 onArtistClick={track.artistId && onArtistClick ? () => onArtistClick(track.artistId!) : undefined}
                 onAlbumClick={track.albumId && onAlbumClick ? () => onAlbumClick(track.albumId!) : undefined}
-                onPlay={() => handleContinueTrackPlay(track, index)}
-                menuActions={{
+                onPlay={trackBlacklisted ? undefined : () => handleContinueTrackPlay(track, index)}
+                menuActions={trackBlacklisted ? {
+                  // Only navigation actions for blacklisted tracks
+                  onGoToAlbum: track.albumId && onTrackGoToAlbum ? () => onTrackGoToAlbum(track.albumId!) : undefined,
+                  onGoToArtist: track.artistId && onTrackGoToArtist ? () => onTrackGoToArtist(track.artistId!) : undefined,
+                  onShowInfo: onTrackShowInfo ? () => onTrackShowInfo(track.id) : undefined
+                } : {
                   onPlayNow: () => handleContinueTrackPlay(track, index),
                   onPlayNext: onTrackPlayNext ? () => onTrackPlayNext(track) : undefined,
                   onPlayLater: onTrackPlayLater ? () => onTrackPlayLater(track) : undefined,

src/lib/components/views/PlaylistDetailView.svelte

@@ -19,6 +19,7 @@
   } from '$lib/stores/offlineStore';
   import { consumeContextTrackFocus, setPlaybackContext } from '$lib/stores/playbackContextStore';
   import { isTrackUnavailable, clearTrackUnavailable, subscribe as subscribeUnavailable } from '$lib/stores/unavailableTracksStore';
+  import { isBlacklisted as isArtistBlacklisted } from '$lib/stores/artistBlacklistStore';
   import { showToast } from '$lib/stores/toastStore';
   import { t } from '$lib/i18n';
   import { onMount, tick } from 'svelte';
@@ -1124,7 +1125,14 @@
   }
 
   function buildQueueTracks(tracks: DisplayTrack[]) {
-    const queueTracks = tracks.map(t => ({
+    // Filter out blacklisted artists before building queue
+    const filteredTracks = tracks.filter(t => {
+      if (t.isLocal) return true; // Local tracks are never blacklisted
+      if (!t.artistId) return true; // No artist ID, can't check blacklist
+      return !isArtistBlacklisted(t.artistId);
+    });
+
+    const queueTracks = filteredTracks.map(t => ({
       id: t.isLocal ? Math.abs(t.id) : t.id,
       title: t.title,
       artist: t.artist || 'Unknown Artist',
@@ -1139,7 +1147,7 @@
       artist_id: t.isLocal ? null : (t.artistId ?? null),
     }));
 
-    const localIds = tracks
+    const localIds = filteredTracks
       .filter(t => t.isLocal)
       .map(t => Math.abs(t.id));
 
@@ -1398,9 +1406,18 @@
     const allTracks = displayTracks;
     if (allTracks.length === 0) return;
 
+    // Filter out blacklisted tracks
+    const playableTracks = allTracks.filter(t => {
+      if (t.isLocal) return true;
+      if (!t.artistId) return true;
+      return !isArtistBlacklisted(t.artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
     // Set playback context for playlist
     if (playlist) {
-      const trackIds = allTracks
+      const trackIds = playableTracks
         .filter(t => !t.isLocal) // Only Qobuz tracks in context
         .map(t => t.id);
 
@@ -1420,8 +1437,8 @@
     try {
       await setPlaylistQueue(0);
 
-      // Play first track (handle local vs Qobuz)
-      const firstTrack = allTracks[0];
+      // Play first playable track (handle local vs Qobuz)
+      const firstTrack = playableTracks[0];
       if (firstTrack.isLocal && onLocalTrackPlay) {
         const localTrack = localTracks.find(t => t.id === Math.abs(firstTrack.id));
         if (localTrack) onLocalTrackPlay(localTrack);
@@ -1466,14 +1483,23 @@
     const allTracks = displayTracks;
     if (allTracks.length === 0) return;
 
+    // Filter out blacklisted tracks
+    const playableTracks = allTracks.filter(t => {
+      if (t.isLocal) return true;
+      if (!t.artistId) return true;
+      return !isArtistBlacklisted(t.artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
     // Collect local track IDs to add to set
-    const localIds = allTracks
+    const localIds = playableTracks
       .filter(t => t.isLocal)
       .map(t => Math.abs(t.id));
 
     // Add in reverse order so first track ends up right after current
-    for (let i = allTracks.length - 1; i >= 0; i--) {
-      const t = allTracks[i];
+    for (let i = playableTracks.length - 1; i >= 0; i--) {
+      const t = playableTracks[i];
       try {
         await invoke('add_to_queue_next', {
           track: {
@@ -1506,7 +1532,16 @@
     const allTracks = displayTracks;
     if (allTracks.length === 0) return;
 
-    const queueTracks = allTracks.map(t => ({
+    // Filter out blacklisted tracks
+    const playableTracks = allTracks.filter(t => {
+      if (t.isLocal) return true;
+      if (!t.artistId) return true;
+      return !isArtistBlacklisted(t.artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
+    const queueTracks = playableTracks.map(t => ({
       id: t.isLocal ? Math.abs(t.id) : t.id,
       title: t.title,
       artist: t.artist || 'Unknown Artist',
@@ -1522,7 +1557,7 @@
     }));
 
     // Collect local track IDs
-    const localIds = allTracks
+    const localIds = playableTracks
       .filter(t => t.isLocal)
       .map(t => Math.abs(t.id));
 
@@ -1763,6 +1798,7 @@
         {@const isTrackPlaying = isActiveTrack && isPlaybackActive}
         {@const available = isTrackAvailable(track)}
         {@const removedFromQobuz = isTrackRemovedFromQobuz(track)}
+        {@const trackBlacklisted = !track.isLocal && track.artistId ? isArtistBlacklisted(track.artistId) : false}
         <div
           class="track-row-wrapper"
           class:unavailable={!available}
@@ -1825,18 +1861,24 @@
             isLocal={track.isLocal}
             isUnavailable={removedFromQobuz && isOwnPlaylist}
             unavailableTooltip={removedFromQobuz ? $t('player.trackUnavailable') : undefined}
-            hideFavorite={track.isLocal || removedFromQobuz}
-            hideDownload={track.isLocal || removedFromQobuz}
+            isBlacklisted={trackBlacklisted}
+            hideFavorite={track.isLocal || removedFromQobuz || trackBlacklisted}
+            hideDownload={track.isLocal || removedFromQobuz || trackBlacklisted}
             downloadStatus={downloadInfo.status}
             downloadProgress={downloadInfo.progress}
-            onPlay={available ? () => handleTrackClick(track, idx) : undefined}
-            onDownload={available && !track.isLocal && onTrackDownload ? () => onTrackDownload(track) : undefined}
-            onRemoveDownload={available && !track.isLocal && onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
+            onPlay={available && !trackBlacklisted ? () => handleTrackClick(track, idx) : undefined}
+            onDownload={available && !track.isLocal && !trackBlacklisted && onTrackDownload ? () => onTrackDownload(track) : undefined}
+            onRemoveDownload={available && !track.isLocal && !trackBlacklisted && onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
             menuActions={removedFromQobuz ? (isOwnPlaylist ? {
               // Only allow remove from playlist and find replacement for tracks removed from Qobuz (owned playlists only)
               onRemoveFromPlaylist: () => removeTrackFromPlaylist(track),
               onFindReplacement: () => openReplacementModal(track)
-            } : {}) : available ? {
+            } : {}) : trackBlacklisted ? {
+              // Blacklisted: only allow navigation and info, no playback
+              onGoToAlbum: !track.isLocal && track.albumId && onTrackGoToAlbum ? () => onTrackGoToAlbum(track.albumId!) : undefined,
+              onGoToArtist: !track.isLocal && track.artistId && onTrackGoToArtist ? () => onTrackGoToArtist(track.artistId!) : undefined,
+              onShowInfo: !track.isLocal && onTrackShowInfo ? () => onTrackShowInfo(track.id) : undefined
+            } : available ? {
               onPlayNow: () => handleTrackClick(track, idx),
               onPlayNext: track.isLocal ? () => handleTrackPlayNext(track) : (onTrackPlayNext ? () => onTrackPlayNext(track) : undefined),
               onPlayLater: track.isLocal ? () => handleTrackPlayLater(track) : (onTrackPlayLater ? () => onTrackPlayLater(track) : undefined),

src/lib/components/views/SettingsView.svelte

@@ -4,7 +4,7 @@
   import ViewTransition from '../ViewTransition.svelte';
   import { getCurrentWebview } from '@tauri-apps/api/webview';
   import { writeText as copyToClipboard } from '@tauri-apps/plugin-clipboard-manager';
-  import { ArrowLeft, ChevronRight, ChevronDown, ChevronUp, Loader2, Sun, Moon, SunMoon, HelpCircle } from 'lucide-svelte';
+  import { ArrowLeft, ChevronRight, ChevronDown, ChevronUp, Loader2, Sun, Moon, SunMoon, HelpCircle, Ban } from 'lucide-svelte';
   import Toggle from '../Toggle.svelte';
   import Dropdown from '../Dropdown.svelte';
   import DeviceDropdown from '../DeviceDropdown.svelte';
@@ -75,10 +75,16 @@
     type UpdatePreferences
   } from '$lib/stores/updatesStore';
   import { openReleasePageAndAcknowledge } from '$lib/services/updatesService';
+  import {
+    getCount as getBlacklistCount,
+    isEnabled as isBlacklistEnabled,
+    subscribe as subscribeBlacklist
+  } from '$lib/stores/artistBlacklistStore';
 
   interface Props {
     onBack?: () => void;
     onLogout?: () => void;
+    onBlacklistManagerClick?: () => void;
     userName?: string;
     userEmail?: string;
     subscription?: string;
@@ -109,6 +115,7 @@
   let {
     onBack,
     onLogout,
+    onBlacklistManagerClick,
     userName = 'User',
     userEmail = '',
     subscription = 'Qobuz™',
@@ -164,6 +171,10 @@
   let isSettingsWhatsNewOpen = $state(false);
   let settingsWhatsNewRelease = $state<ReleaseInfo | null>(null);
 
+  // Blacklist state
+  let blacklistCount = $state(getBlacklistCount());
+  let blacklistEnabled = $state(isBlacklistEnabled());
+
   // Section navigation
   let settingsViewEl: HTMLDivElement;
   let audioSection: HTMLElement;
@@ -172,6 +183,7 @@
   let appearanceSection: HTMLElement;
   let downloadsSection: HTMLElement;
   let librarySection: HTMLElement;
+  let contentFilteringSection: HTMLElement;
   let integrationsSection: HTMLElement;
   let updatesSection: HTMLElement;
   let storageSection: HTMLElement;
@@ -190,6 +202,7 @@
     { id: 'appearance', labelKey: 'settings.appearance.title' },
     { id: 'downloads', labelKey: 'settings.offlineLibrary.title' },
     { id: 'library', labelKey: 'settings.library.title' },
+    { id: 'content-filtering', labelKey: 'settings.contentFiltering.title' },
     { id: 'integrations', labelKey: 'settings.integrations.title' },
     { id: 'updates', labelKey: 'nav.updates' },
     { id: 'storage', labelKey: 'settings.storage.title' },
@@ -212,6 +225,7 @@
       case 'appearance': return appearanceSection;
       case 'downloads': return downloadsSection;
       case 'library': return librarySection;
+      case 'content-filtering': return contentFilteringSection;
       case 'integrations': return integrationsSection;
       case 'updates': return updatesSection;
       case 'storage': return storageSection;
@@ -703,6 +717,12 @@
       hideTitleBar = getHideTitleBar();
     });
 
+    // Subscribe to blacklist state changes
+    const unsubscribeBlacklist = subscribeBlacklist(() => {
+      blacklistCount = getBlacklistCount();
+      blacklistEnabled = isBlacklistEnabled();
+    });
+
     // Scroll tracking for navigation
     const handleScroll = () => {
       if (!settingsViewEl) return;
@@ -732,6 +752,7 @@
       unsubscribeZoom();
       unsubscribeTitleBar();
       unsubscribeUpdates();
+      unsubscribeBlacklist();
       settingsViewEl?.removeEventListener('scroll', handleScroll);
     };
   });
@@ -2384,6 +2405,31 @@
     </div>
   </section>
 
+  <!-- Content Filtering Section -->
+  <section class="section" bind:this={contentFilteringSection}>
+    <h3 class="section-title">{$t('settings.contentFiltering.title')}</h3>
+    <div class="setting-row last">
+      <div class="setting-info">
+        <div class="setting-with-icon">
+          <Ban size={18} class="setting-icon" />
+          <div class="setting-with-description">
+            <span class="setting-label">{$t('settings.contentFiltering.artistBlacklist')}</span>
+            <span class="setting-description">
+              {blacklistCount} {blacklistCount === 1 ? 'artist' : 'artists'} blocked
+              {#if !blacklistEnabled}
+                <span class="status-disabled">({$t('settings.contentFiltering.disabled')})</span>
+              {/if}
+            </span>
+          </div>
+        </div>
+      </div>
+      <button class="link-btn" onclick={onBlacklistManagerClick}>
+        {$t('settings.contentFiltering.manage')}
+        <ChevronRight size={16} />
+      </button>
+    </div>
+  </section>
+
   <!-- Integrations Section -->
   <section class="section" bind:this={integrationsSection}>
     <h3 class="section-title">{$t('settings.integrations.title')}</h3>
@@ -3753,6 +3799,43 @@ flatpak override --user --filesystem=/home/USUARIO/Música com.blitzfc.qbz</pre>
     color: var(--text-primary);
   }
 
+  /* Content Filtering Section */
+  .setting-with-icon {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+  }
+
+  .setting-with-icon :global(.setting-icon) {
+    color: var(--text-muted);
+    margin-top: 2px;
+    flex-shrink: 0;
+  }
+
+  .link-btn {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    padding: 8px 12px;
+    background: var(--bg-tertiary);
+    border: none;
+    border-radius: 6px;
+    color: var(--text-primary);
+    font-size: 13px;
+    cursor: pointer;
+    transition: background-color 150ms ease;
+    flex-shrink: 0;
+  }
+
+  .link-btn:hover {
+    background: var(--bg-hover);
+  }
+
+  .status-disabled {
+    color: #fbbf24;
+    font-size: 12px;
+  }
+
 </style>
 
 <MigrationModal

src/lib/i18n/locales/en.json

@@ -462,6 +462,12 @@
       "fetchArtistImages": "Fetch Qobuz™ Artist Images",
       "fetchArtistImagesDesc": "Show artist photos from Qobuz™ in local library"
     },
+    "contentFiltering": {
+      "title": "Content Filtering",
+      "artistBlacklist": "Artist Blacklist",
+      "manage": "Manage",
+      "disabled": "disabled"
+    },
     "integrations": {
       "title": "Integrations",
       "lastfm": "Last.fm",

src/lib/i18n/locales/es.json

@@ -462,6 +462,12 @@
       "fetchArtistImages": "Obtener imágenes de artistas de Qobuz™",
       "fetchArtistImagesDesc": "Mostrar fotos de artistas de Qobuz™ en la biblioteca local"
     },
+    "contentFiltering": {
+      "title": "Filtrado de Contenido",
+      "artistBlacklist": "Lista negra de artistas",
+      "manage": "Administrar",
+      "disabled": "deshabilitado"
+    },
     "integrations": {
       "title": "Integraciones",
       "lastfm": "Last.fm",

src/lib/stores/artistBlacklistStore.ts

@@ -0,0 +1,150 @@
+/**
+ * Artist Blacklist Store
+ *
+ * Manages the local artist blacklist for filtering unwanted artists
+ * from search results, radio, and suggestions.
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+
+// ============ Types ============
+
+export interface BlacklistedArtist {
+  artist_id: number;
+  artist_name: string;
+  added_at: number;
+  notes: string | null;
+}
+
+export interface BlacklistSettings {
+  enabled: boolean;
+}
+
+// ============ State ============
+
+let blacklist: BlacklistedArtist[] = [];
+let enabled: boolean = true;
+// In-memory Set for O(1) lookups
+let blacklistIds: Set<number> = new Set();
+
+const listeners = new Set<() => void>();
+
+function notifyListeners(): void {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function updateIdSet(): void {
+  blacklistIds = new Set(blacklist.map(a => a.artist_id));
+}
+
+// ============ Public API ============
+
+/**
+ * Load blacklist from backend
+ */
+export async function loadBlacklist(): Promise<BlacklistedArtist[]> {
+  const [list, settings] = await Promise.all([
+    invoke<BlacklistedArtist[]>('get_artist_blacklist'),
+    invoke<BlacklistSettings>('get_blacklist_settings')
+  ]);
+  blacklist = list;
+  enabled = settings.enabled;
+  updateIdSet();
+  notifyListeners();
+  return list;
+}
+
+/**
+ * Add an artist to the blacklist
+ */
+export async function addToBlacklist(
+  artistId: number,
+  artistName: string,
+  notes?: string
+): Promise<void> {
+  await invoke('add_to_artist_blacklist', {
+    artistId,
+    artistName,
+    notes: notes ?? null
+  });
+  // Reload to get the full entry with timestamp
+  await loadBlacklist();
+}
+
+/**
+ * Remove an artist from the blacklist
+ */
+export async function removeFromBlacklist(artistId: number): Promise<void> {
+  await invoke('remove_from_artist_blacklist', { artistId });
+  // Update local state
+  blacklist = blacklist.filter(a => a.artist_id !== artistId);
+  updateIdSet();
+  notifyListeners();
+}
+
+/**
+ * Check if an artist is blacklisted (O(1) local check)
+ */
+export function isBlacklisted(artistId: number): boolean {
+  if (!enabled) return false;
+  return blacklistIds.has(artistId);
+}
+
+/**
+ * Set the enabled state
+ */
+export async function setEnabled(value: boolean): Promise<void> {
+  await invoke('set_blacklist_enabled', { enabled: value });
+  enabled = value;
+  notifyListeners();
+}
+
+/**
+ * Check if blacklist is enabled
+ */
+export function isEnabled(): boolean {
+  return enabled;
+}
+
+/**
+ * Get cached blacklist (no backend call)
+ */
+export function getCachedBlacklist(): BlacklistedArtist[] {
+  return blacklist;
+}
+
+/**
+ * Get blacklist count
+ */
+export function getCount(): number {
+  return blacklist.length;
+}
+
+/**
+ * Clear all blacklisted artists
+ */
+export async function clearBlacklist(): Promise<void> {
+  await invoke('clear_artist_blacklist');
+  blacklist = [];
+  updateIdSet();
+  notifyListeners();
+}
+
+/**
+ * Subscribe to blacklist changes
+ */
+export function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/**
+ * Initialize blacklist store (call on app startup)
+ */
+export async function initBlacklistStore(): Promise<void> {
+  await loadBlacklist();
+}

src/lib/stores/navigationStore.ts

@@ -18,6 +18,7 @@ export type ViewType =
   | 'label'
   | 'playlist'
   | 'playlist-manager'
+  | 'blacklist-manager'
   | 'favorites-tracks'
   | 'favorites-albums'
   | 'favorites-artists'

src/routes/+page.svelte

@@ -37,11 +37,12 @@
     getCurrentContext,
     requestContextTrackFocus
   } from '$lib/stores/playbackContextStore';
-  import { 
+  import {
     initPlaybackPreferences,
     getCachedPreferences,
     isAutoplayEnabled
   } from '$lib/stores/playbackPreferencesStore';
+  import { initBlacklistStore, isBlacklisted as isArtistBlacklisted } from '$lib/stores/artistBlacklistStore';
 
   // UI state management
   import {
@@ -292,6 +293,7 @@
   import FavoritesView from '$lib/components/views/FavoritesView.svelte';
   import LocalLibraryView from '$lib/components/views/LocalLibraryView.svelte';
   import PlaylistManagerView from '$lib/components/views/PlaylistManagerView.svelte';
+  import BlacklistManagerView from '$lib/components/views/BlacklistManagerView.svelte';
 
   // Overlays
   import QueuePanel from '$lib/components/QueuePanel.svelte';
@@ -1256,12 +1258,18 @@
         ? 'Hi-Res'
         : '-';
 
-    // Build queue from album tracks before playing
+    // Build queue from album tracks before playing (filter blacklisted artists)
     if (selectedAlbum?.tracks) {
       console.log('[Album Queue] Building queue from', selectedAlbum.tracks.length, 'album tracks');
 
-      const trackIndex = selectedAlbum.tracks.findIndex(t => t.id === track.id);
-      const queueTracks: BackendQueueTrack[] = selectedAlbum.tracks.map(t => ({
+      // Filter out blacklisted tracks
+      const playableTracks = selectedAlbum.tracks.filter(t => {
+        const artistId = t.artistId ?? selectedAlbum.artistId;
+        return !artistId || !isArtistBlacklisted(artistId);
+      });
+
+      const trackIndex = playableTracks.findIndex(t => t.id === track.id);
+      const queueTracks: BackendQueueTrack[] = playableTracks.map(t => ({
         id: t.id,
         title: t.title,
         artist: t.artist || selectedAlbum?.artist || 'Unknown Artist',
@@ -1276,7 +1284,7 @@
         artist_id: t.artistId ?? selectedAlbum?.artistId
       }));
 
-      console.log('[Album Queue] Mapped to', queueTracks.length, 'queue tracks, startIndex:', trackIndex);
+      console.log('[Album Queue] Mapped to', queueTracks.length, 'queue tracks (filtered), startIndex:', trackIndex);
       console.log('[Album Queue] Track IDs:', queueTracks.map(t => t.id));
 
       // Set the queue starting at the clicked track
@@ -1612,18 +1620,31 @@
     }
   }
 
-  // Play all tracks from album (starting from first track)
+  // Play all tracks from album (starting from first non-blacklisted track)
   async function handlePlayAllAlbum() {
     if (!selectedAlbum?.tracks?.length) return;
-    const firstTrack = selectedAlbum.tracks[0];
-    await handleAlbumTrackPlay(firstTrack);
+    // Find first non-blacklisted track
+    const firstPlayableTrack = selectedAlbum.tracks.find(t => {
+      const artistId = t.artistId ?? selectedAlbum.artistId;
+      return !artistId || !isArtistBlacklisted(artistId);
+    });
+    if (!firstPlayableTrack) return;
+    await handleAlbumTrackPlay(firstPlayableTrack);
   }
 
   // Shuffle play all tracks from album
   async function handleShuffleAlbum() {
     if (!selectedAlbum?.tracks?.length) return;
 
-    console.log('[Album Shuffle] Starting shuffle with', selectedAlbum.tracks.length, 'tracks');
+    // Filter out blacklisted tracks
+    const playableTracks = selectedAlbum.tracks.filter(t => {
+      const artistId = t.artistId ?? selectedAlbum.artistId;
+      return !artistId || !isArtistBlacklisted(artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
+    console.log('[Album Shuffle] Starting shuffle with', playableTracks.length, 'playable tracks');
 
     // Set shuffle mode first
     try {
@@ -1634,8 +1655,8 @@
     }
 
     // Pick a random track to start with
-    const randomIndex = Math.floor(Math.random() * selectedAlbum.tracks.length);
-    const randomTrack = selectedAlbum.tracks[randomIndex];
+    const randomIndex = Math.floor(Math.random() * playableTracks.length);
+    const randomTrack = playableTracks[randomIndex];
 
     console.log('[Album Shuffle] Starting from random track index:', randomIndex, 'track:', randomTrack.title);
 
@@ -1648,10 +1669,18 @@
   async function handleAddAlbumToQueueNext() {
     if (!selectedAlbum?.tracks?.length) return;
 
+    // Filter out blacklisted tracks
+    const playableTracks = selectedAlbum.tracks.filter(t => {
+      const artistId = t.artistId ?? selectedAlbum.artistId;
+      return !artistId || !isArtistBlacklisted(artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
     const artwork = selectedAlbum.artwork || '';
     // Add in reverse order so first track ends up right after current
-    for (let i = selectedAlbum.tracks.length - 1; i >= 0; i--) {
-      const t = selectedAlbum.tracks[i];
+    for (let i = playableTracks.length - 1; i >= 0; i--) {
+      const t = playableTracks[i];
       queueTrackNext({
         id: t.id,
         title: t.title,
@@ -1667,15 +1696,23 @@
         artist_id: t.artistId ?? selectedAlbum?.artistId
       });
     }
-    showToast($t('toast.playingTracksNext', { values: { count: selectedAlbum.tracks.length } }), 'success');
+    showToast($t('toast.playingTracksNext', { values: { count: playableTracks.length } }), 'success');
   }
 
   // Add all album tracks to end of queue
   async function handleAddAlbumToQueueLater() {
     if (!selectedAlbum?.tracks?.length) return;
 
+    // Filter out blacklisted tracks
+    const playableTracks = selectedAlbum.tracks.filter(t => {
+      const artistId = t.artistId ?? selectedAlbum.artistId;
+      return !artistId || !isArtistBlacklisted(artistId);
+    });
+
+    if (playableTracks.length === 0) return;
+
     const artwork = selectedAlbum.artwork || '';
-    const queueTracks: BackendQueueTrack[] = selectedAlbum.tracks.map(t => ({
+    const queueTracks: BackendQueueTrack[] = playableTracks.map(t => ({
       id: t.id,
       title: t.title,
       artist: t.artist || selectedAlbum?.artist || 'Unknown Artist',
@@ -2437,6 +2474,7 @@
     // Initialize playback context and preferences stores
     initPlaybackContextStore();
     initPlaybackPreferences();
+    initBlacklistStore();
 
     // Load infinite play preference
     try {
@@ -2958,6 +2996,7 @@
         <SettingsView
           onBack={navGoBack}
           onLogout={handleLogout}
+          onBlacklistManagerClick={() => navigateTo('blacklist-manager')}
           userName={userInfo?.userName}
           subscription={userInfo?.subscription}
           subscriptionValidUntil={userInfo?.subscriptionValidUntil}
@@ -3172,6 +3211,11 @@
             sidebarRef?.refreshLocalTrackCounts();
           }}
         />
+      {:else if activeView === 'blacklist-manager'}
+        <BlacklistManagerView
+          onBack={navGoBack}
+          onArtistSelect={handleArtistClick}
+        />
       {/if}
     </main>