v1.1.3: version bump, removed duplicate method; this is why we run tests...

2026-04-25 03:12:54 -04:00 · 2026-02-20 20:02:27 -05:00
27 changed files with 10 additions and 21497 deletions
@@ -79,15 +79,7 @@ There's an environment variable to modify this.

 **Recommended workflow**: Use the `sp_dc` cookie method alongside the [Spotify Import Plugin](https://github.com/Viperinius/jellyfin-plugin-spotify-import?tab=readme-ov-file).

-<<<<<<< HEAD
-### Nginx Proxy Setup (Required)
-||||||| f68706f
-
-
-### Nginx Proxy Setup (Required)
-=======
 ### Nginx Proxy Setup (Optional)
->>>>>>> beta

 This service only exposes ports internally. You can use nginx to proxy to it, however PLEASE take significant precautions before exposing this! Everyone decides their own level of risk, but this is currently untested, potentially dangerous software, with almost unfettered access to your Jellyfin server. My recommendation is use Tailscale or something similar!

@@ -161,6 +153,8 @@ This project brings together all the music streaming providers into one unified

 - [Finamp](https://github.com/jmshrv/finamp) (Android/iOS)

+- [Finer Player](https://monk-studio.com/finer) (iOS/iPadOS/macOS/tvOS)
+
 _Working on getting more currently_

 ### Subsonic/Navidrome
@@ -271,518 +265,7 @@ Choose your preferred provider via the `MUSIC_SERVICE` environment variable. Add

 > **Tip**: Make sure the `DOWNLOAD_PATH` points to a directory that your media server can scan, so downloaded songs appear in your library.

-<<<<<<< HEAD
-## Advanced Configuration
-
-### Backend Selection
-
-| Setting | Description |
-|---------|-------------|
-| `Backend:Type` | Backend type: `Subsonic` or `Jellyfin` (default: `Subsonic`) |
-
-### Jellyfin Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Jellyfin:Url` | URL of your Jellyfin server |
-| `Jellyfin:ApiKey` | API key (get from Jellyfin Dashboard > API Keys) |
-| `Jellyfin:UserId` | User ID for library access |
-| `Jellyfin:LibraryId` | Music library ID (optional, auto-detected) |
-| `Jellyfin:MusicService` | Music provider: `SquidWTF`, `Deezer`, or `Qobuz` |
-
-### Subsonic Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Subsonic:Url` | URL of your Navidrome/Subsonic server |
-| `Subsonic:MusicService` | Music provider: `SquidWTF`, `Deezer`, or `Qobuz` (default: `SquidWTF`) |
-
-### Shared Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Library:DownloadPath` | Directory where downloaded songs are stored |
-| `*:ExplicitFilter` | Content filter: `All`, `ExplicitOnly`, or `CleanOnly` |
-| `*:DownloadMode` | Download mode: `Track` or `Album` |
-| `*:StorageMode` | Storage mode: `Permanent` or `Cache` |
-| `*:CacheDurationHours` | Cache expiration time in hours |
-| `*:EnableExternalPlaylists` | Enable external playlist support |
-
-### SquidWTF Settings
-
-| Setting | Description |
-|---------|-------------|
-| `SquidWTF:Quality` | Preferred audio quality: `FLAC`, `MP3_320`, `MP3_128`. If not specified, the highest available quality for your account will be used |
-
-**Load Balancing & Reliability:**
-
-SquidWTF uses a round-robin load balancing strategy across multiple backup API endpoints to distribute requests evenly and prevent overwhelming any single provider. Each request automatically rotates to the next endpoint in the pool, with automatic fallback to other endpoints if one fails. This ensures high availability and prevents rate limiting by distributing load across multiple providers.
-
-### Deezer Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Deezer:Arl` | Your Deezer ARL token (required if using Deezer) |
-| `Deezer:ArlFallback` | Backup ARL token if primary fails |
-| `Deezer:Quality` | Preferred audio quality: `FLAC`, `MP3_320`, `MP3_128`. If not specified, the highest available quality for your account will be used |
-
-### Qobuz Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Qobuz:UserAuthToken` | Your Qobuz User Auth Token (required if using Qobuz) - [How to get it](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)) |
-| `Qobuz:UserId` | Your Qobuz User ID (required if using Qobuz) |
-| `Qobuz:Quality` | Preferred audio quality: `FLAC`, `FLAC_24_HIGH`, `FLAC_24_LOW`, `FLAC_16`, `MP3_320`. If not specified, the highest available quality will be used |
-
-### External Playlists
-
-Allstarr supports discovering and downloading playlists from your streaming providers (SquidWTF, Deezer, and Qobuz).
-
-| Setting | Description |
-|---------|-------------|
-| `Subsonic:EnableExternalPlaylists` | Enable/disable external playlist support (default: `true`) |
-| `Subsonic:PlaylistsDirectory` | Directory name where M3U playlist files are created (default: `playlists`) |
-
-**How it works:**
-1. Search for playlists from an external provider using the global search in your Subsonic client
-2. When you "star" (favorite) a playlist, Allstarr automatically downloads all tracks
-3. An M3U playlist file is created in `{DownloadPath}/playlists/` with relative paths to downloaded tracks
-4. Individual tracks are added to the M3U as they are played or downloaded
-
-**Environment variable:**
-```bash
-# To disable playlists
-Subsonic__EnableExternalPlaylists=false
-```
-
-> **Note**: Due to client-side filtering, playlists from streaming providers may not appear in the "Playlists" tab of some clients, but will show up in global search results.
-
-### Spotify Playlist Injection (Jellyfin Only)
-
-Allstarr automatically fills your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service.
-
-<img width="1649" height="3764" alt="image" src="https://github.com/user-attachments/assets/a4d3d79c-7741-427f-8c01-ffc90f3a579b" />
-
-
-#### Prerequisites
-
-1. **Install the Jellyfin Spotify Import Plugin**
-   - Navigate to Jellyfin Dashboard → Plugins → Catalog
-   - Search for "Spotify Import" by Viperinius
-   - Install and restart Jellyfin
-   - Plugin repository: [Viperinius/jellyfin-plugin-spotify-import](https://github.com/Viperinius/jellyfin-plugin-spotify-import)
-
-2. **Configure the Spotify Import Plugin**
-   - Go to Jellyfin Dashboard → Plugins → Spotify Import
-   - Connect your Spotify account
-   - Select which playlists to sync (e.g., Release Radar, Discover Weekly)
-   - Set a sync schedule (the plugin will create playlists in Jellyfin)
-
-3. **Configure Allstarr**
-   - Enable Spotify Import in Allstarr (see configuration below)
-   - Link your Jellyfin playlists to Spotify playlists via the Web UI
-   - Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
-
-#### Configuration
-
-| Setting | Description |
-|---------|-------------|
-| `SpotifyImport:Enabled` | Enable Spotify playlist injection (default: `false`) |
-| `SpotifyImport:MatchingIntervalHours` | How often to run track matching in hours (default: 24, set to 0 for startup only) |
-| `SpotifyImport:Playlists` | JSON array of playlists (managed via Web UI) |
-
-**Environment variables example:**
-```bash
-# Enable the feature
-SPOTIFY_IMPORT_ENABLED=true
-
-# Matching interval (24 hours = once per day)
-SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS=24
-
-# Playlists (use Web UI to manage instead of editing manually)
-SPOTIFY_IMPORT_PLAYLISTS=[["Discover Weekly","37i9dQZEVXcV6s7Dm7RXsU","first"],["Release Radar","37i9dQZEVXbng2vDHnfQlC","first"]]
-```
-
-#### How It Works
-
-1. **Spotify Import Plugin Runs**
-   - Plugin fetches your Spotify playlists
-   - Creates/updates playlists in Jellyfin with tracks already in your library
-   - Generates "missing tracks" JSON files for songs not found locally
-
-2. **Allstarr Matches Tracks** (on startup + every 24 hours by default)
-   - Reads missing tracks files from the Jellyfin plugin
-   - For each missing track, searches your streaming provider (SquidWTF, Deezer, or Qobuz)
-   - Uses fuzzy matching to find the best match (title + artist similarity)
-   - Rate-limited to avoid overwhelming the service (150ms delay between searches)
-   - Pre-builds playlist cache for instant loading
-
-3. **You Open the Playlist in Jellyfin**
-   - Allstarr intercepts the request
-   - Returns a merged list: local tracks + matched streaming tracks
-   - Loads instantly from cache!
-
-4. **You Play a Track**
-   - Local tracks stream from Jellyfin normally
-   - Matched tracks download from streaming provider on-demand
-   - Downloaded tracks are saved to your library for future use
-
-#### Manual API Triggers
-
-You can manually trigger operations via the admin API:
-
-```bash
-# Get API key from your .env file
-API_KEY="your-api-key-here"
-
-# Fetch missing tracks from Jellyfin plugin
-curl "http://localhost:5274/spotify/sync?api_key=$API_KEY"
-
-# Trigger track matching (searches streaming provider)
-curl "http://localhost:5274/spotify/match?api_key=$API_KEY"
-
-# Match all playlists (refresh all matches)
-curl "http://localhost:5274/spotify/match-all?api_key=$API_KEY"
-
-# Clear cache and rebuild
-curl "http://localhost:5274/spotify/clear-cache?api_key=$API_KEY"
-
-# Refresh specific playlist
-curl "http://localhost:5274/spotify/refresh-playlist?playlistId=PLAYLIST_ID&api_key=$API_KEY"
-```
-
-#### Web UI Management
-
-The easiest way to manage Spotify playlists is through the Web UI at `http://localhost:5275`:
-
-1. **Link Playlists Tab**: Link Jellyfin playlists to Spotify playlists
-2. **Active Playlists Tab**: View status, trigger matching, and manage playlists
-3. **Configuration Tab**: Enable/disable Spotify Import and adjust settings
-
-#### Troubleshooting
-
-**Playlists are empty:**
- Check that the Spotify Import plugin is running and creating playlists
- Verify playlists are linked in the Web UI
- Check logs: `docker-compose logs -f allstarr | grep -i spotify`
-
-**Tracks aren't matching:**
- Ensure your streaming provider is configured (`MUSIC_SERVICE`, credentials)
- Manually trigger matching via Web UI or API
- Check that the Jellyfin plugin generated missing tracks files
-
-**Performance:**
- Matching runs in background with rate limiting (150ms between searches)
- First match may take a few minutes for large playlists
- Subsequent loads are instant (served from cache)
-
-#### Notes
-
- Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
- Matched tracks cached for fast loading
- Missing tracks cache persists across restarts (Redis + file cache)
- Rate limiting prevents overwhelming your streaming provider
- Only works with Jellyfin backend (not Subsonic/Navidrome)
-
-### Getting Credentials
-
-#### Deezer ARL Token
-
-See the [Wiki guide](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Deezer-Credentials-(ARL-Token)) for detailed instructions on obtaining your Deezer ARL token.
-
-#### Qobuz Credentials
-
-See the [Wiki guide](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)) for detailed instructions on obtaining your Qobuz User ID and User Auth Token.
-
-## Limitations
-
- **Playlist Search**: Subsonic clients like Aonsoku filter playlists client-side from a cached `getPlaylists` call. Streaming provider playlists appear in global search (`search3`) but not in the Playlists tab filter.
- **Region Restrictions**: Some tracks may be unavailable depending on your region and provider.
- **Token Expiration**: Provider authentication tokens expire and need periodic refresh.
-
-## Architecture
-
-```
-                                                    ┌─────────────────┐
-                                               ┌───▶│    Jellyfin     │
-┌─────────────────┐     ┌──────────────────┐   │    │    Server       │
-│  Music Client   │────▶│     Allstarr     │───┤    └─────────────────┘
-│  (Aonsoku,      │◀────│   (Proxy)        │◀──┤
-│   Finamp, etc.) │     │                  │   │    ┌─────────────────┐
-└─────────────────┘     └────────┬─────────┘   └───▶│   Navidrome     │
-                                 │                  │   (Subsonic)    │
-                                 ▼                  └─────────────────┘
-                        ┌─────────────────┐
-                        │ Music Providers │
-                        │  - SquidWTF     │
-                        │  - Deezer       │
-                        │  - Qobuz        │
-                        └─────────────────┘
-```
-
-The proxy intercepts requests from your music client and:
-1. Forwards library requests to your configured backend (Jellyfin or Subsonic)
-2. Merges results with content from your music provider
-3. Downloads and caches external tracks on-demand
-4. Serves audio streams transparently
-
-**Note**: Only the controller matching your configured `BACKEND_TYPE` is registered at runtime, preventing route conflicts and ensuring clean API separation.
-||||||| f68706f
-## Advanced Configuration
-
-### Backend Selection
-
-| Setting | Description |
-|---------|-------------|
-| `Backend:Type` | Backend type: `Subsonic` or `Jellyfin` (default: `Subsonic`) |
-
-### Jellyfin Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Jellyfin:Url` | URL of your Jellyfin server |
-| `Jellyfin:ApiKey` | API key (get from Jellyfin Dashboard > API Keys) |
-| `Jellyfin:UserId` | User ID for library access |
-| `Jellyfin:LibraryId` | Music library ID (optional, auto-detected) |
-| `Jellyfin:MusicService` | Music provider: `SquidWTF`, `Deezer`, or `Qobuz` |
-
-### Subsonic Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Subsonic:Url` | URL of your Navidrome/Subsonic server |
-| `Subsonic:MusicService` | Music provider: `SquidWTF`, `Deezer`, or `Qobuz` (default: `SquidWTF`) |
-
-### Shared Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Library:DownloadPath` | Directory where downloaded songs are stored |
-| `*:ExplicitFilter` | Content filter: `All`, `ExplicitOnly`, or `CleanOnly` |
-| `*:DownloadMode` | Download mode: `Track` or `Album` |
-| `*:StorageMode` | Storage mode: `Permanent` or `Cache` |
-| `*:CacheDurationHours` | Cache expiration time in hours |
-| `*:EnableExternalPlaylists` | Enable external playlist support |
-
-### SquidWTF Settings
-
-| Setting | Description |
-|---------|-------------|
-| `SquidWTF:Quality` | Preferred audio quality: `FLAC`, `MP3_320`, `MP3_128`. If not specified, the highest available quality for your account will be used |
-
-**Load Balancing & Reliability:**
-
-SquidWTF uses a round-robin load balancing strategy across multiple backup API endpoints to distribute requests evenly and prevent overwhelming any single provider. Each request automatically rotates to the next endpoint in the pool, with automatic fallback to other endpoints if one fails. This ensures high availability and prevents rate limiting by distributing load across multiple providers.
-
-### Deezer Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Deezer:Arl` | Your Deezer ARL token (required if using Deezer) |
-| `Deezer:ArlFallback` | Backup ARL token if primary fails |
-| `Deezer:Quality` | Preferred audio quality: `FLAC`, `MP3_320`, `MP3_128`. If not specified, the highest available quality for your account will be used |
-
-### Qobuz Settings
-
-| Setting | Description |
-|---------|-------------|
-| `Qobuz:UserAuthToken` | Your Qobuz User Auth Token (required if using Qobuz) - [How to get it](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)) |
-| `Qobuz:UserId` | Your Qobuz User ID (required if using Qobuz) |
-| `Qobuz:Quality` | Preferred audio quality: `FLAC`, `FLAC_24_HIGH`, `FLAC_24_LOW`, `FLAC_16`, `MP3_320`. If not specified, the highest available quality will be used |
-
-### External Playlists
-
-Allstarr supports discovering and downloading playlists from your streaming providers (SquidWTF, Deezer, and Qobuz).
-
-| Setting | Description |
-|---------|-------------|
-| `Subsonic:EnableExternalPlaylists` | Enable/disable external playlist support (default: `true`) |
-| `Subsonic:PlaylistsDirectory` | Directory name where M3U playlist files are created (default: `playlists`) |
-
-**How it works:**
-1. Search for playlists from an external provider using the global search in your Subsonic client
-2. When you "star" (favorite) a playlist, Allstarr automatically downloads all tracks
-3. An M3U playlist file is created in `{DownloadPath}/playlists/` with relative paths to downloaded tracks
-4. Individual tracks are added to the M3U as they are played or downloaded
-
-**Environment variable:**
-```bash
-# To disable playlists
-Subsonic__EnableExternalPlaylists=false
-```
-
-> **Note**: Due to client-side filtering, playlists from streaming providers may not appear in the "Playlists" tab of some clients, but will show up in global search results.
-
-### Spotify Playlist Injection (Jellyfin Only)
-
-Allstarr automatically fills your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service.
-
-#### Prerequisites
-
-1. **Install the Jellyfin Spotify Import Plugin**
-   - Navigate to Jellyfin Dashboard → Plugins → Catalog
-   - Search for "Spotify Import" by Viperinius
-   - Install and restart Jellyfin
-   - Plugin repository: [Viperinius/jellyfin-plugin-spotify-import](https://github.com/Viperinius/jellyfin-plugin-spotify-import)
-
-2. **Configure the Spotify Import Plugin**
-   - Go to Jellyfin Dashboard → Plugins → Spotify Import
-   - Connect your Spotify account
-   - Select which playlists to sync (e.g., Release Radar, Discover Weekly)
-   - Set a sync schedule (the plugin will create playlists in Jellyfin)
-
-3. **Configure Allstarr**
-   - Enable Spotify Import in Allstarr (see configuration below)
-   - Link your Jellyfin playlists to Spotify playlists via the Web UI
-   - Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
-
-#### Configuration
-
-| Setting | Description |
-|---------|-------------|
-| `SpotifyImport:Enabled` | Enable Spotify playlist injection (default: `false`) |
-| `SpotifyImport:MatchingIntervalHours` | How often to run track matching in hours (default: 24, set to 0 for startup only) |
-| `SpotifyImport:Playlists` | JSON array of playlists (managed via Web UI) |
-
-**Environment variables example:**
-```bash
-# Enable the feature
-SPOTIFY_IMPORT_ENABLED=true
-
-# Matching interval (24 hours = once per day)
-SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS=24
-
-# Playlists (use Web UI to manage instead of editing manually)
-SPOTIFY_IMPORT_PLAYLISTS=[["Discover Weekly","37i9dQZEVXcV6s7Dm7RXsU","first"],["Release Radar","37i9dQZEVXbng2vDHnfQlC","first"]]
-```
-
-#### How It Works
-
-1. **Spotify Import Plugin Runs**
-   - Plugin fetches your Spotify playlists
-   - Creates/updates playlists in Jellyfin with tracks already in your library
-   - Generates "missing tracks" JSON files for songs not found locally
-
-2. **Allstarr Matches Tracks** (on startup + every 24 hours by default)
-   - Reads missing tracks files from the Jellyfin plugin
-   - For each missing track, searches your streaming provider (SquidWTF, Deezer, or Qobuz)
-   - Uses fuzzy matching to find the best match (title + artist similarity)
-   - Rate-limited to avoid overwhelming the service (150ms delay between searches)
-   - Pre-builds playlist cache for instant loading
-
-3. **You Open the Playlist in Jellyfin**
-   - Allstarr intercepts the request
-   - Returns a merged list: local tracks + matched streaming tracks
-   - Loads instantly from cache!
-
-4. **You Play a Track**
-   - Local tracks stream from Jellyfin normally
-   - Matched tracks download from streaming provider on-demand
-   - Downloaded tracks are saved to your library for future use
-
-#### Manual API Triggers
-
-You can manually trigger operations via the admin API:
-
-```bash
-# Get API key from your .env file
-API_KEY="your-api-key-here"
-
-# Fetch missing tracks from Jellyfin plugin
-curl "http://localhost:5274/spotify/sync?api_key=$API_KEY"
-
-# Trigger track matching (searches streaming provider)
-curl "http://localhost:5274/spotify/match?api_key=$API_KEY"
-
-# Match all playlists (refresh all matches)
-curl "http://localhost:5274/spotify/match-all?api_key=$API_KEY"
-
-# Clear cache and rebuild
-curl "http://localhost:5274/spotify/clear-cache?api_key=$API_KEY"
-
-# Refresh specific playlist
-curl "http://localhost:5274/spotify/refresh-playlist?playlistId=PLAYLIST_ID&api_key=$API_KEY"
-```
-
-#### Web UI Management
-
-The easiest way to manage Spotify playlists is through the Web UI at `http://localhost:5275`:
-
-1. **Link Playlists Tab**: Link Jellyfin playlists to Spotify playlists
-2. **Active Playlists Tab**: View status, trigger matching, and manage playlists
-3. **Configuration Tab**: Enable/disable Spotify Import and adjust settings
-
-#### Troubleshooting
-
-**Playlists are empty:**
- Check that the Spotify Import plugin is running and creating playlists
- Verify playlists are linked in the Web UI
- Check logs: `docker-compose logs -f allstarr | grep -i spotify`
-
-**Tracks aren't matching:**
- Ensure your streaming provider is configured (`MUSIC_SERVICE`, credentials)
- Manually trigger matching via Web UI or API
- Check that the Jellyfin plugin generated missing tracks files
-
-**Performance:**
- Matching runs in background with rate limiting (150ms between searches)
- First match may take a few minutes for large playlists
- Subsequent loads are instant (served from cache)
-
-#### Notes
-
- Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
- Matched tracks cached for fast loading
- Missing tracks cache persists across restarts (Redis + file cache)
- Rate limiting prevents overwhelming your streaming provider
- Only works with Jellyfin backend (not Subsonic/Navidrome)
-
-### Getting Credentials
-
-#### Deezer ARL Token
-
-See the [Wiki guide](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Deezer-Credentials-(ARL-Token)) for detailed instructions on obtaining your Deezer ARL token.
-
-#### Qobuz Credentials
-
-See the [Wiki guide](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)) for detailed instructions on obtaining your Qobuz User ID and User Auth Token.
-
-## Limitations
-
- **Playlist Search**: Subsonic clients like Aonsoku filter playlists client-side from a cached `getPlaylists` call. Streaming provider playlists appear in global search (`search3`) but not in the Playlists tab filter.
- **Region Restrictions**: Some tracks may be unavailable depending on your region and provider.
- **Token Expiration**: Provider authentication tokens expire and need periodic refresh.
-
-## Architecture
-
-```
-                                                    ┌─────────────────┐
-                                               ┌───▶│    Jellyfin     │
-┌─────────────────┐     ┌──────────────────┐   │    │    Server       │
-│  Music Client   │────▶│     Allstarr     │───┤    └─────────────────┘
-│  (Aonsoku,      │◀────│   (Proxy)        │◀──┤
-│   Finamp, etc.) │     │                  │   │    ┌─────────────────┐
-└─────────────────┘     └────────┬─────────┘   └───▶│   Navidrome     │
-                                 │                  │   (Subsonic)    │
-                                 ▼                  └─────────────────┘
-                        ┌─────────────────┐
-                        │ Music Providers │
-                        │  - SquidWTF     │
-                        │  - Deezer       │
-                        │  - Qobuz        │
-                        └─────────────────┘
-```
-
-The proxy intercepts requests from your music client and:
-1. Forwards library requests to your configured backend (Jellyfin or Subsonic)
-2. Merges results with content from your music provider
-3. Downloads and caches external tracks on-demand
-4. Serves audio streams transparently
-
-**Note**: Only the controller matching your configured `BACKEND_TYPE` is registered at runtime, preventing route conflicts and ensuring clean API separation.
-=======
 For detailed configuration options, see [CONFIGURATION.md](CONFIGURATION.md).
->>>>>>> beta

 ## Manual Installation

@@ -41,13 +41,7 @@ public class JellyfinProxyServiceTests
            ClientName = "TestClient",
            DeviceName = "TestDevice",
            DeviceId = "test-device-id",
-<<<<<<< HEAD
-            ClientVersion = "1.0.1"
-||||||| f68706f
-            ClientVersion = "1.0.0"
-=======
            ClientVersion = "1.0.3"
->>>>>>> beta
        };

        var httpContext = new DefaultHttpContext();
@@ -151,13 +151,7 @@ public class QobuzDownloadServiceTests : IDisposable
        var mockResponse = new HttpResponseMessage
        {
            StatusCode = HttpStatusCode.OK,
-<<<<<<< HEAD
-            Content = new StringContent(@"<html><script src=""/resources/1.0.1-b001/bundle.js""></script></html>")
-||||||| f68706f
-            Content = new StringContent(@"<html><script src=""/resources/1.0.0-b001/bundle.js""></script></html>")
-=======
            Content = new StringContent(@"<html><script src=""/resources/1.0.3-b001/bundle.js""></script></html>")
->>>>>>> beta
        };
        
        _httpMessageHandlerMock.Protected()
@@ -1,348 +1,3 @@
-<<<<<<< HEAD
-using Xunit;
-using Moq;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using allstarr.Services.SquidWTF;
-using allstarr.Services.Common;
-using allstarr.Models.Settings;
-using System.Collections.Generic;
-
-namespace allstarr.Tests;
-
-public class SquidWTFMetadataServiceTests
-{
-    private readonly Mock<ILogger<SquidWTFMetadataService>> _mockLogger;
-    private readonly Mock<IHttpClientFactory> _mockHttpClientFactory;
-    private readonly IOptions<SubsonicSettings> _subsonicSettings;
-    private readonly IOptions<SquidWTFSettings> _squidwtfSettings;
-    private readonly Mock<RedisCacheService> _mockCache;
-    private readonly List<string> _apiUrls;
-
-    public SquidWTFMetadataServiceTests()
-    {
-        _mockLogger = new Mock<ILogger<SquidWTFMetadataService>>();
-        _mockHttpClientFactory = new Mock<IHttpClientFactory>();
-        
-        _subsonicSettings = Options.Create(new SubsonicSettings
-        {
-            ExplicitFilter = ExplicitFilter.All
-        });
-        
-        _squidwtfSettings = Options.Create(new SquidWTFSettings
-        {
-            Quality = "FLAC"
-        });
-        
-        // Create mock Redis cache
-        var mockRedisLogger = new Mock<ILogger<RedisCacheService>>();
-        var mockRedisSettings = Options.Create(new RedisSettings { Enabled = false });
-        _mockCache = new Mock<RedisCacheService>(mockRedisSettings, mockRedisLogger.Object);
-        
-        _apiUrls = new List<string> 
-        { 
-            "https://squid.wtf",
-            "https://mirror1.squid.wtf",
-            "https://mirror2.squid.wtf"
-        };
-        
-        var httpClient = new System.Net.Http.HttpClient();
-        _mockHttpClientFactory.Setup(f => f.CreateClient(It.IsAny<string>())).Returns(httpClient);
-    }
-
-    [Fact]
-    public void Constructor_InitializesWithDependencies()
-    {
-        // Act
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Assert
-        Assert.NotNull(service);
-    }
-
-    [Fact]
-    public void Constructor_AcceptsOptionalGenreEnrichment()
-    {
-        // Arrange - GenreEnrichmentService is optional, just pass null
-
-        // Act
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls,
-            null); // GenreEnrichmentService is optional
-
-        // Assert
-        Assert.NotNull(service);
-    }
-
-    [Fact]
-    public void SearchSongsAsync_AcceptsQueryAndLimit()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.SearchSongsAsync("Mr. Brightside", 20);
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void SearchAlbumsAsync_AcceptsQueryAndLimit()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.SearchAlbumsAsync("Hot Fuss", 20);
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void SearchArtistsAsync_AcceptsQueryAndLimit()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.SearchArtistsAsync("The Killers", 20);
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void SearchPlaylistsAsync_AcceptsQueryAndLimit()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.SearchPlaylistsAsync("Rock Classics", 20);
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetSongAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetSongAsync("squidwtf", "123456");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetAlbumAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetAlbumAsync("squidwtf", "789012");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetArtistAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetArtistAsync("squidwtf", "345678");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetArtistAlbumsAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetArtistAlbumsAsync("squidwtf", "345678");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetPlaylistAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetPlaylistAsync("squidwtf", "playlist123");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void GetPlaylistTracksAsync_RequiresProviderAndId()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.GetPlaylistTracksAsync("squidwtf", "playlist123");
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void SearchAllAsync_CombinesAllSearchTypes()
-    {
-        // Arrange
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Act
-        var result = service.SearchAllAsync("The Killers", 20, 20, 20);
-
-        // Assert
-        Assert.NotNull(result);
-    }
-
-    [Fact]
-    public void ExplicitFilter_RespectsSettings()
-    {
-        // Arrange - Test with CleanOnly filter
-        var cleanOnlySettings = Options.Create(new SubsonicSettings
-        {
-            ExplicitFilter = ExplicitFilter.CleanOnly
-        });
-
-        // Act
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            cleanOnlySettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            _apiUrls);
-
-        // Assert
-        Assert.NotNull(service);
-    }
-
-    [Fact]
-    public void MultipleApiUrls_EnablesRoundRobinFallback()
-    {
-        // Arrange
-        var multipleUrls = new List<string>
-        {
-            "https://primary.squid.wtf",
-            "https://backup1.squid.wtf",
-            "https://backup2.squid.wtf",
-            "https://backup3.squid.wtf"
-        };
-
-        // Act
-        var service = new SquidWTFMetadataService(
-            _mockHttpClientFactory.Object,
-            _subsonicSettings,
-            _squidwtfSettings,
-            _mockLogger.Object,
-            _mockCache.Object,
-            multipleUrls);
-
-        // Assert
-        Assert.NotNull(service);
-    }
-}
-||||||| f68706f
-=======
 using Xunit;
 using Moq;
 using Microsoft.Extensions.Logging;
@@ -685,4 +340,3 @@ public class SquidWTFMetadataServiceTests
        Assert.NotNull(service);
    }
 }
->>>>>>> beta
@@ -9,5 +9,5 @@ public static class AppVersion
    /// <summary>
    /// Current application version.
    /// </summary>
-    public const string Version = "1.1.1";
+    public const string Version = "1.1.3";
 }
@@ -24,4896 +24,6 @@ public class AdminController : ControllerBase
    public AdminController(ILogger<AdminController> logger)
    {
        _logger = logger;
-<<<<<<< HEAD
-        _configuration = configuration;
-        _environment = environment;
-        _spotifyApiSettings = spotifyApiSettings.Value;
-        _spotifyImportSettings = spotifyImportSettings.Value;
-        _jellyfinSettings = jellyfinSettings.Value;
-        _subsonicSettings = subsonicSettings.Value;
-        _deezerSettings = deezerSettings.Value;
-        _qobuzSettings = qobuzSettings.Value;
-        _squidWtfSettings = squidWtfSettings.Value;
-        _musicBrainzSettings = musicBrainzSettings.Value;
-        _spotifyClient = spotifyClient;
-        _playlistFetcher = playlistFetcher;
-        _matchingService = matchingService;
-        _cache = cache;
-        _jellyfinHttpClient = httpClientFactory.CreateClient();
-        _serviceProvider = serviceProvider;
-        
-        // Decode SquidWTF base URLs
-        _squidWtfApiUrls = DecodeSquidWtfUrls();
-        
-        // .env file path is always /app/.env in Docker (mounted from host)
-        // In development, it's in the parent directory of ContentRootPath
-        _envFilePath = _environment.IsDevelopment() 
-            ? Path.Combine(_environment.ContentRootPath, "..", ".env")
-            : "/app/.env";
-    }
-    
-    private static List<string> DecodeSquidWtfUrls()
-    {
-        var encodedUrls = new[]
-        {
-            "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",                      // triton
-            "aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=",              // binimum
-            "aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=",              // kinoplus
-            "aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==",          // spoti-2
-            "aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==",          // spoti-1
-            "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",                      // wolf
-            "aHR0cDovL2h1bmQucXFkbC5zaXRl",                          // hund
-            "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=",                      // katze
-            "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",                      // vogel
-            "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ=="                       // maus
-        };
-        
-        return encodedUrls
-            .Select(encoded => System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encoded)))
-            .ToList();
-    }
-    
-    /// <summary>
-    /// Helper method to safely check if a dynamic cache result has a value
-    /// Handles the case where JsonElement cannot be compared to null directly
-    /// </summary>
-    private static bool HasValue(object? obj)
-    {
-        if (obj == null) return false;
-        if (obj is JsonElement jsonEl) return jsonEl.ValueKind != JsonValueKind.Null && jsonEl.ValueKind != JsonValueKind.Undefined;
-        return true;
-    }
-    
-    /// <summary>
-    /// Get current system status and configuration
-    /// </summary>
-    [HttpGet("status")]
-    public IActionResult GetStatus()
-    {
-        // Determine Spotify auth status based on configuration only
-        // DO NOT call Spotify API here - this endpoint is polled frequently
-        var spotifyAuthStatus = "not_configured";
-        string? spotifyUser = null;
-        
-        if (_spotifyApiSettings.Enabled && !string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie))
-        {
-            // If cookie is set, assume it's working until proven otherwise
-            // Actual validation happens when playlists are fetched
-            spotifyAuthStatus = "configured";
-            spotifyUser = "(cookie set)";
-        }
-        else if (_spotifyApiSettings.Enabled)
-        {
-            spotifyAuthStatus = "missing_cookie";
-        }
-        
-        return Ok(new
-        {
-            version = "1.0.1",
-            backendType = _configuration.GetValue<string>("Backend:Type") ?? "Jellyfin",
-            jellyfinUrl = _jellyfinSettings.Url,
-            spotify = new
-            {
-                apiEnabled = _spotifyApiSettings.Enabled,
-                authStatus = spotifyAuthStatus,
-                user = spotifyUser,
-                hasCookie = !string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie),
-                cookieSetDate = _spotifyApiSettings.SessionCookieSetDate,
-                cacheDurationMinutes = _spotifyApiSettings.CacheDurationMinutes,
-                preferIsrcMatching = _spotifyApiSettings.PreferIsrcMatching
-            },
-            spotifyImport = new
-            {
-                enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
-                playlistCount = _spotifyImportSettings.Playlists.Count
-            },
-            deezer = new
-            {
-                hasArl = !string.IsNullOrEmpty(_deezerSettings.Arl),
-                quality = _deezerSettings.Quality ?? "FLAC"
-            },
-            qobuz = new
-            {
-                hasToken = !string.IsNullOrEmpty(_qobuzSettings.UserAuthToken),
-                quality = _qobuzSettings.Quality ?? "FLAC"
-            },
-            squidWtf = new
-            {
-                quality = _squidWtfSettings.Quality ?? "LOSSLESS"
-            }
-        });
-    }
-    
-    /// <summary>
-    /// Get a random SquidWTF base URL for searching (round-robin)
-    /// </summary>
-    [HttpGet("squidwtf-base-url")]
-    public IActionResult GetSquidWtfBaseUrl()
-    {
-        if (_squidWtfApiUrls.Count == 0)
-        {
-            return NotFound(new { error = "No SquidWTF base URLs configured" });
-        }
-        
-        string baseUrl;
-        lock (_urlIndexLock)
-        {
-            baseUrl = _squidWtfApiUrls[_urlIndex];
-            _urlIndex = (_urlIndex + 1) % _squidWtfApiUrls.Count;
-        }
-        
-        return Ok(new { baseUrl });
-    }
-    
-    /// <summary>
-    /// Get current configuration including cache settings
-    /// </summary>
-    
-    /// <summary>
-    /// Get list of configured playlists with their current data
-    /// </summary>
-    [HttpGet("playlists")]
-    public async Task<IActionResult> GetPlaylists([FromQuery] bool refresh = false)
-    {
-        var playlistCacheFile = "/app/cache/admin_playlists_summary.json";
-        
-        // Check file cache first (5 minute TTL) unless refresh is requested
-        if (!refresh && System.IO.File.Exists(playlistCacheFile))
-        {
-            try
-            {
-                var fileInfo = new FileInfo(playlistCacheFile);
-                var age = DateTime.UtcNow - fileInfo.LastWriteTimeUtc;
-                
-                if (age.TotalMinutes < 5)
-                {
-                    var cachedJson = await System.IO.File.ReadAllTextAsync(playlistCacheFile);
-                    var cachedData = JsonSerializer.Deserialize<Dictionary<string, object>>(cachedJson);
-                    _logger.LogDebug("📦 Returning cached playlist summary (age: {Age:F1}m)", age.TotalMinutes);
-                    return Ok(cachedData);
-                }
-                else
-                {
-                    _logger.LogWarning("🔄 Cache expired (age: {Age:F1}m), refreshing...", age.TotalMinutes);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to read cached playlist summary");
-            }
-        }
-        else if (refresh)
-        {
-            _logger.LogDebug("🔄 Force refresh requested for playlist summary");
-        }
-        
-        var playlists = new List<object>();
-        
-        // Read playlists directly from .env file to get the latest configuration
-        // (IOptions is cached and doesn't reload after .env changes)
-        var configuredPlaylists = await ReadPlaylistsFromEnvFile();
-        
-        foreach (var config in configuredPlaylists)
-        {
-            var playlistInfo = new Dictionary<string, object?>
-            {
-                ["name"] = config.Name,
-                ["id"] = config.Id,
-                ["jellyfinId"] = config.JellyfinId,
-                ["localTracksPosition"] = config.LocalTracksPosition.ToString(),
-                ["syncSchedule"] = config.SyncSchedule ?? "0 8 * * 1",
-                ["trackCount"] = 0,
-                ["localTracks"] = 0,
-                ["externalTracks"] = 0,
-                ["lastFetched"] = null as DateTime?,
-                ["cacheAge"] = null as string
-            };
-            
-            // Get Spotify playlist track count from cache
-            var cacheFilePath = Path.Combine(CacheDirectory, $"{SanitizeFileName(config.Name)}_spotify.json");
-            int spotifyTrackCount = 0;
-            
-            if (System.IO.File.Exists(cacheFilePath))
-            {
-                try
-                {
-                    var json = await System.IO.File.ReadAllTextAsync(cacheFilePath);
-                    using var doc = JsonDocument.Parse(json);
-                    var root = doc.RootElement;
-                    
-                    if (root.TryGetProperty("tracks", out var tracks))
-                    {
-                        spotifyTrackCount = tracks.GetArrayLength();
-                        playlistInfo["trackCount"] = spotifyTrackCount;
-                    }
-                    
-                    if (root.TryGetProperty("fetchedAt", out var fetchedAt))
-                    {
-                        var fetchedTime = fetchedAt.GetDateTime();
-                        playlistInfo["lastFetched"] = fetchedTime;
-                        var age = DateTime.UtcNow - fetchedTime;
-                        playlistInfo["cacheAge"] = age.TotalHours < 1 
-                            ? $"{age.TotalMinutes:F0}m" 
-                            : $"{age.TotalHours:F1}h";
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to read cache for playlist {Name}", config.Name);
-                }
-            }
-            
-            // Get current Jellyfin playlist track count
-            if (!string.IsNullOrEmpty(config.JellyfinId))
-            {
-                try
-                {
-                    // Jellyfin requires UserId parameter to fetch playlist items
-                    var userId = _jellyfinSettings.UserId;
-                    
-                    // If no user configured, try to get the first user
-                    if (string.IsNullOrEmpty(userId))
-                    {
-                        var usersResponse = await _jellyfinHttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, $"{_jellyfinSettings.Url}/Users")
-                        {
-                            Headers = { { "X-Emby-Authorization", GetJellyfinAuthHeader() } }
-                        });
-                        
-                        if (usersResponse.IsSuccessStatusCode)
-                        {
-                            var usersJson = await usersResponse.Content.ReadAsStringAsync();
-                            using var usersDoc = JsonDocument.Parse(usersJson);
-                            if (usersDoc.RootElement.GetArrayLength() > 0)
-                            {
-                                userId = usersDoc.RootElement[0].GetProperty("Id").GetString();
-                            }
-                        }
-                    }
-                    
-                    if (string.IsNullOrEmpty(userId))
-                    {
-                        _logger.LogWarning("No user ID available to fetch playlist items for {Name}", config.Name);
-                    }
-                    else
-                    {
-                        var url = $"{_jellyfinSettings.Url}/Playlists/{config.JellyfinId}/Items?UserId={userId}&Fields=Path";
-                        var request = new HttpRequestMessage(HttpMethod.Get, url);
-                        request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-                        
-                        _logger.LogDebug("Fetching Jellyfin playlist items for {Name} from {Url}", config.Name, url);
-                        
-                        var response = await _jellyfinHttpClient.SendAsync(request);
-                        if (response.IsSuccessStatusCode)
-                        {
-                            var jellyfinJson = await response.Content.ReadAsStringAsync();
-                            using var jellyfinDoc = JsonDocument.Parse(jellyfinJson);
-                            
-                            if (jellyfinDoc.RootElement.TryGetProperty("Items", out var items))
-                            {
-                                // Get Spotify tracks to match against
-                                var spotifyTracks = await _playlistFetcher.GetPlaylistTracksAsync(config.Name);
-                                
-                                // Try to use the pre-built playlist cache first (includes manual mappings!)
-                                var playlistItemsCacheKey = $"spotify:playlist:items:{config.Name}";
-                                
-                                List<Dictionary<string, object?>>? cachedPlaylistItems = null;
-                                try
-                                {
-                                    cachedPlaylistItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(playlistItemsCacheKey);
-                                }
-                                catch (Exception cacheEx)
-                                {
-                                    _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", config.Name);
-                                }
-                                
-                                _logger.LogDebug("Checking cache for {Playlist}: {CacheKey}, Found: {Found}, Count: {Count}", 
-                                    config.Name, playlistItemsCacheKey, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0);
-                                
-                                if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0)
-                                {
-                                    // Use the pre-built cache which respects manual mappings
-                                    var localCount = 0;
-                                    var externalCount = 0;
-                                    
-                                    foreach (var item in cachedPlaylistItems)
-                                    {
-                                        // Check if it's external by looking for external provider in ProviderIds
-                                        // External providers: SquidWTF, Deezer, Qobuz, Tidal
-                                        // Local tracks: Have Jellyfin ID OR no external provider keys
-                                        var isExternal = false;
-                                        
-                                        if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                                        {
-                                            // Handle both Dictionary<string, string> and JsonElement
-                                            Dictionary<string, string>? providerIds = null;
-                                            
-                                            if (providerIdsObj is Dictionary<string, string> dict)
-                                            {
-                                                providerIds = dict;
-                                            }
-                                            else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                                            {
-                                                providerIds = new Dictionary<string, string>();
-                                                foreach (var prop in jsonEl.EnumerateObject())
-                                                {
-                                                    providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                                                }
-                                            }
-                                            
-                                            if (providerIds != null)
-                                            {
-                                                // Check for external provider keys (not MusicBrainz, ISRC, Spotify, Jellyfin, etc)
-                                                isExternal = providerIds.Keys.Any(k => 
-                                                    k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Deezer", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Qobuz", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Tidal", StringComparison.OrdinalIgnoreCase));
-                                            }
-                                        }
-                                        
-                                        if (isExternal)
-                                        {
-                                            externalCount++;
-                                        }
-                                        else
-                                        {
-                                            // Local track (has Jellyfin ID or no external provider)
-                                            localCount++;
-                                        }
-                                    }
-                                    
-                                    var externalMissingCount = spotifyTracks.Count - cachedPlaylistItems.Count;
-                                    if (externalMissingCount < 0) externalMissingCount = 0;
-                                    
-                                    playlistInfo["localTracks"] = localCount;
-                                    playlistInfo["externalMatched"] = externalCount;
-                                    playlistInfo["externalMissing"] = externalMissingCount;
-                                    playlistInfo["externalTotal"] = externalCount + externalMissingCount;
-                                    playlistInfo["totalInJellyfin"] = cachedPlaylistItems.Count;
-                                    playlistInfo["totalPlayable"] = localCount + externalCount; // Total tracks that will be served
-                                    
-                                    _logger.LogDebug("Playlist {Name} (from cache): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", 
-                                        config.Name, spotifyTracks.Count, localCount, externalCount, externalMissingCount, localCount + externalCount);
-                                }
-                                else
-                                {
-                                    // Fallback: Build list of local tracks from Jellyfin (match by name only)
-                                    var localTracks = new List<(string Title, string Artist)>();
-                                    foreach (var item in items.EnumerateArray())
-                                    {
-                                        var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() ?? "" : "";
-                                        var artist = "";
-                                        
-                                        if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-                                        {
-                                            artist = artistsEl[0].GetString() ?? "";
-                                        }
-                                        else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-                                        {
-                                            artist = albumArtistEl.GetString() ?? "";
-                                        }
-                                        
-                                        if (!string.IsNullOrEmpty(title))
-                                        {
-                                            localTracks.Add((title, artist));
-                                        }
-                                    }
-                                    
-                                    // Get matched external tracks cache once
-                                    var matchedTracksKey = $"spotify:matched:ordered:{config.Name}";
-                                    var matchedTracks = await _cache.GetAsync<List<MatchedTrack>>(matchedTracksKey);
-                                    var matchedSpotifyIds = new HashSet<string>(
-                                        matchedTracks?.Select(m => m.SpotifyId) ?? Enumerable.Empty<string>()
-                                    );
-                                    
-                                    var localCount = 0;
-                                    var externalMatchedCount = 0;
-                                    var externalMissingCount = 0;
-                                    
-                                    // Match each Spotify track to determine if it's local, external, or missing
-                                    foreach (var track in spotifyTracks)
-                                    {
-                                        var isLocal = false;
-                                        var hasExternalMapping = false;
-                                        
-                                        // FIRST: Check for manual Jellyfin mapping
-                                        var manualMappingKey = $"spotify:manual-map:{config.Name}:{track.SpotifyId}";
-                                        var manualJellyfinId = await _cache.GetAsync<string>(manualMappingKey);
-                                        
-                                        if (!string.IsNullOrEmpty(manualJellyfinId))
-                                        {
-                                            // Manual Jellyfin mapping exists - this track is definitely local
-                                            isLocal = true;
-                                        }
-                                        else
-                                        {
-                                            // Check for external manual mapping
-                                            var externalMappingKey = $"spotify:external-map:{config.Name}:{track.SpotifyId}";
-                                            var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                                            
-                                            if (!string.IsNullOrEmpty(externalMappingJson))
-                                            {
-                                                // External manual mapping exists
-                                                hasExternalMapping = true;
-                                            }
-                                            else if (localTracks.Count > 0)
-                                            {
-                                                // SECOND: No manual mapping, try fuzzy matching with local tracks
-                                                var bestMatch = localTracks
-                                                    .Select(local => new
-                                                    {
-                                                        Local = local,
-                                                        TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, local.Title),
-                                                        ArtistScore = FuzzyMatcher.CalculateSimilarity(track.PrimaryArtist, local.Artist)
-                                                    })
-                                                    .Select(x => new
-                                                    {
-                                                        x.Local,
-                                                        x.TitleScore,
-                                                        x.ArtistScore,
-                                                        TotalScore = (x.TitleScore * 0.7) + (x.ArtistScore * 0.3)
-                                                    })
-                                                    .OrderByDescending(x => x.TotalScore)
-                                                    .FirstOrDefault();
-                                                
-                                                // Use 70% threshold (same as playback matching)
-                                                if (bestMatch != null && bestMatch.TotalScore >= 70)
-                                                {
-                                                    isLocal = true;
-                                                }
-                                            }
-                                        }
-                                        
-                                        if (isLocal)
-                                        {
-                                            localCount++;
-                                        }
-                                        else
-                                        {
-                                            // Check if external track is matched (either manual mapping or auto-matched)
-                                            if (hasExternalMapping || matchedSpotifyIds.Contains(track.SpotifyId))
-                                            {
-                                                externalMatchedCount++;
-                                            }
-                                            else
-                                            {
-                                                externalMissingCount++;
-                                            }
-                                        }
-                                    }
-                                    
-                                    playlistInfo["localTracks"] = localCount;
-                                    playlistInfo["externalMatched"] = externalMatchedCount;
-                                    playlistInfo["externalMissing"] = externalMissingCount;
-                                    playlistInfo["externalTotal"] = externalMatchedCount + externalMissingCount;
-                                    playlistInfo["totalInJellyfin"] = localCount + externalMatchedCount;
-                                    playlistInfo["totalPlayable"] = localCount + externalMatchedCount; // Total tracks that will be served
-                                    
-                                    _logger.LogWarning("Playlist {Name} (fallback): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", 
-                                        config.Name, spotifyTracks.Count, localCount, externalMatchedCount, externalMissingCount, localCount + externalMatchedCount);
-                                }
-                            }
-                            else
-                            {
-                                _logger.LogWarning("No Items property in Jellyfin response for {Name}", config.Name);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogError("Failed to get Jellyfin playlist {Name}: {StatusCode}", 
-                                config.Name, response.StatusCode);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to get Jellyfin playlist tracks for {Name}", config.Name);
-                }
-            }
-            else
-            {
-                _logger.LogInformation("Playlist {Name} has no JellyfinId configured", config.Name);
-            }
-            
-            playlists.Add(playlistInfo);
-        }
-        
-        // Save to file cache
-        try
-        {
-            var cacheDir = "/app/cache";
-            Directory.CreateDirectory(cacheDir);
-            var cacheFile = Path.Combine(cacheDir, "admin_playlists_summary.json");
-            
-            var response = new { playlists };
-            var json = JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = false });
-            await System.IO.File.WriteAllTextAsync(cacheFile, json);
-            
-            _logger.LogDebug("💾 Saved playlist summary to cache");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save playlist summary cache");
-        }
-        
-        return Ok(new { playlists });
-    }
-    
-    /// <summary>
-    /// Get tracks for a specific playlist with local/external status
-    /// </summary>
-    [HttpGet("playlists/{name}/tracks")]
-    public async Task<IActionResult> GetPlaylistTracks(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        // Get Spotify tracks
-        var spotifyTracks = await _playlistFetcher.GetPlaylistTracksAsync(decodedName);
-        
-        var tracksWithStatus = new List<object>();
-        
-        // Use the pre-built playlist cache (same as GetPlaylists endpoint)
-        // This cache includes all matched tracks with proper provider IDs
-        var playlistItemsCacheKey = $"spotify:playlist:items:{decodedName}";
-        
-        List<Dictionary<string, object?>>? cachedPlaylistItems = null;
-        try
-        {
-            cachedPlaylistItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(playlistItemsCacheKey);
-        }
-        catch (Exception cacheEx)
-        {
-            _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", decodedName);
-        }
-        
-        _logger.LogDebug("GetPlaylistTracks for {Playlist}: Cache found: {Found}, Count: {Count}", 
-            decodedName, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0);
-        
-        if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0)
-        {
-            // Build a map of Spotify ID -> cached item for quick lookup
-            var spotifyIdToItem = new Dictionary<string, Dictionary<string, object?>>();
-            
-            // Also track items by position for fallback matching
-            var itemsByPosition = new Dictionary<int, Dictionary<string, object?>>();
-            
-            for (int i = 0; i < cachedPlaylistItems.Count; i++)
-            {
-                var item = cachedPlaylistItems[i];
-                
-                // Try to get Spotify ID from ProviderIds (works for both local and external)
-                bool hasSpotifyId = false;
-                if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                {
-                    Dictionary<string, string>? providerIds = null;
-                    
-                    if (providerIdsObj is Dictionary<string, string> dict)
-                    {
-                        providerIds = dict;
-                    }
-                    else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                    {
-                        providerIds = new Dictionary<string, string>();
-                        foreach (var prop in jsonEl.EnumerateObject())
-                        {
-                            providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                        }
-                    }
-                    
-                    if (providerIds != null && providerIds.TryGetValue("Spotify", out var spotifyId) && !string.IsNullOrEmpty(spotifyId))
-                    {
-                        spotifyIdToItem[spotifyId] = item;
-                        hasSpotifyId = true;
-                    }
-                }
-                
-                // If no Spotify ID found, use position-based matching as fallback
-                if (!hasSpotifyId)
-                {
-                    itemsByPosition[i] = item;
-                }
-            }
-            
-            // Match each Spotify track to its cached item
-            foreach (var track in spotifyTracks)
-            {
-                bool? isLocal = null;
-                string? externalProvider = null;
-                bool isManualMapping = false;
-                string? manualMappingType = null;
-                string? manualMappingId = null;
-                
-                Dictionary<string, object?>? cachedItem = null;
-                
-                // First try to match by Spotify ID
-                if (spotifyIdToItem.TryGetValue(track.SpotifyId, out cachedItem))
-                {
-                    _logger.LogDebug("Matched track {Title} by Spotify ID", track.Title);
-                }
-                // Fallback: Try position-based matching for items without Spotify ID
-                else if (itemsByPosition.TryGetValue(track.Position, out cachedItem))
-                {
-                    _logger.LogDebug("Matched track {Title} by position {Position}", track.Title, track.Position);
-                }
-                
-                if (cachedItem != null)
-                {
-                    // Track is in the cache - determine if it's local or external
-                    if (cachedItem.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                    {
-                        Dictionary<string, string>? providerIds = null;
-                        
-                        if (providerIdsObj is Dictionary<string, string> dict)
-                        {
-                            providerIds = dict;
-                        }
-                        else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                        {
-                            providerIds = new Dictionary<string, string>();
-                            foreach (var prop in jsonEl.EnumerateObject())
-                            {
-                                providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                            }
-                        }
-                        
-                        if (providerIds != null)
-                        {
-                            _logger.LogDebug("Track {Title} has ProviderIds: {Keys}", track.Title, string.Join(", ", providerIds.Keys));
-                            
-                            // Check for external provider keys (SquidWTF, Deezer, Qobuz, Tidal)
-                            // If found, it's an external track
-                            if (providerIds.Keys.Any(k => 
-                                k.Equals("squidwtf", StringComparison.OrdinalIgnoreCase) ||
-                                k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase)))
-                            {
-                                isLocal = false;
-                                externalProvider = "SquidWTF";
-                                _logger.LogDebug("✓ Track {Title} identified as SquidWTF", track.Title);
-                            }
-                            else if (providerIds.Keys.Any(k => k.Equals("deezer", StringComparison.OrdinalIgnoreCase)))
-                            {
-                                isLocal = false;
-                                externalProvider = "Deezer";
-                                _logger.LogDebug("✓ Track {Title} identified as Deezer", track.Title);
-                            }
-                            else if (providerIds.Keys.Any(k => k.Equals("qobuz", StringComparison.OrdinalIgnoreCase)))
-                            {
-                                isLocal = false;
-                                externalProvider = "Qobuz";
-                                _logger.LogDebug("✓ Track {Title} identified as Qobuz", track.Title);
-                            }
-                            else if (providerIds.Keys.Any(k => k.Equals("tidal", StringComparison.OrdinalIgnoreCase)))
-                            {
-                                isLocal = false;
-                                externalProvider = "Tidal";
-                                _logger.LogDebug("✓ Track {Title} identified as Tidal", track.Title);
-                            }
-                            else
-                            {
-                                // No external provider key found - it's a local Jellyfin track
-                                // Local tracks may have: Jellyfin ID, MusicBrainz IDs, ISRC, etc.
-                                isLocal = true;
-                                _logger.LogDebug("✓ Track {Title} identified as LOCAL (has ProviderIds but no external provider)", track.Title);
-                            }
-                        }
-                        else
-                        {
-                            // ProviderIds exists but is null after parsing - treat as local
-                            isLocal = true;
-                            _logger.LogDebug("✓ Track {Title} identified as LOCAL (ProviderIds null)", track.Title);
-                        }
-                    }
-                    else
-                    {
-                        // Track is in cache but has NO ProviderIds property at all
-                        // This is typical for local Jellyfin tracks - treat as local
-                        isLocal = true;
-                        _logger.LogDebug("✓ Track {Title} identified as LOCAL (in cache, no ProviderIds)", track.Title);
-                    }
-                    
-                    // Check if this is a manual mapping
-                    var manualJellyfinKey = $"spotify:manual-map:{decodedName}:{track.SpotifyId}";
-                    var manualJellyfinId = await _cache.GetAsync<string>(manualJellyfinKey);
-                    
-                    if (!string.IsNullOrEmpty(manualJellyfinId))
-                    {
-                        isManualMapping = true;
-                        manualMappingType = "jellyfin";
-                        manualMappingId = manualJellyfinId;
-                    }
-                    else
-                    {
-                        var externalMappingKey = $"spotify:external-map:{decodedName}:{track.SpotifyId}";
-                        var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                        
-                        if (!string.IsNullOrEmpty(externalMappingJson))
-                        {
-                            try
-                            {
-                                using var extDoc = JsonDocument.Parse(externalMappingJson);
-                                var extRoot = extDoc.RootElement;
-                                
-                                if (extRoot.TryGetProperty("id", out var idEl))
-                                {
-                                    isManualMapping = true;
-                                    manualMappingType = "external";
-                                    manualMappingId = idEl.GetString();
-                                }
-                            }
-                            catch { }
-                        }
-                    }
-                }
-                else
-                {
-                    // Track not in cache - it's missing
-                    isLocal = null;
-                    externalProvider = null;
-                }
-                
-                // Check lyrics status
-                var cacheKey = $"lyrics:{track.PrimaryArtist}:{track.Title}:{track.Album}:{track.DurationMs / 1000}";
-                var existingLyrics = await _cache.GetStringAsync(cacheKey);
-                var hasLyrics = !string.IsNullOrEmpty(existingLyrics);
-                
-                tracksWithStatus.Add(new
-                {
-                    position = track.Position,
-                    title = track.Title,
-                    artists = track.Artists,
-                    album = track.Album,
-                    isrc = track.Isrc,
-                    spotifyId = track.SpotifyId,
-                    durationMs = track.DurationMs,
-                    albumArtUrl = track.AlbumArtUrl,
-                    isLocal = isLocal,
-                    externalProvider = externalProvider,
-                    searchQuery = isLocal != true ? $"{track.Title} {track.PrimaryArtist}" : null,
-                    isManualMapping = isManualMapping,
-                    manualMappingType = manualMappingType,
-                    manualMappingId = manualMappingId,
-                    hasLyrics = hasLyrics
-                });
-            }
-            
-            return Ok(new
-            {
-                name = decodedName,
-                trackCount = spotifyTracks.Count,
-                tracks = tracksWithStatus
-            });
-        }
-        
-        // Fallback: Cache not available, use matched tracks cache
-        _logger.LogWarning("Playlist cache not available for {Playlist}, using fallback", decodedName);
-        
-        var fallbackMatchedTracksKey = $"spotify:matched:ordered:{decodedName}";
-        var fallbackMatchedTracks = await _cache.GetAsync<List<MatchedTrack>>(fallbackMatchedTracksKey);
-        var fallbackMatchedSpotifyIds = new HashSet<string>(
-            fallbackMatchedTracks?.Select(m => m.SpotifyId) ?? Enumerable.Empty<string>()
-        );
-        
-        foreach (var track in spotifyTracks)
-        {
-            bool? isLocal = null;
-            string? externalProvider = null;
-            
-            // Check for manual Jellyfin mapping
-            var manualMappingKey = $"spotify:manual-map:{decodedName}:{track.SpotifyId}";
-            var manualJellyfinId = await _cache.GetAsync<string>(manualMappingKey);
-            
-            if (!string.IsNullOrEmpty(manualJellyfinId))
-            {
-                isLocal = true;
-            }
-            else
-            {
-                // Check for external manual mapping
-                var externalMappingKey = $"spotify:external-map:{decodedName}:{track.SpotifyId}";
-                var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                
-                if (!string.IsNullOrEmpty(externalMappingJson))
-                {
-                    try
-                    {
-                        using var extDoc = JsonDocument.Parse(externalMappingJson);
-                        var extRoot = extDoc.RootElement;
-                        
-                        string? provider = null;
-                        
-                        if (extRoot.TryGetProperty("provider", out var providerEl))
-                        {
-                            provider = providerEl.GetString();
-                        }
-                        
-                        if (!string.IsNullOrEmpty(provider))
-                        {
-                            isLocal = false;
-                            externalProvider = provider;
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to process external manual mapping for {Title}", track.Title);
-                    }
-                }
-                else if (fallbackMatchedSpotifyIds.Contains(track.SpotifyId))
-                {
-                    isLocal = false;
-                    externalProvider = "SquidWTF";
-                }
-                else
-                {
-                    isLocal = null;
-                    externalProvider = null;
-                }
-            }
-            
-            tracksWithStatus.Add(new
-            {
-                position = track.Position,
-                title = track.Title,
-                artists = track.Artists,
-                album = track.Album,
-                isrc = track.Isrc,
-                spotifyId = track.SpotifyId,
-                durationMs = track.DurationMs,
-                albumArtUrl = track.AlbumArtUrl,
-                isLocal = isLocal,
-                externalProvider = externalProvider,
-                searchQuery = isLocal != true ? $"{track.Title} {track.PrimaryArtist}" : null
-            });
-        }
-        
-        return Ok(new
-        {
-            name = decodedName,
-            trackCount = spotifyTracks.Count,
-            tracks = tracksWithStatus
-        });
-    }
-    
-    /// <summary>
-    /// Trigger a manual refresh of all playlists
-    /// </summary>
-    [HttpPost("playlists/refresh")]
-    public async Task<IActionResult> RefreshPlaylists()
-    {
-        _logger.LogInformation("Manual playlist refresh triggered from admin UI");
-        await _playlistFetcher.TriggerFetchAsync();
-        
-        // Invalidate playlist summary cache
-        InvalidatePlaylistSummaryCache();
-        
-        return Ok(new { message = "Playlist refresh triggered", timestamp = DateTime.UtcNow });
-    }
-    
-    /// <summary>
-    /// Re-match tracks when LOCAL library has changed (checks if Jellyfin playlist changed).
-    /// This is a lightweight operation that reuses cached Spotify data.
-    /// </summary>
-    [HttpPost("playlists/{name}/match")]
-    public async Task<IActionResult> MatchPlaylistTracks(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Re-match tracks triggered for playlist: {Name} (checking for local changes)", decodedName);
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            // Clear the Jellyfin playlist signature cache to force re-checking if local tracks changed
-            var jellyfinSignatureCacheKey = $"spotify:playlist:jellyfin-signature:{decodedName}";
-            await _cache.DeleteAsync(jellyfinSignatureCacheKey);
-            _logger.LogDebug("Cleared Jellyfin signature cache to force change detection");
-            
-            // Clear the matched results cache to force re-matching
-            var matchedTracksKey = $"spotify:matched:ordered:{decodedName}";
-            await _cache.DeleteAsync(matchedTracksKey);
-            _logger.LogDebug("Cleared matched tracks cache");
-            
-            // Clear the playlist items cache
-            var playlistItemsCacheKey = $"spotify:playlist:items:{decodedName}";
-            await _cache.DeleteAsync(playlistItemsCacheKey);
-            _logger.LogDebug("Cleared playlist items cache");
-            
-            // Trigger matching (will use cached Spotify data if still valid)
-            await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-            
-            // Invalidate playlist summary cache
-            InvalidatePlaylistSummaryCache();
-            
-            return Ok(new { 
-                message = $"Re-matching tracks for {decodedName} (checking local changes)", 
-                timestamp = DateTime.UtcNow 
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to trigger track matching for {Name}", decodedName);
-            return StatusCode(500, new { error = "Failed to trigger track matching", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Rebuild playlist from scratch when REMOTE (Spotify) playlist has changed.
-    /// Clears all caches including Spotify data and forces fresh fetch.
-    /// </summary>
-    [HttpPost("playlists/{name}/clear-cache")]
-    public async Task<IActionResult> ClearPlaylistCache(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Rebuild from scratch triggered for playlist: {Name} (clearing Spotify cache)", decodedName);
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            // Clear ALL cache keys for this playlist (including Spotify data)
-            var cacheKeys = new[]
-            {
-                $"spotify:playlist:items:{decodedName}",           // Pre-built items cache
-                $"spotify:matched:ordered:{decodedName}",          // Ordered matched tracks
-                $"spotify:matched:{decodedName}",                  // Legacy matched tracks
-                $"spotify:missing:{decodedName}",                  // Missing tracks
-                $"spotify:playlist:jellyfin-signature:{decodedName}", // Jellyfin signature
-                $"spotify:playlist:{decodedName}"                  // Spotify playlist data
-            };
-            
-            foreach (var key in cacheKeys)
-            {
-                await _cache.DeleteAsync(key);
-                _logger.LogDebug("Cleared cache key: {Key}", key);
-            }
-            
-            // Delete file caches
-            var safeName = string.Join("_", decodedName.Split(Path.GetInvalidFileNameChars()));
-            var filesToDelete = new[]
-            {
-                Path.Combine(CacheDirectory, $"{safeName}_items.json"),
-                Path.Combine(CacheDirectory, $"{safeName}_matched.json")
-            };
-            
-            foreach (var file in filesToDelete)
-            {
-                if (System.IO.File.Exists(file))
-                {
-                    System.IO.File.Delete(file);
-                    _logger.LogDebug("Deleted cache file: {File}", file);
-                }
-            }
-            
-            _logger.LogInformation("✓ Cleared all caches for playlist: {Name} (including Spotify data)", decodedName);
-            
-            // Trigger rebuild (will fetch fresh Spotify data)
-            await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-            
-            // Invalidate playlist summary cache
-            InvalidatePlaylistSummaryCache();
-            
-            return Ok(new 
-            { 
-                message = $"Rebuilding {decodedName} from scratch (fetching fresh Spotify data)", 
-                timestamp = DateTime.UtcNow,
-                clearedKeys = cacheKeys.Length,
-                clearedFiles = filesToDelete.Count(f => System.IO.File.Exists(f))
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to clear cache for {Name}", decodedName);
-            return StatusCode(500, new { error = "Failed to clear cache", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Search Jellyfin library for tracks (for manual mapping)
-    /// </summary>
-    [HttpGet("jellyfin/search")]
-    public async Task<IActionResult> SearchJellyfinTracks([FromQuery] string query)
-    {
-        if (string.IsNullOrWhiteSpace(query))
-        {
-            return BadRequest(new { error = "Query is required" });
-        }
-        
-        try
-        {
-            var userId = _jellyfinSettings.UserId;
-            
-            // Build URL with UserId if available
-            var url = $"{_jellyfinSettings.Url}/Items?searchTerm={Uri.EscapeDataString(query)}&includeItemTypes=Audio&recursive=true&limit=20";
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"&UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            _logger.LogDebug("Searching Jellyfin: {Url}", url);
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Jellyfin search failed: {StatusCode} - {Error}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to search Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var tracks = new List<object>();
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    // Verify it's actually an Audio item
-                    var type = item.TryGetProperty("Type", out var typeEl) ? typeEl.GetString() : "";
-                    if (type != "Audio")
-                    {
-                        _logger.LogWarning("Skipping non-audio item: {Type}", type);
-                        continue;
-                    }
-                    
-                    var id = item.TryGetProperty("Id", out var idEl) ? idEl.GetString() : "";
-                    var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() : "";
-                    var album = item.TryGetProperty("Album", out var albumEl) ? albumEl.GetString() : "";
-                    var artist = "";
-                    
-                    if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-                    {
-                        artist = artistsEl[0].GetString() ?? "";
-                    }
-                    else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-                    {
-                        artist = albumArtistEl.GetString() ?? "";
-                    }
-                    
-                    tracks.Add(new { id, title, artist, album });
-                }
-            }
-            
-            return Ok(new { tracks });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to search Jellyfin tracks");
-            return StatusCode(500, new { error = "Search failed" });
-        }
-    }
-    
-    /// <summary>
-    /// Get track details by Jellyfin ID (for URL-based mapping)
-    /// </summary>
-    [HttpGet("jellyfin/track/{id}")]
-    public async Task<IActionResult> GetJellyfinTrack(string id)
-    {
-        if (string.IsNullOrWhiteSpace(id))
-        {
-            return BadRequest(new { error = "Track ID is required" });
-        }
-        
-        try
-        {
-            var userId = _jellyfinSettings.UserId;
-            
-            var url = $"{_jellyfinSettings.Url}/Items/{id}";
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"?UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            _logger.LogDebug("Fetching Jellyfin track {Id} from {Url}", id, url);
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin track {Id}: {StatusCode} - {Error}", 
-                    id, response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Track not found in Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var item = doc.RootElement;
-            
-            // Verify it's an Audio item
-            var type = item.TryGetProperty("Type", out var typeEl) ? typeEl.GetString() : "";
-            if (type != "Audio")
-            {
-                _logger.LogWarning("Item {Id} is not an Audio track, it's a {Type}", id, type);
-                return BadRequest(new { error = $"Item is not an audio track (it's a {type})" });
-            }
-            
-            var trackId = item.TryGetProperty("Id", out var idEl) ? idEl.GetString() : "";
-            var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() : "";
-            var album = item.TryGetProperty("Album", out var albumEl) ? albumEl.GetString() : "";
-            var artist = "";
-            
-            if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-            {
-                artist = artistsEl[0].GetString() ?? "";
-            }
-            else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-            {
-                artist = albumArtistEl.GetString() ?? "";
-            }
-            
-            _logger.LogInformation("Found Jellyfin track: {Title} by {Artist}", title, artist);
-            
-            return Ok(new { id = trackId, title, artist, album });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get Jellyfin track {Id}", id);
-            return StatusCode(500, new { error = "Failed to get track details" });
-        }
-    }
-    
-    /// <summary>
-    /// Save manual track mapping (local Jellyfin or external provider)
-    /// </summary>
-    [HttpPost("playlists/{name}/map")]
-    public async Task<IActionResult> SaveManualMapping(string name, [FromBody] ManualMappingRequest request)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        if (string.IsNullOrWhiteSpace(request.SpotifyId))
-        {
-            return BadRequest(new { error = "SpotifyId is required" });
-        }
-        
-        // Validate that either Jellyfin mapping or external mapping is provided
-        var hasJellyfinMapping = !string.IsNullOrWhiteSpace(request.JellyfinId);
-        var hasExternalMapping = !string.IsNullOrWhiteSpace(request.ExternalProvider) && !string.IsNullOrWhiteSpace(request.ExternalId);
-        
-        if (!hasJellyfinMapping && !hasExternalMapping)
-        {
-            return BadRequest(new { error = "Either JellyfinId or (ExternalProvider + ExternalId) is required" });
-        }
-        
-        if (hasJellyfinMapping && hasExternalMapping)
-        {
-            return BadRequest(new { error = "Cannot specify both Jellyfin and external mapping for the same track" });
-        }
-        
-        try
-        {
-            string? normalizedProvider = null;
-            
-            if (hasJellyfinMapping)
-            {
-                // Store Jellyfin mapping in cache (NO EXPIRATION - manual mappings are permanent)
-                var mappingKey = $"spotify:manual-map:{decodedName}:{request.SpotifyId}";
-                await _cache.SetAsync(mappingKey, request.JellyfinId!);
-                
-                // Also save to file for persistence across restarts
-                await SaveManualMappingToFileAsync(decodedName, request.SpotifyId, request.JellyfinId!, null, null);
-                
-                _logger.LogInformation("Manual Jellyfin mapping saved: {Playlist} - Spotify {SpotifyId} → Jellyfin {JellyfinId}", 
-                    decodedName, request.SpotifyId, request.JellyfinId);
-            }
-            else
-            {
-                // Store external mapping in cache (NO EXPIRATION - manual mappings are permanent)
-                var externalMappingKey = $"spotify:external-map:{decodedName}:{request.SpotifyId}";
-                normalizedProvider = request.ExternalProvider!.ToLowerInvariant(); // Normalize to lowercase
-                var externalMapping = new { provider = normalizedProvider, id = request.ExternalId };
-                await _cache.SetAsync(externalMappingKey, externalMapping);
-                
-                // Also save to file for persistence across restarts
-                await SaveManualMappingToFileAsync(decodedName, request.SpotifyId, null, normalizedProvider, request.ExternalId!);
-                
-                _logger.LogInformation("Manual external mapping saved: {Playlist} - Spotify {SpotifyId} → {Provider} {ExternalId}", 
-                    decodedName, request.SpotifyId, normalizedProvider, request.ExternalId);
-            }
-            
-            // Clear all related caches to force rebuild
-            var matchedCacheKey = $"spotify:matched:{decodedName}";
-            var orderedCacheKey = $"spotify:matched:ordered:{decodedName}";
-            var playlistItemsKey = $"spotify:playlist:items:{decodedName}";
-            
-            await _cache.DeleteAsync(matchedCacheKey);
-            await _cache.DeleteAsync(orderedCacheKey);
-            await _cache.DeleteAsync(playlistItemsKey);
-            
-            // Also delete file caches to force rebuild
-            try
-            {
-                var cacheDir = "/app/cache/spotify";
-                var safeName = string.Join("_", decodedName.Split(Path.GetInvalidFileNameChars()));
-                var matchedFile = Path.Combine(cacheDir, $"{safeName}_matched.json");
-                var itemsFile = Path.Combine(cacheDir, $"{safeName}_items.json");
-                
-                if (System.IO.File.Exists(matchedFile))
-                {
-                    System.IO.File.Delete(matchedFile);
-                    _logger.LogInformation("Deleted matched tracks file cache for {Playlist}", decodedName);
-                }
-                
-                if (System.IO.File.Exists(itemsFile))
-                {
-                    System.IO.File.Delete(itemsFile);
-                    _logger.LogDebug("Deleted playlist items file cache for {Playlist}", decodedName);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to delete file caches for {Playlist}", decodedName);
-            }
-            
-            _logger.LogInformation("Cleared playlist caches for {Playlist} to force rebuild", decodedName);
-            
-            // Fetch external provider track details to return to the UI (only for external mappings)
-            string? trackTitle = null;
-            string? trackArtist = null;
-            string? trackAlbum = null;
-            
-            if (hasExternalMapping && normalizedProvider != null)
-            {
-                try
-                {
-                    var metadataService = HttpContext.RequestServices.GetRequiredService<IMusicMetadataService>();
-                    var externalSong = await metadataService.GetSongAsync(normalizedProvider, request.ExternalId!);
-                    
-                    if (externalSong != null)
-                    {
-                        trackTitle = externalSong.Title;
-                        trackArtist = externalSong.Artist;
-                        trackAlbum = externalSong.Album;
-                        _logger.LogInformation("✓ Fetched external track metadata: {Title} by {Artist}", trackTitle, trackArtist);
-                    }
-                    else
-                    {
-                        _logger.LogError("Failed to fetch external track metadata for {Provider} ID {Id}", 
-                            normalizedProvider, request.ExternalId);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to fetch external track metadata, but mapping was saved");
-                }
-            }
-            
-            // Trigger immediate playlist rebuild with the new mapping
-            if (_matchingService != null)
-            {
-                _logger.LogInformation("Triggering immediate playlist rebuild for {Playlist} with new manual mapping", decodedName);
-                
-                // Run rebuild in background with timeout to avoid blocking the response
-                _ = Task.Run(async () =>
-                {
-                    try
-                    {
-                        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); // 2 minute timeout
-                        await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-                        _logger.LogInformation("✓ Playlist {Playlist} rebuilt successfully with manual mapping", decodedName);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        _logger.LogWarning("Playlist rebuild for {Playlist} timed out after 2 minutes", decodedName);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to rebuild playlist {Playlist} after manual mapping", decodedName);
-                    }
-                });
-            }
-            else
-            {
-                _logger.LogWarning("Matching service not available - playlist will rebuild on next scheduled run");
-            }
-            
-            // Return success with track details if available
-            var mappedTrack = new
-            {
-                id = request.ExternalId,
-                title = trackTitle ?? "Unknown",
-                artist = trackArtist ?? "Unknown",
-                album = trackAlbum ?? "Unknown",
-                isLocal = false,
-                externalProvider = request.ExternalProvider!.ToLowerInvariant()
-            };
-            
-            return Ok(new 
-            { 
-                message = "Mapping saved and playlist rebuild triggered", 
-                track = mappedTrack,
-                rebuildTriggered = _matchingService != null
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save manual mapping");
-            return StatusCode(500, new { error = "Failed to save mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Trigger track matching for all playlists
-    /// </summary>
-    [HttpPost("playlists/match-all")]
-    public async Task<IActionResult> MatchAllPlaylistTracks()
-    {
-        _logger.LogInformation("Manual track matching triggered for all playlists");
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            await _matchingService.TriggerMatchingAsync();
-            return Ok(new { message = "Track matching triggered for all playlists", timestamp = DateTime.UtcNow });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to trigger track matching for all playlists");
-            return StatusCode(500, new { error = "Failed to trigger track matching", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get current configuration (safe values only)
-    /// </summary>
-    [HttpGet("config")]
-    public IActionResult GetConfig()
-    {
-        return Ok(new
-        {
-            backendType = _configuration.GetValue<string>("Backend:Type") ?? "Jellyfin",
-            musicService = _configuration.GetValue<string>("MusicService") ?? "SquidWTF",
-            explicitFilter = _configuration.GetValue<string>("ExplicitFilter") ?? "All",
-            enableExternalPlaylists = _configuration.GetValue<bool>("EnableExternalPlaylists", false),
-            playlistsDirectory = _configuration.GetValue<string>("PlaylistsDirectory") ?? "(not set)",
-            redisEnabled = _configuration.GetValue<bool>("Redis:Enabled", false),
-            spotifyApi = new
-            {
-                enabled = _spotifyApiSettings.Enabled,
-                sessionCookie = MaskValue(_spotifyApiSettings.SessionCookie, showLast: 8),
-                sessionCookieSetDate = _spotifyApiSettings.SessionCookieSetDate,
-                cacheDurationMinutes = _spotifyApiSettings.CacheDurationMinutes,
-                rateLimitDelayMs = _spotifyApiSettings.RateLimitDelayMs,
-                preferIsrcMatching = _spotifyApiSettings.PreferIsrcMatching
-            },
-            spotifyImport = new
-            {
-                enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
-                playlists = _spotifyImportSettings.Playlists.Select(p => new
-                {
-                    name = p.Name,
-                    id = p.Id,
-                    localTracksPosition = p.LocalTracksPosition.ToString()
-                })
-            },
-            jellyfin = new
-            {
-                url = _jellyfinSettings.Url,
-                apiKey = MaskValue(_jellyfinSettings.ApiKey),
-                userId = _jellyfinSettings.UserId ?? "(not set)",
-                libraryId = _jellyfinSettings.LibraryId
-            },
-            library = new
-            {
-                downloadPath = _subsonicSettings.StorageMode == StorageMode.Cache 
-                    ? Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "cache")
-                    : Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "permanent"),
-                keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept"),
-                storageMode = _subsonicSettings.StorageMode.ToString(),
-                cacheDurationHours = _subsonicSettings.CacheDurationHours,
-                downloadMode = _subsonicSettings.DownloadMode.ToString()
-            },
-            deezer = new
-            {
-                arl = MaskValue(_deezerSettings.Arl, showLast: 8),
-                arlFallback = MaskValue(_deezerSettings.ArlFallback, showLast: 8),
-                quality = _deezerSettings.Quality ?? "FLAC"
-            },
-            qobuz = new
-            {
-                userAuthToken = MaskValue(_qobuzSettings.UserAuthToken, showLast: 8),
-                userId = _qobuzSettings.UserId,
-                quality = _qobuzSettings.Quality ?? "FLAC"
-            },
-            squidWtf = new
-            {
-                quality = _squidWtfSettings.Quality ?? "LOSSLESS"
-            },
-            musicBrainz = new
-            {
-                enabled = _musicBrainzSettings.Enabled,
-                username = _musicBrainzSettings.Username ?? "(not set)",
-                password = MaskValue(_musicBrainzSettings.Password),
-                baseUrl = _musicBrainzSettings.BaseUrl,
-                rateLimitMs = _musicBrainzSettings.RateLimitMs
-            }
-        });
-    }
-    
-    /// <summary>
-    /// Update configuration by modifying .env file
-    /// </summary>
-    [HttpPost("config")]
-    public async Task<IActionResult> UpdateConfig([FromBody] ConfigUpdateRequest request)
-    {
-        if (request == null || request.Updates == null || request.Updates.Count == 0)
-        {
-            return BadRequest(new { error = "No updates provided" });
-        }
-        
-        _logger.LogDebug("Config update requested: {Count} changes", request.Updates.Count);
-        
-        try
-        {
-            // Check if .env file exists
-            if (!System.IO.File.Exists(_envFilePath))
-            {
-                _logger.LogWarning(".env file not found at {Path}, creating new file", _envFilePath);
-            }
-            
-            // Read current .env file or create new one
-            var envContent = new Dictionary<string, string>();
-            
-            if (System.IO.File.Exists(_envFilePath))
-            {
-                var lines = await System.IO.File.ReadAllLinesAsync(_envFilePath);
-                foreach (var line in lines)
-                {
-                    if (string.IsNullOrWhiteSpace(line) || line.TrimStart().StartsWith('#'))
-                        continue;
-                    
-                    var eqIndex = line.IndexOf('=');
-                    if (eqIndex > 0)
-                    {
-                        var key = line[..eqIndex].Trim();
-                        var value = line[(eqIndex + 1)..].Trim();
-                        envContent[key] = value;
-                    }
-                }
-                _logger.LogDebug("Loaded {Count} existing env vars from {Path}", envContent.Count, _envFilePath);
-            }
-            
-            // Apply updates with validation
-            var appliedUpdates = new List<string>();
-            foreach (var (key, value) in request.Updates)
-            {
-                // Validate key format
-                if (!IsValidEnvKey(key))
-                {
-                    _logger.LogWarning("Invalid env key rejected: {Key}", key);
-                    return BadRequest(new { error = $"Invalid environment variable key: {key}" });
-                }
-                
-                envContent[key] = value;
-                appliedUpdates.Add(key);
-                _logger.LogInformation("  Setting {Key} = {Value}", key, 
-                    key.Contains("COOKIE") || key.Contains("TOKEN") || key.Contains("KEY") || key.Contains("ARL") 
-                        ? "***" + (value.Length > 8 ? value[^8..] : "") 
-                        : value);
-                
-                // Auto-set cookie date when Spotify session cookie is updated
-                if (key == "SPOTIFY_API_SESSION_COOKIE" && !string.IsNullOrEmpty(value))
-                {
-                    var dateKey = "SPOTIFY_API_SESSION_COOKIE_SET_DATE";
-                    var dateValue = DateTime.UtcNow.ToString("o"); // ISO 8601 format
-                    envContent[dateKey] = dateValue;
-                    appliedUpdates.Add(dateKey);
-                    _logger.LogInformation("  Auto-setting {Key} to {Value}", dateKey, dateValue);
-                }
-            }
-            
-            // Write back to .env file
-            var newContent = string.Join("\n", envContent.Select(kv => $"{kv.Key}={kv.Value}"));
-            await System.IO.File.WriteAllTextAsync(_envFilePath, newContent + "\n");
-            
-            _logger.LogDebug("Config file updated successfully at {Path}", _envFilePath);
-            
-            // Invalidate playlist summary cache if playlists were updated
-            if (appliedUpdates.Contains("SPOTIFY_IMPORT_PLAYLISTS"))
-            {
-                InvalidatePlaylistSummaryCache();
-            }
-            
-            return Ok(new
-            {
-                message = "Configuration updated. Restart container to apply changes.",
-                updatedKeys = appliedUpdates,
-                requiresRestart = true,
-                envFilePath = _envFilePath
-            });
-        }
-        catch (UnauthorizedAccessException ex)
-        {
-            _logger.LogError(ex, "Permission denied writing to .env file at {Path}", _envFilePath);
-            return StatusCode(500, new { 
-                error = "Permission denied", 
-                details = "Cannot write to .env file. Check file permissions and volume mount.",
-                path = _envFilePath
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to update configuration at {Path}", _envFilePath);
-            return StatusCode(500, new { 
-                error = "Failed to update configuration", 
-                details = ex.Message,
-                path = _envFilePath
-            });
-        }
-    }
-    
-    /// <summary>
-    /// Add a new playlist to the configuration
-    /// </summary>
-    [HttpPost("playlists")]
-    public async Task<IActionResult> AddPlaylist([FromBody] AddPlaylistRequest request)
-    {
-        if (string.IsNullOrEmpty(request.Name) || string.IsNullOrEmpty(request.SpotifyId))
-        {
-            return BadRequest(new { error = "Name and SpotifyId are required" });
-        }
-        
-        _logger.LogInformation("Adding playlist: {Name} ({SpotifyId})", request.Name, request.SpotifyId);
-        
-        // Get current playlists
-        var currentPlaylists = _spotifyImportSettings.Playlists.ToList();
-        
-        // Check for duplicates
-        if (currentPlaylists.Any(p => p.Id == request.SpotifyId || p.Name == request.Name))
-        {
-            return BadRequest(new { error = "Playlist with this name or ID already exists" });
-        }
-        
-        // Add new playlist
-        currentPlaylists.Add(new SpotifyPlaylistConfig
-        {
-            Name = request.Name,
-            Id = request.SpotifyId,
-            LocalTracksPosition = request.LocalTracksPosition == "last" 
-                ? LocalTracksPosition.Last 
-                : LocalTracksPosition.First
-        });
-        
-        // Convert to JSON format for env var
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { p.Name, p.Id, p.LocalTracksPosition.ToString().ToLower() }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Remove a playlist from the configuration
-    /// </summary>
-    [HttpDelete("playlists/{name}")]
-    public async Task<IActionResult> RemovePlaylist(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Removing playlist: {Name}", decodedName);
-        
-        // Read current playlists from .env file (not stale in-memory config)
-        var currentPlaylists = await ReadPlaylistsFromEnvFile();
-        var playlist = currentPlaylists.FirstOrDefault(p => p.Name == decodedName);
-        
-        if (playlist == null)
-        {
-            return NotFound(new { error = "Playlist not found" });
-        }
-        
-        currentPlaylists.Remove(playlist);
-        
-        // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last"],...]
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { p.Name, p.Id, p.JellyfinId, p.LocalTracksPosition.ToString().ToLower() }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Clear all cached data
-    /// </summary>
-    [HttpPost("cache/clear")]
-    public async Task<IActionResult> ClearCache()
-    {
-        _logger.LogDebug("Cache clear requested from admin UI");
-        
-        var clearedFiles = 0;
-        var clearedRedisKeys = 0;
-        
-        // Clear file cache
-        if (Directory.Exists(CacheDirectory))
-        {
-            foreach (var file in Directory.GetFiles(CacheDirectory, "*.json"))
-            {
-                try
-                {
-                    System.IO.File.Delete(file);
-                    clearedFiles++;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to delete cache file {File}", file);
-                }
-            }
-        }
-        
-        // Clear ALL Redis cache keys for Spotify playlists
-        // This includes matched tracks, ordered tracks, missing tracks, playlist items, etc.
-        foreach (var playlist in _spotifyImportSettings.Playlists)
-        {
-            var keysToDelete = new[]
-            {
-                $"spotify:playlist:{playlist.Name}",
-                $"spotify:missing:{playlist.Name}",
-                $"spotify:matched:{playlist.Name}",
-                $"spotify:matched:ordered:{playlist.Name}",
-                $"spotify:playlist:items:{playlist.Name}"  // NEW: Clear file-backed playlist items cache
-            };
-            
-            foreach (var key in keysToDelete)
-            {
-                if (await _cache.DeleteAsync(key))
-                {
-                    clearedRedisKeys++;
-                    _logger.LogInformation("Cleared Redis cache key: {Key}", key);
-                }
-            }
-        }
-        
-        // Clear all search cache keys (pattern-based deletion)
-        var searchKeysDeleted = await _cache.DeleteByPatternAsync("search:*");
-        clearedRedisKeys += searchKeysDeleted;
-        
-        // Clear all image cache keys (pattern-based deletion)
-        var imageKeysDeleted = await _cache.DeleteByPatternAsync("image:*");
-        clearedRedisKeys += imageKeysDeleted;
-        
-        _logger.LogInformation("Cache cleared: {Files} files, {RedisKeys} Redis keys (including {SearchKeys} search keys, {ImageKeys} image keys)", 
-            clearedFiles, clearedRedisKeys, searchKeysDeleted, imageKeysDeleted);
-        
-        return Ok(new { 
-            message = "Cache cleared successfully", 
-            filesDeleted = clearedFiles,
-            redisKeysDeleted = clearedRedisKeys
-        });
-    }
-    
-    /// <summary>
-    /// Restart the allstarr container to apply configuration changes
-    /// </summary>
-    [HttpPost("restart")]
-    public async Task<IActionResult> RestartContainer()
-    {
-        _logger.LogDebug("Container restart requested from admin UI");
-        
-        try
-        {
-            // Use Docker socket to restart the container
-            var socketPath = "/var/run/docker.sock";
-            
-            if (!System.IO.File.Exists(socketPath))
-            {
-                _logger.LogWarning("Docker socket not available at {Path}", socketPath);
-                return StatusCode(503, new { 
-                    error = "Docker socket not available", 
-                    message = "Please restart manually: docker-compose restart allstarr" 
-                });
-            }
-            
-            // Get container ID from hostname (Docker sets hostname to container ID by default)
-            // Or use the well-known container name
-            var containerId = Environment.MachineName;
-            var containerName = "allstarr";
-            
-            _logger.LogDebug("Attempting to restart container {ContainerId} / {ContainerName}", containerId, containerName);
-            
-            // Create Unix socket HTTP client
-            var handler = new SocketsHttpHandler
-            {
-                ConnectCallback = async (context, cancellationToken) =>
-                {
-                    var socket = new System.Net.Sockets.Socket(
-                        System.Net.Sockets.AddressFamily.Unix,
-                        System.Net.Sockets.SocketType.Stream,
-                        System.Net.Sockets.ProtocolType.Unspecified);
-                    
-                    var endpoint = new System.Net.Sockets.UnixDomainSocketEndPoint(socketPath);
-                    await socket.ConnectAsync(endpoint, cancellationToken);
-                    
-                    return new System.Net.Sockets.NetworkStream(socket, ownsSocket: true);
-                }
-            };
-            
-            using var dockerClient = new HttpClient(handler)
-            {
-                BaseAddress = new Uri("http://localhost")
-            };
-            
-            // Try to restart by container name first, then by ID
-            var response = await dockerClient.PostAsync($"/containers/{containerName}/restart?t=5", null);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                // Try by container ID
-                response = await dockerClient.PostAsync($"/containers/{containerId}/restart?t=5", null);
-            }
-            
-            if (response.IsSuccessStatusCode)
-            {
-                _logger.LogInformation("Container restart initiated successfully");
-                return Ok(new { message = "Restarting container...", success = true });
-            }
-            else
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to restart container: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { 
-                    error = "Failed to restart container", 
-                    message = "Please restart manually: docker-compose restart allstarr" 
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error restarting container");
-            return StatusCode(500, new { 
-                error = "Failed to restart container", 
-                details = ex.Message,
-                message = "Please restart manually: docker-compose restart allstarr" 
-            });
-        }
-    }
-    
-    /// <summary>
-    /// Initialize cookie date to current date if cookie exists but date is not set
-    /// </summary>
-    [HttpPost("config/init-cookie-date")]
-    public async Task<IActionResult> InitCookieDate()
-    {
-        // Only init if cookie exists but date is not set
-        if (string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie))
-        {
-            return BadRequest(new { error = "No cookie set" });
-        }
-        
-        if (!string.IsNullOrEmpty(_spotifyApiSettings.SessionCookieSetDate))
-        {
-            return Ok(new { message = "Cookie date already set", date = _spotifyApiSettings.SessionCookieSetDate });
-        }
-        
-        _logger.LogInformation("Initializing cookie date to current date (cookie existed without date tracking)");
-        
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_API_SESSION_COOKIE_SET_DATE"] = DateTime.UtcNow.ToString("o")
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Get all Jellyfin users
-    /// </summary>
-    [HttpGet("jellyfin/users")]
-    public async Task<IActionResult> GetJellyfinUsers()
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            var url = $"{_jellyfinSettings.Url}/Users";
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin users: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch users from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var users = new List<object>();
-            
-            foreach (var user in doc.RootElement.EnumerateArray())
-            {
-                var id = user.GetProperty("Id").GetString();
-                var name = user.GetProperty("Name").GetString();
-                
-                users.Add(new { id, name });
-            }
-            
-            return Ok(new { users });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin users");
-            return StatusCode(500, new { error = "Failed to fetch users", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get all Jellyfin libraries (virtual folders)
-    /// </summary>
-    [HttpGet("jellyfin/libraries")]
-    public async Task<IActionResult> GetJellyfinLibraries()
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            var url = $"{_jellyfinSettings.Url}/Library/VirtualFolders";
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin libraries: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch libraries from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var libraries = new List<object>();
-            
-            foreach (var lib in doc.RootElement.EnumerateArray())
-            {
-                var name = lib.GetProperty("Name").GetString();
-                var itemId = lib.TryGetProperty("ItemId", out var id) ? id.GetString() : null;
-                var collectionType = lib.TryGetProperty("CollectionType", out var ct) ? ct.GetString() : null;
-                
-                libraries.Add(new { id = itemId, name, collectionType });
-            }
-            
-            return Ok(new { libraries });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin libraries");
-            return StatusCode(500, new { error = "Failed to fetch libraries", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get all playlists from the user's Spotify account
-    /// </summary>
-    [HttpGet("spotify/user-playlists")]
-    public async Task<IActionResult> GetSpotifyUserPlaylists()
-    {
-        if (!_spotifyApiSettings.Enabled || string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie))
-        {
-            return BadRequest(new { error = "Spotify API not configured. Please set sp_dc session cookie." });
-        }
-        
-        try
-        {
-            // Get list of already-configured Spotify playlist IDs
-            var configuredPlaylists = await ReadPlaylistsFromEnvFile();
-            var linkedSpotifyIds = new HashSet<string>(
-                configuredPlaylists.Select(p => p.Id),
-                StringComparer.OrdinalIgnoreCase
-            );
-            
-            // Use SpotifyApiClient's GraphQL method - much less rate-limited than REST API
-            var spotifyPlaylists = await _spotifyClient.GetUserPlaylistsAsync(searchName: null);
-            
-            if (spotifyPlaylists == null || spotifyPlaylists.Count == 0)
-            {
-                return Ok(new { playlists = new List<object>() });
-            }
-            
-            var playlists = spotifyPlaylists.Select(p => new
-            {
-                id = p.SpotifyId,
-                name = p.Name,
-                trackCount = p.TotalTracks,
-                owner = p.OwnerName ?? "",
-                isPublic = p.Public,
-                isLinked = linkedSpotifyIds.Contains(p.SpotifyId)
-            }).ToList();
-            
-            return Ok(new { playlists });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Spotify user playlists");
-            return StatusCode(500, new { error = "Failed to fetch Spotify playlists", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get all playlists from Jellyfin
-    /// </summary>
-    [HttpGet("jellyfin/playlists")]
-    public async Task<IActionResult> GetJellyfinPlaylists([FromQuery] string? userId = null)
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            // Build URL with optional userId filter
-            var url = $"{_jellyfinSettings.Url}/Items?IncludeItemTypes=Playlist&Recursive=true&Fields=ProviderIds,ChildCount,RecursiveItemCount,SongCount";
-            
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"&UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin playlists: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch playlists from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var playlists = new List<object>();
-            
-            // Read current playlists from .env file for accurate linked status
-            var configuredPlaylists = await ReadPlaylistsFromEnvFile();
-            
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    var id = item.GetProperty("Id").GetString();
-                    var name = item.GetProperty("Name").GetString();
-                    
-                    // Try multiple fields for track count - Jellyfin may use different fields
-                    var childCount = 0;
-                    if (item.TryGetProperty("ChildCount", out var cc) && cc.ValueKind == JsonValueKind.Number)
-                        childCount = cc.GetInt32();
-                    else if (item.TryGetProperty("SongCount", out var sc) && sc.ValueKind == JsonValueKind.Number)
-                        childCount = sc.GetInt32();
-                    else if (item.TryGetProperty("RecursiveItemCount", out var ric) && ric.ValueKind == JsonValueKind.Number)
-                        childCount = ric.GetInt32();
-                    
-                    // Check if this playlist is configured in allstarr by Jellyfin ID
-                    var configuredPlaylist = configuredPlaylists
-                        .FirstOrDefault(p => p.JellyfinId.Equals(id, StringComparison.OrdinalIgnoreCase));
-                    var isConfigured = configuredPlaylist != null;
-                    var linkedSpotifyId = configuredPlaylist?.Id;
-                    
-                    // Only fetch detailed track stats for configured Spotify playlists
-                    // This avoids expensive queries for large non-Spotify playlists
-                    var trackStats = (LocalTracks: 0, ExternalTracks: 0, ExternalAvailable: 0);
-                    if (isConfigured)
-                    {
-                        trackStats = await GetPlaylistTrackStats(id!);
-                    }
-                    
-                    // Use actual track stats for configured playlists, otherwise use Jellyfin's count
-                    var actualTrackCount = isConfigured 
-                        ? trackStats.LocalTracks + trackStats.ExternalTracks 
-                        : childCount;
-                    
-                    playlists.Add(new
-                    {
-                        id,
-                        name,
-                        trackCount = actualTrackCount,
-                        linkedSpotifyId,
-                        isConfigured,
-                        localTracks = trackStats.LocalTracks,
-                        externalTracks = trackStats.ExternalTracks,
-                        externalAvailable = trackStats.ExternalAvailable
-                    });
-                }
-            }
-            
-            return Ok(new { playlists });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin playlists");
-            return StatusCode(500, new { error = "Failed to fetch playlists", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get track statistics for a playlist (local vs external)
-    /// </summary>
-    private async Task<(int LocalTracks, int ExternalTracks, int ExternalAvailable)> GetPlaylistTrackStats(string playlistId)
-    {
-        try
-        {
-            // Jellyfin requires a UserId to fetch playlist items
-            // We'll use the first available user if not specified
-            var userId = _jellyfinSettings.UserId;
-            
-            // If no user configured, try to get the first user
-            if (string.IsNullOrEmpty(userId))
-            {
-                var usersResponse = await _jellyfinHttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, $"{_jellyfinSettings.Url}/Users")
-                {
-                    Headers = { { "X-Emby-Authorization", GetJellyfinAuthHeader() } }
-                });
-                
-                if (usersResponse.IsSuccessStatusCode)
-                {
-                    var usersJson = await usersResponse.Content.ReadAsStringAsync();
-                    using var usersDoc = JsonDocument.Parse(usersJson);
-                    if (usersDoc.RootElement.GetArrayLength() > 0)
-                    {
-                        userId = usersDoc.RootElement[0].GetProperty("Id").GetString();
-                    }
-                }
-            }
-            
-            if (string.IsNullOrEmpty(userId))
-            {
-                _logger.LogWarning("No user ID available to fetch playlist items for {PlaylistId}", playlistId);
-                return (0, 0, 0);
-            }
-            
-            var url = $"{_jellyfinSettings.Url}/Playlists/{playlistId}/Items?UserId={userId}&Fields=Path";
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogError("Failed to fetch playlist items for {PlaylistId}: {StatusCode}", playlistId, response.StatusCode);
-                return (0, 0, 0);
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var localTracks = 0;
-            var externalTracks = 0;
-            var externalAvailable = 0;
-            
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    // Simpler detection: Check if Path exists and is not empty
-                    // External tracks from allstarr won't have a Path property
-                    var hasPath = item.TryGetProperty("Path", out var pathProp) && 
-                                  pathProp.ValueKind == JsonValueKind.String &&
-                                  !string.IsNullOrEmpty(pathProp.GetString());
-                    
-                    if (hasPath)
-                    {
-                        var pathStr = pathProp.GetString()!;
-                        // Check if it's a real file path (not a URL)
-                        if (pathStr.StartsWith("/") || pathStr.Contains(":\\"))
-                        {
-                            localTracks++;
-                        }
-                        else
-                        {
-                            // It's a URL or external source
-                            externalTracks++;
-                            externalAvailable++;
-                        }
-                    }
-                    else
-                    {
-                        // No path means it's external
-                        externalTracks++;
-                        externalAvailable++;
-                    }
-                }
-                
-                _logger.LogDebug("Playlist {PlaylistId} stats: {Local} local, {External} external", 
-                    playlistId, localTracks, externalTracks);
-            }
-            else
-            {
-                _logger.LogWarning("No Items property in playlist response for {PlaylistId}", playlistId);
-            }
-            
-            return (localTracks, externalTracks, externalAvailable);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get track stats for playlist {PlaylistId}", playlistId);
-            return (0, 0, 0);
-        }
-    }
-    
-    /// <summary>
-    /// Link a Jellyfin playlist to a Spotify playlist
-    /// </summary>
-    [HttpPost("jellyfin/playlists/{jellyfinPlaylistId}/link")]
-    public async Task<IActionResult> LinkPlaylist(string jellyfinPlaylistId, [FromBody] LinkPlaylistRequest request)
-    {
-        if (string.IsNullOrEmpty(request.SpotifyPlaylistId))
-        {
-            return BadRequest(new { error = "SpotifyPlaylistId is required" });
-        }
-        
-        if (string.IsNullOrEmpty(request.Name))
-        {
-            return BadRequest(new { error = "Name is required" });
-        }
-        
-        _logger.LogInformation("Linking Jellyfin playlist {JellyfinId} to Spotify playlist {SpotifyId} with name {Name}", 
-            jellyfinPlaylistId, request.SpotifyPlaylistId, request.Name);
-        
-        // Read current playlists from .env file (not in-memory config which is stale)
-        var currentPlaylists = await ReadPlaylistsFromEnvFile();
-        
-        // Check if already configured by Jellyfin ID
-        var existingByJellyfinId = currentPlaylists
-            .FirstOrDefault(p => p.JellyfinId.Equals(jellyfinPlaylistId, StringComparison.OrdinalIgnoreCase));
-        
-        if (existingByJellyfinId != null)
-        {
-            return BadRequest(new { error = $"This Jellyfin playlist is already linked to '{existingByJellyfinId.Name}'" });
-        }
-        
-        // Check if already configured by name
-        var existingByName = currentPlaylists
-            .FirstOrDefault(p => p.Name.Equals(request.Name, StringComparison.OrdinalIgnoreCase));
-        
-        if (existingByName != null)
-        {
-            return BadRequest(new { error = $"Playlist name '{request.Name}' is already configured" });
-        }
-        
-        // Add the playlist to configuration
-        currentPlaylists.Add(new SpotifyPlaylistConfig
-        {
-            Name = request.Name,
-            Id = request.SpotifyPlaylistId,
-            JellyfinId = jellyfinPlaylistId,
-            LocalTracksPosition = LocalTracksPosition.First, // Use Spotify order
-            SyncSchedule = request.SyncSchedule ?? "0 8 * * 1" // Default to Monday 8 AM
-        });
-        
-        // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last","cronSchedule"],...]
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { 
-                p.Name, 
-                p.Id, 
-                p.JellyfinId, 
-                p.LocalTracksPosition.ToString().ToLower(),
-                p.SyncSchedule ?? "0 8 * * 1"
-            }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Unlink a playlist (remove from configuration)
-    /// </summary>
-    [HttpDelete("jellyfin/playlists/{name}/unlink")]
-    public async Task<IActionResult> UnlinkPlaylist(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        return await RemovePlaylist(decodedName);
-    }
-    
-    /// <summary>
-    /// Update playlist sync schedule
-    /// </summary>
-    [HttpPut("playlists/{name}/schedule")]
-    public async Task<IActionResult> UpdatePlaylistSchedule(string name, [FromBody] UpdateScheduleRequest request)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        if (string.IsNullOrWhiteSpace(request.SyncSchedule))
-        {
-            return BadRequest(new { error = "SyncSchedule is required" });
-        }
-        
-        // Basic cron validation
-        var cronParts = request.SyncSchedule.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
-        if (cronParts.Length != 5)
-        {
-            return BadRequest(new { error = "Invalid cron format. Expected: minute hour day month dayofweek" });
-        }
-        
-        // Read current playlists
-        var currentPlaylists = await ReadPlaylistsFromEnvFile();
-        var playlist = currentPlaylists.FirstOrDefault(p => p.Name.Equals(decodedName, StringComparison.OrdinalIgnoreCase));
-        
-        if (playlist == null)
-        {
-            return NotFound(new { error = $"Playlist '{decodedName}' not found" });
-        }
-        
-        // Update the schedule
-        playlist.SyncSchedule = request.SyncSchedule.Trim();
-        
-        // Save back to .env
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { 
-                p.Name, 
-                p.Id, 
-                p.JellyfinId, 
-                p.LocalTracksPosition.ToString().ToLower(),
-                p.SyncSchedule ?? "0 8 * * 1"
-            }).ToArray()
-        );
-        
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    private string GetJellyfinAuthHeader()
-    {
-        return $"MediaBrowser Client=\"Allstarr\", Device=\"Server\", DeviceId=\"allstarr-admin\", Version=\"1.0.1\", Token=\"{_jellyfinSettings.ApiKey}\"";
-    }
-    
-    /// <summary>
-    /// Read current playlists from .env file (not stale in-memory config)
-    /// </summary>
-    private async Task<List<SpotifyPlaylistConfig>> ReadPlaylistsFromEnvFile()
-    {
-        var playlists = new List<SpotifyPlaylistConfig>();
-        
-        if (!System.IO.File.Exists(_envFilePath))
-        {
-            return playlists;
-        }
-        
-        try
-        {
-            var lines = await System.IO.File.ReadAllLinesAsync(_envFilePath);
-            foreach (var line in lines)
-            {
-                if (line.TrimStart().StartsWith("SPOTIFY_IMPORT_PLAYLISTS="))
-                {
-                    var value = line.Substring(line.IndexOf('=') + 1).Trim();
-                    
-                    if (string.IsNullOrWhiteSpace(value) || value == "[]")
-                    {
-                        return playlists;
-                    }
-                    
-                    // Parse JSON array format: [["Name","SpotifyId","JellyfinId","first|last","cronSchedule"],...]
-                    var playlistArrays = JsonSerializer.Deserialize<string[][]>(value);
-                    if (playlistArrays != null)
-                    {
-                        foreach (var arr in playlistArrays)
-                        {
-                            if (arr.Length >= 2)
-                            {
-                                playlists.Add(new SpotifyPlaylistConfig
-                                {
-                                    Name = arr[0].Trim(),
-                                    Id = arr[1].Trim(),
-                                    JellyfinId = arr.Length >= 3 ? arr[2].Trim() : "",
-                                    LocalTracksPosition = arr.Length >= 4 && 
-                                        arr[3].Trim().Equals("last", StringComparison.OrdinalIgnoreCase)
-                                        ? LocalTracksPosition.Last
-                                        : LocalTracksPosition.First,
-                                    SyncSchedule = arr.Length >= 5 ? arr[4].Trim() : "0 8 * * 1"
-                                });
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to read playlists from .env file");
-        }
-        
-        return playlists;
-    }
-    
-    private static string MaskValue(string? value, int showLast = 0)
-    {
-        if (string.IsNullOrEmpty(value)) return "(not set)";
-        if (value.Length <= showLast) return "***";
-        return showLast > 0 ? "***" + value[^showLast..] : value[..8] + "...";
-    }
-    
-    private static string SanitizeFileName(string name)
-    {
-        return string.Join("_", name.Split(Path.GetInvalidFileNameChars()));
-    }
-    
-    private static bool IsValidEnvKey(string key)
-    {
-        // Only allow alphanumeric, underscore, and must start with letter/underscore
-        return Regex.IsMatch(key, @"^[A-Z_][A-Z0-9_]*$", RegexOptions.IgnoreCase);
-    }
-    
-    /// <summary>
-    /// Export .env file for backup/transfer
-    /// </summary>
-    [HttpGet("export-env")]
-    public IActionResult ExportEnv()
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_envFilePath))
-            {
-                return NotFound(new { error = ".env file not found" });
-            }
-
-            var envContent = System.IO.File.ReadAllText(_envFilePath);
-            var bytes = System.Text.Encoding.UTF8.GetBytes(envContent);
-            
-            return File(bytes, "text/plain", ".env");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to export .env file");
-            return StatusCode(500, new { error = "Failed to export .env file", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Import .env file from upload
-    /// </summary>
-    [HttpPost("import-env")]
-    public async Task<IActionResult> ImportEnv([FromForm] IFormFile file)
-    {
-        if (file == null || file.Length == 0)
-        {
-            return BadRequest(new { error = "No file provided" });
-        }
-
-        if (!file.FileName.EndsWith(".env"))
-        {
-            return BadRequest(new { error = "File must be a .env file" });
-        }
-
-        try
-        {
-            // Read uploaded file
-            using var reader = new StreamReader(file.OpenReadStream());
-            var content = await reader.ReadToEndAsync();
-            
-            // Validate it's a valid .env file (basic check)
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                return BadRequest(new { error = ".env file is empty" });
-            }
-
-            // Backup existing .env
-            if (System.IO.File.Exists(_envFilePath))
-            {
-                var backupPath = $"{_envFilePath}.backup.{DateTime.UtcNow:yyyyMMddHHmmss}";
-                System.IO.File.Copy(_envFilePath, backupPath, true);
-                _logger.LogDebug("Backed up existing .env to {BackupPath}", backupPath);
-            }
-
-            // Write new .env file
-            await System.IO.File.WriteAllTextAsync(_envFilePath, content);
-            
-            _logger.LogInformation(".env file imported successfully");
-            
-            return Ok(new 
-            { 
-                success = true, 
-                message = ".env file imported successfully. Restart the application for changes to take effect." 
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to import .env file");
-            return StatusCode(500, new { error = "Failed to import .env file", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Gets detailed memory usage statistics for debugging.
-    /// </summary>
-    [HttpGet("memory-stats")]
-    public IActionResult GetMemoryStats()
-    {
-        try
-        {
-            // Get memory stats BEFORE GC
-            var memoryBeforeGC = GC.GetTotalMemory(false);
-            var gen0Before = GC.CollectionCount(0);
-            var gen1Before = GC.CollectionCount(1);
-            var gen2Before = GC.CollectionCount(2);
-            
-            // Force garbage collection to get accurate numbers
-            GC.Collect();
-            GC.WaitForPendingFinalizers();
-            GC.Collect();
-
-            var memoryAfterGC = GC.GetTotalMemory(false);
-            var gen0After = GC.CollectionCount(0);
-            var gen1After = GC.CollectionCount(1);
-            var gen2After = GC.CollectionCount(2);
-            
-            // Get process memory info
-            var process = System.Diagnostics.Process.GetCurrentProcess();
-            
-            return Ok(new {
-                Timestamp = DateTime.UtcNow,
-                BeforeGC = new {
-                    GCMemoryBytes = memoryBeforeGC,
-                    GCMemoryMB = Math.Round(memoryBeforeGC / (1024.0 * 1024.0), 2)
-                },
-                AfterGC = new {
-                    GCMemoryBytes = memoryAfterGC,
-                    GCMemoryMB = Math.Round(memoryAfterGC / (1024.0 * 1024.0), 2)
-                },
-                MemoryFreedMB = Math.Round((memoryBeforeGC - memoryAfterGC) / (1024.0 * 1024.0), 2),
-                ProcessWorkingSetBytes = process.WorkingSet64,
-                ProcessWorkingSetMB = Math.Round(process.WorkingSet64 / (1024.0 * 1024.0), 2),
-                ProcessPrivateMemoryBytes = process.PrivateMemorySize64,
-                ProcessPrivateMemoryMB = Math.Round(process.PrivateMemorySize64 / (1024.0 * 1024.0), 2),
-                ProcessVirtualMemoryBytes = process.VirtualMemorySize64,
-                ProcessVirtualMemoryMB = Math.Round(process.VirtualMemorySize64 / (1024.0 * 1024.0), 2),
-                GCCollections = new {
-                    Gen0Before = gen0Before,
-                    Gen0After = gen0After,
-                    Gen0Triggered = gen0After - gen0Before,
-                    Gen1Before = gen1Before,
-                    Gen1After = gen1After,
-                    Gen1Triggered = gen1After - gen1Before,
-                    Gen2Before = gen2Before,
-                    Gen2After = gen2After,
-                    Gen2Triggered = gen2After - gen2Before
-                },
-                GCMode = GCSettings.IsServerGC ? "Server" : "Workstation",
-                GCLatencyMode = GCSettings.LatencyMode.ToString()
-            });
-        }
-        catch (Exception ex)
-        {
-            return BadRequest(new { error = ex.Message });
-        }
-||||||| f68706f
-        _configuration = configuration;
-        _environment = environment;
-        _spotifyApiSettings = spotifyApiSettings.Value;
-        _spotifyImportSettings = spotifyImportSettings.Value;
-        _jellyfinSettings = jellyfinSettings.Value;
-        _subsonicSettings = subsonicSettings.Value;
-        _deezerSettings = deezerSettings.Value;
-        _qobuzSettings = qobuzSettings.Value;
-        _squidWtfSettings = squidWtfSettings.Value;
-        _musicBrainzSettings = musicBrainzSettings.Value;
-        _spotifyClient = spotifyClient;
-        _playlistFetcher = playlistFetcher;
-        _matchingService = matchingService;
-        _cache = cache;
-        _jellyfinHttpClient = httpClientFactory.CreateClient();
-        _serviceProvider = serviceProvider;
-        
-        // Decode SquidWTF base URLs
-        _squidWtfApiUrls = DecodeSquidWtfUrls();
-        
-        // .env file path is always /app/.env in Docker (mounted from host)
-        // In development, it's in the parent directory of ContentRootPath
-        _envFilePath = _environment.IsDevelopment() 
-            ? Path.Combine(_environment.ContentRootPath, "..", ".env")
-            : "/app/.env";
-    }
-    
-    private static List<string> DecodeSquidWtfUrls()
-    {
-        var encodedUrls = new[]
-        {
-            "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",                      // triton
-            "aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=",              // binimum
-            "aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=",              // kinoplus
-            "aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==",          // spoti-2
-            "aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==",          // spoti-1
-            "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",                      // wolf
-            "aHR0cDovL2h1bmQucXFkbC5zaXRl",                          // hund
-            "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=",                      // katze
-            "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",                      // vogel
-            "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ=="                       // maus
-        };
-        
-        return encodedUrls
-            .Select(encoded => System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encoded)))
-            .ToList();
-    }
-    
-    /// <summary>
-    /// Helper method to safely check if a dynamic cache result has a value
-    /// Handles the case where JsonElement cannot be compared to null directly
-    /// </summary>
-    private static bool HasValue(object? obj)
-    {
-        if (obj == null) return false;
-        if (obj is JsonElement jsonEl) return jsonEl.ValueKind != JsonValueKind.Null && jsonEl.ValueKind != JsonValueKind.Undefined;
-        return true;
-    }
-    
-    /// <summary>
-    /// Get current system status and configuration
-    /// </summary>
-    [HttpGet("status")]
-    public IActionResult GetStatus()
-    {
-        // Determine Spotify auth status based on configuration only
-        // DO NOT call Spotify API here - this endpoint is polled frequently
-        var spotifyAuthStatus = "not_configured";
-        string? spotifyUser = null;
-        
-        if (_spotifyApiSettings.Enabled && !string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie))
-        {
-            // If cookie is set, assume it's working until proven otherwise
-            // Actual validation happens when playlists are fetched
-            spotifyAuthStatus = "configured";
-            spotifyUser = "(cookie set)";
-        }
-        else if (_spotifyApiSettings.Enabled)
-        {
-            spotifyAuthStatus = "missing_cookie";
-        }
-        
-        return Ok(new
-        {
-            version = "1.0.0",
-            backendType = _configuration.GetValue<string>("Backend:Type") ?? "Jellyfin",
-            jellyfinUrl = _jellyfinSettings.Url,
-            spotify = new
-            {
-                apiEnabled = _spotifyApiSettings.Enabled,
-                authStatus = spotifyAuthStatus,
-                user = spotifyUser,
-                hasCookie = !string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie),
-                cookieSetDate = _spotifyApiSettings.SessionCookieSetDate,
-                cacheDurationMinutes = _spotifyApiSettings.CacheDurationMinutes,
-                preferIsrcMatching = _spotifyApiSettings.PreferIsrcMatching
-            },
-            spotifyImport = new
-            {
-                enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
-                playlistCount = _spotifyImportSettings.Playlists.Count
-            },
-            deezer = new
-            {
-                hasArl = !string.IsNullOrEmpty(_deezerSettings.Arl),
-                quality = _deezerSettings.Quality ?? "FLAC"
-            },
-            qobuz = new
-            {
-                hasToken = !string.IsNullOrEmpty(_qobuzSettings.UserAuthToken),
-                quality = _qobuzSettings.Quality ?? "FLAC"
-            },
-            squidWtf = new
-            {
-                quality = _squidWtfSettings.Quality ?? "LOSSLESS"
-            }
-        });
-    }
-    
-    /// <summary>
-    /// Get a random SquidWTF base URL for searching (round-robin)
-    /// </summary>
-    [HttpGet("squidwtf-base-url")]
-    public IActionResult GetSquidWtfBaseUrl()
-    {
-        if (_squidWtfApiUrls.Count == 0)
-        {
-            return NotFound(new { error = "No SquidWTF base URLs configured" });
-        }
-        
-        string baseUrl;
-        lock (_urlIndexLock)
-        {
-            baseUrl = _squidWtfApiUrls[_urlIndex];
-            _urlIndex = (_urlIndex + 1) % _squidWtfApiUrls.Count;
-        }
-        
-        return Ok(new { baseUrl });
-    }
-    
-    /// <summary>
-    /// Get list of configured playlists with their current data
-    /// </summary>
-    [HttpGet("playlists")]
-    public async Task<IActionResult> GetPlaylists([FromQuery] bool refresh = false)
-    {
-        var playlistCacheFile = "/app/cache/admin_playlists_summary.json";
-        
-        // Check file cache first (5 minute TTL) unless refresh is requested
-        if (!refresh && System.IO.File.Exists(playlistCacheFile))
-        {
-            try
-            {
-                var fileInfo = new FileInfo(playlistCacheFile);
-                var age = DateTime.UtcNow - fileInfo.LastWriteTimeUtc;
-                
-                if (age.TotalMinutes < 5)
-                {
-                    var cachedJson = await System.IO.File.ReadAllTextAsync(playlistCacheFile);
-                    var cachedData = JsonSerializer.Deserialize<Dictionary<string, object>>(cachedJson);
-                    _logger.LogDebug("📦 Returning cached playlist summary (age: {Age:F1}m)", age.TotalMinutes);
-                    return Ok(cachedData);
-                }
-                else
-                {
-                    _logger.LogDebug("🔄 Cache expired (age: {Age:F1}m), refreshing...", age.TotalMinutes);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to read cached playlist summary");
-            }
-        }
-        else if (refresh)
-        {
-            _logger.LogInformation("🔄 Force refresh requested for playlist summary");
-        }
-        
-        var playlists = new List<object>();
-        
-        // Read playlists directly from .env file to get the latest configuration
-        // (IOptions is cached and doesn't reload after .env changes)
-        var configuredPlaylists = await ReadPlaylistsFromEnvFile();
-        
-        foreach (var config in configuredPlaylists)
-        {
-            var playlistInfo = new Dictionary<string, object?>
-            {
-                ["name"] = config.Name,
-                ["id"] = config.Id,
-                ["jellyfinId"] = config.JellyfinId,
-                ["localTracksPosition"] = config.LocalTracksPosition.ToString(),
-                ["trackCount"] = 0,
-                ["localTracks"] = 0,
-                ["externalTracks"] = 0,
-                ["lastFetched"] = null as DateTime?,
-                ["cacheAge"] = null as string
-            };
-            
-            // Get Spotify playlist track count from cache
-            var cacheFilePath = Path.Combine(CacheDirectory, $"{SanitizeFileName(config.Name)}_spotify.json");
-            int spotifyTrackCount = 0;
-            
-            if (System.IO.File.Exists(cacheFilePath))
-            {
-                try
-                {
-                    var json = await System.IO.File.ReadAllTextAsync(cacheFilePath);
-                    using var doc = JsonDocument.Parse(json);
-                    var root = doc.RootElement;
-                    
-                    if (root.TryGetProperty("tracks", out var tracks))
-                    {
-                        spotifyTrackCount = tracks.GetArrayLength();
-                        playlistInfo["trackCount"] = spotifyTrackCount;
-                    }
-                    
-                    if (root.TryGetProperty("fetchedAt", out var fetchedAt))
-                    {
-                        var fetchedTime = fetchedAt.GetDateTime();
-                        playlistInfo["lastFetched"] = fetchedTime;
-                        var age = DateTime.UtcNow - fetchedTime;
-                        playlistInfo["cacheAge"] = age.TotalHours < 1 
-                            ? $"{age.TotalMinutes:F0}m" 
-                            : $"{age.TotalHours:F1}h";
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to read cache for playlist {Name}", config.Name);
-                }
-            }
-            
-            // Get current Jellyfin playlist track count
-            if (!string.IsNullOrEmpty(config.JellyfinId))
-            {
-                try
-                {
-                    // Jellyfin requires UserId parameter to fetch playlist items
-                    var userId = _jellyfinSettings.UserId;
-                    
-                    // If no user configured, try to get the first user
-                    if (string.IsNullOrEmpty(userId))
-                    {
-                        var usersResponse = await _jellyfinHttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, $"{_jellyfinSettings.Url}/Users")
-                        {
-                            Headers = { { "X-Emby-Authorization", GetJellyfinAuthHeader() } }
-                        });
-                        
-                        if (usersResponse.IsSuccessStatusCode)
-                        {
-                            var usersJson = await usersResponse.Content.ReadAsStringAsync();
-                            using var usersDoc = JsonDocument.Parse(usersJson);
-                            if (usersDoc.RootElement.GetArrayLength() > 0)
-                            {
-                                userId = usersDoc.RootElement[0].GetProperty("Id").GetString();
-                            }
-                        }
-                    }
-                    
-                    if (string.IsNullOrEmpty(userId))
-                    {
-                        _logger.LogWarning("No user ID available to fetch playlist items for {Name}", config.Name);
-                    }
-                    else
-                    {
-                        var url = $"{_jellyfinSettings.Url}/Playlists/{config.JellyfinId}/Items?UserId={userId}&Fields=Path";
-                        var request = new HttpRequestMessage(HttpMethod.Get, url);
-                        request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-                        
-                        _logger.LogDebug("Fetching Jellyfin playlist items for {Name} from {Url}", config.Name, url);
-                        
-                        var response = await _jellyfinHttpClient.SendAsync(request);
-                        if (response.IsSuccessStatusCode)
-                        {
-                            var jellyfinJson = await response.Content.ReadAsStringAsync();
-                            using var jellyfinDoc = JsonDocument.Parse(jellyfinJson);
-                            
-                            if (jellyfinDoc.RootElement.TryGetProperty("Items", out var items))
-                            {
-                                // Get Spotify tracks to match against
-                                var spotifyTracks = await _playlistFetcher.GetPlaylistTracksAsync(config.Name);
-                                
-                                // Try to use the pre-built playlist cache first (includes manual mappings!)
-                                var playlistItemsCacheKey = $"spotify:playlist:items:{config.Name}";
-                                
-                                List<Dictionary<string, object?>>? cachedPlaylistItems = null;
-                                try
-                                {
-                                    cachedPlaylistItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(playlistItemsCacheKey);
-                                }
-                                catch (Exception cacheEx)
-                                {
-                                    _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", config.Name);
-                                }
-                                
-                                _logger.LogInformation("Checking cache for {Playlist}: {CacheKey}, Found: {Found}, Count: {Count}", 
-                                    config.Name, playlistItemsCacheKey, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0);
-                                
-                                if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0)
-                                {
-                                    // Use the pre-built cache which respects manual mappings
-                                    var localCount = 0;
-                                    var externalCount = 0;
-                                    
-                                    foreach (var item in cachedPlaylistItems)
-                                    {
-                                        // Check if it's external by looking for external provider in ProviderIds
-                                        // External providers: SquidWTF, Deezer, Qobuz, Tidal
-                                        var isExternal = false;
-                                        
-                                        if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                                        {
-                                            // Handle both Dictionary<string, string> and JsonElement
-                                            Dictionary<string, string>? providerIds = null;
-                                            
-                                            if (providerIdsObj is Dictionary<string, string> dict)
-                                            {
-                                                providerIds = dict;
-                                            }
-                                            else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                                            {
-                                                providerIds = new Dictionary<string, string>();
-                                                foreach (var prop in jsonEl.EnumerateObject())
-                                                {
-                                                    providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                                                }
-                                            }
-                                            
-                                            if (providerIds != null)
-                                            {
-                                                // Check for external provider keys (not MusicBrainz, ISRC, Spotify, etc)
-                                                isExternal = providerIds.Keys.Any(k => 
-                                                    k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Deezer", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Qobuz", StringComparison.OrdinalIgnoreCase) ||
-                                                    k.Equals("Tidal", StringComparison.OrdinalIgnoreCase));
-                                            }
-                                        }
-                                        
-                                        if (isExternal)
-                                        {
-                                            externalCount++;
-                                        }
-                                        else
-                                        {
-                                            localCount++;
-                                        }
-                                    }
-                                    
-                                    var externalMissingCount = spotifyTracks.Count - cachedPlaylistItems.Count;
-                                    if (externalMissingCount < 0) externalMissingCount = 0;
-                                    
-                                    playlistInfo["localTracks"] = localCount;
-                                    playlistInfo["externalMatched"] = externalCount;
-                                    playlistInfo["externalMissing"] = externalMissingCount;
-                                    playlistInfo["externalTotal"] = externalCount + externalMissingCount;
-                                    playlistInfo["totalInJellyfin"] = cachedPlaylistItems.Count;
-                                    playlistInfo["totalPlayable"] = localCount + externalCount; // Total tracks that will be served
-                                    
-                                    _logger.LogInformation("Playlist {Name} (from cache): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", 
-                                        config.Name, spotifyTracks.Count, localCount, externalCount, externalMissingCount, localCount + externalCount);
-                                }
-                                else
-                                {
-                                    // Fallback: Build list of local tracks from Jellyfin (match by name only)
-                                    var localTracks = new List<(string Title, string Artist)>();
-                                    foreach (var item in items.EnumerateArray())
-                                    {
-                                        var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() ?? "" : "";
-                                        var artist = "";
-                                        
-                                        if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-                                        {
-                                            artist = artistsEl[0].GetString() ?? "";
-                                        }
-                                        else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-                                        {
-                                            artist = albumArtistEl.GetString() ?? "";
-                                        }
-                                        
-                                        if (!string.IsNullOrEmpty(title))
-                                        {
-                                            localTracks.Add((title, artist));
-                                        }
-                                    }
-                                    
-                                    // Get matched external tracks cache once
-                                    var matchedTracksKey = $"spotify:matched:ordered:{config.Name}";
-                                    var matchedTracks = await _cache.GetAsync<List<MatchedTrack>>(matchedTracksKey);
-                                    var matchedSpotifyIds = new HashSet<string>(
-                                        matchedTracks?.Select(m => m.SpotifyId) ?? Enumerable.Empty<string>()
-                                    );
-                                    
-                                    var localCount = 0;
-                                    var externalMatchedCount = 0;
-                                    var externalMissingCount = 0;
-                                    
-                                    // Match each Spotify track to determine if it's local, external, or missing
-                                    foreach (var track in spotifyTracks)
-                                    {
-                                        var isLocal = false;
-                                        var hasExternalMapping = false;
-                                        
-                                        // FIRST: Check for manual Jellyfin mapping
-                                        var manualMappingKey = $"spotify:manual-map:{config.Name}:{track.SpotifyId}";
-                                        var manualJellyfinId = await _cache.GetAsync<string>(manualMappingKey);
-                                        
-                                        if (!string.IsNullOrEmpty(manualJellyfinId))
-                                        {
-                                            // Manual Jellyfin mapping exists - this track is definitely local
-                                            isLocal = true;
-                                        }
-                                        else
-                                        {
-                                            // Check for external manual mapping
-                                            var externalMappingKey = $"spotify:external-map:{config.Name}:{track.SpotifyId}";
-                                            var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                                            
-                                            if (!string.IsNullOrEmpty(externalMappingJson))
-                                            {
-                                                // External manual mapping exists
-                                                hasExternalMapping = true;
-                                            }
-                                            else if (localTracks.Count > 0)
-                                            {
-                                                // SECOND: No manual mapping, try fuzzy matching with local tracks
-                                                var bestMatch = localTracks
-                                                    .Select(local => new
-                                                    {
-                                                        Local = local,
-                                                        TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, local.Title),
-                                                        ArtistScore = FuzzyMatcher.CalculateSimilarity(track.PrimaryArtist, local.Artist)
-                                                    })
-                                                    .Select(x => new
-                                                    {
-                                                        x.Local,
-                                                        x.TitleScore,
-                                                        x.ArtistScore,
-                                                        TotalScore = (x.TitleScore * 0.7) + (x.ArtistScore * 0.3)
-                                                    })
-                                                    .OrderByDescending(x => x.TotalScore)
-                                                    .FirstOrDefault();
-                                                
-                                                // Use 70% threshold (same as playback matching)
-                                                if (bestMatch != null && bestMatch.TotalScore >= 70)
-                                                {
-                                                    isLocal = true;
-                                                }
-                                            }
-                                        }
-                                        
-                                        if (isLocal)
-                                        {
-                                            localCount++;
-                                        }
-                                        else
-                                        {
-                                            // Check if external track is matched (either manual mapping or auto-matched)
-                                            if (hasExternalMapping || matchedSpotifyIds.Contains(track.SpotifyId))
-                                            {
-                                                externalMatchedCount++;
-                                            }
-                                            else
-                                            {
-                                                externalMissingCount++;
-                                            }
-                                        }
-                                    }
-                                    
-                                    playlistInfo["localTracks"] = localCount;
-                                    playlistInfo["externalMatched"] = externalMatchedCount;
-                                    playlistInfo["externalMissing"] = externalMissingCount;
-                                    playlistInfo["externalTotal"] = externalMatchedCount + externalMissingCount;
-                                    playlistInfo["totalInJellyfin"] = localCount + externalMatchedCount;
-                                    playlistInfo["totalPlayable"] = localCount + externalMatchedCount; // Total tracks that will be served
-                                    
-                                    _logger.LogDebug("Playlist {Name} (fallback): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", 
-                                        config.Name, spotifyTracks.Count, localCount, externalMatchedCount, externalMissingCount, localCount + externalMatchedCount);
-                                }
-                            }
-                            else
-                            {
-                                _logger.LogWarning("No Items property in Jellyfin response for {Name}", config.Name);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("Failed to get Jellyfin playlist {Name}: {StatusCode}", 
-                                config.Name, response.StatusCode);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to get Jellyfin playlist tracks for {Name}", config.Name);
-                }
-            }
-            else
-            {
-                _logger.LogWarning("Playlist {Name} has no JellyfinId configured", config.Name);
-            }
-            
-            playlists.Add(playlistInfo);
-        }
-        
-        // Save to file cache
-        try
-        {
-            var cacheDir = "/app/cache";
-            Directory.CreateDirectory(cacheDir);
-            var cacheFile = Path.Combine(cacheDir, "admin_playlists_summary.json");
-            
-            var response = new { playlists };
-            var json = JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = false });
-            await System.IO.File.WriteAllTextAsync(cacheFile, json);
-            
-            _logger.LogDebug("💾 Saved playlist summary to cache");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to save playlist summary cache");
-        }
-        
-        return Ok(new { playlists });
-    }
-    
-    /// <summary>
-    /// Get tracks for a specific playlist with local/external status
-    /// </summary>
-    [HttpGet("playlists/{name}/tracks")]
-    public async Task<IActionResult> GetPlaylistTracks(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        // Get Spotify tracks
-        var spotifyTracks = await _playlistFetcher.GetPlaylistTracksAsync(decodedName);
-        
-        var tracksWithStatus = new List<object>();
-        
-        // Use the pre-built playlist cache (same as GetPlaylists endpoint)
-        // This cache includes all matched tracks with proper provider IDs
-        var playlistItemsCacheKey = $"spotify:playlist:items:{decodedName}";
-        
-        List<Dictionary<string, object?>>? cachedPlaylistItems = null;
-        try
-        {
-            cachedPlaylistItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(playlistItemsCacheKey);
-        }
-        catch (Exception cacheEx)
-        {
-            _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", decodedName);
-        }
-        
-        _logger.LogInformation("GetPlaylistTracks for {Playlist}: Cache found: {Found}, Count: {Count}", 
-            decodedName, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0);
-        
-        if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0)
-        {
-            // Build a map of Spotify ID -> cached item for quick lookup
-            var spotifyIdToItem = new Dictionary<string, Dictionary<string, object?>>();
-            
-            foreach (var item in cachedPlaylistItems)
-            {
-                if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                {
-                    Dictionary<string, string>? providerIds = null;
-                    
-                    if (providerIdsObj is Dictionary<string, string> dict)
-                    {
-                        providerIds = dict;
-                    }
-                    else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                    {
-                        providerIds = new Dictionary<string, string>();
-                        foreach (var prop in jsonEl.EnumerateObject())
-                        {
-                            providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                        }
-                    }
-                    
-                    if (providerIds != null && providerIds.TryGetValue("Spotify", out var spotifyId) && !string.IsNullOrEmpty(spotifyId))
-                    {
-                        spotifyIdToItem[spotifyId] = item;
-                    }
-                }
-            }
-            
-            // Match each Spotify track to its cached item
-            foreach (var track in spotifyTracks)
-            {
-                bool? isLocal = null;
-                string? externalProvider = null;
-                bool isManualMapping = false;
-                string? manualMappingType = null;
-                string? manualMappingId = null;
-                
-                if (spotifyIdToItem.TryGetValue(track.SpotifyId, out var cachedItem))
-                {
-                    // Track is in the cache - determine if it's local or external
-                    if (cachedItem.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null)
-                    {
-                        Dictionary<string, string>? providerIds = null;
-                        
-                        if (providerIdsObj is Dictionary<string, string> dict)
-                        {
-                            providerIds = dict;
-                        }
-                        else if (providerIdsObj is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                        {
-                            providerIds = new Dictionary<string, string>();
-                            foreach (var prop in jsonEl.EnumerateObject())
-                            {
-                                providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                            }
-                        }
-                        
-                        if (providerIds != null)
-                        {
-                            _logger.LogDebug("Track {Title} has ProviderIds: {Keys}", track.Title, string.Join(", ", providerIds.Keys));
-                            
-                            // Check for external provider keys (case-insensitive)
-                            // External providers: squidwtf, deezer, qobuz, tidal (lowercase)
-                            var providerKey = providerIds.Keys.FirstOrDefault(k => 
-                                k.Equals("squidwtf", StringComparison.OrdinalIgnoreCase) ||
-                                k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase));
-                            
-                            if (providerKey != null)
-                            {
-                                isLocal = false;
-                                externalProvider = "SquidWTF";
-                                _logger.LogDebug("✓ Track {Title} identified as SquidWTF", track.Title);
-                            }
-                            else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("deezer", StringComparison.OrdinalIgnoreCase))) != null)
-                            {
-                                isLocal = false;
-                                externalProvider = "Deezer";
-                                _logger.LogDebug("✓ Track {Title} identified as Deezer", track.Title);
-                            }
-                            else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("qobuz", StringComparison.OrdinalIgnoreCase))) != null)
-                            {
-                                isLocal = false;
-                                externalProvider = "Qobuz";
-                                _logger.LogDebug("✓ Track {Title} identified as Qobuz", track.Title);
-                            }
-                            else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("tidal", StringComparison.OrdinalIgnoreCase))) != null)
-                            {
-                                isLocal = false;
-                                externalProvider = "Tidal";
-                                _logger.LogDebug("✓ Track {Title} identified as Tidal", track.Title);
-                            }
-                            else
-                            {
-                                // No external provider key found - it's a local track
-                                // Local tracks have MusicBrainz, ISRC, Spotify IDs but no external provider
-                                isLocal = true;
-                                _logger.LogDebug("✓ Track {Title} identified as LOCAL (has ProviderIds but no external provider)", track.Title);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("Track {Title} has ProviderIds object but it's null after parsing", track.Title);
-                        }
-                    }
-                    else
-                    {
-                        _logger.LogWarning("Track {Title} in cache but has NO ProviderIds - treating as missing", track.Title);
-                        isLocal = null;
-                        externalProvider = null;
-                    }
-                    
-                    // Check if this is a manual mapping
-                    var manualJellyfinKey = $"spotify:manual-map:{decodedName}:{track.SpotifyId}";
-                    var manualJellyfinId = await _cache.GetAsync<string>(manualJellyfinKey);
-                    
-                    if (!string.IsNullOrEmpty(manualJellyfinId))
-                    {
-                        isManualMapping = true;
-                        manualMappingType = "jellyfin";
-                        manualMappingId = manualJellyfinId;
-                    }
-                    else
-                    {
-                        var externalMappingKey = $"spotify:external-map:{decodedName}:{track.SpotifyId}";
-                        var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                        
-                        if (!string.IsNullOrEmpty(externalMappingJson))
-                        {
-                            try
-                            {
-                                using var extDoc = JsonDocument.Parse(externalMappingJson);
-                                var extRoot = extDoc.RootElement;
-                                
-                                if (extRoot.TryGetProperty("id", out var idEl))
-                                {
-                                    isManualMapping = true;
-                                    manualMappingType = "external";
-                                    manualMappingId = idEl.GetString();
-                                }
-                            }
-                            catch { }
-                        }
-                    }
-                }
-                else
-                {
-                    // Track not in cache - it's missing
-                    isLocal = null;
-                    externalProvider = null;
-                }
-                
-                // Check lyrics status
-                var cacheKey = $"lyrics:{track.PrimaryArtist}:{track.Title}:{track.Album}:{track.DurationMs / 1000}";
-                var existingLyrics = await _cache.GetStringAsync(cacheKey);
-                var hasLyrics = !string.IsNullOrEmpty(existingLyrics);
-                
-                tracksWithStatus.Add(new
-                {
-                    position = track.Position,
-                    title = track.Title,
-                    artists = track.Artists,
-                    album = track.Album,
-                    isrc = track.Isrc,
-                    spotifyId = track.SpotifyId,
-                    durationMs = track.DurationMs,
-                    albumArtUrl = track.AlbumArtUrl,
-                    isLocal = isLocal,
-                    externalProvider = externalProvider,
-                    searchQuery = isLocal != true ? $"{track.Title} {track.PrimaryArtist}" : null,
-                    isManualMapping = isManualMapping,
-                    manualMappingType = manualMappingType,
-                    manualMappingId = manualMappingId,
-                    hasLyrics = hasLyrics
-                });
-            }
-            
-            return Ok(new
-            {
-                name = decodedName,
-                trackCount = spotifyTracks.Count,
-                tracks = tracksWithStatus
-            });
-        }
-        
-        // Fallback: Cache not available, use matched tracks cache
-        _logger.LogWarning("Playlist cache not available for {Playlist}, using fallback", decodedName);
-        
-        var fallbackMatchedTracksKey = $"spotify:matched:ordered:{decodedName}";
-        var fallbackMatchedTracks = await _cache.GetAsync<List<MatchedTrack>>(fallbackMatchedTracksKey);
-        var fallbackMatchedSpotifyIds = new HashSet<string>(
-            fallbackMatchedTracks?.Select(m => m.SpotifyId) ?? Enumerable.Empty<string>()
-        );
-        
-        foreach (var track in spotifyTracks)
-        {
-            bool? isLocal = null;
-            string? externalProvider = null;
-            
-            // Check for manual Jellyfin mapping
-            var manualMappingKey = $"spotify:manual-map:{decodedName}:{track.SpotifyId}";
-            var manualJellyfinId = await _cache.GetAsync<string>(manualMappingKey);
-            
-            if (!string.IsNullOrEmpty(manualJellyfinId))
-            {
-                isLocal = true;
-            }
-            else
-            {
-                // Check for external manual mapping
-                var externalMappingKey = $"spotify:external-map:{decodedName}:{track.SpotifyId}";
-                var externalMappingJson = await _cache.GetStringAsync(externalMappingKey);
-                
-                if (!string.IsNullOrEmpty(externalMappingJson))
-                {
-                    try
-                    {
-                        using var extDoc = JsonDocument.Parse(externalMappingJson);
-                        var extRoot = extDoc.RootElement;
-                        
-                        string? provider = null;
-                        
-                        if (extRoot.TryGetProperty("provider", out var providerEl))
-                        {
-                            provider = providerEl.GetString();
-                        }
-                        
-                        if (!string.IsNullOrEmpty(provider))
-                        {
-                            isLocal = false;
-                            externalProvider = provider;
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogWarning(ex, "Failed to process external manual mapping for {Title}", track.Title);
-                    }
-                }
-                else if (fallbackMatchedSpotifyIds.Contains(track.SpotifyId))
-                {
-                    isLocal = false;
-                    externalProvider = "SquidWTF";
-                }
-                else
-                {
-                    isLocal = null;
-                    externalProvider = null;
-                }
-            }
-            
-            tracksWithStatus.Add(new
-            {
-                position = track.Position,
-                title = track.Title,
-                artists = track.Artists,
-                album = track.Album,
-                isrc = track.Isrc,
-                spotifyId = track.SpotifyId,
-                durationMs = track.DurationMs,
-                albumArtUrl = track.AlbumArtUrl,
-                isLocal = isLocal,
-                externalProvider = externalProvider,
-                searchQuery = isLocal != true ? $"{track.Title} {track.PrimaryArtist}" : null
-            });
-        }
-        
-        return Ok(new
-        {
-            name = decodedName,
-            trackCount = spotifyTracks.Count,
-            tracks = tracksWithStatus
-        });
-    }
-    
-    /// <summary>
-    /// Trigger a manual refresh of all playlists
-    /// </summary>
-    [HttpPost("playlists/refresh")]
-    public async Task<IActionResult> RefreshPlaylists()
-    {
-        _logger.LogInformation("Manual playlist refresh triggered from admin UI");
-        await _playlistFetcher.TriggerFetchAsync();
-        
-        // Invalidate playlist summary cache
-        InvalidatePlaylistSummaryCache();
-        
-        return Ok(new { message = "Playlist refresh triggered", timestamp = DateTime.UtcNow });
-    }
-    
-    /// <summary>
-    /// Trigger track matching for a specific playlist
-    /// </summary>
-    [HttpPost("playlists/{name}/match")]
-    public async Task<IActionResult> MatchPlaylistTracks(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Manual track matching triggered for playlist: {Name}", decodedName);
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-            
-            // Invalidate playlist summary cache
-            InvalidatePlaylistSummaryCache();
-            
-            return Ok(new { message = $"Track matching triggered for {decodedName}", timestamp = DateTime.UtcNow });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to trigger track matching for {Name}", decodedName);
-            return StatusCode(500, new { error = "Failed to trigger track matching", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Clear cache and rebuild for a specific playlist
-    /// </summary>
-    [HttpPost("playlists/{name}/clear-cache")]
-    public async Task<IActionResult> ClearPlaylistCache(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Clear cache & rebuild triggered for playlist: {Name}", decodedName);
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            // Clear all cache keys for this playlist
-            var cacheKeys = new[]
-            {
-                $"spotify:playlist:items:{decodedName}",      // Pre-built items cache
-                $"spotify:matched:ordered:{decodedName}",     // Ordered matched tracks
-                $"spotify:matched:{decodedName}",             // Legacy matched tracks
-                $"spotify:missing:{decodedName}"              // Missing tracks
-            };
-            
-            foreach (var key in cacheKeys)
-            {
-                await _cache.DeleteAsync(key);
-                _logger.LogDebug("Cleared cache key: {Key}", key);
-            }
-            
-            // Delete file caches
-            var safeName = string.Join("_", decodedName.Split(Path.GetInvalidFileNameChars()));
-            var filesToDelete = new[]
-            {
-                Path.Combine(CacheDirectory, $"{safeName}_items.json"),
-                Path.Combine(CacheDirectory, $"{safeName}_matched.json")
-            };
-            
-            foreach (var file in filesToDelete)
-            {
-                if (System.IO.File.Exists(file))
-                {
-                    System.IO.File.Delete(file);
-                    _logger.LogDebug("Deleted cache file: {File}", file);
-                }
-            }
-            
-            _logger.LogInformation("✓ Cleared all caches for playlist: {Name}", decodedName);
-            
-            // Trigger rebuild
-            await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-            
-            // Invalidate playlist summary cache
-            InvalidatePlaylistSummaryCache();
-            
-            return Ok(new 
-            { 
-                message = $"Cache cleared and rebuild triggered for {decodedName}", 
-                timestamp = DateTime.UtcNow,
-                clearedKeys = cacheKeys.Length,
-                clearedFiles = filesToDelete.Count(System.IO.File.Exists)
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to clear cache for {Name}", decodedName);
-            return StatusCode(500, new { error = "Failed to clear cache", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Search Jellyfin library for tracks (for manual mapping)
-    /// </summary>
-    [HttpGet("jellyfin/search")]
-    public async Task<IActionResult> SearchJellyfinTracks([FromQuery] string query)
-    {
-        if (string.IsNullOrWhiteSpace(query))
-        {
-            return BadRequest(new { error = "Query is required" });
-        }
-        
-        try
-        {
-            var userId = _jellyfinSettings.UserId;
-            
-            // Build URL with UserId if available
-            var url = $"{_jellyfinSettings.Url}/Items?searchTerm={Uri.EscapeDataString(query)}&includeItemTypes=Audio&recursive=true&limit=20";
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"&UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            _logger.LogDebug("Searching Jellyfin: {Url}", url);
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogWarning("Jellyfin search failed: {StatusCode} - {Error}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to search Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var tracks = new List<object>();
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    // Verify it's actually an Audio item
-                    var type = item.TryGetProperty("Type", out var typeEl) ? typeEl.GetString() : "";
-                    if (type != "Audio")
-                    {
-                        _logger.LogDebug("Skipping non-audio item: {Type}", type);
-                        continue;
-                    }
-                    
-                    var id = item.TryGetProperty("Id", out var idEl) ? idEl.GetString() : "";
-                    var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() : "";
-                    var album = item.TryGetProperty("Album", out var albumEl) ? albumEl.GetString() : "";
-                    var artist = "";
-                    
-                    if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-                    {
-                        artist = artistsEl[0].GetString() ?? "";
-                    }
-                    else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-                    {
-                        artist = albumArtistEl.GetString() ?? "";
-                    }
-                    
-                    tracks.Add(new { id, title, artist, album });
-                }
-            }
-            
-            return Ok(new { tracks });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to search Jellyfin tracks");
-            return StatusCode(500, new { error = "Search failed" });
-        }
-    }
-    
-    /// <summary>
-    /// Get track details by Jellyfin ID (for URL-based mapping)
-    /// </summary>
-    [HttpGet("jellyfin/track/{id}")]
-    public async Task<IActionResult> GetJellyfinTrack(string id)
-    {
-        if (string.IsNullOrWhiteSpace(id))
-        {
-            return BadRequest(new { error = "Track ID is required" });
-        }
-        
-        try
-        {
-            var userId = _jellyfinSettings.UserId;
-            
-            var url = $"{_jellyfinSettings.Url}/Items/{id}";
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"?UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            _logger.LogDebug("Fetching Jellyfin track {Id} from {Url}", id, url);
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogWarning("Failed to fetch Jellyfin track {Id}: {StatusCode} - {Error}", 
-                    id, response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Track not found in Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var item = doc.RootElement;
-            
-            // Verify it's an Audio item
-            var type = item.TryGetProperty("Type", out var typeEl) ? typeEl.GetString() : "";
-            if (type != "Audio")
-            {
-                _logger.LogWarning("Item {Id} is not an Audio track, it's a {Type}", id, type);
-                return BadRequest(new { error = $"Item is not an audio track (it's a {type})" });
-            }
-            
-            var trackId = item.TryGetProperty("Id", out var idEl) ? idEl.GetString() : "";
-            var title = item.TryGetProperty("Name", out var nameEl) ? nameEl.GetString() : "";
-            var album = item.TryGetProperty("Album", out var albumEl) ? albumEl.GetString() : "";
-            var artist = "";
-            
-            if (item.TryGetProperty("Artists", out var artistsEl) && artistsEl.GetArrayLength() > 0)
-            {
-                artist = artistsEl[0].GetString() ?? "";
-            }
-            else if (item.TryGetProperty("AlbumArtist", out var albumArtistEl))
-            {
-                artist = albumArtistEl.GetString() ?? "";
-            }
-            
-            _logger.LogInformation("Found Jellyfin track: {Title} by {Artist}", title, artist);
-            
-            return Ok(new { id = trackId, title, artist, album });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get Jellyfin track {Id}", id);
-            return StatusCode(500, new { error = "Failed to get track details" });
-        }
-    }
-    
-    /// <summary>
-    /// Save manual track mapping (local Jellyfin or external provider)
-    /// </summary>
-    [HttpPost("playlists/{name}/map")]
-    public async Task<IActionResult> SaveManualMapping(string name, [FromBody] ManualMappingRequest request)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        if (string.IsNullOrWhiteSpace(request.SpotifyId))
-        {
-            return BadRequest(new { error = "SpotifyId is required" });
-        }
-        
-        // Validate that either Jellyfin mapping or external mapping is provided
-        var hasJellyfinMapping = !string.IsNullOrWhiteSpace(request.JellyfinId);
-        var hasExternalMapping = !string.IsNullOrWhiteSpace(request.ExternalProvider) && !string.IsNullOrWhiteSpace(request.ExternalId);
-        
-        if (!hasJellyfinMapping && !hasExternalMapping)
-        {
-            return BadRequest(new { error = "Either JellyfinId or (ExternalProvider + ExternalId) is required" });
-        }
-        
-        if (hasJellyfinMapping && hasExternalMapping)
-        {
-            return BadRequest(new { error = "Cannot specify both Jellyfin and external mapping for the same track" });
-        }
-        
-        try
-        {
-            string? normalizedProvider = null;
-            
-            if (hasJellyfinMapping)
-            {
-                // Store Jellyfin mapping in cache (NO EXPIRATION - manual mappings are permanent)
-                var mappingKey = $"spotify:manual-map:{decodedName}:{request.SpotifyId}";
-                await _cache.SetAsync(mappingKey, request.JellyfinId!);
-                
-                // Also save to file for persistence across restarts
-                await SaveManualMappingToFileAsync(decodedName, request.SpotifyId, request.JellyfinId!, null, null);
-                
-                _logger.LogInformation("Manual Jellyfin mapping saved: {Playlist} - Spotify {SpotifyId} → Jellyfin {JellyfinId}", 
-                    decodedName, request.SpotifyId, request.JellyfinId);
-            }
-            else
-            {
-                // Store external mapping in cache (NO EXPIRATION - manual mappings are permanent)
-                var externalMappingKey = $"spotify:external-map:{decodedName}:{request.SpotifyId}";
-                normalizedProvider = request.ExternalProvider!.ToLowerInvariant(); // Normalize to lowercase
-                var externalMapping = new { provider = normalizedProvider, id = request.ExternalId };
-                await _cache.SetAsync(externalMappingKey, externalMapping);
-                
-                // Also save to file for persistence across restarts
-                await SaveManualMappingToFileAsync(decodedName, request.SpotifyId, null, normalizedProvider, request.ExternalId!);
-                
-                _logger.LogInformation("Manual external mapping saved: {Playlist} - Spotify {SpotifyId} → {Provider} {ExternalId}", 
-                    decodedName, request.SpotifyId, normalizedProvider, request.ExternalId);
-            }
-            
-            // Clear all related caches to force rebuild
-            var matchedCacheKey = $"spotify:matched:{decodedName}";
-            var orderedCacheKey = $"spotify:matched:ordered:{decodedName}";
-            var playlistItemsKey = $"spotify:playlist:items:{decodedName}";
-            
-            await _cache.DeleteAsync(matchedCacheKey);
-            await _cache.DeleteAsync(orderedCacheKey);
-            await _cache.DeleteAsync(playlistItemsKey);
-            
-            // Also delete file caches to force rebuild
-            try
-            {
-                var cacheDir = "/app/cache/spotify";
-                var safeName = string.Join("_", decodedName.Split(Path.GetInvalidFileNameChars()));
-                var matchedFile = Path.Combine(cacheDir, $"{safeName}_matched.json");
-                var itemsFile = Path.Combine(cacheDir, $"{safeName}_items.json");
-                
-                if (System.IO.File.Exists(matchedFile))
-                {
-                    System.IO.File.Delete(matchedFile);
-                    _logger.LogDebug("Deleted matched tracks file cache for {Playlist}", decodedName);
-                }
-                
-                if (System.IO.File.Exists(itemsFile))
-                {
-                    System.IO.File.Delete(itemsFile);
-                    _logger.LogDebug("Deleted playlist items file cache for {Playlist}", decodedName);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to delete file caches for {Playlist}", decodedName);
-            }
-            
-            _logger.LogInformation("Cleared playlist caches for {Playlist} to force rebuild", decodedName);
-            
-            // Fetch external provider track details to return to the UI (only for external mappings)
-            string? trackTitle = null;
-            string? trackArtist = null;
-            string? trackAlbum = null;
-            
-            if (hasExternalMapping && normalizedProvider != null)
-            {
-                try
-                {
-                    var metadataService = HttpContext.RequestServices.GetRequiredService<IMusicMetadataService>();
-                    var externalSong = await metadataService.GetSongAsync(normalizedProvider, request.ExternalId!);
-                    
-                    if (externalSong != null)
-                    {
-                        trackTitle = externalSong.Title;
-                        trackArtist = externalSong.Artist;
-                        trackAlbum = externalSong.Album;
-                        _logger.LogInformation("✓ Fetched external track metadata: {Title} by {Artist}", trackTitle, trackArtist);
-                    }
-                    else
-                    {
-                        _logger.LogWarning("Failed to fetch external track metadata for {Provider} ID {Id}", 
-                            normalizedProvider, request.ExternalId);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to fetch external track metadata, but mapping was saved");
-                }
-            }
-            
-            // Trigger immediate playlist rebuild with the new mapping
-            if (_matchingService != null)
-            {
-                _logger.LogInformation("Triggering immediate playlist rebuild for {Playlist} with new manual mapping", decodedName);
-                
-                // Run rebuild in background with timeout to avoid blocking the response
-                _ = Task.Run(async () =>
-                {
-                    try
-                    {
-                        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); // 2 minute timeout
-                        await _matchingService.TriggerMatchingForPlaylistAsync(decodedName);
-                        _logger.LogInformation("✓ Playlist {Playlist} rebuilt successfully with manual mapping", decodedName);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        _logger.LogWarning("Playlist rebuild for {Playlist} timed out after 2 minutes", decodedName);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to rebuild playlist {Playlist} after manual mapping", decodedName);
-                    }
-                });
-            }
-            else
-            {
-                _logger.LogWarning("Matching service not available - playlist will rebuild on next scheduled run");
-            }
-            
-            // Return success with track details if available
-            var mappedTrack = new
-            {
-                id = request.ExternalId,
-                title = trackTitle ?? "Unknown",
-                artist = trackArtist ?? "Unknown",
-                album = trackAlbum ?? "Unknown",
-                isLocal = false,
-                externalProvider = request.ExternalProvider!.ToLowerInvariant()
-            };
-            
-            return Ok(new 
-            { 
-                message = "Mapping saved and playlist rebuild triggered", 
-                track = mappedTrack,
-                rebuildTriggered = _matchingService != null
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save manual mapping");
-            return StatusCode(500, new { error = "Failed to save mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Trigger track matching for all playlists
-    /// </summary>
-    [HttpPost("playlists/match-all")]
-    public async Task<IActionResult> MatchAllPlaylistTracks()
-    {
-        _logger.LogInformation("Manual track matching triggered for all playlists");
-        
-        if (_matchingService == null)
-        {
-            return BadRequest(new { error = "Track matching service is not available" });
-        }
-        
-        try
-        {
-            await _matchingService.TriggerMatchingAsync();
-            return Ok(new { message = "Track matching triggered for all playlists", timestamp = DateTime.UtcNow });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to trigger track matching for all playlists");
-            return StatusCode(500, new { error = "Failed to trigger track matching", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get current configuration (safe values only)
-    /// </summary>
-    [HttpGet("config")]
-    public IActionResult GetConfig()
-    {
-        return Ok(new
-        {
-            spotifyApi = new
-            {
-                enabled = _spotifyApiSettings.Enabled,
-                sessionCookie = MaskValue(_spotifyApiSettings.SessionCookie, showLast: 8),
-                sessionCookieSetDate = _spotifyApiSettings.SessionCookieSetDate,
-                cacheDurationMinutes = _spotifyApiSettings.CacheDurationMinutes,
-                rateLimitDelayMs = _spotifyApiSettings.RateLimitDelayMs,
-                preferIsrcMatching = _spotifyApiSettings.PreferIsrcMatching
-            },
-            spotifyImport = new
-            {
-                enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
-                playlists = _spotifyImportSettings.Playlists.Select(p => new
-                {
-                    name = p.Name,
-                    id = p.Id,
-                    localTracksPosition = p.LocalTracksPosition.ToString()
-                })
-            },
-            jellyfin = new
-            {
-                url = _jellyfinSettings.Url,
-                apiKey = MaskValue(_jellyfinSettings.ApiKey),
-                userId = _jellyfinSettings.UserId ?? "(not set)",
-                libraryId = _jellyfinSettings.LibraryId
-            },
-            library = new
-            {
-                downloadPath = _subsonicSettings.StorageMode == StorageMode.Cache 
-                    ? Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "cache")
-                    : Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "permanent"),
-                keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept"),
-                storageMode = _subsonicSettings.StorageMode.ToString(),
-                cacheDurationHours = _subsonicSettings.CacheDurationHours,
-                downloadMode = _subsonicSettings.DownloadMode.ToString()
-            },
-            deezer = new
-            {
-                arl = MaskValue(_deezerSettings.Arl, showLast: 8),
-                arlFallback = MaskValue(_deezerSettings.ArlFallback, showLast: 8),
-                quality = _deezerSettings.Quality ?? "FLAC"
-            },
-            qobuz = new
-            {
-                userAuthToken = MaskValue(_qobuzSettings.UserAuthToken, showLast: 8),
-                userId = _qobuzSettings.UserId,
-                quality = _qobuzSettings.Quality ?? "FLAC"
-            },
-            squidWtf = new
-            {
-                quality = _squidWtfSettings.Quality ?? "LOSSLESS"
-            },
-            musicBrainz = new
-            {
-                enabled = _musicBrainzSettings.Enabled,
-                username = _musicBrainzSettings.Username ?? "(not set)",
-                password = MaskValue(_musicBrainzSettings.Password),
-                baseUrl = _musicBrainzSettings.BaseUrl,
-                rateLimitMs = _musicBrainzSettings.RateLimitMs
-            }
-        });
-    }
-    
-    /// <summary>
-    /// Update configuration by modifying .env file
-    /// </summary>
-    [HttpPost("config")]
-    public async Task<IActionResult> UpdateConfig([FromBody] ConfigUpdateRequest request)
-    {
-        if (request == null || request.Updates == null || request.Updates.Count == 0)
-        {
-            return BadRequest(new { error = "No updates provided" });
-        }
-        
-        _logger.LogInformation("Config update requested: {Count} changes", request.Updates.Count);
-        
-        try
-        {
-            // Check if .env file exists
-            if (!System.IO.File.Exists(_envFilePath))
-            {
-                _logger.LogWarning(".env file not found at {Path}, creating new file", _envFilePath);
-            }
-            
-            // Read current .env file or create new one
-            var envContent = new Dictionary<string, string>();
-            
-            if (System.IO.File.Exists(_envFilePath))
-            {
-                var lines = await System.IO.File.ReadAllLinesAsync(_envFilePath);
-                foreach (var line in lines)
-                {
-                    if (string.IsNullOrWhiteSpace(line) || line.TrimStart().StartsWith('#'))
-                        continue;
-                    
-                    var eqIndex = line.IndexOf('=');
-                    if (eqIndex > 0)
-                    {
-                        var key = line[..eqIndex].Trim();
-                        var value = line[(eqIndex + 1)..].Trim();
-                        envContent[key] = value;
-                    }
-                }
-                _logger.LogInformation("Loaded {Count} existing env vars from {Path}", envContent.Count, _envFilePath);
-            }
-            
-            // Apply updates with validation
-            var appliedUpdates = new List<string>();
-            foreach (var (key, value) in request.Updates)
-            {
-                // Validate key format
-                if (!IsValidEnvKey(key))
-                {
-                    _logger.LogWarning("Invalid env key rejected: {Key}", key);
-                    return BadRequest(new { error = $"Invalid environment variable key: {key}" });
-                }
-                
-                envContent[key] = value;
-                appliedUpdates.Add(key);
-                _logger.LogInformation("  Setting {Key} = {Value}", key, 
-                    key.Contains("COOKIE") || key.Contains("TOKEN") || key.Contains("KEY") || key.Contains("ARL") 
-                        ? "***" + (value.Length > 8 ? value[^8..] : "") 
-                        : value);
-                
-                // Auto-set cookie date when Spotify session cookie is updated
-                if (key == "SPOTIFY_API_SESSION_COOKIE" && !string.IsNullOrEmpty(value))
-                {
-                    var dateKey = "SPOTIFY_API_SESSION_COOKIE_SET_DATE";
-                    var dateValue = DateTime.UtcNow.ToString("o"); // ISO 8601 format
-                    envContent[dateKey] = dateValue;
-                    appliedUpdates.Add(dateKey);
-                    _logger.LogInformation("  Auto-setting {Key} to {Value}", dateKey, dateValue);
-                }
-            }
-            
-            // Write back to .env file
-            var newContent = string.Join("\n", envContent.Select(kv => $"{kv.Key}={kv.Value}"));
-            await System.IO.File.WriteAllTextAsync(_envFilePath, newContent + "\n");
-            
-            _logger.LogInformation("Config file updated successfully at {Path}", _envFilePath);
-            
-            return Ok(new
-            {
-                message = "Configuration updated. Restart container to apply changes.",
-                updatedKeys = appliedUpdates,
-                requiresRestart = true,
-                envFilePath = _envFilePath
-            });
-        }
-        catch (UnauthorizedAccessException ex)
-        {
-            _logger.LogError(ex, "Permission denied writing to .env file at {Path}", _envFilePath);
-            return StatusCode(500, new { 
-                error = "Permission denied", 
-                details = "Cannot write to .env file. Check file permissions and volume mount.",
-                path = _envFilePath
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to update configuration at {Path}", _envFilePath);
-            return StatusCode(500, new { 
-                error = "Failed to update configuration", 
-                details = ex.Message,
-                path = _envFilePath
-            });
-        }
-    }
-    
-    /// <summary>
-    /// Add a new playlist to the configuration
-    /// </summary>
-    [HttpPost("playlists")]
-    public async Task<IActionResult> AddPlaylist([FromBody] AddPlaylistRequest request)
-    {
-        if (string.IsNullOrEmpty(request.Name) || string.IsNullOrEmpty(request.SpotifyId))
-        {
-            return BadRequest(new { error = "Name and SpotifyId are required" });
-        }
-        
-        _logger.LogInformation("Adding playlist: {Name} ({SpotifyId})", request.Name, request.SpotifyId);
-        
-        // Get current playlists
-        var currentPlaylists = _spotifyImportSettings.Playlists.ToList();
-        
-        // Check for duplicates
-        if (currentPlaylists.Any(p => p.Id == request.SpotifyId || p.Name == request.Name))
-        {
-            return BadRequest(new { error = "Playlist with this name or ID already exists" });
-        }
-        
-        // Add new playlist
-        currentPlaylists.Add(new SpotifyPlaylistConfig
-        {
-            Name = request.Name,
-            Id = request.SpotifyId,
-            LocalTracksPosition = request.LocalTracksPosition == "last" 
-                ? LocalTracksPosition.Last 
-                : LocalTracksPosition.First
-        });
-        
-        // Convert to JSON format for env var
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { p.Name, p.Id, p.LocalTracksPosition.ToString().ToLower() }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Remove a playlist from the configuration
-    /// </summary>
-    [HttpDelete("playlists/{name}")]
-    public async Task<IActionResult> RemovePlaylist(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        _logger.LogInformation("Removing playlist: {Name}", decodedName);
-        
-        // Read current playlists from .env file (not stale in-memory config)
-        var currentPlaylists = await ReadPlaylistsFromEnvFile();
-        var playlist = currentPlaylists.FirstOrDefault(p => p.Name == decodedName);
-        
-        if (playlist == null)
-        {
-            return NotFound(new { error = "Playlist not found" });
-        }
-        
-        currentPlaylists.Remove(playlist);
-        
-        // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last"],...]
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { p.Name, p.Id, p.JellyfinId, p.LocalTracksPosition.ToString().ToLower() }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Clear all cached data
-    /// </summary>
-    [HttpPost("cache/clear")]
-    public async Task<IActionResult> ClearCache()
-    {
-        _logger.LogInformation("Cache clear requested from admin UI");
-        
-        var clearedFiles = 0;
-        var clearedRedisKeys = 0;
-        
-        // Clear file cache
-        if (Directory.Exists(CacheDirectory))
-        {
-            foreach (var file in Directory.GetFiles(CacheDirectory, "*.json"))
-            {
-                try
-                {
-                    System.IO.File.Delete(file);
-                    clearedFiles++;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to delete cache file {File}", file);
-                }
-            }
-        }
-        
-        // Clear ALL Redis cache keys for Spotify playlists
-        // This includes matched tracks, ordered tracks, missing tracks, playlist items, etc.
-        foreach (var playlist in _spotifyImportSettings.Playlists)
-        {
-            var keysToDelete = new[]
-            {
-                $"spotify:playlist:{playlist.Name}",
-                $"spotify:missing:{playlist.Name}",
-                $"spotify:matched:{playlist.Name}",
-                $"spotify:matched:ordered:{playlist.Name}",
-                $"spotify:playlist:items:{playlist.Name}"  // NEW: Clear file-backed playlist items cache
-            };
-            
-            foreach (var key in keysToDelete)
-            {
-                if (await _cache.DeleteAsync(key))
-                {
-                    clearedRedisKeys++;
-                    _logger.LogInformation("Cleared Redis cache key: {Key}", key);
-                }
-            }
-        }
-        
-        // Clear all search cache keys (pattern-based deletion)
-        var searchKeysDeleted = await _cache.DeleteByPatternAsync("search:*");
-        clearedRedisKeys += searchKeysDeleted;
-        
-        // Clear all image cache keys (pattern-based deletion)
-        var imageKeysDeleted = await _cache.DeleteByPatternAsync("image:*");
-        clearedRedisKeys += imageKeysDeleted;
-        
-        _logger.LogInformation("Cache cleared: {Files} files, {RedisKeys} Redis keys (including {SearchKeys} search keys, {ImageKeys} image keys)", 
-            clearedFiles, clearedRedisKeys, searchKeysDeleted, imageKeysDeleted);
-        
-        return Ok(new { 
-            message = "Cache cleared successfully", 
-            filesDeleted = clearedFiles,
-            redisKeysDeleted = clearedRedisKeys
-        });
-    }
-    
-    /// <summary>
-    /// Restart the allstarr container to apply configuration changes
-    /// </summary>
-    [HttpPost("restart")]
-    public async Task<IActionResult> RestartContainer()
-    {
-        _logger.LogInformation("Container restart requested from admin UI");
-        
-        try
-        {
-            // Use Docker socket to restart the container
-            var socketPath = "/var/run/docker.sock";
-            
-            if (!System.IO.File.Exists(socketPath))
-            {
-                _logger.LogWarning("Docker socket not available at {Path}", socketPath);
-                return StatusCode(503, new { 
-                    error = "Docker socket not available", 
-                    message = "Please restart manually: docker-compose restart allstarr" 
-                });
-            }
-            
-            // Get container ID from hostname (Docker sets hostname to container ID by default)
-            // Or use the well-known container name
-            var containerId = Environment.MachineName;
-            var containerName = "allstarr";
-            
-            _logger.LogInformation("Attempting to restart container {ContainerId} / {ContainerName}", containerId, containerName);
-            
-            // Create Unix socket HTTP client
-            var handler = new SocketsHttpHandler
-            {
-                ConnectCallback = async (context, cancellationToken) =>
-                {
-                    var socket = new System.Net.Sockets.Socket(
-                        System.Net.Sockets.AddressFamily.Unix,
-                        System.Net.Sockets.SocketType.Stream,
-                        System.Net.Sockets.ProtocolType.Unspecified);
-                    
-                    var endpoint = new System.Net.Sockets.UnixDomainSocketEndPoint(socketPath);
-                    await socket.ConnectAsync(endpoint, cancellationToken);
-                    
-                    return new System.Net.Sockets.NetworkStream(socket, ownsSocket: true);
-                }
-            };
-            
-            using var dockerClient = new HttpClient(handler)
-            {
-                BaseAddress = new Uri("http://localhost")
-            };
-            
-            // Try to restart by container name first, then by ID
-            var response = await dockerClient.PostAsync($"/containers/{containerName}/restart?t=5", null);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                // Try by container ID
-                response = await dockerClient.PostAsync($"/containers/{containerId}/restart?t=5", null);
-            }
-            
-            if (response.IsSuccessStatusCode)
-            {
-                _logger.LogInformation("Container restart initiated successfully");
-                return Ok(new { message = "Restarting container...", success = true });
-            }
-            else
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to restart container: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { 
-                    error = "Failed to restart container", 
-                    message = "Please restart manually: docker-compose restart allstarr" 
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error restarting container");
-            return StatusCode(500, new { 
-                error = "Failed to restart container", 
-                details = ex.Message,
-                message = "Please restart manually: docker-compose restart allstarr" 
-            });
-        }
-    }
-    
-    /// <summary>
-    /// Initialize cookie date to current date if cookie exists but date is not set
-    /// </summary>
-    [HttpPost("config/init-cookie-date")]
-    public async Task<IActionResult> InitCookieDate()
-    {
-        // Only init if cookie exists but date is not set
-        if (string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie))
-        {
-            return BadRequest(new { error = "No cookie set" });
-        }
-        
-        if (!string.IsNullOrEmpty(_spotifyApiSettings.SessionCookieSetDate))
-        {
-            return Ok(new { message = "Cookie date already set", date = _spotifyApiSettings.SessionCookieSetDate });
-        }
-        
-        _logger.LogInformation("Initializing cookie date to current date (cookie existed without date tracking)");
-        
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_API_SESSION_COOKIE_SET_DATE"] = DateTime.UtcNow.ToString("o")
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Get all Jellyfin users
-    /// </summary>
-    [HttpGet("jellyfin/users")]
-    public async Task<IActionResult> GetJellyfinUsers()
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            var url = $"{_jellyfinSettings.Url}/Users";
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin users: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch users from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var users = new List<object>();
-            
-            foreach (var user in doc.RootElement.EnumerateArray())
-            {
-                var id = user.GetProperty("Id").GetString();
-                var name = user.GetProperty("Name").GetString();
-                
-                users.Add(new { id, name });
-            }
-            
-            return Ok(new { users });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin users");
-            return StatusCode(500, new { error = "Failed to fetch users", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get all Jellyfin libraries (virtual folders)
-    /// </summary>
-    [HttpGet("jellyfin/libraries")]
-    public async Task<IActionResult> GetJellyfinLibraries()
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            var url = $"{_jellyfinSettings.Url}/Library/VirtualFolders";
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin libraries: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch libraries from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var libraries = new List<object>();
-            
-            foreach (var lib in doc.RootElement.EnumerateArray())
-            {
-                var name = lib.GetProperty("Name").GetString();
-                var itemId = lib.TryGetProperty("ItemId", out var id) ? id.GetString() : null;
-                var collectionType = lib.TryGetProperty("CollectionType", out var ct) ? ct.GetString() : null;
-                
-                libraries.Add(new { id = itemId, name, collectionType });
-            }
-            
-            return Ok(new { libraries });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin libraries");
-            return StatusCode(500, new { error = "Failed to fetch libraries", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get all playlists from Jellyfin
-    /// </summary>
-    [HttpGet("jellyfin/playlists")]
-    public async Task<IActionResult> GetJellyfinPlaylists([FromQuery] string? userId = null)
-    {
-        if (string.IsNullOrEmpty(_jellyfinSettings.Url) || string.IsNullOrEmpty(_jellyfinSettings.ApiKey))
-        {
-            return BadRequest(new { error = "Jellyfin URL or API key not configured" });
-        }
-        
-        try
-        {
-            // Build URL with optional userId filter
-            var url = $"{_jellyfinSettings.Url}/Items?IncludeItemTypes=Playlist&Recursive=true&Fields=ProviderIds,ChildCount,RecursiveItemCount,SongCount";
-            
-            if (!string.IsNullOrEmpty(userId))
-            {
-                url += $"&UserId={userId}";
-            }
-            
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                var errorBody = await response.Content.ReadAsStringAsync();
-                _logger.LogError("Failed to fetch Jellyfin playlists: {StatusCode} - {Body}", response.StatusCode, errorBody);
-                return StatusCode((int)response.StatusCode, new { error = "Failed to fetch playlists from Jellyfin" });
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var playlists = new List<object>();
-            
-            // Read current playlists from .env file for accurate linked status
-            var configuredPlaylists = await ReadPlaylistsFromEnvFile();
-            
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    var id = item.GetProperty("Id").GetString();
-                    var name = item.GetProperty("Name").GetString();
-                    
-                    // Try multiple fields for track count - Jellyfin may use different fields
-                    var childCount = 0;
-                    if (item.TryGetProperty("ChildCount", out var cc) && cc.ValueKind == JsonValueKind.Number)
-                        childCount = cc.GetInt32();
-                    else if (item.TryGetProperty("SongCount", out var sc) && sc.ValueKind == JsonValueKind.Number)
-                        childCount = sc.GetInt32();
-                    else if (item.TryGetProperty("RecursiveItemCount", out var ric) && ric.ValueKind == JsonValueKind.Number)
-                        childCount = ric.GetInt32();
-                    
-                    // Check if this playlist is configured in allstarr by Jellyfin ID
-                    var configuredPlaylist = configuredPlaylists
-                        .FirstOrDefault(p => p.JellyfinId.Equals(id, StringComparison.OrdinalIgnoreCase));
-                    var isConfigured = configuredPlaylist != null;
-                    var linkedSpotifyId = configuredPlaylist?.Id;
-                    
-                    // Only fetch detailed track stats for configured Spotify playlists
-                    // This avoids expensive queries for large non-Spotify playlists
-                    var trackStats = (LocalTracks: 0, ExternalTracks: 0, ExternalAvailable: 0);
-                    if (isConfigured)
-                    {
-                        trackStats = await GetPlaylistTrackStats(id!);
-                    }
-                    
-                    playlists.Add(new
-                    {
-                        id,
-                        name,
-                        trackCount = childCount,
-                        linkedSpotifyId,
-                        isConfigured,
-                        localTracks = trackStats.LocalTracks,
-                        externalTracks = trackStats.ExternalTracks,
-                        externalAvailable = trackStats.ExternalAvailable
-                    });
-                }
-            }
-            
-            return Ok(new { playlists });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Jellyfin playlists");
-            return StatusCode(500, new { error = "Failed to fetch playlists", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Get track statistics for a playlist (local vs external)
-    /// </summary>
-    private async Task<(int LocalTracks, int ExternalTracks, int ExternalAvailable)> GetPlaylistTrackStats(string playlistId)
-    {
-        try
-        {
-            // Jellyfin requires a UserId to fetch playlist items
-            // We'll use the first available user if not specified
-            var userId = _jellyfinSettings.UserId;
-            
-            // If no user configured, try to get the first user
-            if (string.IsNullOrEmpty(userId))
-            {
-                var usersResponse = await _jellyfinHttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, $"{_jellyfinSettings.Url}/Users")
-                {
-                    Headers = { { "X-Emby-Authorization", GetJellyfinAuthHeader() } }
-                });
-                
-                if (usersResponse.IsSuccessStatusCode)
-                {
-                    var usersJson = await usersResponse.Content.ReadAsStringAsync();
-                    using var usersDoc = JsonDocument.Parse(usersJson);
-                    if (usersDoc.RootElement.GetArrayLength() > 0)
-                    {
-                        userId = usersDoc.RootElement[0].GetProperty("Id").GetString();
-                    }
-                }
-            }
-            
-            if (string.IsNullOrEmpty(userId))
-            {
-                _logger.LogWarning("No user ID available to fetch playlist items for {PlaylistId}", playlistId);
-                return (0, 0, 0);
-            }
-            
-            var url = $"{_jellyfinSettings.Url}/Playlists/{playlistId}/Items?UserId={userId}&Fields=Path";
-            var request = new HttpRequestMessage(HttpMethod.Get, url);
-            request.Headers.Add("X-Emby-Authorization", GetJellyfinAuthHeader());
-            
-            var response = await _jellyfinHttpClient.SendAsync(request);
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogWarning("Failed to fetch playlist items for {PlaylistId}: {StatusCode}", playlistId, response.StatusCode);
-                return (0, 0, 0);
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            using var doc = JsonDocument.Parse(json);
-            
-            var localTracks = 0;
-            var externalTracks = 0;
-            var externalAvailable = 0;
-            
-            if (doc.RootElement.TryGetProperty("Items", out var items))
-            {
-                foreach (var item in items.EnumerateArray())
-                {
-                    // Simpler detection: Check if Path exists and is not empty
-                    // External tracks from allstarr won't have a Path property
-                    var hasPath = item.TryGetProperty("Path", out var pathProp) && 
-                                  pathProp.ValueKind == JsonValueKind.String &&
-                                  !string.IsNullOrEmpty(pathProp.GetString());
-                    
-                    if (hasPath)
-                    {
-                        var pathStr = pathProp.GetString()!;
-                        // Check if it's a real file path (not a URL)
-                        if (pathStr.StartsWith("/") || pathStr.Contains(":\\"))
-                        {
-                            localTracks++;
-                        }
-                        else
-                        {
-                            // It's a URL or external source
-                            externalTracks++;
-                            externalAvailable++;
-                        }
-                    }
-                    else
-                    {
-                        // No path means it's external
-                        externalTracks++;
-                        externalAvailable++;
-                    }
-                }
-                
-                _logger.LogDebug("Playlist {PlaylistId} stats: {Local} local, {External} external", 
-                    playlistId, localTracks, externalTracks);
-            }
-            else
-            {
-                _logger.LogWarning("No Items property in playlist response for {PlaylistId}", playlistId);
-            }
-            
-            return (localTracks, externalTracks, externalAvailable);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get track stats for playlist {PlaylistId}", playlistId);
-            return (0, 0, 0);
-        }
-    }
-    
-    /// <summary>
-    /// Link a Jellyfin playlist to a Spotify playlist
-    /// </summary>
-    [HttpPost("jellyfin/playlists/{jellyfinPlaylistId}/link")]
-    public async Task<IActionResult> LinkPlaylist(string jellyfinPlaylistId, [FromBody] LinkPlaylistRequest request)
-    {
-        if (string.IsNullOrEmpty(request.SpotifyPlaylistId))
-        {
-            return BadRequest(new { error = "SpotifyPlaylistId is required" });
-        }
-        
-        if (string.IsNullOrEmpty(request.Name))
-        {
-            return BadRequest(new { error = "Name is required" });
-        }
-        
-        _logger.LogInformation("Linking Jellyfin playlist {JellyfinId} to Spotify playlist {SpotifyId} with name {Name}", 
-            jellyfinPlaylistId, request.SpotifyPlaylistId, request.Name);
-        
-        // Read current playlists from .env file (not in-memory config which is stale)
-        var currentPlaylists = await ReadPlaylistsFromEnvFile();
-        
-        // Check if already configured by Jellyfin ID
-        var existingByJellyfinId = currentPlaylists
-            .FirstOrDefault(p => p.JellyfinId.Equals(jellyfinPlaylistId, StringComparison.OrdinalIgnoreCase));
-        
-        if (existingByJellyfinId != null)
-        {
-            return BadRequest(new { error = $"This Jellyfin playlist is already linked to '{existingByJellyfinId.Name}'" });
-        }
-        
-        // Check if already configured by name
-        var existingByName = currentPlaylists
-            .FirstOrDefault(p => p.Name.Equals(request.Name, StringComparison.OrdinalIgnoreCase));
-        
-        if (existingByName != null)
-        {
-            return BadRequest(new { error = $"Playlist name '{request.Name}' is already configured" });
-        }
-        
-        // Add the playlist to configuration
-        currentPlaylists.Add(new SpotifyPlaylistConfig
-        {
-            Name = request.Name,
-            Id = request.SpotifyPlaylistId,
-            JellyfinId = jellyfinPlaylistId,
-            LocalTracksPosition = LocalTracksPosition.First // Use Spotify order
-        });
-        
-        // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last"],...]
-        var playlistsJson = JsonSerializer.Serialize(
-            currentPlaylists.Select(p => new[] { p.Name, p.Id, p.JellyfinId, p.LocalTracksPosition.ToString().ToLower() }).ToArray()
-        );
-        
-        // Update .env file
-        var updateRequest = new ConfigUpdateRequest
-        {
-            Updates = new Dictionary<string, string>
-            {
-                ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson
-            }
-        };
-        
-        return await UpdateConfig(updateRequest);
-    }
-    
-    /// <summary>
-    /// Unlink a playlist (remove from configuration)
-    /// </summary>
-    [HttpDelete("jellyfin/playlists/{name}/unlink")]
-    public async Task<IActionResult> UnlinkPlaylist(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        return await RemovePlaylist(decodedName);
-    }
-    
-    private string GetJellyfinAuthHeader()
-    {
-        return $"MediaBrowser Client=\"Allstarr\", Device=\"Server\", DeviceId=\"allstarr-admin\", Version=\"1.0.0\", Token=\"{_jellyfinSettings.ApiKey}\"";
-    }
-    
-    /// <summary>
-    /// Read current playlists from .env file (not stale in-memory config)
-    /// </summary>
-    private async Task<List<SpotifyPlaylistConfig>> ReadPlaylistsFromEnvFile()
-    {
-        var playlists = new List<SpotifyPlaylistConfig>();
-        
-        if (!System.IO.File.Exists(_envFilePath))
-        {
-            return playlists;
-        }
-        
-        try
-        {
-            var lines = await System.IO.File.ReadAllLinesAsync(_envFilePath);
-            foreach (var line in lines)
-            {
-                if (line.TrimStart().StartsWith("SPOTIFY_IMPORT_PLAYLISTS="))
-                {
-                    var value = line.Substring(line.IndexOf('=') + 1).Trim();
-                    
-                    if (string.IsNullOrWhiteSpace(value) || value == "[]")
-                    {
-                        return playlists;
-                    }
-                    
-                    // Parse JSON array format: [["Name","SpotifyId","JellyfinId","first|last"],...]
-                    var playlistArrays = JsonSerializer.Deserialize<string[][]>(value);
-                    if (playlistArrays != null)
-                    {
-                        foreach (var arr in playlistArrays)
-                        {
-                            if (arr.Length >= 2)
-                            {
-                                playlists.Add(new SpotifyPlaylistConfig
-                                {
-                                    Name = arr[0].Trim(),
-                                    Id = arr[1].Trim(),
-                                    JellyfinId = arr.Length >= 3 ? arr[2].Trim() : "",
-                                    LocalTracksPosition = arr.Length >= 4 && 
-                                        arr[3].Trim().Equals("last", StringComparison.OrdinalIgnoreCase)
-                                        ? LocalTracksPosition.Last
-                                        : LocalTracksPosition.First
-                                });
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to read playlists from .env file");
-        }
-        
-        return playlists;
-    }
-    
-    private static string MaskValue(string? value, int showLast = 0)
-    {
-        if (string.IsNullOrEmpty(value)) return "(not set)";
-        if (value.Length <= showLast) return "***";
-        return showLast > 0 ? "***" + value[^showLast..] : value[..8] + "...";
-    }
-    
-    private static string SanitizeFileName(string name)
-    {
-        return string.Join("_", name.Split(Path.GetInvalidFileNameChars()));
-    }
-    
-    private static bool IsValidEnvKey(string key)
-    {
-        // Only allow alphanumeric, underscore, and must start with letter/underscore
-        return Regex.IsMatch(key, @"^[A-Z_][A-Z0-9_]*$", RegexOptions.IgnoreCase);
-    }
-    
-    /// <summary>
-    /// Export .env file for backup/transfer
-    /// </summary>
-    [HttpGet("export-env")]
-    public IActionResult ExportEnv()
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_envFilePath))
-            {
-                return NotFound(new { error = ".env file not found" });
-            }
-
-            var envContent = System.IO.File.ReadAllText(_envFilePath);
-            var bytes = System.Text.Encoding.UTF8.GetBytes(envContent);
-            
-            return File(bytes, "text/plain", ".env");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to export .env file");
-            return StatusCode(500, new { error = "Failed to export .env file", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Import .env file from upload
-    /// </summary>
-    [HttpPost("import-env")]
-    public async Task<IActionResult> ImportEnv([FromForm] IFormFile file)
-    {
-        if (file == null || file.Length == 0)
-        {
-            return BadRequest(new { error = "No file provided" });
-        }
-
-        if (!file.FileName.EndsWith(".env"))
-        {
-            return BadRequest(new { error = "File must be a .env file" });
-        }
-
-        try
-        {
-            // Read uploaded file
-            using var reader = new StreamReader(file.OpenReadStream());
-            var content = await reader.ReadToEndAsync();
-            
-            // Validate it's a valid .env file (basic check)
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                return BadRequest(new { error = ".env file is empty" });
-            }
-
-            // Backup existing .env
-            if (System.IO.File.Exists(_envFilePath))
-            {
-                var backupPath = $"{_envFilePath}.backup.{DateTime.UtcNow:yyyyMMddHHmmss}";
-                System.IO.File.Copy(_envFilePath, backupPath, true);
-                _logger.LogInformation("Backed up existing .env to {BackupPath}", backupPath);
-            }
-
-            // Write new .env file
-            await System.IO.File.WriteAllTextAsync(_envFilePath, content);
-            
-            _logger.LogInformation(".env file imported successfully");
-            
-            return Ok(new 
-            { 
-                success = true, 
-                message = ".env file imported successfully. Restart the application for changes to take effect." 
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to import .env file");
-            return StatusCode(500, new { error = "Failed to import .env file", details = ex.Message });
-        }
-    }
-    
-    /// <summary>
-    /// Gets detailed memory usage statistics for debugging.
-    /// </summary>
-    [HttpGet("memory-stats")]
-    public IActionResult GetMemoryStats()
-    {
-        try
-        {
-            // Get memory stats BEFORE GC
-            var memoryBeforeGC = GC.GetTotalMemory(false);
-            var gen0Before = GC.CollectionCount(0);
-            var gen1Before = GC.CollectionCount(1);
-            var gen2Before = GC.CollectionCount(2);
-            
-            // Force garbage collection to get accurate numbers
-            GC.Collect();
-            GC.WaitForPendingFinalizers();
-            GC.Collect();
-
-            var memoryAfterGC = GC.GetTotalMemory(false);
-            var gen0After = GC.CollectionCount(0);
-            var gen1After = GC.CollectionCount(1);
-            var gen2After = GC.CollectionCount(2);
-            
-            // Get process memory info
-            var process = System.Diagnostics.Process.GetCurrentProcess();
-            
-            return Ok(new {
-                Timestamp = DateTime.UtcNow,
-                BeforeGC = new {
-                    GCMemoryBytes = memoryBeforeGC,
-                    GCMemoryMB = Math.Round(memoryBeforeGC / (1024.0 * 1024.0), 2)
-                },
-                AfterGC = new {
-                    GCMemoryBytes = memoryAfterGC,
-                    GCMemoryMB = Math.Round(memoryAfterGC / (1024.0 * 1024.0), 2)
-                },
-                MemoryFreedMB = Math.Round((memoryBeforeGC - memoryAfterGC) / (1024.0 * 1024.0), 2),
-                ProcessWorkingSetBytes = process.WorkingSet64,
-                ProcessWorkingSetMB = Math.Round(process.WorkingSet64 / (1024.0 * 1024.0), 2),
-                ProcessPrivateMemoryBytes = process.PrivateMemorySize64,
-                ProcessPrivateMemoryMB = Math.Round(process.PrivateMemorySize64 / (1024.0 * 1024.0), 2),
-                ProcessVirtualMemoryBytes = process.VirtualMemorySize64,
-                ProcessVirtualMemoryMB = Math.Round(process.VirtualMemorySize64 / (1024.0 * 1024.0), 2),
-                GCCollections = new {
-                    Gen0Before = gen0Before,
-                    Gen0After = gen0After,
-                    Gen0Triggered = gen0After - gen0Before,
-                    Gen1Before = gen1Before,
-                    Gen1After = gen1After,
-                    Gen1Triggered = gen1After - gen1Before,
-                    Gen2Before = gen2Before,
-                    Gen2After = gen2After,
-                    Gen2Triggered = gen2After - gen2Before
-                },
-                GCMode = GCSettings.IsServerGC ? "Server" : "Workstation",
-                GCLatencyMode = GCSettings.LatencyMode.ToString()
-            });
-        }
-        catch (Exception ex)
-        {
-            return BadRequest(new { error = ex.Message });
-        }
-=======
->>>>>>> beta
    }

    [HttpGet("health")]
@@ -4921,2108 +31,4 @@ public class AdminController : ControllerBase
    {
        return Ok(new { status = "healthy", message = "Admin API is running" });
    }
-<<<<<<< HEAD
-
-    /// <summary>
-    /// Gets current active sessions for debugging.
-    /// </summary>
-    [HttpGet("sessions")]
-    public IActionResult GetActiveSessions()
-    {
-        try
-        {
-            var sessionManager = HttpContext.RequestServices.GetService<JellyfinSessionManager>();
-            if (sessionManager == null)
-            {
-                return BadRequest(new { error = "Session manager not available" });
-            }
-
-            var sessionInfo = sessionManager.GetSessionsInfo();
-            return Ok(sessionInfo);
-        }
-        catch (Exception ex)
-        {
-            return BadRequest(new { error = ex.Message });
-        }
-    }
-
-    /// <summary>
-    /// Helper method to trigger GC after large file operations to prevent memory leaks.
-    /// </summary>
-    private static void TriggerGCAfterLargeOperation(int sizeInBytes)
-    {
-        // Only trigger GC for files larger than 1MB to avoid performance impact
-        if (sizeInBytes > 1024 * 1024)
-        {
-            // Suggest GC collection for large objects (they go to LOH and aren't collected as frequently)
-            GC.Collect(2, GCCollectionMode.Optimized, blocking: false);
-        }
-    }
-
-    #region Spotify Admin Endpoints
-
-    /// <summary>
-    /// Manual trigger endpoint to force fetch Spotify missing tracks.
-    /// </summary>
-    [HttpGet("spotify/sync")]
-    public async Task<IActionResult> TriggerSpotifySync([FromServices] IEnumerable<IHostedService> hostedServices)
-    {
-        try
-        {
-            if (!_spotifyImportSettings.Enabled)
-            {
-                return BadRequest(new { error = "Spotify Import is not enabled" });
-            }
-
-            _logger.LogInformation("Manual Spotify sync triggered via admin endpoint");
-            
-            // Find the SpotifyMissingTracksFetcher service
-            var fetcherService = hostedServices
-                .OfType<allstarr.Services.Spotify.SpotifyMissingTracksFetcher>()
-                .FirstOrDefault();
-
-            if (fetcherService == null)
-            {
-                return BadRequest(new { error = "SpotifyMissingTracksFetcher service not found" });
-            }
-
-            // Trigger the sync in background
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    // Use reflection to call the private ExecuteOnceAsync method
-                    var method = fetcherService.GetType().GetMethod("ExecuteOnceAsync", 
-                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-                    
-                    if (method != null)
-                    {
-                        await (Task)method.Invoke(fetcherService, new object[] { CancellationToken.None })!;
-                        _logger.LogInformation("Manual Spotify sync completed successfully");
-                    }
-                    else
-                    {
-                        _logger.LogError("Could not find ExecuteOnceAsync method on SpotifyMissingTracksFetcher");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error during manual Spotify sync");
-                }
-            });
-
-            return Ok(new { 
-                message = "Spotify sync started in background",
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error triggering Spotify sync");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Manual trigger endpoint to force Spotify track matching.
-    /// </summary>
-    [HttpGet("spotify/match")]
-    public async Task<IActionResult> TriggerSpotifyMatch([FromServices] IEnumerable<IHostedService> hostedServices)
-    {
-        try
-        {
-            if (!_spotifyApiSettings.Enabled)
-            {
-                return BadRequest(new { error = "Spotify API is not enabled" });
-            }
-
-            _logger.LogInformation("Manual Spotify track matching triggered via admin endpoint");
-            
-            // Find the SpotifyTrackMatchingService
-            var matchingService = hostedServices
-                .OfType<allstarr.Services.Spotify.SpotifyTrackMatchingService>()
-                .FirstOrDefault();
-
-            if (matchingService == null)
-            {
-                return BadRequest(new { error = "SpotifyTrackMatchingService not found" });
-            }
-
-            // Trigger matching in background
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    // Use reflection to call the private ExecuteOnceAsync method
-                    var method = matchingService.GetType().GetMethod("ExecuteOnceAsync", 
-                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-                    
-                    if (method != null)
-                    {
-                        await (Task)method.Invoke(matchingService, new object[] { CancellationToken.None })!;
-                        _logger.LogInformation("Manual Spotify track matching completed successfully");
-                    }
-                    else
-                    {
-                        _logger.LogError("Could not find ExecuteOnceAsync method on SpotifyTrackMatchingService");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error during manual Spotify track matching");
-                }
-            });
-
-            return Ok(new { 
-                message = "Spotify track matching started in background",
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error triggering Spotify track matching");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Clear Spotify playlist cache to force re-matching.
-    /// </summary>
-    [HttpPost("spotify/clear-cache")]
-    public async Task<IActionResult> ClearSpotifyCache()
-    {
-        try
-        {
-            var clearedKeys = new List<string>();
-            
-            // Clear Redis cache for all configured playlists
-            foreach (var playlist in _spotifyImportSettings.Playlists)
-            {
-                var keys = new[]
-                {
-                    $"spotify:playlist:{playlist.Name}",
-                    $"spotify:playlist:items:{playlist.Name}",
-                    $"spotify:matched:{playlist.Name}"
-                };
-                
-                foreach (var key in keys)
-                {
-                    await _cache.DeleteAsync(key);
-                    clearedKeys.Add(key);
-                }
-            }
-            
-            _logger.LogDebug("Cleared Spotify cache for {Count} keys via admin endpoint", clearedKeys.Count);
-            
-            return Ok(new { 
-                message = "Spotify cache cleared successfully",
-                clearedKeys = clearedKeys,
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error clearing Spotify cache");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    #endregion
-
-    #region Debug Endpoints
-
-    /// <summary>
-    /// Gets endpoint usage statistics from the log file.
-    /// </summary>
-    [HttpGet("debug/endpoint-usage")]
-    public async Task<IActionResult> GetEndpointUsage(
-        [FromQuery] int top = 100,
-        [FromQuery] string? since = null)
-    {
-        try
-        {
-            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
-            
-            if (!System.IO.File.Exists(logFile))
-            {
-                return Ok(new { 
-                    message = "No endpoint usage data available",
-                    endpoints = new object[0]
-                });
-            }
-            
-            var lines = await System.IO.File.ReadAllLinesAsync(logFile);
-            var usage = new Dictionary<string, int>();
-            DateTime? sinceDate = null;
-            
-            if (!string.IsNullOrEmpty(since) && DateTime.TryParse(since, out var parsedDate))
-            {
-                sinceDate = parsedDate;
-            }
-            
-            foreach (var line in lines.Skip(1)) // Skip header
-            {
-                var parts = line.Split(',');
-                if (parts.Length >= 3)
-                {
-                    var timestamp = parts[0];
-                    var method = parts[1];
-                    var endpoint = parts[2];
-                    
-                    // Combine method and endpoint for better clarity
-                    var fullEndpoint = $"{method} {endpoint}";
-                    
-                    // Filter by date if specified
-                    if (sinceDate.HasValue && DateTime.TryParse(timestamp, out var logDate))
-                    {
-                        if (logDate < sinceDate.Value)
-                            continue;
-                    }
-                    
-                    usage[fullEndpoint] = usage.GetValueOrDefault(fullEndpoint, 0) + 1;
-                }
-            }
-            
-            var topEndpoints = usage
-                .OrderByDescending(kv => kv.Value)
-                .Take(top)
-                .Select(kv => new { endpoint = kv.Key, count = kv.Value })
-                .ToArray();
-            
-            return Ok(new {
-                totalEndpoints = usage.Count,
-                totalRequests = usage.Values.Sum(),
-                since = since,
-                top = top,
-                endpoints = topEndpoints
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting endpoint usage");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Clears the endpoint usage log file.
-    /// </summary>
-    [HttpDelete("debug/endpoint-usage")]
-    public IActionResult ClearEndpointUsage()
-    {
-        try
-        {
-            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
-            
-            if (System.IO.File.Exists(logFile))
-            {
-                System.IO.File.Delete(logFile);
-                _logger.LogDebug("Cleared endpoint usage log via admin endpoint");
-                
-                return Ok(new { 
-                    message = "Endpoint usage log cleared successfully",
-                    timestamp = DateTime.UtcNow
-                });
-            }
-            else
-            {
-                return Ok(new { 
-                    message = "No endpoint usage log file found",
-                    timestamp = DateTime.UtcNow
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error clearing endpoint usage log");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    #endregion
-    
-    #region Private Helper Methods
-    
-    /// <summary>
-    /// Saves a manual mapping to file for persistence across restarts.
-    /// Manual mappings NEVER expire - they are permanent user decisions.
-    /// </summary>
-    private async Task SaveManualMappingToFileAsync(
-        string playlistName, 
-        string spotifyId, 
-        string? jellyfinId, 
-        string? externalProvider, 
-        string? externalId)
-    {
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            Directory.CreateDirectory(mappingsDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(mappingsDir, $"{safeName}_mappings.json");
-            
-            // Load existing mappings
-            var mappings = new Dictionary<string, ManualMappingEntry>();
-            if (System.IO.File.Exists(filePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(filePath);
-                mappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json) 
-                    ?? new Dictionary<string, ManualMappingEntry>();
-            }
-            
-            // Add or update mapping
-            mappings[spotifyId] = new ManualMappingEntry
-            {
-                SpotifyId = spotifyId,
-                JellyfinId = jellyfinId,
-                ExternalProvider = externalProvider,
-                ExternalId = externalId,
-                CreatedAt = DateTime.UtcNow
-            };
-            
-            // Save back to file
-            var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, updatedJson);
-            
-            _logger.LogDebug("💾 Saved manual mapping to file: {Playlist} - {SpotifyId}", playlistName, spotifyId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save manual mapping to file for {Playlist}", playlistName);
-        }
-    }
-    
-    /// <summary>
-    /// Save lyrics mapping to file for persistence across restarts.
-    /// Lyrics mappings NEVER expire - they are permanent user decisions.
-    /// </summary>
-    private async Task SaveLyricsMappingToFileAsync(
-        string artist,
-        string title,
-        string album,
-        int durationSeconds,
-        int lyricsId)
-    {
-        try
-        {
-            var mappingsFile = "/app/cache/lyrics_mappings.json";
-            
-            // Load existing mappings
-            var mappings = new List<LyricsMappingEntry>();
-            if (System.IO.File.Exists(mappingsFile))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(mappingsFile);
-                mappings = JsonSerializer.Deserialize<List<LyricsMappingEntry>>(json) 
-                    ?? new List<LyricsMappingEntry>();
-            }
-            
-            // Remove any existing mapping for this track
-            mappings.RemoveAll(m => 
-                m.Artist.Equals(artist, StringComparison.OrdinalIgnoreCase) && 
-                m.Title.Equals(title, StringComparison.OrdinalIgnoreCase));
-            
-            // Add new mapping
-            mappings.Add(new LyricsMappingEntry
-            {
-                Artist = artist,
-                Title = title,
-                Album = album,
-                DurationSeconds = durationSeconds,
-                LyricsId = lyricsId,
-                CreatedAt = DateTime.UtcNow
-            });
-            
-            // Save back to file
-            var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(mappingsFile, updatedJson);
-            
-            _logger.LogDebug("💾 Saved lyrics mapping to file: {Artist} - {Title} → Lyrics ID {LyricsId}", 
-                artist, title, lyricsId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save lyrics mapping to file for {Artist} - {Title}", artist, title);
-        }
-    }
-    
-    /// <summary>
-    /// Save manual lyrics ID mapping for a track
-    /// </summary>
-    [HttpPost("lyrics/map")]
-    public async Task<IActionResult> SaveLyricsMapping([FromBody] LyricsMappingRequest request)
-    {
-        if (string.IsNullOrWhiteSpace(request.Artist) || string.IsNullOrWhiteSpace(request.Title))
-        {
-            return BadRequest(new { error = "Artist and Title are required" });
-        }
-        
-        if (request.LyricsId <= 0)
-        {
-            return BadRequest(new { error = "Valid LyricsId is required" });
-        }
-        
-        try
-        {
-            // Store lyrics mapping in cache (NO EXPIRATION - manual mappings are permanent)
-            var mappingKey = $"lyrics:manual-map:{request.Artist}:{request.Title}";
-            await _cache.SetStringAsync(mappingKey, request.LyricsId.ToString());
-            
-            // Also save to file for persistence across restarts
-            await SaveLyricsMappingToFileAsync(request.Artist, request.Title, request.Album ?? "", request.DurationSeconds, request.LyricsId);
-            
-            _logger.LogInformation("Manual lyrics mapping saved: {Artist} - {Title} → Lyrics ID {LyricsId}", 
-                request.Artist, request.Title, request.LyricsId);
-            
-            // Optionally fetch and cache the lyrics immediately
-            try
-            {
-                var lyricsService = _serviceProvider.GetService<allstarr.Services.Lyrics.LrclibService>();
-                if (lyricsService != null)
-                {
-                    var lyricsInfo = await lyricsService.GetLyricsByIdAsync(request.LyricsId);
-                    if (lyricsInfo != null && !string.IsNullOrEmpty(lyricsInfo.PlainLyrics))
-                    {
-                        // Cache the lyrics using the standard cache key
-                        var lyricsCacheKey = $"lyrics:{request.Artist}:{request.Title}:{request.Album ?? ""}:{request.DurationSeconds}";
-                        await _cache.SetAsync(lyricsCacheKey, lyricsInfo.PlainLyrics);
-                        _logger.LogDebug("✓ Fetched and cached lyrics for {Artist} - {Title}", request.Artist, request.Title);
-                        
-                        return Ok(new 
-                        { 
-                            message = "Lyrics mapping saved and lyrics cached successfully",
-                            lyricsId = request.LyricsId,
-                            cached = true,
-                            lyrics = new
-                            {
-                                id = lyricsInfo.Id,
-                                trackName = lyricsInfo.TrackName,
-                                artistName = lyricsInfo.ArtistName,
-                                albumName = lyricsInfo.AlbumName,
-                                duration = lyricsInfo.Duration,
-                                instrumental = lyricsInfo.Instrumental
-                            }
-                        });
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to fetch lyrics after mapping, but mapping was saved");
-            }
-            
-            return Ok(new 
-            { 
-                message = "Lyrics mapping saved successfully",
-                lyricsId = request.LyricsId,
-                cached = false
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save lyrics mapping");
-            return StatusCode(500, new { error = "Failed to save lyrics mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Get manual lyrics mappings
-    /// </summary>
-    [HttpGet("lyrics/mappings")]
-    public async Task<IActionResult> GetLyricsMappings()
-    {
-        try
-        {
-            var mappingsFile = "/app/cache/lyrics_mappings.json";
-            
-            if (!System.IO.File.Exists(mappingsFile))
-            {
-                return Ok(new { mappings = new List<object>() });
-            }
-            
-            var json = await System.IO.File.ReadAllTextAsync(mappingsFile);
-            var mappings = JsonSerializer.Deserialize<List<LyricsMappingEntry>>(json) ?? new List<LyricsMappingEntry>();
-            
-            return Ok(new { mappings });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get lyrics mappings");
-            return StatusCode(500, new { error = "Failed to get lyrics mappings" });
-        }
-    }
-    
-    /// <summary>
-    /// Get all manual track mappings (both Jellyfin and external) for all playlists
-    /// </summary>
-    [HttpGet("mappings/tracks")]
-    public async Task<IActionResult> GetAllTrackMappings()
-    {
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            var allMappings = new List<object>();
-            
-            if (!Directory.Exists(mappingsDir))
-            {
-                return Ok(new { mappings = allMappings, totalCount = 0 });
-            }
-            
-            var files = Directory.GetFiles(mappingsDir, "*_mappings.json");
-            
-            foreach (var file in files)
-            {
-                try
-                {
-                    var json = await System.IO.File.ReadAllTextAsync(file);
-                    var playlistMappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json);
-                    
-                    if (playlistMappings != null)
-                    {
-                        var fileName = Path.GetFileNameWithoutExtension(file);
-                        var playlistName = fileName.Replace("_mappings", "").Replace("_", " ");
-                        
-                        foreach (var mapping in playlistMappings.Values)
-                        {
-                            allMappings.Add(new
-                            {
-                                playlist = playlistName,
-                                spotifyId = mapping.SpotifyId,
-                                type = !string.IsNullOrEmpty(mapping.JellyfinId) ? "jellyfin" : "external",
-                                jellyfinId = mapping.JellyfinId,
-                                externalProvider = mapping.ExternalProvider,
-                                externalId = mapping.ExternalId,
-                                createdAt = mapping.CreatedAt
-                            });
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to read mapping file {File}", file);
-                }
-            }
-            
-            return Ok(new 
-            { 
-                mappings = allMappings.OrderBy(m => ((dynamic)m).playlist).ThenBy(m => ((dynamic)m).createdAt),
-                totalCount = allMappings.Count,
-                jellyfinCount = allMappings.Count(m => ((dynamic)m).type == "jellyfin"),
-                externalCount = allMappings.Count(m => ((dynamic)m).type == "external")
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get track mappings");
-            return StatusCode(500, new { error = "Failed to get track mappings" });
-        }
-    }
-    
-    /// <summary>
-    /// Delete a manual track mapping
-    /// </summary>
-    [HttpDelete("mappings/tracks")]
-    public async Task<IActionResult> DeleteTrackMapping([FromQuery] string playlist, [FromQuery] string spotifyId)
-    {
-        if (string.IsNullOrEmpty(playlist) || string.IsNullOrEmpty(spotifyId))
-        {
-            return BadRequest(new { error = "playlist and spotifyId parameters are required" });
-        }
-        
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            var safeName = string.Join("_", playlist.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(mappingsDir, $"{safeName}_mappings.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                return NotFound(new { error = "Mapping file not found for playlist" });
-            }
-            
-            // Load existing mappings
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var mappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json);
-            
-            if (mappings == null || !mappings.ContainsKey(spotifyId))
-            {
-                return NotFound(new { error = "Mapping not found" });
-            }
-            
-            // Remove the mapping
-            mappings.Remove(spotifyId);
-            
-            // Save back to file (or delete file if empty)
-            if (mappings.Count == 0)
-            {
-                System.IO.File.Delete(filePath);
-                _logger.LogInformation("🗑️ Deleted empty mapping file for playlist {Playlist}", playlist);
-            }
-            else
-            {
-                var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(filePath, updatedJson);
-                _logger.LogInformation("🗑️ Deleted mapping: {Playlist} - {SpotifyId}", playlist, spotifyId);
-            }
-            
-            // Also remove from Redis cache
-            var cacheKey = $"manual:mapping:{playlist}:{spotifyId}";
-            await _cache.DeleteAsync(cacheKey);
-            
-            return Ok(new { success = true, message = "Mapping deleted successfully" });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to delete track mapping for {Playlist} - {SpotifyId}", playlist, spotifyId);
-            return StatusCode(500, new { error = "Failed to delete track mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Test Spotify lyrics API by fetching lyrics for a specific Spotify track ID
-    /// Example: GET /api/admin/lyrics/spotify/test?trackId=3yII7UwgLF6K5zW3xad3MP
-    /// </summary>
-    [HttpGet("lyrics/spotify/test")]
-    public async Task<IActionResult> TestSpotifyLyrics([FromQuery] string trackId)
-    {
-        if (string.IsNullOrEmpty(trackId))
-        {
-            return BadRequest(new { error = "trackId parameter is required" });
-        }
-        
-        try
-        {
-            var spotifyLyricsService = _serviceProvider.GetService<allstarr.Services.Lyrics.SpotifyLyricsService>();
-            
-            if (spotifyLyricsService == null)
-            {
-                return StatusCode(500, new { error = "Spotify lyrics service not available" });
-            }
-            
-            _logger.LogInformation("Testing Spotify lyrics for track ID: {TrackId}", trackId);
-            
-            var result = await spotifyLyricsService.GetLyricsByTrackIdAsync(trackId);
-            
-            if (result == null)
-            {
-                return NotFound(new 
-                { 
-                    error = "No lyrics found",
-                    trackId,
-                    message = "Lyrics may not be available for this track, or the Spotify API is not configured correctly"
-                });
-            }
-            
-            return Ok(new
-            {
-                success = true,
-                trackId = result.SpotifyTrackId,
-                syncType = result.SyncType,
-                lineCount = result.Lines.Count,
-                language = result.Language,
-                provider = result.Provider,
-                providerDisplayName = result.ProviderDisplayName,
-                lines = result.Lines.Select(l => new
-                {
-                    startTimeMs = l.StartTimeMs,
-                    endTimeMs = l.EndTimeMs,
-                    words = l.Words
-                }).ToList(),
-                // Also show LRC format
-                lrcFormat = string.Join("\n", result.Lines.Select(l =>
-                {
-                    var timestamp = TimeSpan.FromMilliseconds(l.StartTimeMs);
-                    var mm = (int)timestamp.TotalMinutes;
-                    var ss = timestamp.Seconds;
-                    var ms = timestamp.Milliseconds / 10;
-                    return $"[{mm:D2}:{ss:D2}.{ms:D2}]{l.Words}";
-                }))
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to test Spotify lyrics for track {TrackId}", trackId);
-            return StatusCode(500, new { error = $"Failed to fetch lyrics: {ex.Message}" });
-        }
-    }
-    
-    /// <summary>
-    /// Prefetch lyrics for a specific playlist
-    /// </summary>
-    [HttpPost("playlists/{name}/prefetch-lyrics")]
-    public async Task<IActionResult> PrefetchPlaylistLyrics(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        try
-        {
-            var lyricsPrefetchService = _serviceProvider.GetService<allstarr.Services.Lyrics.LyricsPrefetchService>();
-            
-            if (lyricsPrefetchService == null)
-            {
-                return StatusCode(500, new { error = "Lyrics prefetch service not available" });
-            }
-            
-            _logger.LogInformation("Starting lyrics prefetch for playlist: {Playlist}", decodedName);
-            
-            var (fetched, cached, missing) = await lyricsPrefetchService.PrefetchPlaylistLyricsAsync(
-                decodedName, 
-                HttpContext.RequestAborted);
-            
-            return Ok(new
-            {
-                message = "Lyrics prefetch complete",
-                playlist = decodedName,
-                fetched,
-                cached,
-                missing,
-                total = fetched + cached + missing
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to prefetch lyrics for playlist {Playlist}", decodedName);
-            return StatusCode(500, new { error = $"Failed to prefetch lyrics: {ex.Message}" });
-        }
-    }
-    
-    #endregion
-    
-    #region Helper Methods
-    
-    /// <summary>
-    /// Invalidates the cached playlist summary so it will be regenerated on next request
-    /// </summary>
-    private void InvalidatePlaylistSummaryCache()
-    {
-        try
-        {
-            var cacheFile = "/app/cache/admin_playlists_summary.json";
-            if (System.IO.File.Exists(cacheFile))
-            {
-                System.IO.File.Delete(cacheFile);
-                _logger.LogDebug("🗑️ Invalidated playlist summary cache");
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to invalidate playlist summary cache");
-        }
-    }
-    
-    #endregion
-
-public class ManualMappingRequest
-{
-    public string SpotifyId { get; set; } = "";
-    public string? JellyfinId { get; set; }
-    public string? ExternalProvider { get; set; }
-    public string? ExternalId { get; set; }
-||||||| f68706f
-
-    /// <summary>
-    /// Gets current active sessions for debugging.
-    /// </summary>
-    [HttpGet("sessions")]
-    public IActionResult GetActiveSessions()
-    {
-        try
-        {
-            var sessionManager = HttpContext.RequestServices.GetService<JellyfinSessionManager>();
-            if (sessionManager == null)
-            {
-                return BadRequest(new { error = "Session manager not available" });
-            }
-
-            var sessionInfo = sessionManager.GetSessionsInfo();
-            return Ok(sessionInfo);
-        }
-        catch (Exception ex)
-        {
-            return BadRequest(new { error = ex.Message });
-        }
-    }
-
-    /// <summary>
-    /// Helper method to trigger GC after large file operations to prevent memory leaks.
-    /// </summary>
-    private static void TriggerGCAfterLargeOperation(int sizeInBytes)
-    {
-        // Only trigger GC for files larger than 1MB to avoid performance impact
-        if (sizeInBytes > 1024 * 1024)
-        {
-            // Suggest GC collection for large objects (they go to LOH and aren't collected as frequently)
-            GC.Collect(2, GCCollectionMode.Optimized, blocking: false);
-        }
-    }
-
-    #region Spotify Admin Endpoints
-
-    /// <summary>
-    /// Manual trigger endpoint to force fetch Spotify missing tracks.
-    /// </summary>
-    [HttpGet("spotify/sync")]
-    public async Task<IActionResult> TriggerSpotifySync([FromServices] IEnumerable<IHostedService> hostedServices)
-    {
-        try
-        {
-            if (!_spotifyImportSettings.Enabled)
-            {
-                return BadRequest(new { error = "Spotify Import is not enabled" });
-            }
-
-            _logger.LogInformation("Manual Spotify sync triggered via admin endpoint");
-            
-            // Find the SpotifyMissingTracksFetcher service
-            var fetcherService = hostedServices
-                .OfType<allstarr.Services.Spotify.SpotifyMissingTracksFetcher>()
-                .FirstOrDefault();
-
-            if (fetcherService == null)
-            {
-                return BadRequest(new { error = "SpotifyMissingTracksFetcher service not found" });
-            }
-
-            // Trigger the sync in background
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    // Use reflection to call the private ExecuteOnceAsync method
-                    var method = fetcherService.GetType().GetMethod("ExecuteOnceAsync", 
-                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-                    
-                    if (method != null)
-                    {
-                        await (Task)method.Invoke(fetcherService, new object[] { CancellationToken.None })!;
-                        _logger.LogInformation("Manual Spotify sync completed successfully");
-                    }
-                    else
-                    {
-                        _logger.LogError("Could not find ExecuteOnceAsync method on SpotifyMissingTracksFetcher");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error during manual Spotify sync");
-                }
-            });
-
-            return Ok(new { 
-                message = "Spotify sync started in background",
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error triggering Spotify sync");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Manual trigger endpoint to force Spotify track matching.
-    /// </summary>
-    [HttpGet("spotify/match")]
-    public async Task<IActionResult> TriggerSpotifyMatch([FromServices] IEnumerable<IHostedService> hostedServices)
-    {
-        try
-        {
-            if (!_spotifyApiSettings.Enabled)
-            {
-                return BadRequest(new { error = "Spotify API is not enabled" });
-            }
-
-            _logger.LogInformation("Manual Spotify track matching triggered via admin endpoint");
-            
-            // Find the SpotifyTrackMatchingService
-            var matchingService = hostedServices
-                .OfType<allstarr.Services.Spotify.SpotifyTrackMatchingService>()
-                .FirstOrDefault();
-
-            if (matchingService == null)
-            {
-                return BadRequest(new { error = "SpotifyTrackMatchingService not found" });
-            }
-
-            // Trigger matching in background
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    // Use reflection to call the private ExecuteOnceAsync method
-                    var method = matchingService.GetType().GetMethod("ExecuteOnceAsync", 
-                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-                    
-                    if (method != null)
-                    {
-                        await (Task)method.Invoke(matchingService, new object[] { CancellationToken.None })!;
-                        _logger.LogInformation("Manual Spotify track matching completed successfully");
-                    }
-                    else
-                    {
-                        _logger.LogError("Could not find ExecuteOnceAsync method on SpotifyTrackMatchingService");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error during manual Spotify track matching");
-                }
-            });
-
-            return Ok(new { 
-                message = "Spotify track matching started in background",
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error triggering Spotify track matching");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Clear Spotify playlist cache to force re-matching.
-    /// </summary>
-    [HttpPost("spotify/clear-cache")]
-    public async Task<IActionResult> ClearSpotifyCache()
-    {
-        try
-        {
-            var clearedKeys = new List<string>();
-            
-            // Clear Redis cache for all configured playlists
-            foreach (var playlist in _spotifyImportSettings.Playlists)
-            {
-                var keys = new[]
-                {
-                    $"spotify:playlist:{playlist.Name}",
-                    $"spotify:playlist:items:{playlist.Name}",
-                    $"spotify:matched:{playlist.Name}"
-                };
-                
-                foreach (var key in keys)
-                {
-                    await _cache.DeleteAsync(key);
-                    clearedKeys.Add(key);
-                }
-            }
-            
-            _logger.LogInformation("Cleared Spotify cache for {Count} keys via admin endpoint", clearedKeys.Count);
-            
-            return Ok(new { 
-                message = "Spotify cache cleared successfully",
-                clearedKeys = clearedKeys,
-                timestamp = DateTime.UtcNow
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error clearing Spotify cache");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    #endregion
-
-    #region Debug Endpoints
-
-    /// <summary>
-    /// Gets endpoint usage statistics from the log file.
-    /// </summary>
-    [HttpGet("debug/endpoint-usage")]
-    public async Task<IActionResult> GetEndpointUsage(
-        [FromQuery] int top = 100,
-        [FromQuery] string? since = null)
-    {
-        try
-        {
-            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
-            
-            if (!System.IO.File.Exists(logFile))
-            {
-                return Ok(new { 
-                    message = "No endpoint usage data available",
-                    endpoints = new object[0]
-                });
-            }
-            
-            var lines = await System.IO.File.ReadAllLinesAsync(logFile);
-            var usage = new Dictionary<string, int>();
-            DateTime? sinceDate = null;
-            
-            if (!string.IsNullOrEmpty(since) && DateTime.TryParse(since, out var parsedDate))
-            {
-                sinceDate = parsedDate;
-            }
-            
-            foreach (var line in lines.Skip(1)) // Skip header
-            {
-                var parts = line.Split(',');
-                if (parts.Length >= 3)
-                {
-                    var timestamp = parts[0];
-                    var method = parts[1];
-                    var endpoint = parts[2];
-                    
-                    // Combine method and endpoint for better clarity
-                    var fullEndpoint = $"{method} {endpoint}";
-                    
-                    // Filter by date if specified
-                    if (sinceDate.HasValue && DateTime.TryParse(timestamp, out var logDate))
-                    {
-                        if (logDate < sinceDate.Value)
-                            continue;
-                    }
-                    
-                    usage[fullEndpoint] = usage.GetValueOrDefault(fullEndpoint, 0) + 1;
-                }
-            }
-            
-            var topEndpoints = usage
-                .OrderByDescending(kv => kv.Value)
-                .Take(top)
-                .Select(kv => new { endpoint = kv.Key, count = kv.Value })
-                .ToArray();
-            
-            return Ok(new {
-                totalEndpoints = usage.Count,
-                totalRequests = usage.Values.Sum(),
-                since = since,
-                top = top,
-                endpoints = topEndpoints
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting endpoint usage");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    /// <summary>
-    /// Clears the endpoint usage log file.
-    /// </summary>
-    [HttpDelete("debug/endpoint-usage")]
-    public IActionResult ClearEndpointUsage()
-    {
-        try
-        {
-            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
-            
-            if (System.IO.File.Exists(logFile))
-            {
-                System.IO.File.Delete(logFile);
-                _logger.LogInformation("Cleared endpoint usage log via admin endpoint");
-                
-                return Ok(new { 
-                    message = "Endpoint usage log cleared successfully",
-                    timestamp = DateTime.UtcNow
-                });
-            }
-            else
-            {
-                return Ok(new { 
-                    message = "No endpoint usage log file found",
-                    timestamp = DateTime.UtcNow
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error clearing endpoint usage log");
-            return StatusCode(500, new { error = "Internal server error" });
-        }
-    }
-
-    #endregion
-    
-    #region Private Helper Methods
-    
-    /// <summary>
-    /// Saves a manual mapping to file for persistence across restarts.
-    /// Manual mappings NEVER expire - they are permanent user decisions.
-    /// </summary>
-    private async Task SaveManualMappingToFileAsync(
-        string playlistName, 
-        string spotifyId, 
-        string? jellyfinId, 
-        string? externalProvider, 
-        string? externalId)
-    {
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            Directory.CreateDirectory(mappingsDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(mappingsDir, $"{safeName}_mappings.json");
-            
-            // Load existing mappings
-            var mappings = new Dictionary<string, ManualMappingEntry>();
-            if (System.IO.File.Exists(filePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(filePath);
-                mappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json) 
-                    ?? new Dictionary<string, ManualMappingEntry>();
-            }
-            
-            // Add or update mapping
-            mappings[spotifyId] = new ManualMappingEntry
-            {
-                SpotifyId = spotifyId,
-                JellyfinId = jellyfinId,
-                ExternalProvider = externalProvider,
-                ExternalId = externalId,
-                CreatedAt = DateTime.UtcNow
-            };
-            
-            // Save back to file
-            var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, updatedJson);
-            
-            _logger.LogDebug("💾 Saved manual mapping to file: {Playlist} - {SpotifyId}", playlistName, spotifyId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save manual mapping to file for {Playlist}", playlistName);
-        }
-    }
-    
-    /// <summary>
-    /// Save lyrics mapping to file for persistence across restarts.
-    /// Lyrics mappings NEVER expire - they are permanent user decisions.
-    /// </summary>
-    private async Task SaveLyricsMappingToFileAsync(
-        string artist,
-        string title,
-        string album,
-        int durationSeconds,
-        int lyricsId)
-    {
-        try
-        {
-            var mappingsFile = "/app/cache/lyrics_mappings.json";
-            
-            // Load existing mappings
-            var mappings = new List<LyricsMappingEntry>();
-            if (System.IO.File.Exists(mappingsFile))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(mappingsFile);
-                mappings = JsonSerializer.Deserialize<List<LyricsMappingEntry>>(json) 
-                    ?? new List<LyricsMappingEntry>();
-            }
-            
-            // Remove any existing mapping for this track
-            mappings.RemoveAll(m => 
-                m.Artist.Equals(artist, StringComparison.OrdinalIgnoreCase) && 
-                m.Title.Equals(title, StringComparison.OrdinalIgnoreCase));
-            
-            // Add new mapping
-            mappings.Add(new LyricsMappingEntry
-            {
-                Artist = artist,
-                Title = title,
-                Album = album,
-                DurationSeconds = durationSeconds,
-                LyricsId = lyricsId,
-                CreatedAt = DateTime.UtcNow
-            });
-            
-            // Save back to file
-            var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(mappingsFile, updatedJson);
-            
-            _logger.LogDebug("💾 Saved lyrics mapping to file: {Artist} - {Title} → Lyrics ID {LyricsId}", 
-                artist, title, lyricsId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save lyrics mapping to file for {Artist} - {Title}", artist, title);
-        }
-    }
-    
-    /// <summary>
-    /// Save manual lyrics ID mapping for a track
-    /// </summary>
-    [HttpPost("lyrics/map")]
-    public async Task<IActionResult> SaveLyricsMapping([FromBody] LyricsMappingRequest request)
-    {
-        if (string.IsNullOrWhiteSpace(request.Artist) || string.IsNullOrWhiteSpace(request.Title))
-        {
-            return BadRequest(new { error = "Artist and Title are required" });
-        }
-        
-        if (request.LyricsId <= 0)
-        {
-            return BadRequest(new { error = "Valid LyricsId is required" });
-        }
-        
-        try
-        {
-            // Store lyrics mapping in cache (NO EXPIRATION - manual mappings are permanent)
-            var mappingKey = $"lyrics:manual-map:{request.Artist}:{request.Title}";
-            await _cache.SetStringAsync(mappingKey, request.LyricsId.ToString());
-            
-            // Also save to file for persistence across restarts
-            await SaveLyricsMappingToFileAsync(request.Artist, request.Title, request.Album ?? "", request.DurationSeconds, request.LyricsId);
-            
-            _logger.LogInformation("Manual lyrics mapping saved: {Artist} - {Title} → Lyrics ID {LyricsId}", 
-                request.Artist, request.Title, request.LyricsId);
-            
-            // Optionally fetch and cache the lyrics immediately
-            try
-            {
-                var lyricsService = _serviceProvider.GetService<allstarr.Services.Lyrics.LrclibService>();
-                if (lyricsService != null)
-                {
-                    var lyricsInfo = await lyricsService.GetLyricsByIdAsync(request.LyricsId);
-                    if (lyricsInfo != null && !string.IsNullOrEmpty(lyricsInfo.PlainLyrics))
-                    {
-                        // Cache the lyrics using the standard cache key
-                        var lyricsCacheKey = $"lyrics:{request.Artist}:{request.Title}:{request.Album ?? ""}:{request.DurationSeconds}";
-                        await _cache.SetAsync(lyricsCacheKey, lyricsInfo.PlainLyrics);
-                        _logger.LogInformation("✓ Fetched and cached lyrics for {Artist} - {Title}", request.Artist, request.Title);
-                        
-                        return Ok(new 
-                        { 
-                            message = "Lyrics mapping saved and lyrics cached successfully",
-                            lyricsId = request.LyricsId,
-                            cached = true,
-                            lyrics = new
-                            {
-                                id = lyricsInfo.Id,
-                                trackName = lyricsInfo.TrackName,
-                                artistName = lyricsInfo.ArtistName,
-                                albumName = lyricsInfo.AlbumName,
-                                duration = lyricsInfo.Duration,
-                                instrumental = lyricsInfo.Instrumental
-                            }
-                        });
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to fetch lyrics after mapping, but mapping was saved");
-            }
-            
-            return Ok(new 
-            { 
-                message = "Lyrics mapping saved successfully",
-                lyricsId = request.LyricsId,
-                cached = false
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save lyrics mapping");
-            return StatusCode(500, new { error = "Failed to save lyrics mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Get manual lyrics mappings
-    /// </summary>
-    [HttpGet("lyrics/mappings")]
-    public async Task<IActionResult> GetLyricsMappings()
-    {
-        try
-        {
-            var mappingsFile = "/app/cache/lyrics_mappings.json";
-            
-            if (!System.IO.File.Exists(mappingsFile))
-            {
-                return Ok(new { mappings = new List<object>() });
-            }
-            
-            var json = await System.IO.File.ReadAllTextAsync(mappingsFile);
-            var mappings = JsonSerializer.Deserialize<List<LyricsMappingEntry>>(json) ?? new List<LyricsMappingEntry>();
-            
-            return Ok(new { mappings });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get lyrics mappings");
-            return StatusCode(500, new { error = "Failed to get lyrics mappings" });
-        }
-    }
-    
-    /// <summary>
-    /// Get all manual track mappings (both Jellyfin and external) for all playlists
-    /// </summary>
-    [HttpGet("mappings/tracks")]
-    public async Task<IActionResult> GetAllTrackMappings()
-    {
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            var allMappings = new List<object>();
-            
-            if (!Directory.Exists(mappingsDir))
-            {
-                return Ok(new { mappings = allMappings, totalCount = 0 });
-            }
-            
-            var files = Directory.GetFiles(mappingsDir, "*_mappings.json");
-            
-            foreach (var file in files)
-            {
-                try
-                {
-                    var json = await System.IO.File.ReadAllTextAsync(file);
-                    var playlistMappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json);
-                    
-                    if (playlistMappings != null)
-                    {
-                        var fileName = Path.GetFileNameWithoutExtension(file);
-                        var playlistName = fileName.Replace("_mappings", "").Replace("_", " ");
-                        
-                        foreach (var mapping in playlistMappings.Values)
-                        {
-                            allMappings.Add(new
-                            {
-                                playlist = playlistName,
-                                spotifyId = mapping.SpotifyId,
-                                type = !string.IsNullOrEmpty(mapping.JellyfinId) ? "jellyfin" : "external",
-                                jellyfinId = mapping.JellyfinId,
-                                externalProvider = mapping.ExternalProvider,
-                                externalId = mapping.ExternalId,
-                                createdAt = mapping.CreatedAt
-                            });
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to read mapping file {File}", file);
-                }
-            }
-            
-            return Ok(new 
-            { 
-                mappings = allMappings.OrderBy(m => ((dynamic)m).playlist).ThenBy(m => ((dynamic)m).createdAt),
-                totalCount = allMappings.Count,
-                jellyfinCount = allMappings.Count(m => ((dynamic)m).type == "jellyfin"),
-                externalCount = allMappings.Count(m => ((dynamic)m).type == "external")
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get track mappings");
-            return StatusCode(500, new { error = "Failed to get track mappings" });
-        }
-    }
-    
-    /// <summary>
-    /// Delete a manual track mapping
-    /// </summary>
-    [HttpDelete("mappings/tracks")]
-    public async Task<IActionResult> DeleteTrackMapping([FromQuery] string playlist, [FromQuery] string spotifyId)
-    {
-        if (string.IsNullOrEmpty(playlist) || string.IsNullOrEmpty(spotifyId))
-        {
-            return BadRequest(new { error = "playlist and spotifyId parameters are required" });
-        }
-        
-        try
-        {
-            var mappingsDir = "/app/cache/mappings";
-            var safeName = string.Join("_", playlist.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(mappingsDir, $"{safeName}_mappings.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                return NotFound(new { error = "Mapping file not found for playlist" });
-            }
-            
-            // Load existing mappings
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var mappings = JsonSerializer.Deserialize<Dictionary<string, ManualMappingEntry>>(json);
-            
-            if (mappings == null || !mappings.ContainsKey(spotifyId))
-            {
-                return NotFound(new { error = "Mapping not found" });
-            }
-            
-            // Remove the mapping
-            mappings.Remove(spotifyId);
-            
-            // Save back to file (or delete file if empty)
-            if (mappings.Count == 0)
-            {
-                System.IO.File.Delete(filePath);
-                _logger.LogInformation("🗑️ Deleted empty mapping file for playlist {Playlist}", playlist);
-            }
-            else
-            {
-                var updatedJson = JsonSerializer.Serialize(mappings, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(filePath, updatedJson);
-                _logger.LogInformation("🗑️ Deleted mapping: {Playlist} - {SpotifyId}", playlist, spotifyId);
-            }
-            
-            // Also remove from Redis cache
-            var cacheKey = $"manual:mapping:{playlist}:{spotifyId}";
-            await _cache.DeleteAsync(cacheKey);
-            
-            return Ok(new { success = true, message = "Mapping deleted successfully" });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to delete track mapping for {Playlist} - {SpotifyId}", playlist, spotifyId);
-            return StatusCode(500, new { error = "Failed to delete track mapping" });
-        }
-    }
-    
-    /// <summary>
-    /// Test Spotify lyrics API by fetching lyrics for a specific Spotify track ID
-    /// Example: GET /api/admin/lyrics/spotify/test?trackId=3yII7UwgLF6K5zW3xad3MP
-    /// </summary>
-    [HttpGet("lyrics/spotify/test")]
-    public async Task<IActionResult> TestSpotifyLyrics([FromQuery] string trackId)
-    {
-        if (string.IsNullOrEmpty(trackId))
-        {
-            return BadRequest(new { error = "trackId parameter is required" });
-        }
-        
-        try
-        {
-            var spotifyLyricsService = _serviceProvider.GetService<allstarr.Services.Lyrics.SpotifyLyricsService>();
-            
-            if (spotifyLyricsService == null)
-            {
-                return StatusCode(500, new { error = "Spotify lyrics service not available" });
-            }
-            
-            _logger.LogInformation("Testing Spotify lyrics for track ID: {TrackId}", trackId);
-            
-            var result = await spotifyLyricsService.GetLyricsByTrackIdAsync(trackId);
-            
-            if (result == null)
-            {
-                return NotFound(new 
-                { 
-                    error = "No lyrics found",
-                    trackId,
-                    message = "Lyrics may not be available for this track, or the Spotify API is not configured correctly"
-                });
-            }
-            
-            return Ok(new
-            {
-                success = true,
-                trackId = result.SpotifyTrackId,
-                syncType = result.SyncType,
-                lineCount = result.Lines.Count,
-                language = result.Language,
-                provider = result.Provider,
-                providerDisplayName = result.ProviderDisplayName,
-                lines = result.Lines.Select(l => new
-                {
-                    startTimeMs = l.StartTimeMs,
-                    endTimeMs = l.EndTimeMs,
-                    words = l.Words
-                }).ToList(),
-                // Also show LRC format
-                lrcFormat = string.Join("\n", result.Lines.Select(l =>
-                {
-                    var timestamp = TimeSpan.FromMilliseconds(l.StartTimeMs);
-                    var mm = (int)timestamp.TotalMinutes;
-                    var ss = timestamp.Seconds;
-                    var ms = timestamp.Milliseconds / 10;
-                    return $"[{mm:D2}:{ss:D2}.{ms:D2}]{l.Words}";
-                }))
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to test Spotify lyrics for track {TrackId}", trackId);
-            return StatusCode(500, new { error = $"Failed to fetch lyrics: {ex.Message}" });
-        }
-    }
-    
-    /// <summary>
-    /// Prefetch lyrics for a specific playlist
-    /// </summary>
-    [HttpPost("playlists/{name}/prefetch-lyrics")]
-    public async Task<IActionResult> PrefetchPlaylistLyrics(string name)
-    {
-        var decodedName = Uri.UnescapeDataString(name);
-        
-        try
-        {
-            var lyricsPrefetchService = _serviceProvider.GetService<allstarr.Services.Lyrics.LyricsPrefetchService>();
-            
-            if (lyricsPrefetchService == null)
-            {
-                return StatusCode(500, new { error = "Lyrics prefetch service not available" });
-            }
-            
-            _logger.LogInformation("Starting lyrics prefetch for playlist: {Playlist}", decodedName);
-            
-            var (fetched, cached, missing) = await lyricsPrefetchService.PrefetchPlaylistLyricsAsync(
-                decodedName, 
-                HttpContext.RequestAborted);
-            
-            return Ok(new
-            {
-                message = "Lyrics prefetch complete",
-                playlist = decodedName,
-                fetched,
-                cached,
-                missing,
-                total = fetched + cached + missing
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to prefetch lyrics for playlist {Playlist}", decodedName);
-            return StatusCode(500, new { error = $"Failed to prefetch lyrics: {ex.Message}" });
-        }
-    }
-    
-    #endregion
-    
-    #region Helper Methods
-    
-    /// <summary>
-    /// Invalidates the cached playlist summary so it will be regenerated on next request
-    /// </summary>
-    private void InvalidatePlaylistSummaryCache()
-    {
-        try
-        {
-            var cacheFile = "/app/cache/admin_playlists_summary.json";
-            if (System.IO.File.Exists(cacheFile))
-            {
-                System.IO.File.Delete(cacheFile);
-                _logger.LogDebug("🗑️ Invalidated playlist summary cache");
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to invalidate playlist summary cache");
-        }
-    }
-    
-    #endregion
-
-public class ManualMappingRequest
-{
-    public string SpotifyId { get; set; } = "";
-    public string? JellyfinId { get; set; }
-    public string? ExternalProvider { get; set; }
-    public string? ExternalId { get; set; }
-=======
->>>>>>> beta
 }
-<<<<<<< HEAD
-
-public class LyricsMappingRequest
-{
-    public string Artist { get; set; } = "";
-    public string Title { get; set; } = "";
-    public string? Album { get; set; }
-    public int DurationSeconds { get; set; }
-    public int LyricsId { get; set; }
-}
-
-public class ManualMappingEntry
-{
-    public string SpotifyId { get; set; } = "";
-    public string? JellyfinId { get; set; }
-    public string? ExternalProvider { get; set; }
-    public string? ExternalId { get; set; }
-    public DateTime CreatedAt { get; set; }
-}
-
-public class LyricsMappingEntry
-{
-    public string Artist { get; set; } = "";
-    public string Title { get; set; } = "";
-    public string? Album { get; set; }
-    public int DurationSeconds { get; set; }
-    public int LyricsId { get; set; }
-    public DateTime CreatedAt { get; set; }
-}
-
-public class ConfigUpdateRequest
-{
-    public Dictionary<string, string> Updates { get; set; } = new();
-}
-
-public class AddPlaylistRequest
-{
-    public string Name { get; set; } = string.Empty;
-    public string SpotifyId { get; set; } = string.Empty;
-    public string LocalTracksPosition { get; set; } = "first";
-}
-
-public class LinkPlaylistRequest
-{
-    public string Name { get; set; } = string.Empty;
-    public string SpotifyPlaylistId { get; set; } = string.Empty;
-    public string SyncSchedule { get; set; } = "0 8 * * 1"; // Default: 8 AM every Monday
-}
-
-public class UpdateScheduleRequest
-{
-    public string SyncSchedule { get; set; } = string.Empty;
-}
-
-    /// <summary>
-    /// GET /api/admin/downloads
-    /// Lists all downloaded files in the KEPT folder only (favorited tracks)
-    /// </summary>
-    [HttpGet("downloads")]
-    public IActionResult GetDownloads()
-    {
-        try
-        {
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            
-            _logger.LogDebug("📂 Checking kept folder: {Path}", keptPath);
-            _logger.LogInformation("📂 Directory exists: {Exists}", Directory.Exists(keptPath));
-            
-            if (!Directory.Exists(keptPath))
-            {
-                _logger.LogWarning("Kept folder does not exist: {Path}", keptPath);
-                return Ok(new { files = new List<object>(), totalSize = 0, count = 0 });
-            }
-            
-            var files = new List<object>();
-            long totalSize = 0;
-            
-            // Recursively get all audio files from kept folder
-            var audioExtensions = new[] { ".flac", ".mp3", ".m4a", ".opus" };
-            
-            var allFiles = Directory.GetFiles(keptPath, "*.*", SearchOption.AllDirectories)
-                .Where(f => audioExtensions.Contains(Path.GetExtension(f).ToLowerInvariant()))
-                .ToList();
-            
-            _logger.LogDebug("📂 Found {Count} audio files in kept folder", allFiles.Count);
-            
-            foreach (var filePath in allFiles)
-            {
-                _logger.LogDebug("📂 Processing file: {Path}", filePath);
-                
-                var fileInfo = new FileInfo(filePath);
-                var relativePath = Path.GetRelativePath(keptPath, filePath);
-                
-                // Parse artist/album/track from path structure
-                var parts = relativePath.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-                var artist = parts.Length > 0 ? parts[0] : "";
-                var album = parts.Length > 1 ? parts[1] : "";
-                var fileName = parts.Length > 2 ? parts[^1] : Path.GetFileName(filePath);
-                
-                files.Add(new
-                {
-                    path = relativePath,
-                    fullPath = filePath,
-                    artist,
-                    album,
-                    fileName,
-                    size = fileInfo.Length,
-                    sizeFormatted = FormatFileSize(fileInfo.Length),
-                    lastModified = fileInfo.LastWriteTimeUtc,
-                    extension = fileInfo.Extension
-                });
-                
-                totalSize += fileInfo.Length;
-            }
-            
-            _logger.LogDebug("📂 Returning {Count} kept files, total size: {Size}", files.Count, FormatFileSize(totalSize));
-            
-            return Ok(new
-            {
-                files = files.OrderBy(f => ((dynamic)f).artist).ThenBy(f => ((dynamic)f).album).ThenBy(f => ((dynamic)f).fileName),
-                totalSize,
-                totalSizeFormatted = FormatFileSize(totalSize),
-                count = files.Count
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to list kept downloads");
-            return StatusCode(500, new { error = "Failed to list kept downloads" });
-        }
-    }
-    
-    /// <summary>
-    /// DELETE /api/admin/downloads
-    /// Deletes a specific kept file and cleans up empty folders
-    /// </summary>
-    [HttpDelete("downloads")]
-    public IActionResult DeleteDownload([FromQuery] string path)
-    {
-        try
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                return BadRequest(new { error = "Path is required" });
-            }
-            
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var fullPath = Path.Combine(keptPath, path);
-            
-            _logger.LogDebug("🗑️ Delete request for: {Path}", fullPath);
-            
-            // Security: Ensure the path is within the kept directory
-            var normalizedFullPath = Path.GetFullPath(fullPath);
-            var normalizedKeptPath = Path.GetFullPath(keptPath);
-            
-            if (!normalizedFullPath.StartsWith(normalizedKeptPath))
-            {
-                _logger.LogWarning("🗑️ Invalid path (outside kept folder): {Path}", normalizedFullPath);
-                return BadRequest(new { error = "Invalid path" });
-            }
-            
-            if (!System.IO.File.Exists(fullPath))
-            {
-                _logger.LogWarning("🗑️ File not found: {Path}", fullPath);
-                return NotFound(new { error = "File not found" });
-            }
-            
-            System.IO.File.Delete(fullPath);
-            _logger.LogDebug("🗑️ Deleted file: {Path}", fullPath);
-            
-            // Clean up empty directories (Album folder, then Artist folder if empty)
-            var directory = Path.GetDirectoryName(fullPath);
-            while (directory != null && directory != keptPath && directory.StartsWith(keptPath))
-            {
-                if (Directory.Exists(directory) && !Directory.EnumerateFileSystemEntries(directory).Any())
-                {
-                    Directory.Delete(directory);
-                    _logger.LogInformation("🗑️ Deleted empty directory: {Dir}", directory);
-                    directory = Path.GetDirectoryName(directory);
-                }
-                else
-                {
-                    _logger.LogInformation("🗑️ Directory not empty or doesn't exist, stopping cleanup: {Dir}", directory);
-                    break;
-                }
-            }
-            
-            return Ok(new { success = true, message = "File deleted successfully" });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to delete file: {Path}", path);
-            return StatusCode(500, new { error = "Failed to delete file" });
-        }
-    }
-    
-    /// <summary>
-    /// GET /api/admin/downloads/file
-    /// Downloads a specific file from the kept folder
-    /// </summary>
-    [HttpGet("downloads/file")]
-    public IActionResult DownloadFile([FromQuery] string path)
-    {
-        try
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                return BadRequest(new { error = "Path is required" });
-            }
-            
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var fullPath = Path.Combine(keptPath, path);
-            
-            // Security: Ensure the path is within the kept directory
-            var normalizedFullPath = Path.GetFullPath(fullPath);
-            var normalizedKeptPath = Path.GetFullPath(keptPath);
-            
-            if (!normalizedFullPath.StartsWith(normalizedKeptPath))
-            {
-                return BadRequest(new { error = "Invalid path" });
-            }
-            
-            if (!System.IO.File.Exists(fullPath))
-            {
-                return NotFound(new { error = "File not found" });
-            }
-            
-            var fileName = Path.GetFileName(fullPath);
-            var fileStream = System.IO.File.OpenRead(fullPath);
-            
-            return File(fileStream, "application/octet-stream", fileName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to download file: {Path}", path);
-            return StatusCode(500, new { error = "Failed to download file" });
-        }
-    }
-    
-    private static string FormatFileSize(long bytes)
-    {
-        string[] sizes = { "B", "KB", "MB", "GB", "TB" };
-        double len = bytes;
-        int order = 0;
-        while (len >= 1024 && order < sizes.Length - 1)
-        {
-            order++;
-            len = len / 1024;
-        }
-        return $"{len:0.##} {sizes[order]}";
-    }
-}
-
-/// <summary>
-/// Request model for updating configuration
-/// </summary>
-public class ConfigUpdateRequest
-{
-    public Dictionary<string, string> Updates { get; set; } = new();
-}
-||||||| f68706f
-
-public class LyricsMappingRequest
-{
-    public string Artist { get; set; } = "";
-    public string Title { get; set; } = "";
-    public string? Album { get; set; }
-    public int DurationSeconds { get; set; }
-    public int LyricsId { get; set; }
-}
-
-public class ManualMappingEntry
-{
-    public string SpotifyId { get; set; } = "";
-    public string? JellyfinId { get; set; }
-    public string? ExternalProvider { get; set; }
-    public string? ExternalId { get; set; }
-    public DateTime CreatedAt { get; set; }
-}
-
-public class LyricsMappingEntry
-{
-    public string Artist { get; set; } = "";
-    public string Title { get; set; } = "";
-    public string? Album { get; set; }
-    public int DurationSeconds { get; set; }
-    public int LyricsId { get; set; }
-    public DateTime CreatedAt { get; set; }
-}
-
-public class ConfigUpdateRequest
-{
-    public Dictionary<string, string> Updates { get; set; } = new();
-}
-
-public class AddPlaylistRequest
-{
-    public string Name { get; set; } = string.Empty;
-    public string SpotifyId { get; set; } = string.Empty;
-    public string LocalTracksPosition { get; set; } = "first";
-}
-
-public class LinkPlaylistRequest
-{
-    public string Name { get; set; } = string.Empty;
-    public string SpotifyPlaylistId { get; set; } = string.Empty;
-}
-
-    /// <summary>
-    /// GET /api/admin/downloads
-    /// Lists all downloaded files in the KEPT folder only (favorited tracks)
-    /// </summary>
-    [HttpGet("downloads")]
-    public IActionResult GetDownloads()
-    {
-        try
-        {
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            
-            _logger.LogInformation("📂 Checking kept folder: {Path}", keptPath);
-            _logger.LogInformation("📂 Directory exists: {Exists}", Directory.Exists(keptPath));
-            
-            if (!Directory.Exists(keptPath))
-            {
-                _logger.LogWarning("Kept folder does not exist: {Path}", keptPath);
-                return Ok(new { files = new List<object>(), totalSize = 0, count = 0 });
-            }
-            
-            var files = new List<object>();
-            long totalSize = 0;
-            
-            // Recursively get all audio files from kept folder
-            var audioExtensions = new[] { ".flac", ".mp3", ".m4a", ".opus" };
-            
-            var allFiles = Directory.GetFiles(keptPath, "*.*", SearchOption.AllDirectories)
-                .Where(f => audioExtensions.Contains(Path.GetExtension(f).ToLowerInvariant()))
-                .ToList();
-            
-            _logger.LogInformation("📂 Found {Count} audio files in kept folder", allFiles.Count);
-            
-            foreach (var filePath in allFiles)
-            {
-                _logger.LogDebug("📂 Processing file: {Path}", filePath);
-                
-                var fileInfo = new FileInfo(filePath);
-                var relativePath = Path.GetRelativePath(keptPath, filePath);
-                
-                // Parse artist/album/track from path structure
-                var parts = relativePath.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-                var artist = parts.Length > 0 ? parts[0] : "";
-                var album = parts.Length > 1 ? parts[1] : "";
-                var fileName = parts.Length > 2 ? parts[^1] : Path.GetFileName(filePath);
-                
-                files.Add(new
-                {
-                    path = relativePath,
-                    fullPath = filePath,
-                    artist,
-                    album,
-                    fileName,
-                    size = fileInfo.Length,
-                    sizeFormatted = FormatFileSize(fileInfo.Length),
-                    lastModified = fileInfo.LastWriteTimeUtc,
-                    extension = fileInfo.Extension
-                });
-                
-                totalSize += fileInfo.Length;
-            }
-            
-            _logger.LogInformation("📂 Returning {Count} kept files, total size: {Size}", files.Count, FormatFileSize(totalSize));
-            
-            return Ok(new
-            {
-                files = files.OrderBy(f => ((dynamic)f).artist).ThenBy(f => ((dynamic)f).album).ThenBy(f => ((dynamic)f).fileName),
-                totalSize,
-                totalSizeFormatted = FormatFileSize(totalSize),
-                count = files.Count
-            });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to list kept downloads");
-            return StatusCode(500, new { error = "Failed to list kept downloads" });
-        }
-    }
-    
-    /// <summary>
-    /// DELETE /api/admin/downloads
-    /// Deletes a specific kept file and cleans up empty folders
-    /// </summary>
-    [HttpDelete("downloads")]
-    public IActionResult DeleteDownload([FromQuery] string path)
-    {
-        try
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                return BadRequest(new { error = "Path is required" });
-            }
-            
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var fullPath = Path.Combine(keptPath, path);
-            
-            _logger.LogInformation("🗑️ Delete request for: {Path}", fullPath);
-            
-            // Security: Ensure the path is within the kept directory
-            var normalizedFullPath = Path.GetFullPath(fullPath);
-            var normalizedKeptPath = Path.GetFullPath(keptPath);
-            
-            if (!normalizedFullPath.StartsWith(normalizedKeptPath))
-            {
-                _logger.LogWarning("🗑️ Invalid path (outside kept folder): {Path}", normalizedFullPath);
-                return BadRequest(new { error = "Invalid path" });
-            }
-            
-            if (!System.IO.File.Exists(fullPath))
-            {
-                _logger.LogWarning("🗑️ File not found: {Path}", fullPath);
-                return NotFound(new { error = "File not found" });
-            }
-            
-            System.IO.File.Delete(fullPath);
-            _logger.LogInformation("🗑️ Deleted file: {Path}", fullPath);
-            
-            // Clean up empty directories (Album folder, then Artist folder if empty)
-            var directory = Path.GetDirectoryName(fullPath);
-            while (directory != null && directory != keptPath && directory.StartsWith(keptPath))
-            {
-                if (Directory.Exists(directory) && !Directory.EnumerateFileSystemEntries(directory).Any())
-                {
-                    Directory.Delete(directory);
-                    _logger.LogInformation("🗑️ Deleted empty directory: {Dir}", directory);
-                    directory = Path.GetDirectoryName(directory);
-                }
-                else
-                {
-                    _logger.LogDebug("🗑️ Directory not empty or doesn't exist, stopping cleanup: {Dir}", directory);
-                    break;
-                }
-            }
-            
-            return Ok(new { success = true, message = "File deleted successfully" });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to delete file: {Path}", path);
-            return StatusCode(500, new { error = "Failed to delete file" });
-        }
-    }
-    
-    /// <summary>
-    /// GET /api/admin/downloads/file
-    /// Downloads a specific file from the kept folder
-    /// </summary>
-    [HttpGet("downloads/file")]
-    public IActionResult DownloadFile([FromQuery] string path)
-    {
-        try
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                return BadRequest(new { error = "Path is required" });
-            }
-            
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var fullPath = Path.Combine(keptPath, path);
-            
-            // Security: Ensure the path is within the kept directory
-            var normalizedFullPath = Path.GetFullPath(fullPath);
-            var normalizedKeptPath = Path.GetFullPath(keptPath);
-            
-            if (!normalizedFullPath.StartsWith(normalizedKeptPath))
-            {
-                return BadRequest(new { error = "Invalid path" });
-            }
-            
-            if (!System.IO.File.Exists(fullPath))
-            {
-                return NotFound(new { error = "File not found" });
-            }
-            
-            var fileName = Path.GetFileName(fullPath);
-            var fileStream = System.IO.File.OpenRead(fullPath);
-            
-            return File(fileStream, "application/octet-stream", fileName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to download file: {Path}", path);
-            return StatusCode(500, new { error = "Failed to download file" });
-        }
-    }
-    
-    private static string FormatFileSize(long bytes)
-    {
-        string[] sizes = { "B", "KB", "MB", "GB", "TB" };
-        double len = bytes;
-        int order = 0;
-        while (len >= 1024 && order < sizes.Length - 1)
-        {
-            order++;
-            len = len / 1024;
-        }
-        return $"{len:0.##} {sizes[order]}";
-    }
-}
-=======
->>>>>>> beta
@@ -513,7 +513,12 @@ public partial class JellyfinController
        // For library items, proxy transparently with full query string
        _logger.LogDebug("Proxying library item request to Jellyfin: ParentId={ParentId}", parentId);

-        var endpoint = $"Users/{Request.RouteValues["userId"]}/Items{Request.QueryString}";
+        // Build endpoint - handle both /Items and /Users/{userId}/Items routes
+        var userIdFromRoute = Request.RouteValues["userId"]?.ToString();
+        var endpoint = string.IsNullOrEmpty(userIdFromRoute) 
+            ? $"Items{Request.QueryString}"
+            : $"Users/{userIdFromRoute}/Items{Request.QueryString}";
+            
        var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);

        return HandleProxyResponse(result, statusCode);
@@ -45,14 +45,9 @@ public partial class JellyfinController : ControllerBase
    private readonly SpotifyLyricsService? _spotifyLyricsService;
    private readonly LyricsPlusService? _lyricsPlusService;
    private readonly LrclibService? _lrclibService;
-<<<<<<< HEAD
-    private readonly LyricsOrchestrator? _lyricsOrchestrator;
-||||||| f68706f
-=======
    private readonly LyricsOrchestrator? _lyricsOrchestrator;
    private readonly ScrobblingOrchestrator? _scrobblingOrchestrator;
    private readonly ScrobblingHelper? _scrobblingHelper;
->>>>>>> beta
    private readonly OdesliService _odesliService;
    private readonly RedisCacheService _cache;
    private readonly IConfiguration _configuration;
@@ -78,19 +73,11 @@ public partial class JellyfinController : ControllerBase
        PlaylistSyncService? playlistSyncService = null,
        SpotifyPlaylistFetcher? spotifyPlaylistFetcher = null,
        SpotifyLyricsService? spotifyLyricsService = null,
-<<<<<<< HEAD
-        LyricsPlusService? lyricsPlusService = null,
-        LrclibService? lrclibService = null,
-        LyricsOrchestrator? lyricsOrchestrator = null)
-||||||| f68706f
-        LrclibService? lrclibService = null)
-=======
        LyricsPlusService? lyricsPlusService = null,
        LrclibService? lrclibService = null,
        LyricsOrchestrator? lyricsOrchestrator = null,
        ScrobblingOrchestrator? scrobblingOrchestrator = null,
        ScrobblingHelper? scrobblingHelper = null)
->>>>>>> beta
    {
        _settings = settings.Value;
        _spotifySettings = spotifySettings.Value;
@@ -109,14 +96,9 @@ public partial class JellyfinController : ControllerBase
        _spotifyLyricsService = spotifyLyricsService;
        _lyricsPlusService = lyricsPlusService;
        _lrclibService = lrclibService;
-<<<<<<< HEAD
-        _lyricsOrchestrator = lyricsOrchestrator;
-||||||| f68706f
-=======
        _lyricsOrchestrator = lyricsOrchestrator;
        _scrobblingOrchestrator = scrobblingOrchestrator;
        _scrobblingHelper = scrobblingHelper;
->>>>>>> beta
        _odesliService = odesliService;
        _cache = cache;
        _configuration = configuration;
@@ -128,881 +110,6 @@ public partial class JellyfinController : ControllerBase
        }
    }

-<<<<<<< HEAD
-    #region Search
-
-    /// <summary>
-    /// Searches local Jellyfin library and external providers.
-    /// Combines songs/albums/artists. Works with /Items and /Users/{userId}/Items.
-    /// </summary>
-    [HttpGet("Items", Order = 1)]
-    [HttpGet("Users/{userId}/Items", Order = 1)]
-    public async Task<IActionResult> SearchItems(
-        [FromQuery] string? searchTerm,
-        [FromQuery] string? includeItemTypes,
-        [FromQuery] int limit = 20,
-        [FromQuery] int startIndex = 0,
-        [FromQuery] string? parentId = null,
-        [FromQuery] string? artistIds = null,
-        [FromQuery] string? sortBy = null,
-        [FromQuery] bool recursive = true,
-        string? userId = null)
-    {
-        _logger.LogDebug("=== SEARCHITEMS V2 CALLED === searchTerm={SearchTerm}, includeItemTypes={ItemTypes}, parentId={ParentId}, artistIds={ArtistIds}, userId={UserId}", 
-            searchTerm, includeItemTypes, parentId, artistIds, userId);
-
-        // Cache search results in Redis only (no file persistence, 15 min TTL)
-        // Only cache actual searches, not browse operations
-        if (!string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(artistIds))
-        {
-            var cacheKey = $"search:{searchTerm?.ToLowerInvariant()}:{includeItemTypes}:{limit}:{startIndex}";
-            var cachedResult = await _cache.GetAsync<object>(cacheKey);
-            
-            if (cachedResult != null)
-            {
-                _logger.LogDebug("✅ Returning cached search results for '{SearchTerm}'", searchTerm);
-                return new JsonResult(cachedResult);
-            }
-        }
-
-        // If filtering by artist, handle external artists
-        if (!string.IsNullOrWhiteSpace(artistIds))
-        {
-            var artistId = artistIds.Split(',')[0]; // Take first artist if multiple
-            var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(artistId);
-            
-            if (isExternal)
-            {
-                _logger.LogInformation("Fetching albums for external artist: {Provider}/{ExternalId}", provider, externalId);
-                return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
-            }
-        }
-
-        // If no search term, proxy to Jellyfin for browsing
-        // If Jellyfin returns empty results, we'll just return empty (not mixing browse with external)
-        if (string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(parentId))
-        {
-            _logger.LogDebug("No search term or parentId, proxying to Jellyfin with full query string");
-            
-            // Build the full endpoint path with query string
-            var endpoint = userId != null ? $"Users/{userId}/Items" : "Items";
-            
-            // Ensure MediaSources is included in Fields parameter for bitrate info
-            var queryString = Request.QueryString.Value ?? "";
-            
-            if (!string.IsNullOrEmpty(queryString))
-            {
-                // Parse query string to modify Fields parameter
-                var queryParams = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(queryString);
-                
-                if (queryParams.ContainsKey("Fields"))
-                {
-                    var fieldsValue = queryParams["Fields"].ToString();
-                    if (!fieldsValue.Contains("MediaSources", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // Append MediaSources to existing Fields
-                        var newFields = string.IsNullOrEmpty(fieldsValue) 
-                            ? "MediaSources" 
-                            : $"{fieldsValue},MediaSources";
-                        
-                        // Rebuild query string with updated Fields
-                        var newQueryParams = new Dictionary<string, string>();
-                        foreach (var kvp in queryParams)
-                        {
-                            if (kvp.Key == "Fields")
-                            {
-                                newQueryParams[kvp.Key] = newFields;
-                            }
-                            else
-                            {
-                                newQueryParams[kvp.Key] = kvp.Value.ToString();
-                            }
-                        }
-                        
-                        queryString = "?" + string.Join("&", newQueryParams.Select(kvp => 
-                            $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}"));
-                    }
-                }
-                else
-                {
-                    // No Fields parameter, add it
-                    queryString = $"{queryString}&Fields=MediaSources";
-                }
-            }
-            else
-            {
-                // No query string at all
-                queryString = "?Fields=MediaSources";
-            }
-            
-            endpoint = $"{endpoint}{queryString}";
-            
-            var (browseResult, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
-
-            if (browseResult == null)
-            {
-                if (statusCode == 401)
-                {
-                    _logger.LogInformation("Jellyfin returned 401 Unauthorized, returning 401 to client");
-                    return Unauthorized(new { error = "Authentication required" });
-                }
-                
-                _logger.LogDebug("Jellyfin returned {StatusCode}, returning empty result", statusCode);
-                return new JsonResult(new { Items = Array.Empty<object>(), TotalRecordCount = 0, StartIndex = startIndex });
-            }
-
-            // Update Spotify playlist counts if enabled and response contains playlists
-            if (_spotifySettings.Enabled && browseResult.RootElement.TryGetProperty("Items", out var _))
-            {
-                _logger.LogDebug("Browse result has Items, checking for Spotify playlists to update counts");
-                browseResult = await UpdateSpotifyPlaylistCounts(browseResult);
-            }
-
-            var result = JsonSerializer.Deserialize<object>(browseResult.RootElement.GetRawText());
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                var rawText = browseResult.RootElement.GetRawText();
-                var preview = rawText.Length > 200 ? rawText[..200] : rawText;
-                _logger.LogDebug("Jellyfin browse result preview: {Result}", preview);
-            }
-            return new JsonResult(result);
-        }
-
-        // If browsing a specific parent (album, artist, playlist)
-        if (!string.IsNullOrWhiteSpace(parentId))
-        {
-            // Check if this is the music library root - if so, treat as a search
-            var isMusicLibrary = parentId == _settings.LibraryId;
-            
-            if (!isMusicLibrary || string.IsNullOrWhiteSpace(searchTerm))
-            {
-                _logger.LogDebug("Browsing parent: {ParentId}", parentId);
-                return await GetChildItems(parentId, includeItemTypes, limit, startIndex, sortBy);
-            }
-            
-            // If searching within music library root, continue to integrated search below
-            _logger.LogInformation("Searching within music library {ParentId}, including external sources", parentId);
-        }
-
-        var cleanQuery = searchTerm?.Trim().Trim('"') ?? "";
-        _logger.LogDebug("Performing integrated search for: {Query}", cleanQuery);
-
-        // Run local and external searches in parallel
-        var itemTypes = ParseItemTypes(includeItemTypes);
-        var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, recursive, Request.Headers);
-        
-        // Use parallel metadata service if available (races providers), otherwise use primary
-        var externalTask = _parallelMetadataService != null
-            ? _parallelMetadataService.SearchAllAsync(cleanQuery, limit, limit, limit)
-            : _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
-
-        var playlistTask = _settings.EnableExternalPlaylists
-            ? _metadataService.SearchPlaylistsAsync(cleanQuery, limit)
-            : Task.FromResult(new List<ExternalPlaylist>());
-
-        await Task.WhenAll(jellyfinTask, externalTask, playlistTask);
-
-        var (jellyfinResult, _) = await jellyfinTask;
-        var externalResult = await externalTask;
-        var playlistResult = await playlistTask;
-
-        _logger.LogDebug("Search results: Jellyfin={JellyfinCount}, External Songs={ExtSongs}, Albums={ExtAlbums}, Artists={ExtArtists}, Playlists={Playlists}",
-            jellyfinResult != null ? "found" : "null",
-            externalResult.Songs.Count,
-            externalResult.Albums.Count,
-            externalResult.Artists.Count,
-            playlistResult.Count);
-
-        // Parse Jellyfin results into domain models
-        var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
-
-        // Sort all results by match score (local tracks get +10 boost)
-        // This ensures best matches appear first regardless of source
-        var allSongs = localSongs.Concat(externalResult.Songs)
-            .Select(s => new { Song = s, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title) + (s.IsLocal ? 10.0 : 0.0) })
-            .OrderByDescending(x => x.Score)
-            .Select(x => x.Song)
-            .ToList();
-
-        var allAlbums = localAlbums.Concat(externalResult.Albums)
-            .Select(a => new { Album = a, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title) + (a.IsLocal ? 10.0 : 0.0) })
-            .OrderByDescending(x => x.Score)
-            .Select(x => x.Album)
-            .ToList();
-
-        var allArtists = localArtists.Concat(externalResult.Artists)
-            .Select(a => new { Artist = a, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name) + (a.IsLocal ? 10.0 : 0.0) })
-            .OrderByDescending(x => x.Score)
-            .Select(x => x.Artist)
-            .ToList();
-
-        // Log top results for debugging
-        if (_logger.IsEnabled(LogLevel.Debug))
-        {
-            if (allSongs.Any())
-            {
-                var topSong = allSongs.First();
-                var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topSong.Title) + (topSong.IsLocal ? 10.0 : 0.0);
-                _logger.LogDebug("🎵 Top song: '{Title}' (local={IsLocal}, score={Score:F2})", 
-                    topSong.Title, topSong.IsLocal, topScore);
-            }
-            if (allAlbums.Any())
-            {
-                var topAlbum = allAlbums.First();
-                var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topAlbum.Title) + (topAlbum.IsLocal ? 10.0 : 0.0);
-                _logger.LogDebug("💿 Top album: '{Title}' (local={IsLocal}, score={Score:F2})", 
-                    topAlbum.Title, topAlbum.IsLocal, topScore);
-            }
-            if (allArtists.Any())
-            {
-                var topArtist = allArtists.First();
-                var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topArtist.Name) + (topArtist.IsLocal ? 10.0 : 0.0);
-                _logger.LogDebug("🎤 Top artist: '{Name}' (local={IsLocal}, score={Score:F2})", 
-                    topArtist.Name, topArtist.IsLocal, topScore);
-            }
-        }
-
-        // Convert to Jellyfin format
-        var mergedSongs = allSongs.Select(s => _responseBuilder.ConvertSongToJellyfinItem(s)).ToList();
-        var mergedAlbums = allAlbums.Select(a => _responseBuilder.ConvertAlbumToJellyfinItem(a)).ToList();
-        var mergedArtists = allArtists.Select(a => _responseBuilder.ConvertArtistToJellyfinItem(a)).ToList();
-
-        // Add playlists (preserve their order too)
-        if (playlistResult.Count > 0)
-        {
-            var playlistItems = playlistResult
-                .Select(p => _responseBuilder.ConvertPlaylistToJellyfinItem(p))
-                .ToList();
-            
-            mergedAlbums.AddRange(playlistItems);
-        }
-
-        _logger.LogDebug("Merged and sorted results by score: Songs={Songs}, Albums={Albums}, Artists={Artists}",
-            mergedSongs.Count, mergedAlbums.Count, mergedArtists.Count);
-
-        // Pre-fetch lyrics for top 3 songs in background (don't await)
-        if (_lrclibService != null && mergedSongs.Count > 0)
-        {
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    var top3 = mergedSongs.Take(3).ToList();
-                    _logger.LogDebug("🎵 Pre-fetching lyrics for top {Count} search results", top3.Count);
-                    
-                    foreach (var songItem in top3)
-                    {
-                        if (songItem.TryGetValue("Name", out var nameObj) && nameObj is JsonElement nameEl &&
-                            songItem.TryGetValue("Artists", out var artistsObj) && artistsObj is JsonElement artistsEl &&
-                            artistsEl.GetArrayLength() > 0)
-                        {
-                            var title = nameEl.GetString() ?? "";
-                            var artist = artistsEl[0].GetString() ?? "";
-                            
-                            if (!string.IsNullOrEmpty(title) && !string.IsNullOrEmpty(artist))
-                            {
-                                await _lrclibService.GetLyricsAsync(title, artist, "", 0);
-                            }
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to pre-fetch lyrics for search results");
-                }
-            });
-        }
-
-        // Filter by item types if specified
-        var items = new List<Dictionary<string, object?>>();
-
-        _logger.LogDebug("Filtering by item types: {ItemTypes}", itemTypes == null ? "null" : string.Join(",", itemTypes));
-
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicArtist"))
-        {
-            _logger.LogDebug("Adding {Count} artists to results", mergedArtists.Count);
-            items.AddRange(mergedArtists);
-        }
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicAlbum") || itemTypes.Contains("Playlist"))
-        {
-            _logger.LogDebug("Adding {Count} albums to results", mergedAlbums.Count);
-            items.AddRange(mergedAlbums);
-        }
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("Audio"))
-        {
-            _logger.LogDebug("Adding {Count} songs to results", mergedSongs.Count);
-            items.AddRange(mergedSongs);
-        }
-
-        // Apply pagination
-        var pagedItems = items.Skip(startIndex).Take(limit).ToList();
-
-        _logger.LogDebug("Returning {Count} items (total: {Total})", pagedItems.Count, items.Count);
-
-        try
-        {
-            // Return with PascalCase - use ContentResult to bypass JSON serialization issues
-            var response = new
-            {
-                Items = pagedItems,
-                TotalRecordCount = items.Count,
-                StartIndex = startIndex
-            };
-
-            // Cache search results in Redis (15 min TTL, no file persistence)
-            if (!string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(artistIds))
-            {
-                var cacheKey = $"search:{searchTerm?.ToLowerInvariant()}:{includeItemTypes}:{limit}:{startIndex}";
-                await _cache.SetAsync(cacheKey, response, CacheExtensions.SearchResultsTTL);
-                _logger.LogDebug("💾 Cached search results for '{SearchTerm}' ({Minutes} min TTL)", searchTerm, CacheExtensions.SearchResultsTTL.TotalMinutes);
-            }
-
-            _logger.LogDebug("About to serialize response...");
-
-            var json = System.Text.Json.JsonSerializer.Serialize(response, new System.Text.Json.JsonSerializerOptions
-            {
-                PropertyNamingPolicy = null,
-                DictionaryKeyPolicy = null
-            });
-
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                var preview = json.Length > 200 ? json[..200] : json;
-                _logger.LogDebug("JSON response preview: {Json}", preview);
-            }
-
-            return Content(json, "application/json");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error serializing search response");
-            throw;
-        }
-    }
-
-    /// <summary>
-    /// Gets child items of a parent (tracks in album, albums for artist).
-    /// </summary>
-    private async Task<IActionResult> GetChildItems(
-        string parentId,
-        string? includeItemTypes,
-        int limit,
-        int startIndex,
-        string? sortBy)
-    {
-        // Check if this is an external playlist
-        if (PlaylistIdHelper.IsExternalPlaylist(parentId))
-        {
-            return await GetPlaylistTracks(parentId);
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(parentId);
-
-        if (isExternal)
-        {
-            // Get external album or artist content
-            return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
-        }
-
-        // Proxy to Jellyfin for local content
-        var (result, statusCode) = await _proxyService.GetItemsAsync(
-            parentId: parentId,
-            includeItemTypes: ParseItemTypes(includeItemTypes),
-            sortBy: sortBy,
-            limit: limit,
-            startIndex: startIndex,
-            clientHeaders: Request.Headers);
-
-        return HandleProxyResponse(result, statusCode);
-    }
-
-    /// <summary>
-    /// Quick search endpoint. Works with /Search/Hints and /Users/{userId}/Search/Hints.
-    /// </summary>
-    [HttpGet("Search/Hints", Order = 1)]
-    [HttpGet("Users/{userId}/Search/Hints", Order = 1)]
-    public async Task<IActionResult> SearchHints(
-        [FromQuery] string searchTerm,
-        [FromQuery] int limit = 20,
-        [FromQuery] string? includeItemTypes = null,
-        string? userId = null)
-    {
-        if (string.IsNullOrWhiteSpace(searchTerm))
-        {
-            return _responseBuilder.CreateJsonResponse(new
-            {
-                SearchHints = Array.Empty<object>(),
-                TotalRecordCount = 0
-            });
-        }
-
-        var cleanQuery = searchTerm.Trim().Trim('"');
-        var itemTypes = ParseItemTypes(includeItemTypes);
-
-        // Run searches in parallel
-        var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, true, Request.Headers);
-        var externalTask = _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
-
-        await Task.WhenAll(jellyfinTask, externalTask);
-
-        var (jellyfinResult, _) = await jellyfinTask;
-        var externalResult = await externalTask;
-
-        var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
-
-        // NO deduplication - merge all results and take top matches
-        var allSongs = localSongs.Concat(externalResult.Songs).Take(limit).ToList();
-        var allAlbums = localAlbums.Concat(externalResult.Albums).Take(limit).ToList();
-        var allArtists = localArtists.Concat(externalResult.Artists).Take(limit).ToList();
-
-        return _responseBuilder.CreateSearchHintsResponse(
-            allSongs.Take(limit).ToList(),
-            allAlbums.Take(limit).ToList(),
-            allArtists.Take(limit).ToList());
-    }
-
-    #endregion
-
-||||||| f68706f
-    #region Search
-
-    /// <summary>
-    /// Searches local Jellyfin library and external providers.
-    /// Combines songs/albums/artists. Works with /Items and /Users/{userId}/Items.
-    /// </summary>
-    [HttpGet("Items", Order = 1)]
-    [HttpGet("Users/{userId}/Items", Order = 1)]
-    public async Task<IActionResult> SearchItems(
-        [FromQuery] string? searchTerm,
-        [FromQuery] string? includeItemTypes,
-        [FromQuery] int limit = 20,
-        [FromQuery] int startIndex = 0,
-        [FromQuery] string? parentId = null,
-        [FromQuery] string? artistIds = null,
-        [FromQuery] string? sortBy = null,
-        [FromQuery] bool recursive = true,
-        string? userId = null)
-    {
-        _logger.LogInformation("=== SEARCHITEMS V2 CALLED === searchTerm={SearchTerm}, includeItemTypes={ItemTypes}, parentId={ParentId}, artistIds={ArtistIds}, userId={UserId}", 
-            searchTerm, includeItemTypes, parentId, artistIds, userId);
-
-        // Cache search results in Redis only (no file persistence, 15 min TTL)
-        // Only cache actual searches, not browse operations
-        if (!string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(artistIds))
-        {
-            var cacheKey = $"search:{searchTerm?.ToLowerInvariant()}:{includeItemTypes}:{limit}:{startIndex}";
-            var cachedResult = await _cache.GetAsync<object>(cacheKey);
-            
-            if (cachedResult != null)
-            {
-                _logger.LogDebug("✅ Returning cached search results for '{SearchTerm}'", searchTerm);
-                return new JsonResult(cachedResult);
-            }
-        }
-
-        // If filtering by artist, handle external artists
-        if (!string.IsNullOrWhiteSpace(artistIds))
-        {
-            var artistId = artistIds.Split(',')[0]; // Take first artist if multiple
-            var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(artistId);
-            
-            if (isExternal)
-            {
-                _logger.LogInformation("Fetching albums for external artist: {Provider}/{ExternalId}", provider, externalId);
-                return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
-            }
-        }
-
-        // If no search term, proxy to Jellyfin for browsing
-        // If Jellyfin returns empty results, we'll just return empty (not mixing browse with external)
-        if (string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(parentId))
-        {
-            _logger.LogDebug("No search term or parentId, proxying to Jellyfin with full query string");
-            
-            // Build the full endpoint path with query string
-            var endpoint = userId != null ? $"Users/{userId}/Items" : "Items";
-            
-            // Ensure MediaSources is included in Fields parameter for bitrate info
-            var queryString = Request.QueryString.Value ?? "";
-            
-            if (!string.IsNullOrEmpty(queryString))
-            {
-                // Parse query string to modify Fields parameter
-                var queryParams = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(queryString);
-                
-                if (queryParams.ContainsKey("Fields"))
-                {
-                    var fieldsValue = queryParams["Fields"].ToString();
-                    if (!fieldsValue.Contains("MediaSources", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // Append MediaSources to existing Fields
-                        var newFields = string.IsNullOrEmpty(fieldsValue) 
-                            ? "MediaSources" 
-                            : $"{fieldsValue},MediaSources";
-                        
-                        // Rebuild query string with updated Fields
-                        var newQueryParams = new Dictionary<string, string>();
-                        foreach (var kvp in queryParams)
-                        {
-                            if (kvp.Key == "Fields")
-                            {
-                                newQueryParams[kvp.Key] = newFields;
-                            }
-                            else
-                            {
-                                newQueryParams[kvp.Key] = kvp.Value.ToString();
-                            }
-                        }
-                        
-                        queryString = "?" + string.Join("&", newQueryParams.Select(kvp => 
-                            $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}"));
-                    }
-                }
-                else
-                {
-                    // No Fields parameter, add it
-                    queryString = $"{queryString}&Fields=MediaSources";
-                }
-            }
-            else
-            {
-                // No query string at all
-                queryString = "?Fields=MediaSources";
-            }
-            
-            endpoint = $"{endpoint}{queryString}";
-            
-            var (browseResult, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
-
-            if (browseResult == null)
-            {
-                if (statusCode == 401)
-                {
-                    _logger.LogInformation("Jellyfin returned 401 Unauthorized, returning 401 to client");
-                    return Unauthorized(new { error = "Authentication required" });
-                }
-                
-                _logger.LogInformation("Jellyfin returned {StatusCode}, returning empty result", statusCode);
-                return new JsonResult(new { Items = Array.Empty<object>(), TotalRecordCount = 0, StartIndex = startIndex });
-            }
-
-            // Update Spotify playlist counts if enabled and response contains playlists
-            if (_spotifySettings.Enabled && browseResult.RootElement.TryGetProperty("Items", out var _))
-            {
-                _logger.LogInformation("Browse result has Items, checking for Spotify playlists to update counts");
-                browseResult = await UpdateSpotifyPlaylistCounts(browseResult);
-            }
-
-            var result = JsonSerializer.Deserialize<object>(browseResult.RootElement.GetRawText());
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                var rawText = browseResult.RootElement.GetRawText();
-                var preview = rawText.Length > 200 ? rawText[..200] : rawText;
-                _logger.LogDebug("Jellyfin browse result preview: {Result}", preview);
-            }
-            return new JsonResult(result);
-        }
-
-        // If browsing a specific parent (album, artist, playlist)
-        if (!string.IsNullOrWhiteSpace(parentId))
-        {
-            // Check if this is the music library root - if so, treat as a search
-            var isMusicLibrary = parentId == _settings.LibraryId;
-            
-            if (!isMusicLibrary || string.IsNullOrWhiteSpace(searchTerm))
-            {
-                _logger.LogDebug("Browsing parent: {ParentId}", parentId);
-                return await GetChildItems(parentId, includeItemTypes, limit, startIndex, sortBy);
-            }
-            
-            // If searching within music library root, continue to integrated search below
-            _logger.LogInformation("Searching within music library {ParentId}, including external sources", parentId);
-        }
-
-        var cleanQuery = searchTerm?.Trim().Trim('"') ?? "";
-        _logger.LogInformation("Performing integrated search for: {Query}", cleanQuery);
-
-        // Run local and external searches in parallel
-        var itemTypes = ParseItemTypes(includeItemTypes);
-        var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, recursive, Request.Headers);
-        
-        // Use parallel metadata service if available (races providers), otherwise use primary
-        var externalTask = _parallelMetadataService != null
-            ? _parallelMetadataService.SearchAllAsync(cleanQuery, limit, limit, limit)
-            : _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
-
-        var playlistTask = _settings.EnableExternalPlaylists
-            ? _metadataService.SearchPlaylistsAsync(cleanQuery, limit)
-            : Task.FromResult(new List<ExternalPlaylist>());
-
-        await Task.WhenAll(jellyfinTask, externalTask, playlistTask);
-
-        var (jellyfinResult, _) = await jellyfinTask;
-        var externalResult = await externalTask;
-        var playlistResult = await playlistTask;
-
-        _logger.LogInformation("Search results: Jellyfin={JellyfinCount}, External Songs={ExtSongs}, Albums={ExtAlbums}, Artists={ExtArtists}, Playlists={Playlists}",
-            jellyfinResult != null ? "found" : "null",
-            externalResult.Songs.Count,
-            externalResult.Albums.Count,
-            externalResult.Artists.Count,
-            playlistResult.Count);
-
-        // Parse Jellyfin results into domain models
-        var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
-
-        // Respect source ordering (SquidWTF/Tidal has better search ranking than our fuzzy matching)
-        // Just interleave local and external results based on which source has better overall match
-        
-        // Calculate average match score for each source to determine which should come first
-        var localSongsAvgScore = localSongs.Any() 
-            ? localSongs.Average(s => FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title)) 
-            : 0.0;
-        var externalSongsAvgScore = externalResult.Songs.Any() 
-            ? externalResult.Songs.Average(s => FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title)) 
-            : 0.0;
-
-        var localAlbumsAvgScore = localAlbums.Any() 
-            ? localAlbums.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title)) 
-            : 0.0;
-        var externalAlbumsAvgScore = externalResult.Albums.Any() 
-            ? externalResult.Albums.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title)) 
-            : 0.0;
-
-        var localArtistsAvgScore = localArtists.Any() 
-            ? localArtists.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name)) 
-            : 0.0;
-        var externalArtistsAvgScore = externalResult.Artists.Any() 
-            ? externalResult.Artists.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name)) 
-            : 0.0;
-
-        // Interleave results: put better-matching source first, preserve original ordering within each source
-        var allSongs = localSongsAvgScore >= externalSongsAvgScore
-            ? localSongs.Concat(externalResult.Songs).ToList()
-            : externalResult.Songs.Concat(localSongs).ToList();
-
-        var allAlbums = localAlbumsAvgScore >= externalAlbumsAvgScore
-            ? localAlbums.Concat(externalResult.Albums).ToList()
-            : externalResult.Albums.Concat(localAlbums).ToList();
-
-        var allArtists = localArtistsAvgScore >= externalArtistsAvgScore
-            ? localArtists.Concat(externalResult.Artists).ToList()
-            : externalResult.Artists.Concat(localArtists).ToList();
-
-        // Log results for debugging
-        if (_logger.IsEnabled(LogLevel.Debug))
-        {
-            _logger.LogDebug("🎵 Songs: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}",
-                localSongsAvgScore, externalSongsAvgScore, localSongsAvgScore >= externalSongsAvgScore);
-            _logger.LogDebug("💿 Albums: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}",
-                localAlbumsAvgScore, externalAlbumsAvgScore, localAlbumsAvgScore >= externalAlbumsAvgScore);
-            _logger.LogDebug("🎤 Artists: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}",
-                localArtistsAvgScore, externalArtistsAvgScore, localArtistsAvgScore >= externalArtistsAvgScore);
-        }
-
-        // Convert to Jellyfin format
-        var mergedSongs = allSongs.Select(s => _responseBuilder.ConvertSongToJellyfinItem(s)).ToList();
-        var mergedAlbums = allAlbums.Select(a => _responseBuilder.ConvertAlbumToJellyfinItem(a)).ToList();
-        var mergedArtists = allArtists.Select(a => _responseBuilder.ConvertArtistToJellyfinItem(a)).ToList();
-
-        // Add playlists (preserve their order too)
-        if (playlistResult.Count > 0)
-        {
-            var playlistItems = playlistResult
-                .Select(p => _responseBuilder.ConvertPlaylistToJellyfinItem(p))
-                .ToList();
-            
-            mergedAlbums.AddRange(playlistItems);
-        }
-
-        _logger.LogInformation("Merged results (preserving source order): Songs={Songs}, Albums={Albums}, Artists={Artists}",
-            mergedSongs.Count, mergedAlbums.Count, mergedArtists.Count);
-
-        // Pre-fetch lyrics for top 3 songs in background (don't await)
-        if (_lrclibService != null && mergedSongs.Count > 0)
-        {
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    var top3 = mergedSongs.Take(3).ToList();
-                    _logger.LogDebug("🎵 Pre-fetching lyrics for top {Count} search results", top3.Count);
-                    
-                    foreach (var songItem in top3)
-                    {
-                        if (songItem.TryGetValue("Name", out var nameObj) && nameObj is JsonElement nameEl &&
-                            songItem.TryGetValue("Artists", out var artistsObj) && artistsObj is JsonElement artistsEl &&
-                            artistsEl.GetArrayLength() > 0)
-                        {
-                            var title = nameEl.GetString() ?? "";
-                            var artist = artistsEl[0].GetString() ?? "";
-                            
-                            if (!string.IsNullOrEmpty(title) && !string.IsNullOrEmpty(artist))
-                            {
-                                await _lrclibService.GetLyricsAsync(title, artist, "", 0);
-                            }
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogDebug(ex, "Failed to pre-fetch lyrics for search results");
-                }
-            });
-        }
-
-        // Filter by item types if specified
-        var items = new List<Dictionary<string, object?>>();
-
-        _logger.LogInformation("Filtering by item types: {ItemTypes}", itemTypes == null ? "null" : string.Join(",", itemTypes));
-
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicArtist"))
-        {
-            _logger.LogInformation("Adding {Count} artists to results", mergedArtists.Count);
-            items.AddRange(mergedArtists);
-        }
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicAlbum") || itemTypes.Contains("Playlist"))
-        {
-            _logger.LogInformation("Adding {Count} albums to results", mergedAlbums.Count);
-            items.AddRange(mergedAlbums);
-        }
-        if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("Audio"))
-        {
-            _logger.LogInformation("Adding {Count} songs to results", mergedSongs.Count);
-            items.AddRange(mergedSongs);
-        }
-
-        // Apply pagination
-        var pagedItems = items.Skip(startIndex).Take(limit).ToList();
-
-        _logger.LogInformation("Returning {Count} items (total: {Total})", pagedItems.Count, items.Count);
-
-        try
-        {
-            // Return with PascalCase - use ContentResult to bypass JSON serialization issues
-            var response = new
-            {
-                Items = pagedItems,
-                TotalRecordCount = items.Count,
-                StartIndex = startIndex
-            };
-
-            // Cache search results in Redis (15 min TTL, no file persistence)
-            if (!string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(artistIds))
-            {
-                var cacheKey = $"search:{searchTerm?.ToLowerInvariant()}:{includeItemTypes}:{limit}:{startIndex}";
-                await _cache.SetAsync(cacheKey, response, TimeSpan.FromMinutes(15));
-                _logger.LogDebug("💾 Cached search results for '{SearchTerm}' (15 min TTL)", searchTerm);
-            }
-
-            _logger.LogInformation("About to serialize response...");
-
-            var json = System.Text.Json.JsonSerializer.Serialize(response, new System.Text.Json.JsonSerializerOptions
-            {
-                PropertyNamingPolicy = null,
-                DictionaryKeyPolicy = null
-            });
-
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                var preview = json.Length > 200 ? json[..200] : json;
-                _logger.LogDebug("JSON response preview: {Json}", preview);
-            }
-
-            return Content(json, "application/json");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error serializing search response");
-            throw;
-        }
-    }
-
-    /// <summary>
-    /// Gets child items of a parent (tracks in album, albums for artist).
-    /// </summary>
-    private async Task<IActionResult> GetChildItems(
-        string parentId,
-        string? includeItemTypes,
-        int limit,
-        int startIndex,
-        string? sortBy)
-    {
-        // Check if this is an external playlist
-        if (PlaylistIdHelper.IsExternalPlaylist(parentId))
-        {
-            return await GetPlaylistTracks(parentId);
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(parentId);
-
-        if (isExternal)
-        {
-            // Get external album or artist content
-            return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
-        }
-
-        // Proxy to Jellyfin for local content
-        var (result, statusCode) = await _proxyService.GetItemsAsync(
-            parentId: parentId,
-            includeItemTypes: ParseItemTypes(includeItemTypes),
-            sortBy: sortBy,
-            limit: limit,
-            startIndex: startIndex,
-            clientHeaders: Request.Headers);
-
-        return HandleProxyResponse(result, statusCode);
-    }
-
-    /// <summary>
-    /// Quick search endpoint. Works with /Search/Hints and /Users/{userId}/Search/Hints.
-    /// </summary>
-    [HttpGet("Search/Hints", Order = 1)]
-    [HttpGet("Users/{userId}/Search/Hints", Order = 1)]
-    public async Task<IActionResult> SearchHints(
-        [FromQuery] string searchTerm,
-        [FromQuery] int limit = 20,
-        [FromQuery] string? includeItemTypes = null,
-        string? userId = null)
-    {
-        if (string.IsNullOrWhiteSpace(searchTerm))
-        {
-            return _responseBuilder.CreateJsonResponse(new
-            {
-                SearchHints = Array.Empty<object>(),
-                TotalRecordCount = 0
-            });
-        }
-
-        var cleanQuery = searchTerm.Trim().Trim('"');
-        var itemTypes = ParseItemTypes(includeItemTypes);
-
-        // Run searches in parallel
-        var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, true, Request.Headers);
-        var externalTask = _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
-
-        await Task.WhenAll(jellyfinTask, externalTask);
-
-        var (jellyfinResult, _) = await jellyfinTask;
-        var externalResult = await externalTask;
-
-        var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
-
-        // NO deduplication - merge all results and take top matches
-        var allSongs = localSongs.Concat(externalResult.Songs).Take(limit).ToList();
-        var allAlbums = localAlbums.Concat(externalResult.Albums).Take(limit).ToList();
-        var allArtists = localArtists.Concat(externalResult.Artists).Take(limit).ToList();
-
-        return _responseBuilder.CreateSearchHintsResponse(
-            allSongs.Take(limit).ToList(),
-            allAlbums.Take(limit).ToList(),
-            allArtists.Take(limit).ToList());
-    }
-
-    #endregion
-
-=======
->>>>>>> beta
    #region Items

    /// <summary>
@@ -1086,16 +193,8 @@ public partial class JellyfinController : ControllerBase
    {
        var itemTypes = ParseItemTypes(includeItemTypes);

-<<<<<<< HEAD
-        _logger.LogDebug("GetExternalChildItems: provider={Provider}, externalId={ExternalId}, itemTypes={ItemTypes}", 
-            provider, externalId, string.Join(",", itemTypes ?? Array.Empty<string>()));
-||||||| f68706f
-        _logger.LogInformation("GetExternalChildItems: provider={Provider}, externalId={ExternalId}, itemTypes={ItemTypes}", 
-            provider, externalId, string.Join(",", itemTypes ?? Array.Empty<string>()));
-=======
        _logger.LogDebug("GetExternalChildItems: provider={Provider}, type={Type}, externalId={ExternalId}, itemTypes={ItemTypes}", 
            provider, type, externalId, string.Join(",", itemTypes ?? Array.Empty<string>()));
->>>>>>> beta

        // Check if asking for audio (album tracks or artist songs)
        if (itemTypes?.Contains("Audio") == true)
@@ -1121,30 +220,8 @@ public partial class JellyfinController : ControllerBase
            }
        }

-<<<<<<< HEAD
-        // Otherwise assume it's artist albums
-        _logger.LogDebug("Fetching artist albums for {Provider}/{ExternalId}", provider, externalId);
-        var albums = await _metadataService.GetArtistAlbumsAsync(provider, externalId);
-        var artist = await _metadataService.GetArtistAsync(provider, externalId);
-
-        _logger.LogDebug("Found {Count} albums for artist {ArtistName}", albums.Count, artist?.Name ?? "unknown");
-
-        // Fill artist info
-        if (artist != null)
-||||||| f68706f
-        // Otherwise assume it's artist albums
-        _logger.LogDebug("Fetching artist albums for {Provider}/{ExternalId}", provider, externalId);
-        var albums = await _metadataService.GetArtistAlbumsAsync(provider, externalId);
-        var artist = await _metadataService.GetArtistAsync(provider, externalId);
-
-        _logger.LogInformation("Found {Count} albums for artist {ArtistName}", albums.Count, artist?.Name ?? "unknown");
-
-        // Fill artist info
-        if (artist != null)
-=======
        // Check if asking for albums (artist albums)
        if (itemTypes?.Contains("MusicAlbum") == true || itemTypes == null)
->>>>>>> beta
        {
            if (type == "artist")
            {
@@ -1370,454 +447,6 @@ public partial class JellyfinController : ControllerBase

    #endregion

-<<<<<<< HEAD
-    #region Audio Streaming
-
-    /// <summary>
-    /// Downloads/streams audio. Works with local and external content.
-    /// </summary>
-    [HttpGet("Items/{itemId}/Download")]
-    [HttpGet("Items/{itemId}/File")]
-    public async Task<IActionResult> DownloadAudio(string itemId)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // Build path for Jellyfin download/file endpoint
-            var endpoint = Request.Path.Value?.Contains("/File", StringComparison.OrdinalIgnoreCase) == true ? "File" : "Download";
-            var fullPath = $"Items/{itemId}/{endpoint}";
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // Handle external content
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    /// <summary>
-    /// Streams audio for a given item. Downloads on-demand for external content.
-    /// </summary>
-    [HttpGet("Audio/{itemId}/stream")]
-    [HttpGet("Audio/{itemId}/stream.{container}")]
-    public async Task<IActionResult> StreamAudio(string itemId, string? container = null)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // Build path for Jellyfin stream
-            var fullPath = string.IsNullOrEmpty(container) 
-                ? $"Audio/{itemId}/stream" 
-                : $"Audio/{itemId}/stream.{container}";
-            
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // Handle external content
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    /// <summary>
-    /// Proxies a stream from Jellyfin with proper header forwarding.
-    /// </summary>
-    private async Task<IActionResult> ProxyJellyfinStream(string path, string itemId)
-    {
-        var jellyfinUrl = $"{_settings.Url?.TrimEnd('/')}/{path}";
-        
-        try
-        {
-            var request = new HttpRequestMessage(HttpMethod.Get, jellyfinUrl);
-            
-            // Forward auth headers
-            if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
-            {
-                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
-            }
-            else if (Request.Headers.TryGetValue("Authorization", out var auth))
-            {
-                request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
-            }
-            
-            // Forward Range header for seeking
-            if (Request.Headers.TryGetValue("Range", out var range))
-            {
-                request.Headers.TryAddWithoutValidation("Range", range.ToString());
-            }
-            
-            var response = await _proxyService.HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogError("Jellyfin stream failed: {StatusCode} for {ItemId}", response.StatusCode, itemId);
-                return StatusCode((int)response.StatusCode);
-            }
-            
-            // Set response status and headers
-            Response.StatusCode = (int)response.StatusCode;
-            
-            var contentType = response.Content.Headers.ContentType?.ToString() ?? "audio/mpeg";
-            
-            // Forward caching headers for client-side caching
-            if (response.Headers.ETag != null)
-            {
-                Response.Headers["ETag"] = response.Headers.ETag.ToString();
-            }
-            
-            if (response.Content.Headers.LastModified.HasValue)
-            {
-                Response.Headers["Last-Modified"] = response.Content.Headers.LastModified.Value.ToString("R");
-            }
-            
-            if (response.Headers.CacheControl != null)
-            {
-                Response.Headers["Cache-Control"] = response.Headers.CacheControl.ToString();
-            }
-            
-            // Forward range headers for seeking
-            if (response.Content.Headers.ContentRange != null)
-            {
-                Response.Headers["Content-Range"] = response.Content.Headers.ContentRange.ToString();
-            }
-            
-            if (response.Headers.AcceptRanges != null)
-            {
-                Response.Headers["Accept-Ranges"] = string.Join(", ", response.Headers.AcceptRanges);
-            }
-            
-            if (response.Content.Headers.ContentLength.HasValue)
-            {
-                Response.Headers["Content-Length"] = response.Content.Headers.ContentLength.Value.ToString();
-            }
-            
-            var stream = await response.Content.ReadAsStreamAsync();
-            return File(stream, contentType);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to proxy stream from Jellyfin for {ItemId}", itemId);
-            return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
-        }
-    }
-
-    /// <summary>
-    /// Streams external content, using cache if available or downloading on-demand.
-    /// </summary>
-    private async Task<IActionResult> StreamExternalContent(string provider, string externalId)
-    {
-        // Check for locally cached file
-        var localPath = await _localLibraryService.GetLocalPathForExternalSongAsync(provider, externalId);
-
-        if (localPath != null && System.IO.File.Exists(localPath))
-        {
-            // Update last write time for cache cleanup (extends cache lifetime)
-            try
-            {
-                System.IO.File.SetLastWriteTimeUtc(localPath, DateTime.UtcNow);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to update last write time for {Path}", localPath);
-            }
-            
-            var stream = System.IO.File.OpenRead(localPath);
-            return File(stream, GetContentType(localPath), enableRangeProcessing: true);
-        }
-
-        // Download and stream on-demand
-        try
-        {
-            var downloadStream = await _downloadService.DownloadAndStreamAsync(
-                provider, 
-                externalId, 
-                HttpContext.RequestAborted);
-
-            return File(downloadStream, "audio/mpeg", enableRangeProcessing: true);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to stream external song {Provider}:{ExternalId}", provider, externalId);
-            return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
-        }
-    }
-
-    /// <summary>
-    /// Universal audio endpoint - handles transcoding, format negotiation, and adaptive streaming.
-    /// This is the primary endpoint used by Jellyfin Web and most clients.
-    /// </summary>
-    [HttpGet("Audio/{itemId}/universal")]
-    [HttpHead("Audio/{itemId}/universal")]
-    public async Task<IActionResult> UniversalAudio(string itemId)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // For local content, proxy the universal endpoint with all query parameters
-            var fullPath = $"Audio/{itemId}/universal";
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // For external content, use simple streaming (no transcoding support yet)
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    #endregion
-
-||||||| f68706f
-    #region Audio Streaming
-
-    /// <summary>
-    /// Downloads/streams audio. Works with local and external content.
-    /// </summary>
-    [HttpGet("Items/{itemId}/Download")]
-    [HttpGet("Items/{itemId}/File")]
-    public async Task<IActionResult> DownloadAudio(string itemId)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // Build path for Jellyfin download/file endpoint
-            var endpoint = Request.Path.Value?.Contains("/File", StringComparison.OrdinalIgnoreCase) == true ? "File" : "Download";
-            var fullPath = $"Items/{itemId}/{endpoint}";
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // Handle external content
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    /// <summary>
-    /// Streams audio for a given item. Downloads on-demand for external content.
-    /// </summary>
-    [HttpGet("Audio/{itemId}/stream")]
-    [HttpGet("Audio/{itemId}/stream.{container}")]
-    public async Task<IActionResult> StreamAudio(string itemId, string? container = null)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // Build path for Jellyfin stream
-            var fullPath = string.IsNullOrEmpty(container) 
-                ? $"Audio/{itemId}/stream" 
-                : $"Audio/{itemId}/stream.{container}";
-            
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // Handle external content
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    /// <summary>
-    /// Proxies a stream from Jellyfin with proper header forwarding.
-    /// </summary>
-    private async Task<IActionResult> ProxyJellyfinStream(string path, string itemId)
-    {
-        var jellyfinUrl = $"{_settings.Url?.TrimEnd('/')}/{path}";
-        
-        try
-        {
-            var request = new HttpRequestMessage(HttpMethod.Get, jellyfinUrl);
-            
-            // Forward auth headers
-            if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
-            {
-                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
-            }
-            else if (Request.Headers.TryGetValue("Authorization", out var auth))
-            {
-                request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
-            }
-            
-            // Forward Range header for seeking
-            if (Request.Headers.TryGetValue("Range", out var range))
-            {
-                request.Headers.TryAddWithoutValidation("Range", range.ToString());
-            }
-            
-            var response = await _proxyService.HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogError("Jellyfin stream failed: {StatusCode} for {ItemId}", response.StatusCode, itemId);
-                return StatusCode((int)response.StatusCode);
-            }
-            
-            // Set response status and headers
-            Response.StatusCode = (int)response.StatusCode;
-            
-            var contentType = response.Content.Headers.ContentType?.ToString() ?? "audio/mpeg";
-            
-            // Forward caching headers for client-side caching
-            if (response.Headers.ETag != null)
-            {
-                Response.Headers["ETag"] = response.Headers.ETag.ToString();
-            }
-            
-            if (response.Content.Headers.LastModified.HasValue)
-            {
-                Response.Headers["Last-Modified"] = response.Content.Headers.LastModified.Value.ToString("R");
-            }
-            
-            if (response.Headers.CacheControl != null)
-            {
-                Response.Headers["Cache-Control"] = response.Headers.CacheControl.ToString();
-            }
-            
-            // Forward range headers for seeking
-            if (response.Content.Headers.ContentRange != null)
-            {
-                Response.Headers["Content-Range"] = response.Content.Headers.ContentRange.ToString();
-            }
-            
-            if (response.Headers.AcceptRanges != null)
-            {
-                Response.Headers["Accept-Ranges"] = string.Join(", ", response.Headers.AcceptRanges);
-            }
-            
-            if (response.Content.Headers.ContentLength.HasValue)
-            {
-                Response.Headers["Content-Length"] = response.Content.Headers.ContentLength.Value.ToString();
-            }
-            
-            var stream = await response.Content.ReadAsStreamAsync();
-            return File(stream, contentType);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to proxy stream from Jellyfin for {ItemId}", itemId);
-            return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
-        }
-    }
-
-    /// <summary>
-    /// Streams external content, using cache if available or downloading on-demand.
-    /// </summary>
-    private async Task<IActionResult> StreamExternalContent(string provider, string externalId)
-    {
-        // Check for locally cached file
-        var localPath = await _localLibraryService.GetLocalPathForExternalSongAsync(provider, externalId);
-
-        if (localPath != null && System.IO.File.Exists(localPath))
-        {
-            // Update last access time for cache cleanup
-            try
-            {
-                System.IO.File.SetLastAccessTimeUtc(localPath, DateTime.UtcNow);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to update last access time for {Path}", localPath);
-            }
-            
-            var stream = System.IO.File.OpenRead(localPath);
-            return File(stream, GetContentType(localPath), enableRangeProcessing: true);
-        }
-
-        // Download and stream on-demand
-        try
-        {
-            var downloadStream = await _downloadService.DownloadAndStreamAsync(
-                provider, 
-                externalId, 
-                HttpContext.RequestAborted);
-
-            return File(downloadStream, "audio/mpeg", enableRangeProcessing: true);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to stream external song {Provider}:{ExternalId}", provider, externalId);
-            return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
-        }
-    }
-
-    /// <summary>
-    /// Universal audio endpoint - handles transcoding, format negotiation, and adaptive streaming.
-    /// This is the primary endpoint used by Jellyfin Web and most clients.
-    /// </summary>
-    [HttpGet("Audio/{itemId}/universal")]
-    [HttpHead("Audio/{itemId}/universal")]
-    public async Task<IActionResult> UniversalAudio(string itemId)
-    {
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return BadRequest(new { error = "Missing item ID" });
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-        if (!isExternal)
-        {
-            // For local content, proxy the universal endpoint with all query parameters
-            var fullPath = $"Audio/{itemId}/universal";
-            if (Request.QueryString.HasValue)
-            {
-                fullPath = $"{fullPath}{Request.QueryString.Value}";
-            }
-
-            return await ProxyJellyfinStream(fullPath, itemId);
-        }
-
-        // For external content, use simple streaming (no transcoding support yet)
-        return await StreamExternalContent(provider!, externalId!);
-    }
-
-    #endregion
-
-=======
->>>>>>> beta
    #region Images

    /// <summary>
@@ -1984,862 +613,6 @@ public partial class JellyfinController : ControllerBase

    #endregion

-<<<<<<< HEAD
-    #region Lyrics
-
-    /// <summary>
-    /// Gets lyrics for an item.
-    /// Priority: 1. Jellyfin embedded lyrics, 2. Spotify synced lyrics, 3. LRCLIB
-    /// </summary>
-    [HttpGet("Audio/{itemId}/Lyrics")]
-    [HttpGet("Items/{itemId}/Lyrics")]
-    public async Task<IActionResult> GetLyrics(string itemId)
-    {
-        _logger.LogDebug("🎵 GetLyrics called for itemId: {ItemId}", itemId);
-        
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return NotFound();
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-        
-        _logger.LogDebug("🎵 Lyrics request: itemId={ItemId}, isExternal={IsExternal}, provider={Provider}, externalId={ExternalId}", 
-            itemId, isExternal, provider, externalId);
-
-        // For local tracks, check if Jellyfin already has embedded lyrics
-        if (!isExternal)
-        {
-            _logger.LogDebug("Checking Jellyfin for embedded lyrics for local track: {ItemId}", itemId);
-            
-            // Try to get lyrics from Jellyfin first (it reads embedded lyrics from files)
-            var (jellyfinLyrics, statusCode) = await _proxyService.GetJsonAsync($"Audio/{itemId}/Lyrics", null, Request.Headers);
-            
-            _logger.LogDebug("Jellyfin lyrics check result: statusCode={StatusCode}, hasLyrics={HasLyrics}", 
-                statusCode, jellyfinLyrics != null);
-            
-            if (jellyfinLyrics != null && statusCode == 200)
-            {
-                _logger.LogInformation("Found embedded lyrics in Jellyfin for track {ItemId}", itemId);
-                return new JsonResult(JsonSerializer.Deserialize<object>(jellyfinLyrics.RootElement.GetRawText()));
-            }
-            
-            _logger.LogWarning("No embedded lyrics found in Jellyfin (status: {StatusCode}), trying Spotify/LRCLIB", statusCode);
-        }
-
-        // Get song metadata for lyrics search
-        Song? song = null;
-        string? spotifyTrackId = null;
-        
-        if (isExternal)
-        {
-            song = await _metadataService.GetSongAsync(provider!, externalId!);
-            
-            // Use Spotify ID from song metadata if available (populated during GetSongAsync)
-            if (song != null && !string.IsNullOrEmpty(song.SpotifyId))
-            {
-                spotifyTrackId = song.SpotifyId;
-                _logger.LogInformation("Using Spotify ID {SpotifyId} from song metadata for {Provider}/{ExternalId}", 
-                    spotifyTrackId, provider, externalId);
-            }
-            // Fallback: Try to find Spotify ID from matched tracks cache
-            else if (song != null)
-            {
-                spotifyTrackId = await FindSpotifyIdForExternalTrackAsync(song);
-                if (!string.IsNullOrEmpty(spotifyTrackId))
-                {
-                    _logger.LogDebug("Found Spotify ID {SpotifyId} for external track {Provider}/{ExternalId} from cache", 
-                        spotifyTrackId, provider, externalId);
-                }
-                else
-                {
-                    // Last resort: Try to convert via Odesli/song.link
-                    if (provider == "squidwtf")
-                    {
-                        spotifyTrackId = await _odesliService.ConvertTidalToSpotifyIdAsync(externalId!, HttpContext.RequestAborted);
-                    }
-                    else
-                    {
-                        // For other providers, build the URL and convert
-                        var sourceUrl = provider?.ToLowerInvariant() switch
-                        {
-                            "deezer" => $"https://www.deezer.com/track/{externalId}",
-                            "qobuz" => $"https://www.qobuz.com/us-en/album/-/-/{externalId}",
-                            _ => null
-                        };
-                        
-                        if (!string.IsNullOrEmpty(sourceUrl))
-                        {
-                            spotifyTrackId = await _odesliService.ConvertUrlToSpotifyIdAsync(sourceUrl, HttpContext.RequestAborted);
-                        }
-                    }
-                    
-                    if (!string.IsNullOrEmpty(spotifyTrackId))
-                    {
-                        _logger.LogDebug("Converted {Provider}/{ExternalId} to Spotify ID {SpotifyId} via Odesli", 
-                            provider, externalId, spotifyTrackId);
-                    }
-                }
-            }
-        }
-        else
-        {
-            // For local songs, get metadata from Jellyfin
-            var (item, _) = await _proxyService.GetItemAsync(itemId, Request.Headers);
-            if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) && 
-                typeEl.GetString() == "Audio")
-            {
-                song = new Song
-                {
-                    Title = item.RootElement.TryGetProperty("Name", out var name) ? name.GetString() ?? "" : "",
-                    Artist = item.RootElement.TryGetProperty("AlbumArtist", out var artist) ? artist.GetString() ?? "" : "",
-                    Album = item.RootElement.TryGetProperty("Album", out var album) ? album.GetString() ?? "" : "",
-                    Duration = item.RootElement.TryGetProperty("RunTimeTicks", out var ticks) ? (int)(ticks.GetInt64() / 10000000) : 0
-                };
-                
-                // Check for Spotify ID in provider IDs
-                if (item.RootElement.TryGetProperty("ProviderIds", out var providerIds))
-                {
-                    if (providerIds.TryGetProperty("Spotify", out var spotifyId))
-                    {
-                        spotifyTrackId = spotifyId.GetString();
-                    }
-                }
-            }
-        }
-
-        if (song == null)
-        {
-            return NotFound(new { error = "Song not found" });
-        }
-
-        // Strip [S] suffix from title, artist, and album for lyrics search
-        // The [S] tag is added to external tracks but shouldn't be used in lyrics queries
-        var searchTitle = song.Title.Replace(" [S]", "").Trim();
-        var searchArtist = song.Artist?.Replace(" [S]", "").Trim() ?? "";
-        var searchAlbum = song.Album?.Replace(" [S]", "").Trim() ?? "";
-        var searchArtists = song.Artists.Select(a => a.Replace(" [S]", "").Trim()).ToList();
-        
-        if (searchArtists.Count == 0 && !string.IsNullOrEmpty(searchArtist))
-        {
-            searchArtists.Add(searchArtist);
-        }
-
-        // Use orchestrator for clean, modular lyrics fetching
-        LyricsInfo? lyrics = null;
-        
-        if (_lyricsOrchestrator != null)
-        {
-            lyrics = await _lyricsOrchestrator.GetLyricsAsync(
-                trackName: searchTitle,
-                artistNames: searchArtists.ToArray(),
-                albumName: searchAlbum,
-                durationSeconds: song.Duration ?? 0,
-                spotifyTrackId: spotifyTrackId);
-        }
-        else
-        {
-            // Fallback to manual fetching if orchestrator not available
-            _logger.LogWarning("LyricsOrchestrator not available, using fallback method");
-            
-            // Try Spotify lyrics ONLY if we have a valid Spotify track ID
-            if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId))
-            {
-                var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim();
-                
-                if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local"))
-                {
-                    var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId);
-                    
-                    if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0)
-                    {
-                        lyrics = _spotifyLyricsService.ToLyricsInfo(spotifyLyrics);
-                    }
-                }
-            }
-            
-            // Fall back to LyricsPlus
-            if (lyrics == null && _lyricsPlusService != null)
-            {
-                lyrics = await _lyricsPlusService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-            }
-            
-            // Fall back to LRCLIB
-            if (lyrics == null && _lrclibService != null)
-            {
-                lyrics = await _lrclibService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-            }
-        }
-
-        if (lyrics == null)
-        {
-            return NotFound(new { error = "Lyrics not found" });
-        }
-
-        // Prefer synced lyrics, fall back to plain
-        var lyricsText = lyrics.SyncedLyrics ?? lyrics.PlainLyrics ?? "";
-        var isSynced = !string.IsNullOrEmpty(lyrics.SyncedLyrics);
-
-        _logger.LogInformation("Lyrics for {Artist} - {Track}: synced={HasSynced}, plainLength={PlainLen}, syncedLength={SyncLen}", 
-            song.Artist, song.Title, isSynced, lyrics.PlainLyrics?.Length ?? 0, lyrics.SyncedLyrics?.Length ?? 0);
-
-        // Parse LRC format into individual lines for Jellyfin
-        var lyricLines = new List<Dictionary<string, object>>();
-        
-        if (isSynced && !string.IsNullOrEmpty(lyrics.SyncedLyrics))
-        {
-            _logger.LogDebug("Parsing synced lyrics (LRC format)");
-            // Parse LRC format: [mm:ss.xx] text
-            // Skip ID tags like [ar:Artist], [ti:Title], etc.
-            var lines = lyrics.SyncedLyrics.Split('\n', StringSplitOptions.RemoveEmptyEntries);
-            foreach (var line in lines)
-            {
-                // Match timestamp format [mm:ss.xx] or [mm:ss.xxx]
-                var match = System.Text.RegularExpressions.Regex.Match(line, @"^\[(\d+):(\d+)\.(\d+)\]\s*(.*)$");
-                if (match.Success)
-                {
-                    var minutes = int.Parse(match.Groups[1].Value);
-                    var seconds = int.Parse(match.Groups[2].Value);
-                    var centiseconds = int.Parse(match.Groups[3].Value);
-                    var text = match.Groups[4].Value;
-                    
-                    // Convert to ticks (100 nanoseconds)
-                    var totalMilliseconds = (minutes * 60 + seconds) * 1000 + centiseconds * 10;
-                    var ticks = totalMilliseconds * 10000L;
-                    
-                    // For synced lyrics, include Start timestamp
-                    lyricLines.Add(new Dictionary<string, object>
-                    {
-                        ["Text"] = text,
-                        ["Start"] = ticks
-                    });
-                }
-                // Skip ID tags like [ar:Artist], [ti:Title], [length:2:23], etc.
-            }
-            _logger.LogDebug("Parsed {Count} synced lyric lines (skipped ID tags)", lyricLines.Count);
-        }
-        else if (!string.IsNullOrEmpty(lyricsText))
-        {
-            _logger.LogInformation("Splitting plain lyrics into lines (no timestamps)");
-            // Plain lyrics - split by newlines and return each line separately
-            // IMPORTANT: Do NOT include "Start" field at all for unsynced lyrics
-            // Including it (even as null) causes clients to treat it as synced with timestamp 0:00
-            var lines = lyricsText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
-            foreach (var line in lines)
-            {
-                lyricLines.Add(new Dictionary<string, object>
-                {
-                    ["Text"] = line.Trim()
-                });
-            }
-            _logger.LogDebug("Split into {Count} plain lyric lines", lyricLines.Count);
-        }
-        else
-        {
-            _logger.LogWarning("No lyrics text available");
-            // No lyrics at all
-            lyricLines.Add(new Dictionary<string, object>
-            {
-                ["Text"] = ""
-            });
-        }
-
-        var response = new
-        {
-            Metadata = new
-            {
-                Artist = lyrics.ArtistName,
-                Album = lyrics.AlbumName,
-                Title = lyrics.TrackName,
-                Length = lyrics.Duration,
-                IsSynced = isSynced
-            },
-            Lyrics = lyricLines
-        };
-
-        _logger.LogDebug("Returning lyrics response: {LineCount} lines, synced={IsSynced}", lyricLines.Count, isSynced);
-        
-        // Log a sample of the response for debugging
-        if (lyricLines.Count > 0)
-        {
-            var sampleLine = lyricLines[0];
-            var hasStart = sampleLine.ContainsKey("Start");
-            _logger.LogDebug("Sample line: Text='{Text}', HasStart={HasStart}", 
-                sampleLine.GetValueOrDefault("Text"), hasStart);
-        }
-
-        return Ok(response);
-    }
-    
-    /// <summary>
-    /// Proactively fetches and caches lyrics for a track in the background.
-    /// Called when playback starts to ensure lyrics are ready when requested.
-    /// </summary>
-    private async Task PrefetchLyricsForTrackAsync(string itemId, bool isExternal, string? provider, string? externalId)
-    {
-        try
-        {
-            Song? song = null;
-            string? spotifyTrackId = null;
-            
-            if (isExternal && !string.IsNullOrEmpty(provider) && !string.IsNullOrEmpty(externalId))
-            {
-                // Get external track metadata
-                song = await _metadataService.GetSongAsync(provider, externalId);
-                
-                // Try to find Spotify ID from matched tracks cache
-                if (song != null)
-                {
-                    spotifyTrackId = await FindSpotifyIdForExternalTrackAsync(song);
-                    
-                    // If no cached Spotify ID, try Odesli conversion
-                    if (string.IsNullOrEmpty(spotifyTrackId) && provider == "squidwtf")
-                    {
-                        spotifyTrackId = await _odesliService.ConvertTidalToSpotifyIdAsync(externalId, HttpContext.RequestAborted);
-                    }
-                }
-            }
-            else
-            {
-                // Get local track metadata from Jellyfin
-                var (item, _) = await _proxyService.GetItemAsync(itemId, Request.Headers);
-                if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) && 
-                    typeEl.GetString() == "Audio")
-                {
-                    song = new Song
-                    {
-                        Title = item.RootElement.TryGetProperty("Name", out var name) ? name.GetString() ?? "" : "",
-                        Artist = item.RootElement.TryGetProperty("AlbumArtist", out var artist) ? artist.GetString() ?? "" : "",
-                        Album = item.RootElement.TryGetProperty("Album", out var album) ? album.GetString() ?? "" : "",
-                        Duration = item.RootElement.TryGetProperty("RunTimeTicks", out var ticks) ? (int)(ticks.GetInt64() / 10000000) : 0
-                    };
-                    
-                    // Check for Spotify ID in provider IDs
-                    if (item.RootElement.TryGetProperty("ProviderIds", out var providerIds))
-                    {
-                        if (providerIds.TryGetProperty("Spotify", out var spotifyId))
-                        {
-                            spotifyTrackId = spotifyId.GetString();
-                        }
-                    }
-                }
-            }
-            
-            if (song == null)
-            {
-                _logger.LogDebug("Could not get song metadata for lyrics prefetch: {ItemId}", itemId);
-                return;
-            }
-            
-            // Strip [S] suffix for lyrics search
-            var searchTitle = song.Title.Replace(" [S]", "").Trim();
-            var searchArtist = song.Artist?.Replace(" [S]", "").Trim() ?? "";
-            var searchAlbum = song.Album?.Replace(" [S]", "").Trim() ?? "";
-            var searchArtists = song.Artists.Select(a => a.Replace(" [S]", "").Trim()).ToList();
-            
-            if (searchArtists.Count == 0 && !string.IsNullOrEmpty(searchArtist))
-            {
-                searchArtists.Add(searchArtist);
-            }
-            
-            _logger.LogDebug("🎵 Prefetching lyrics for: {Artist} - {Title}", searchArtist, searchTitle);
-            
-            // Use orchestrator for prefetching
-            if (_lyricsOrchestrator != null)
-            {
-                await _lyricsOrchestrator.PrefetchLyricsAsync(
-                    trackName: searchTitle,
-                    artistNames: searchArtists.ToArray(),
-                    albumName: searchAlbum,
-                    durationSeconds: song.Duration ?? 0,
-                    spotifyTrackId: spotifyTrackId);
-                return;
-            }
-            
-            // Fallback to manual prefetching if orchestrator not available
-            _logger.LogWarning("LyricsOrchestrator not available for prefetch, using fallback method");
-            
-            // Try Spotify lyrics if we have a valid Spotify track ID
-            if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId))
-            {
-                var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim();
-                
-                if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local"))
-                {
-                    var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId);
-                    
-                    if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0)
-                    {
-                        _logger.LogDebug("✓ Prefetched Spotify lyrics for {Artist} - {Title} ({LineCount} lines)", 
-                            searchArtist, searchTitle, spotifyLyrics.Lines.Count);
-                        return; // Success, lyrics are now cached
-                    }
-                }
-            }
-            
-            // Fall back to LyricsPlus
-            if (_lyricsPlusService != null)
-            {
-                var lyrics = await _lyricsPlusService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-                
-                if (lyrics != null)
-                {
-                    _logger.LogDebug("✓ Prefetched LyricsPlus lyrics for {Artist} - {Title}", searchArtist, searchTitle);
-                    return; // Success, lyrics are now cached
-                }
-            }
-            
-            // Fall back to LRCLIB
-            if (_lrclibService != null)
-            {
-                var lyrics = await _lrclibService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-                
-                if (lyrics != null)
-                {
-                    _logger.LogDebug("✓ Prefetched LRCLIB lyrics for {Artist} - {Title}", searchArtist, searchTitle);
-                }
-                else
-                {
-                    _logger.LogDebug("No lyrics found for {Artist} - {Title}", searchArtist, searchTitle);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error prefetching lyrics for track {ItemId}", itemId);
-        }
-    }
-
-    #endregion
-
-||||||| f68706f
-    #region Lyrics
-
-    /// <summary>
-    /// Gets lyrics for an item.
-    /// Priority: 1. Jellyfin embedded lyrics, 2. Spotify synced lyrics, 3. LRCLIB
-    /// </summary>
-    [HttpGet("Audio/{itemId}/Lyrics")]
-    [HttpGet("Items/{itemId}/Lyrics")]
-    public async Task<IActionResult> GetLyrics(string itemId)
-    {
-        _logger.LogInformation("🎵 GetLyrics called for itemId: {ItemId}", itemId);
-        
-        if (string.IsNullOrWhiteSpace(itemId))
-        {
-            return NotFound();
-        }
-
-        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-        
-        _logger.LogInformation("🎵 Lyrics request: itemId={ItemId}, isExternal={IsExternal}, provider={Provider}, externalId={ExternalId}", 
-            itemId, isExternal, provider, externalId);
-
-        // For local tracks, check if Jellyfin already has embedded lyrics
-        if (!isExternal)
-        {
-            _logger.LogInformation("Checking Jellyfin for embedded lyrics for local track: {ItemId}", itemId);
-            
-            // Try to get lyrics from Jellyfin first (it reads embedded lyrics from files)
-            var (jellyfinLyrics, statusCode) = await _proxyService.GetJsonAsync($"Audio/{itemId}/Lyrics", null, Request.Headers);
-            
-            _logger.LogInformation("Jellyfin lyrics check result: statusCode={StatusCode}, hasLyrics={HasLyrics}", 
-                statusCode, jellyfinLyrics != null);
-            
-            if (jellyfinLyrics != null && statusCode == 200)
-            {
-                _logger.LogInformation("Found embedded lyrics in Jellyfin for track {ItemId}", itemId);
-                return new JsonResult(JsonSerializer.Deserialize<object>(jellyfinLyrics.RootElement.GetRawText()));
-            }
-            
-            _logger.LogInformation("No embedded lyrics found in Jellyfin (status: {StatusCode}), trying Spotify/LRCLIB", statusCode);
-        }
-
-        // Get song metadata for lyrics search
-        Song? song = null;
-        string? spotifyTrackId = null;
-        
-        if (isExternal)
-        {
-            song = await _metadataService.GetSongAsync(provider!, externalId!);
-            
-            // Use Spotify ID from song metadata if available (populated during GetSongAsync)
-            if (song != null && !string.IsNullOrEmpty(song.SpotifyId))
-            {
-                spotifyTrackId = song.SpotifyId;
-                _logger.LogInformation("Using Spotify ID {SpotifyId} from song metadata for {Provider}/{ExternalId}", 
-                    spotifyTrackId, provider, externalId);
-            }
-            // Fallback: Try to find Spotify ID from matched tracks cache
-            else if (song != null)
-            {
-                spotifyTrackId = await FindSpotifyIdForExternalTrackAsync(song);
-                if (!string.IsNullOrEmpty(spotifyTrackId))
-                {
-                    _logger.LogInformation("Found Spotify ID {SpotifyId} for external track {Provider}/{ExternalId} from cache", 
-                        spotifyTrackId, provider, externalId);
-                }
-                else
-                {
-                    // Last resort: Try to convert via Odesli/song.link
-                    if (provider == "squidwtf")
-                    {
-                        spotifyTrackId = await _odesliService.ConvertTidalToSpotifyIdAsync(externalId!, HttpContext.RequestAborted);
-                    }
-                    else
-                    {
-                        // For other providers, build the URL and convert
-                        var sourceUrl = provider?.ToLowerInvariant() switch
-                        {
-                            "deezer" => $"https://www.deezer.com/track/{externalId}",
-                            "qobuz" => $"https://www.qobuz.com/us-en/album/-/-/{externalId}",
-                            _ => null
-                        };
-                        
-                        if (!string.IsNullOrEmpty(sourceUrl))
-                        {
-                            spotifyTrackId = await _odesliService.ConvertUrlToSpotifyIdAsync(sourceUrl, HttpContext.RequestAborted);
-                        }
-                    }
-                    
-                    if (!string.IsNullOrEmpty(spotifyTrackId))
-                    {
-                        _logger.LogInformation("Converted {Provider}/{ExternalId} to Spotify ID {SpotifyId} via Odesli", 
-                            provider, externalId, spotifyTrackId);
-                    }
-                }
-            }
-        }
-        else
-        {
-            // For local songs, get metadata from Jellyfin
-            var (item, _) = await _proxyService.GetItemAsync(itemId, Request.Headers);
-            if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) && 
-                typeEl.GetString() == "Audio")
-            {
-                song = new Song
-                {
-                    Title = item.RootElement.TryGetProperty("Name", out var name) ? name.GetString() ?? "" : "",
-                    Artist = item.RootElement.TryGetProperty("AlbumArtist", out var artist) ? artist.GetString() ?? "" : "",
-                    Album = item.RootElement.TryGetProperty("Album", out var album) ? album.GetString() ?? "" : "",
-                    Duration = item.RootElement.TryGetProperty("RunTimeTicks", out var ticks) ? (int)(ticks.GetInt64() / 10000000) : 0
-                };
-                
-                // Check for Spotify ID in provider IDs
-                if (item.RootElement.TryGetProperty("ProviderIds", out var providerIds))
-                {
-                    if (providerIds.TryGetProperty("Spotify", out var spotifyId))
-                    {
-                        spotifyTrackId = spotifyId.GetString();
-                    }
-                }
-            }
-        }
-
-        if (song == null)
-        {
-            return NotFound(new { error = "Song not found" });
-        }
-
-        // Strip [S] suffix from title, artist, and album for lyrics search
-        // The [S] tag is added to external tracks but shouldn't be used in lyrics queries
-        var searchTitle = song.Title.Replace(" [S]", "").Trim();
-        var searchArtist = song.Artist?.Replace(" [S]", "").Trim() ?? "";
-        var searchAlbum = song.Album?.Replace(" [S]", "").Trim() ?? "";
-        var searchArtists = song.Artists.Select(a => a.Replace(" [S]", "").Trim()).ToList();
-        
-        if (searchArtists.Count == 0 && !string.IsNullOrEmpty(searchArtist))
-        {
-            searchArtists.Add(searchArtist);
-        }
-
-        LyricsInfo? lyrics = null;
-        
-        // Try Spotify lyrics ONLY if we have a valid Spotify track ID
-        // Spotify lyrics only work for tracks from injected playlists that have been matched
-        if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId))
-        {
-            // Validate that this is a real Spotify ID (not spotify:local or other invalid formats)
-            var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim();
-            
-            // Spotify track IDs are 22 characters, base62 encoded
-            if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local"))
-            {
-                _logger.LogInformation("Trying Spotify lyrics for track ID: {SpotifyId} ({Artist} - {Title})", 
-                    cleanSpotifyId, searchArtist, searchTitle);
-                
-                var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId);
-                
-                if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0)
-                {
-                    _logger.LogInformation("Found Spotify lyrics for {Artist} - {Title} ({LineCount} lines, type: {SyncType})", 
-                        searchArtist, searchTitle, spotifyLyrics.Lines.Count, spotifyLyrics.SyncType);
-                    lyrics = _spotifyLyricsService.ToLyricsInfo(spotifyLyrics);
-                }
-                else
-                {
-                    _logger.LogDebug("No Spotify lyrics found for track ID {SpotifyId}", cleanSpotifyId);
-                }
-            }
-            else
-            {
-                _logger.LogDebug("Invalid Spotify ID format: {SpotifyId}, skipping Spotify lyrics", spotifyTrackId);
-            }
-        }
-        
-        // Fall back to LRCLIB if no Spotify lyrics
-        if (lyrics == null)
-        {
-            _logger.LogInformation("Searching LRCLIB for lyrics: {Artists} - {Title}", 
-                string.Join(", ", searchArtists), 
-                searchTitle);
-            var lrclibService = HttpContext.RequestServices.GetService<LrclibService>();
-            if (lrclibService != null)
-            {
-                lyrics = await lrclibService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-            }
-        }
-
-        if (lyrics == null)
-        {
-            return NotFound(new { error = "Lyrics not found" });
-        }
-
-        // Prefer synced lyrics, fall back to plain
-        var lyricsText = lyrics.SyncedLyrics ?? lyrics.PlainLyrics ?? "";
-        var isSynced = !string.IsNullOrEmpty(lyrics.SyncedLyrics);
-
-        _logger.LogInformation("Lyrics for {Artist} - {Track}: synced={HasSynced}, plainLength={PlainLen}, syncedLength={SyncLen}", 
-            song.Artist, song.Title, isSynced, lyrics.PlainLyrics?.Length ?? 0, lyrics.SyncedLyrics?.Length ?? 0);
-
-        // Parse LRC format into individual lines for Jellyfin
-        var lyricLines = new List<Dictionary<string, object>>();
-        
-        if (isSynced && !string.IsNullOrEmpty(lyrics.SyncedLyrics))
-        {
-            _logger.LogInformation("Parsing synced lyrics (LRC format)");
-            // Parse LRC format: [mm:ss.xx] text
-            // Skip ID tags like [ar:Artist], [ti:Title], etc.
-            var lines = lyrics.SyncedLyrics.Split('\n', StringSplitOptions.RemoveEmptyEntries);
-            foreach (var line in lines)
-            {
-                // Match timestamp format [mm:ss.xx] or [mm:ss.xxx]
-                var match = System.Text.RegularExpressions.Regex.Match(line, @"^\[(\d+):(\d+)\.(\d+)\]\s*(.*)$");
-                if (match.Success)
-                {
-                    var minutes = int.Parse(match.Groups[1].Value);
-                    var seconds = int.Parse(match.Groups[2].Value);
-                    var centiseconds = int.Parse(match.Groups[3].Value);
-                    var text = match.Groups[4].Value;
-                    
-                    // Convert to ticks (100 nanoseconds)
-                    var totalMilliseconds = (minutes * 60 + seconds) * 1000 + centiseconds * 10;
-                    var ticks = totalMilliseconds * 10000L;
-                    
-                    // For synced lyrics, include Start timestamp
-                    lyricLines.Add(new Dictionary<string, object>
-                    {
-                        ["Text"] = text,
-                        ["Start"] = ticks
-                    });
-                }
-                // Skip ID tags like [ar:Artist], [ti:Title], [length:2:23], etc.
-            }
-            _logger.LogInformation("Parsed {Count} synced lyric lines (skipped ID tags)", lyricLines.Count);
-        }
-        else if (!string.IsNullOrEmpty(lyricsText))
-        {
-            _logger.LogInformation("Splitting plain lyrics into lines (no timestamps)");
-            // Plain lyrics - split by newlines and return each line separately
-            // IMPORTANT: Do NOT include "Start" field at all for unsynced lyrics
-            // Including it (even as null) causes clients to treat it as synced with timestamp 0:00
-            var lines = lyricsText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
-            foreach (var line in lines)
-            {
-                lyricLines.Add(new Dictionary<string, object>
-                {
-                    ["Text"] = line.Trim()
-                });
-            }
-            _logger.LogInformation("Split into {Count} plain lyric lines", lyricLines.Count);
-        }
-        else
-        {
-            _logger.LogWarning("No lyrics text available");
-            // No lyrics at all
-            lyricLines.Add(new Dictionary<string, object>
-            {
-                ["Text"] = ""
-            });
-        }
-
-        var response = new
-        {
-            Metadata = new
-            {
-                Artist = lyrics.ArtistName,
-                Album = lyrics.AlbumName,
-                Title = lyrics.TrackName,
-                Length = lyrics.Duration,
-                IsSynced = isSynced
-            },
-            Lyrics = lyricLines
-        };
-
-        _logger.LogInformation("Returning lyrics response: {LineCount} lines, synced={IsSynced}", lyricLines.Count, isSynced);
-        
-        // Log a sample of the response for debugging
-        if (lyricLines.Count > 0)
-        {
-            var sampleLine = lyricLines[0];
-            var hasStart = sampleLine.ContainsKey("Start");
-            _logger.LogInformation("Sample line: Text='{Text}', HasStart={HasStart}", 
-                sampleLine.GetValueOrDefault("Text"), hasStart);
-        }
-
-        return Ok(response);
-    }
-    
-    /// <summary>
-    /// Proactively fetches and caches lyrics for a track in the background.
-    /// Called when playback starts to ensure lyrics are ready when requested.
-    /// </summary>
-    private async Task PrefetchLyricsForTrackAsync(string itemId, bool isExternal, string? provider, string? externalId)
-    {
-        try
-        {
-            Song? song = null;
-            string? spotifyTrackId = null;
-            
-            if (isExternal && !string.IsNullOrEmpty(provider) && !string.IsNullOrEmpty(externalId))
-            {
-                // Get external track metadata
-                song = await _metadataService.GetSongAsync(provider, externalId);
-                
-                // Try to find Spotify ID from matched tracks cache
-                if (song != null)
-                {
-                    spotifyTrackId = await FindSpotifyIdForExternalTrackAsync(song);
-                    
-                    // If no cached Spotify ID, try Odesli conversion
-                    if (string.IsNullOrEmpty(spotifyTrackId) && provider == "squidwtf")
-                    {
-                        spotifyTrackId = await _odesliService.ConvertTidalToSpotifyIdAsync(externalId, HttpContext.RequestAborted);
-                    }
-                }
-            }
-            else
-            {
-                // Get local track metadata from Jellyfin
-                var (item, _) = await _proxyService.GetItemAsync(itemId, Request.Headers);
-                if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) && 
-                    typeEl.GetString() == "Audio")
-                {
-                    song = new Song
-                    {
-                        Title = item.RootElement.TryGetProperty("Name", out var name) ? name.GetString() ?? "" : "",
-                        Artist = item.RootElement.TryGetProperty("AlbumArtist", out var artist) ? artist.GetString() ?? "" : "",
-                        Album = item.RootElement.TryGetProperty("Album", out var album) ? album.GetString() ?? "" : "",
-                        Duration = item.RootElement.TryGetProperty("RunTimeTicks", out var ticks) ? (int)(ticks.GetInt64() / 10000000) : 0
-                    };
-                    
-                    // Check for Spotify ID in provider IDs
-                    if (item.RootElement.TryGetProperty("ProviderIds", out var providerIds))
-                    {
-                        if (providerIds.TryGetProperty("Spotify", out var spotifyId))
-                        {
-                            spotifyTrackId = spotifyId.GetString();
-                        }
-                    }
-                }
-            }
-            
-            if (song == null)
-            {
-                _logger.LogDebug("Could not get song metadata for lyrics prefetch: {ItemId}", itemId);
-                return;
-            }
-            
-            // Strip [S] suffix for lyrics search
-            var searchTitle = song.Title.Replace(" [S]", "").Trim();
-            var searchArtist = song.Artist?.Replace(" [S]", "").Trim() ?? "";
-            var searchAlbum = song.Album?.Replace(" [S]", "").Trim() ?? "";
-            var searchArtists = song.Artists.Select(a => a.Replace(" [S]", "").Trim()).ToList();
-            
-            if (searchArtists.Count == 0 && !string.IsNullOrEmpty(searchArtist))
-            {
-                searchArtists.Add(searchArtist);
-            }
-            
-            _logger.LogDebug("🎵 Prefetching lyrics for: {Artist} - {Title}", searchArtist, searchTitle);
-            
-            // Try Spotify lyrics if we have a valid Spotify track ID
-            if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId))
-            {
-                var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim();
-                
-                if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local"))
-                {
-                    var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId);
-                    
-                    if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0)
-                    {
-                        _logger.LogDebug("✓ Prefetched Spotify lyrics for {Artist} - {Title} ({LineCount} lines)", 
-                            searchArtist, searchTitle, spotifyLyrics.Lines.Count);
-                        return; // Success, lyrics are now cached
-                    }
-                }
-            }
-            
-            // Fall back to LRCLIB
-            if (_lrclibService != null)
-            {
-                var lyrics = await _lrclibService.GetLyricsAsync(
-                    searchTitle,
-                    searchArtists.ToArray(),
-                    searchAlbum,
-                    song.Duration ?? 0);
-                
-                if (lyrics != null)
-                {
-                    _logger.LogDebug("✓ Prefetched LRCLIB lyrics for {Artist} - {Title}", searchArtist, searchTitle);
-                }
-                else
-                {
-                    _logger.LogDebug("No lyrics found for {Artist} - {Title}", searchArtist, searchTitle);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogDebug(ex, "Error prefetching lyrics for track {ItemId}", itemId);
-        }
-    }
-
-    #endregion
-
-=======
->>>>>>> beta
    #region Favorites

    /// <summary>
@@ -3019,532 +792,6 @@ public partial class JellyfinController : ControllerBase

    #endregion

-<<<<<<< HEAD
-    #region Playlists
-
-    /// <summary>
-    /// Gets playlist tracks displayed as an album.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistAsAlbum(string playlistId)
-    {
-        try
-        {
-            var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-
-            var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
-            if (playlist == null)
-            {
-                return _responseBuilder.CreateError(404, "Playlist not found");
-            }
-
-            var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
-
-            // Cache tracks for playlist sync
-            if (_playlistSyncService != null)
-            {
-                foreach (var track in tracks)
-                {
-                    if (!string.IsNullOrEmpty(track.ExternalId))
-                    {
-                        var trackId = $"ext-{provider}-{track.ExternalId}";
-                        _playlistSyncService.AddTrackToPlaylistCache(trackId, playlistId);
-                    }
-                }
-                _logger.LogDebug("Cached {Count} tracks for playlist {PlaylistId}", tracks.Count, playlistId);
-            }
-
-            return _responseBuilder.CreatePlaylistAsAlbumResponse(playlist, tracks);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting playlist {PlaylistId}", playlistId);
-            return _responseBuilder.CreateError(500, "Failed to get playlist");
-        }
-    }
-
-    /// <summary>
-    /// Gets playlist tracks as child items.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistTracks(string playlistId)
-    {
-        try
-        {
-            _logger.LogDebug("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId);
-            
-            // Check if this is an external playlist (Deezer/Qobuz) first
-            if (PlaylistIdHelper.IsExternalPlaylist(playlistId))
-            {
-                var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-                var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
-                return _responseBuilder.CreateItemsResponse(tracks);
-            }
-
-            // Check if this is a Spotify playlist (by ID)
-            _logger.LogInformation("Spotify Import Enabled: {Enabled}, Configured Playlists: {Count}", 
-                _spotifySettings.Enabled, _spotifySettings.Playlists.Count);
-            
-            if (_spotifySettings.Enabled && _spotifySettings.IsSpotifyPlaylist(playlistId))
-            {
-                // Get playlist info from Jellyfin to get the name for matching missing tracks
-                _logger.LogInformation("Fetching playlist info from Jellyfin for ID: {PlaylistId}", playlistId);
-                var (playlistInfo, _) = await _proxyService.GetJsonAsync($"Items/{playlistId}", null, Request.Headers);
-                
-                if (playlistInfo != null && playlistInfo.RootElement.TryGetProperty("Name", out var nameElement))
-                {
-                    var playlistName = nameElement.GetString() ?? "";
-                    _logger.LogInformation("✓ MATCHED! Intercepting Spotify playlist: {PlaylistName} (ID: {PlaylistId})", 
-                        playlistName, playlistId);
-                    return await GetSpotifyPlaylistTracksAsync(playlistName, playlistId);
-                }
-                else
-                {
-                    _logger.LogWarning("Could not get playlist name from Jellyfin for ID: {PlaylistId}", playlistId);
-                }
-            }
-
-            // Regular Jellyfin playlist - proxy through
-            var endpoint = $"Playlists/{playlistId}/Items";
-            if (Request.QueryString.HasValue)
-            {
-                endpoint = $"{endpoint}{Request.QueryString.Value}";
-            }
-            
-            _logger.LogDebug("Proxying to Jellyfin: {Endpoint}", endpoint);
-            var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
-            
-            return HandleProxyResponse(result, statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting playlist tracks {PlaylistId}", playlistId);
-            return _responseBuilder.CreateError(500, "Failed to get playlist tracks");
-        }
-    }
-
-    /// <summary>
-    /// Gets a playlist cover image.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistImage(string playlistId)
-    {
-        try
-        {
-            // Check cache first (1 hour TTL for playlist images since they can change)
-            var cacheKey = $"playlist:image:{playlistId}";
-            var cachedImage = await _cache.GetAsync<byte[]>(cacheKey);
-            
-            if (cachedImage != null)
-            {
-                _logger.LogDebug("Serving cached playlist image for {PlaylistId}", playlistId);
-                return File(cachedImage, "image/jpeg");
-            }
-            
-            var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-            var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
-
-            if (playlist == null || string.IsNullOrEmpty(playlist.CoverUrl))
-            {
-                return NotFound();
-            }
-
-            var response = await _proxyService.HttpClient.GetAsync(playlist.CoverUrl);
-            if (!response.IsSuccessStatusCode)
-            {
-                return NotFound();
-            }
-
-            var imageBytes = await response.Content.ReadAsByteArrayAsync();
-            var contentType = response.Content.Headers.ContentType?.ToString() ?? "image/jpeg";
-            
-            // Cache for configurable duration (playlists can change)
-            await _cache.SetAsync(cacheKey, imageBytes, CacheExtensions.PlaylistImagesTTL);
-            _logger.LogDebug("Cached playlist image for {PlaylistId}", playlistId);
-            
-            return File(imageBytes, contentType);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to get playlist image {PlaylistId}", playlistId);
-            return NotFound();
-        }
-    }
-
-    #endregion
-
-    #region Authentication
-
-    /// <summary>
-    /// Authenticates a user by username and password.
-    /// This is the primary login endpoint for Jellyfin clients.
-    /// </summary>
-    [HttpPost("Users/AuthenticateByName")]
-    public async Task<IActionResult> AuthenticateByName()
-    {
-        try
-        {
-            // Enable buffering to allow multiple reads of the request body
-            Request.EnableBuffering();
-            
-            // Read the request body
-            using var reader = new StreamReader(Request.Body, leaveOpen: true);
-            var body = await reader.ReadToEndAsync();
-            
-            // Reset stream position
-            Request.Body.Position = 0;
-            
-            _logger.LogDebug("Authentication request received");
-            // DO NOT log request body or detailed headers - contains password
-            
-            // Forward to Jellyfin server with client headers - completely transparent proxy
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Users/AuthenticateByName", body, Request.Headers);
-            
-            // Pass through Jellyfin's response exactly as-is (transparent proxy)
-            if (result != null)
-            {
-                var responseJson = result.RootElement.GetRawText();
-                
-                // On successful auth, extract access token and post session capabilities in background
-                if (statusCode == 200)
-                {
-                    _logger.LogInformation("Authentication successful");
-                    
-                    // Extract access token from response for session capabilities
-                    string? accessToken = null;
-                    if (result.RootElement.TryGetProperty("AccessToken", out var tokenEl))
-                    {
-                        accessToken = tokenEl.GetString();
-                    }
-                    
-                    // Post session capabilities in background if we have a token
-                    if (!string.IsNullOrEmpty(accessToken))
-                    {
-                        // Capture token in closure - don't use Request.Headers (will be disposed)
-                        var token = accessToken;
-                        _ = Task.Run(async () =>
-                        {
-                            try
-                            {
-                                _logger.LogDebug("🔧 Posting session capabilities after authentication");
-                                
-                                // Build auth header with the new token
-                                var authHeaders = new HeaderDictionary
-                                {
-                                    ["X-Emby-Token"] = token
-                                };
-                                
-                                var capabilities = new
-                                {
-                                    PlayableMediaTypes = new[] { "Audio" },
-                                    SupportedCommands = Array.Empty<string>(),
-                                    SupportsMediaControl = false,
-                                    SupportsPersistentIdentifier = true,
-                                    SupportsSync = false
-                                };
-                                
-                                var capabilitiesJson = JsonSerializer.Serialize(capabilities);
-                                var (capResult, capStatus) = await _proxyService.PostJsonAsync("Sessions/Capabilities/Full", capabilitiesJson, authHeaders);
-                                
-                                if (capStatus == 204 || capStatus == 200)
-                                {
-                                    _logger.LogDebug("✓ Session capabilities posted after auth ({StatusCode})", capStatus);
-                                }
-                                else
-                                {
-                                    _logger.LogDebug("⚠ Session capabilities returned {StatusCode} after auth", capStatus);
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                _logger.LogError(ex, "Failed to post session capabilities after auth");
-                            }
-                        });
-                    }
-                }
-                else
-                {
-                    _logger.LogError("Authentication failed - status {StatusCode}", statusCode);
-                }
-                
-                // Return Jellyfin's exact response
-                return Content(responseJson, "application/json");
-            }
-            
-            // No response body from Jellyfin - return status code only
-            _logger.LogWarning("Authentication request returned {StatusCode} with no response body", statusCode);
-            return StatusCode(statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error during authentication");
-            return StatusCode(500, new { error = $"Authentication error: {ex.Message}" });
-        }
-    }
-
-    #endregion
-
-||||||| f68706f
-    #region Playlists
-
-    /// <summary>
-    /// Gets playlist tracks displayed as an album.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistAsAlbum(string playlistId)
-    {
-        try
-        {
-            var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-
-            var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
-            if (playlist == null)
-            {
-                return _responseBuilder.CreateError(404, "Playlist not found");
-            }
-
-            var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
-
-            // Cache tracks for playlist sync
-            if (_playlistSyncService != null)
-            {
-                foreach (var track in tracks)
-                {
-                    if (!string.IsNullOrEmpty(track.ExternalId))
-                    {
-                        var trackId = $"ext-{provider}-{track.ExternalId}";
-                        _playlistSyncService.AddTrackToPlaylistCache(trackId, playlistId);
-                    }
-                }
-                _logger.LogDebug("Cached {Count} tracks for playlist {PlaylistId}", tracks.Count, playlistId);
-            }
-
-            return _responseBuilder.CreatePlaylistAsAlbumResponse(playlist, tracks);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting playlist {PlaylistId}", playlistId);
-            return _responseBuilder.CreateError(500, "Failed to get playlist");
-        }
-    }
-
-    /// <summary>
-    /// Gets playlist tracks as child items.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistTracks(string playlistId)
-    {
-        try
-        {
-            _logger.LogInformation("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId);
-            
-            // Check if this is an external playlist (Deezer/Qobuz) first
-            if (PlaylistIdHelper.IsExternalPlaylist(playlistId))
-            {
-                var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-                var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
-                return _responseBuilder.CreateItemsResponse(tracks);
-            }
-
-            // Check if this is a Spotify playlist (by ID)
-            _logger.LogInformation("Spotify Import Enabled: {Enabled}, Configured Playlists: {Count}", 
-                _spotifySettings.Enabled, _spotifySettings.Playlists.Count);
-            
-            if (_spotifySettings.Enabled && _spotifySettings.IsSpotifyPlaylist(playlistId))
-            {
-                // Get playlist info from Jellyfin to get the name for matching missing tracks
-                _logger.LogInformation("Fetching playlist info from Jellyfin for ID: {PlaylistId}", playlistId);
-                var (playlistInfo, _) = await _proxyService.GetJsonAsync($"Items/{playlistId}", null, Request.Headers);
-                
-                if (playlistInfo != null && playlistInfo.RootElement.TryGetProperty("Name", out var nameElement))
-                {
-                    var playlistName = nameElement.GetString() ?? "";
-                    _logger.LogInformation("✓ MATCHED! Intercepting Spotify playlist: {PlaylistName} (ID: {PlaylistId})", 
-                        playlistName, playlistId);
-                    return await GetSpotifyPlaylistTracksAsync(playlistName, playlistId);
-                }
-                else
-                {
-                    _logger.LogWarning("Could not get playlist name from Jellyfin for ID: {PlaylistId}", playlistId);
-                }
-            }
-
-            // Regular Jellyfin playlist - proxy through
-            var endpoint = $"Playlists/{playlistId}/Items";
-            if (Request.QueryString.HasValue)
-            {
-                endpoint = $"{endpoint}{Request.QueryString.Value}";
-            }
-            
-            _logger.LogInformation("Proxying to Jellyfin: {Endpoint}", endpoint);
-            var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
-            
-            return HandleProxyResponse(result, statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting playlist tracks {PlaylistId}", playlistId);
-            return _responseBuilder.CreateError(500, "Failed to get playlist tracks");
-        }
-    }
-
-    /// <summary>
-    /// Gets a playlist cover image.
-    /// </summary>
-    private async Task<IActionResult> GetPlaylistImage(string playlistId)
-    {
-        try
-        {
-            // Check cache first (1 hour TTL for playlist images since they can change)
-            var cacheKey = $"playlist:image:{playlistId}";
-            var cachedImage = await _cache.GetAsync<byte[]>(cacheKey);
-            
-            if (cachedImage != null)
-            {
-                _logger.LogDebug("Serving cached playlist image for {PlaylistId}", playlistId);
-                return File(cachedImage, "image/jpeg");
-            }
-            
-            var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-            var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
-
-            if (playlist == null || string.IsNullOrEmpty(playlist.CoverUrl))
-            {
-                return NotFound();
-            }
-
-            var response = await _proxyService.HttpClient.GetAsync(playlist.CoverUrl);
-            if (!response.IsSuccessStatusCode)
-            {
-                return NotFound();
-            }
-
-            var imageBytes = await response.Content.ReadAsByteArrayAsync();
-            var contentType = response.Content.Headers.ContentType?.ToString() ?? "image/jpeg";
-            
-            // Cache for 1 hour (playlists can change, so don't cache too long)
-            await _cache.SetAsync(cacheKey, imageBytes, TimeSpan.FromHours(1));
-            _logger.LogDebug("Cached playlist image for {PlaylistId}", playlistId);
-            
-            return File(imageBytes, contentType);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to get playlist image {PlaylistId}", playlistId);
-            return NotFound();
-        }
-    }
-
-    #endregion
-
-    #region Authentication
-
-    /// <summary>
-    /// Authenticates a user by username and password.
-    /// This is the primary login endpoint for Jellyfin clients.
-    /// </summary>
-    [HttpPost("Users/AuthenticateByName")]
-    public async Task<IActionResult> AuthenticateByName()
-    {
-        try
-        {
-            // Enable buffering to allow multiple reads of the request body
-            Request.EnableBuffering();
-            
-            // Read the request body
-            using var reader = new StreamReader(Request.Body, leaveOpen: true);
-            var body = await reader.ReadToEndAsync();
-            
-            // Reset stream position
-            Request.Body.Position = 0;
-            
-            _logger.LogInformation("Authentication request received");
-            // DO NOT log request body or detailed headers - contains password
-            
-            // Forward to Jellyfin server with client headers - completely transparent proxy
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Users/AuthenticateByName", body, Request.Headers);
-            
-            // Pass through Jellyfin's response exactly as-is (transparent proxy)
-            if (result != null)
-            {
-                var responseJson = result.RootElement.GetRawText();
-                
-                // On successful auth, extract access token and post session capabilities in background
-                if (statusCode == 200)
-                {
-                    _logger.LogInformation("Authentication successful");
-                    
-                    // Extract access token from response for session capabilities
-                    string? accessToken = null;
-                    if (result.RootElement.TryGetProperty("AccessToken", out var tokenEl))
-                    {
-                        accessToken = tokenEl.GetString();
-                    }
-                    
-                    // Post session capabilities in background if we have a token
-                    if (!string.IsNullOrEmpty(accessToken))
-                    {
-                        // Capture token in closure - don't use Request.Headers (will be disposed)
-                        var token = accessToken;
-                        _ = Task.Run(async () =>
-                        {
-                            try
-                            {
-                                _logger.LogDebug("🔧 Posting session capabilities after authentication");
-                                
-                                // Build auth header with the new token
-                                var authHeaders = new HeaderDictionary
-                                {
-                                    ["X-Emby-Token"] = token
-                                };
-                                
-                                var capabilities = new
-                                {
-                                    PlayableMediaTypes = new[] { "Audio" },
-                                    SupportedCommands = Array.Empty<string>(),
-                                    SupportsMediaControl = false,
-                                    SupportsPersistentIdentifier = true,
-                                    SupportsSync = false
-                                };
-                                
-                                var capabilitiesJson = JsonSerializer.Serialize(capabilities);
-                                var (capResult, capStatus) = await _proxyService.PostJsonAsync("Sessions/Capabilities/Full", capabilitiesJson, authHeaders);
-                                
-                                if (capStatus == 204 || capStatus == 200)
-                                {
-                                    _logger.LogDebug("✓ Session capabilities posted after auth ({StatusCode})", capStatus);
-                                }
-                                else
-                                {
-                                    _logger.LogDebug("⚠ Session capabilities returned {StatusCode} after auth", capStatus);
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                _logger.LogDebug(ex, "Failed to post session capabilities after auth");
-                            }
-                        });
-                    }
-                }
-                else
-                {
-                    _logger.LogWarning("Authentication failed - status {StatusCode}", statusCode);
-                }
-                
-                // Return Jellyfin's exact response
-                return Content(responseJson, "application/json");
-            }
-            
-            // No response body from Jellyfin - return status code only
-            _logger.LogWarning("Authentication request returned {StatusCode} with no response body", statusCode);
-            return StatusCode(statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error during authentication");
-            return StatusCode(500, new { error = $"Authentication error: {ex.Message}" });
-        }
-    }
-
-    #endregion
-
-=======
->>>>>>> beta
    #region Recommendations & Instant Mix

    /// <summary>
@@ -3749,1210 +996,6 @@ public partial class JellyfinController : ControllerBase

    #endregion

-<<<<<<< HEAD
-    #region Playback Session Reporting
-
-    #region Session Management
-
-    /// <summary>
-    /// Reports session capabilities. Required for Jellyfin to track active sessions.
-    /// Handles both POST (with body) and GET (query params only) methods.
-    /// </summary>
-    [HttpPost("Sessions/Capabilities")]
-    [HttpPost("Sessions/Capabilities/Full")]
-    [HttpGet("Sessions/Capabilities")]
-    [HttpGet("Sessions/Capabilities/Full")]
-    public async Task<IActionResult> ReportCapabilities()
-    {
-        try
-        {
-            var method = Request.Method;
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            
-            _logger.LogDebug("📡 Session capabilities reported - Method: {Method}, Query: {Query}", method, queryString);
-            _logger.LogInformation("Headers: {Headers}", 
-                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Device", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Client", StringComparison.OrdinalIgnoreCase))
-                    .Select(h => $"{h.Key}={h.Value}")));
-            
-            // Forward to Jellyfin with query string and headers
-            var endpoint = $"Sessions/Capabilities{queryString}";
-            
-            // Read body if present (POST requests)
-            string body = "{}";
-            if (method == "POST" && Request.ContentLength > 0)
-            {
-                Request.EnableBuffering();
-                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-                {
-                    body = await reader.ReadToEndAsync();
-                }
-                Request.Body.Position = 0;
-                _logger.LogInformation("Capabilities body: {Body}", body);
-            }
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, body, Request.Headers);
-            
-            if (statusCode == 204 || statusCode == 200)
-            {
-                _logger.LogDebug("✓ Session capabilities forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogWarning("⚠ Jellyfin returned 401 for capabilities (token expired)");
-            }
-            else
-            {
-                _logger.LogWarning("⚠ Jellyfin returned {StatusCode} for capabilities", statusCode);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to report session capabilities");
-            return StatusCode(500);
-        }
-    }
-
-    /// <summary>
-    /// Reports playback start. Handles both local and external tracks.
-    /// For local tracks, forwards to Jellyfin. For external tracks, logs locally.
-    /// Also ensures session is initialized if this is the first report from a device.
-    /// </summary>
-    [HttpPost("Sessions/Playing")]
-    public async Task<IActionResult> ReportPlaybackStart()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            _logger.LogDebug("📻 Playback START reported");
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            string? itemName = null;
-            long? positionTicks = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
-            {
-                itemName = itemNameProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-            
-            // Track the playing item for scrobbling on session cleanup
-            var (deviceId, client, device, version) = ExtractDeviceInfo(Request.Headers);
-            if (!string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(itemId))
-            {
-                _sessionManager.UpdatePlayingItem(deviceId, itemId, positionTicks);
-            }
-
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    _logger.LogInformation("🎵 External track playback started: {Name} ({Provider}/{ExternalId})", 
-                        itemName ?? "Unknown", provider, externalId);
-                    
-                    // Proactively fetch lyrics in background for external tracks
-                    _ = Task.Run(async () =>
-                    {
-                        try
-                        {
-                            await PrefetchLyricsForTrackAsync(itemId, isExternal: true, provider, externalId);
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.LogError(ex, "Failed to prefetch lyrics for external track {ItemId}", itemId);
-                        }
-                    });
-                    
-                    // Create a ghost/fake item to report to Jellyfin so "Now Playing" shows up
-                    // Generate a deterministic UUID from the external ID
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    // Build minimal playback start with just the ghost UUID
-                    // Don't include the Item object - Jellyfin will just track the session without item details
-                    var playbackStart = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0,
-                        CanSeek = true,
-                        IsPaused = false,
-                        IsMuted = false,
-                        PlayMethod = "DirectPlay"
-                    };
-                    
-                    var playbackJson = JsonSerializer.Serialize(playbackStart);
-                    _logger.LogDebug("📤 Sending ghost playback start for external track: {Json}", playbackJson);
-                    
-                    // Forward to Jellyfin with ghost UUID
-                    var (ghostResult, ghostStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", playbackJson, Request.Headers);
-                    
-                    if (ghostStatusCode == 204 || ghostStatusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Ghost playback start forwarded to Jellyfin for external track ({StatusCode})", ghostStatusCode);
-                    }
-                    else
-                    {
-                        _logger.LogWarning("⚠️ Ghost playback start returned status {StatusCode} for external track", ghostStatusCode);
-                    }
-                    
-                    return NoContent();
-                }
-                
-                _logger.LogInformation("🎵 Local track playback started: {Name} (ID: {ItemId})", 
-                    itemName ?? "Unknown", itemId);
-                
-                // Proactively fetch lyrics in background for local tracks
-                _ = Task.Run(async () =>
-                {
-                    try
-                    {
-                        await PrefetchLyricsForTrackAsync(itemId, isExternal: false, null, null);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to prefetch lyrics for local track {ItemId}", itemId);
-                    }
-                });
-            }
-
-            // For local tracks, forward playback start to Jellyfin FIRST
-            _logger.LogDebug("Forwarding playback start to Jellyfin...");
-            
-            // Fetch full item details to include in playback report
-            try
-            {
-                var (itemResult, itemStatus) = await _proxyService.GetJsonAsync($"Items/{itemId}", null, Request.Headers);
-                if (itemResult != null && itemStatus == 200)
-                {
-                    var item = itemResult.RootElement;
-                    _logger.LogInformation("📦 Fetched item details for playback report");
-                    
-                    // Build playback start info - Jellyfin will fetch item details itself
-                    var playbackStart = new
-                    {
-                        ItemId = itemId,
-                        PositionTicks = positionTicks ?? 0,
-                        // Let Jellyfin fetch the item details - don't include NowPlayingItem
-                    };
-                    
-                    var playbackJson = JsonSerializer.Serialize(playbackStart);
-                    _logger.LogInformation("📤 Sending playback start: {Json}", playbackJson);
-                    
-                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", playbackJson, Request.Headers);
-                    
-                    if (statusCode == 204 || statusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                        
-                        // NOW ensure session exists with capabilities (after playback is reported)
-                        if (!string.IsNullOrEmpty(deviceId))
-                        {
-                            var sessionCreated = await _sessionManager.EnsureSessionAsync(deviceId, client ?? "Unknown", device ?? "Unknown", version ?? "1.0", Request.Headers);
-                            if (sessionCreated)
-                            {
-                                _logger.LogDebug("✓ SESSION: Session ensured for device {DeviceId} after playback start", deviceId);
-                            }
-                            else
-                            {
-                                _logger.LogError("⚠️ SESSION: Failed to ensure session for device {DeviceId}", deviceId);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("⚠️ SESSION: No device ID found in headers for playback start");
-                        }
-                    }
-                    else
-                    {
-                        _logger.LogWarning("⚠️  Playback start returned status {StatusCode}", statusCode);
-                    }
-                }
-                else
-                {
-                    _logger.LogWarning("⚠️  Could not fetch item details ({StatusCode}), sending basic playback start", itemStatus);
-                    // Fall back to basic playback start
-                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
-                    if (statusCode == 204 || statusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to send playback start, trying basic");
-                // Fall back to basic playback start
-                var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
-                if (statusCode == 204 || statusCode == 200)
-                {
-                    _logger.LogInformation("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                }
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to report playback start");
-            return NoContent(); // Return success anyway to not break playback
-        }
-    }
-
-    /// <summary>
-    /// Reports playback progress. Handles both local and external tracks.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Progress")]
-    public async Task<IActionResult> ReportPlaybackProgress()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            // Update session activity
-            var (deviceId, _, _, _) = ExtractDeviceInfo(Request.Headers);
-            if (!string.IsNullOrEmpty(deviceId))
-            {
-                _sessionManager.UpdateActivity(deviceId);
-            }
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            long? positionTicks = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-            
-            // Track the playing item for scrobbling on session cleanup
-            if (!string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(itemId))
-            {
-                _sessionManager.UpdatePlayingItem(deviceId, itemId, positionTicks);
-            }
-            
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    // For external tracks, report progress with ghost UUID to Jellyfin
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    // Build progress report with ghost UUID
-                    var progressReport = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0,
-                        IsPaused = false,
-                        IsMuted = false,
-                        CanSeek = true,
-                        PlayMethod = "DirectPlay"
-                    };
-                    
-                    var progressJson = JsonSerializer.Serialize(progressReport);
-                    
-                    // Forward to Jellyfin with ghost UUID
-                    var (progressResult, progressStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Progress", progressJson, Request.Headers);
-                    
-                    // Log progress occasionally for debugging (every ~30 seconds)
-                    if (positionTicks.HasValue)
-                    {
-                        var position = TimeSpan.FromTicks(positionTicks.Value);
-                        if (position.Seconds % 30 == 0 && position.Milliseconds < 500)
-                        {
-                            _logger.LogDebug("▶️ External track progress: {Position:mm\\:ss} ({Provider}/{ExternalId}) - Status: {StatusCode}", 
-                                position, provider, externalId, progressStatusCode);
-                        }
-                    }
-                    
-                    return NoContent();
-                }
-                
-                // Log progress for local tracks (only every ~10 seconds to avoid spam)
-                if (positionTicks.HasValue)
-                {
-                    var position = TimeSpan.FromTicks(positionTicks.Value);
-                    // Only log at 10-second intervals
-                    if (position.Seconds % 10 == 0 && position.Milliseconds < 500)
-                    {
-                        _logger.LogDebug("▶️ Progress: {Position:mm\\:ss} for item {ItemId}", position, itemId);
-                    }
-                }
-            }
-
-            // For local tracks, forward to Jellyfin
-            _logger.LogDebug("📤 Sending playback progress body: {Body}", body);
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Progress", body, Request.Headers);
-            
-            if (statusCode != 204 && statusCode != 200)
-            {
-                _logger.LogWarning("⚠️ Progress report returned {StatusCode} for item {ItemId}", statusCode, itemId);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to report playback progress");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Reports playback stopped. Handles both local and external tracks.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Stopped")]
-    public async Task<IActionResult> ReportPlaybackStopped()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            _logger.LogInformation("⏹️  Playback STOPPED reported");
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            string? itemName = null;
-            long? positionTicks = null;
-            string? deviceId = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
-            {
-                itemName = itemNameProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-
-            // Try to get device ID from headers for session management
-            if (Request.Headers.TryGetValue("X-Emby-Device-Id", out var deviceIdHeader))
-            {
-                deviceId = deviceIdHeader.FirstOrDefault();
-            }
-
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    var position = positionTicks.HasValue 
-                        ? TimeSpan.FromTicks(positionTicks.Value).ToString(@"mm\:ss")
-                        : "unknown";
-                    _logger.LogInformation("🎵 External track playback stopped: {Name} at {Position} ({Provider}/{ExternalId})", 
-                        itemName ?? "Unknown", position, provider, externalId);
-                    
-                    // Report stop to Jellyfin with ghost UUID
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    var stopInfo = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0
-                    };
-                    
-                    var stopJson = JsonSerializer.Serialize(stopInfo);
-                    _logger.LogDebug("📤 Sending ghost playback stop for external track: {Json}", stopJson);
-                    
-                    var (stopResult, stopStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", stopJson, Request.Headers);
-                    
-                    if (stopStatusCode == 204 || stopStatusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Ghost playback stop forwarded to Jellyfin ({StatusCode})", stopStatusCode);
-                    }
-                    
-                    return NoContent();
-                }
-                
-                _logger.LogInformation("🎵 Local track playback stopped: {Name} (ID: {ItemId})", 
-                    itemName ?? "Unknown", itemId);
-            }
-
-            // For local tracks, forward to Jellyfin
-            _logger.LogDebug("Forwarding playback stop to Jellyfin...");
-            
-            // Log the body being sent for debugging
-            _logger.LogInformation("📤 Sending playback stop body: {Body}", body);
-            
-            // Validate that body is not empty
-            if (string.IsNullOrWhiteSpace(body) || body == "{}")
-            {
-                _logger.LogWarning("⚠️  Playback stop body is empty, building minimal valid payload");
-                // Build a minimal valid PlaybackStopInfo
-                var stopInfo = new
-                {
-                    ItemId = itemId,
-                    PositionTicks = positionTicks ?? 0
-                };
-                body = JsonSerializer.Serialize(stopInfo);
-                _logger.LogInformation("📤 Built playback stop body: {Body}", body);
-            }
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", body, Request.Headers);
-            
-            if (statusCode == 204 || statusCode == 200)
-            {
-                _logger.LogDebug("✓ Playback stop forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogWarning("Playback stop returned 401 (token expired)");
-            }
-            else
-            {
-                _logger.LogWarning("Playback stop forward failed with status {StatusCode}", statusCode);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to report playback stopped");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Pings a playback session to keep it alive.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Ping")]
-    public async Task<IActionResult> PingPlaybackSession([FromQuery] string playSessionId)
-    {
-        try
-        {
-            _logger.LogDebug("Playback session ping: {SessionId}", playSessionId);
-            
-            // Forward to Jellyfin
-            var endpoint = $"Sessions/Playing/Ping?playSessionId={Uri.EscapeDataString(playSessionId)}";
-            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, "{}", Request.Headers);
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to ping playback session");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Catch-all for any other session-related requests.
-    /// <summary>
-    /// Catch-all proxy for any other session-related endpoints we haven't explicitly implemented.
-    /// This ensures all session management calls get proxied to Jellyfin.
-    /// Examples: GET /Sessions, POST /Sessions/Logout, etc.
-    /// </summary>
-    [HttpGet("Sessions")]
-    [HttpPost("Sessions")]
-    [HttpGet("Sessions/{**path}")]
-    [HttpPost("Sessions/{**path}")]
-    [HttpPut("Sessions/{**path}")]
-    [HttpDelete("Sessions/{**path}")]
-    public async Task<IActionResult> ProxySessionRequest(string? path = null)
-    {
-        try
-        {
-            var method = Request.Method;
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            var endpoint = string.IsNullOrEmpty(path) ? $"Sessions{queryString}" : $"Sessions/{path}{queryString}";
-            
-            _logger.LogDebug("🔄 Proxying session request: {Method} {Endpoint}", method, endpoint);
-            _logger.LogDebug("Session proxy headers: {Headers}", 
-                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase))
-                    .Select(h => $"{h.Key}={h.Value}")));
-            
-            // Read body if present
-            string body = "{}";
-            if ((method == "POST" || method == "PUT") && Request.ContentLength > 0)
-            {
-                Request.EnableBuffering();
-                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-                {
-                    body = await reader.ReadToEndAsync();
-                }
-                Request.Body.Position = 0;
-                _logger.LogDebug("Session proxy body: {Body}", body);
-            }
-            
-            // Forward to Jellyfin
-            var (result, statusCode) = method switch
-            {
-                "GET" => await _proxyService.GetJsonAsync(endpoint, null, Request.Headers),
-                "POST" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers),
-                "PUT" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for PUT
-                "DELETE" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for DELETE
-                _ => (null, 405)
-            };
-            
-            if (result != null)
-            {
-                _logger.LogDebug("✓ Session request proxied successfully ({StatusCode})", statusCode);
-                return new JsonResult(result.RootElement.Clone());
-            }
-            
-            _logger.LogDebug("✓ Session request proxied ({StatusCode}, no body)", statusCode);
-            return StatusCode(statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to proxy session request: {Path}", path);
-            return StatusCode(500);
-        }
-    }
-
-    #endregion // Session Management
-
-    #endregion // Playback Session Reporting
-
-||||||| f68706f
-    #region Playback Session Reporting
-
-    #region Session Management
-
-    /// <summary>
-    /// Reports session capabilities. Required for Jellyfin to track active sessions.
-    /// Handles both POST (with body) and GET (query params only) methods.
-    /// </summary>
-    [HttpPost("Sessions/Capabilities")]
-    [HttpPost("Sessions/Capabilities/Full")]
-    [HttpGet("Sessions/Capabilities")]
-    [HttpGet("Sessions/Capabilities/Full")]
-    public async Task<IActionResult> ReportCapabilities()
-    {
-        try
-        {
-            var method = Request.Method;
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            
-            _logger.LogDebug("📡 Session capabilities reported - Method: {Method}, Query: {Query}", method, queryString);
-            _logger.LogInformation("Headers: {Headers}", 
-                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Device", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Client", StringComparison.OrdinalIgnoreCase))
-                    .Select(h => $"{h.Key}={h.Value}")));
-            
-            // Forward to Jellyfin with query string and headers
-            var endpoint = $"Sessions/Capabilities{queryString}";
-            
-            // Read body if present (POST requests)
-            string body = "{}";
-            if (method == "POST" && Request.ContentLength > 0)
-            {
-                Request.EnableBuffering();
-                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-                {
-                    body = await reader.ReadToEndAsync();
-                }
-                Request.Body.Position = 0;
-                _logger.LogInformation("Capabilities body: {Body}", body);
-            }
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, body, Request.Headers);
-            
-            if (statusCode == 204 || statusCode == 200)
-            {
-                _logger.LogDebug("✓ Session capabilities forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogDebug("⚠ Jellyfin returned 401 for capabilities (token expired)");
-            }
-            else
-            {
-                _logger.LogWarning("⚠ Jellyfin returned {StatusCode} for capabilities", statusCode);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to report session capabilities");
-            return StatusCode(500);
-        }
-    }
-
-    /// <summary>
-    /// Reports playback start. Handles both local and external tracks.
-    /// For local tracks, forwards to Jellyfin. For external tracks, logs locally.
-    /// Also ensures session is initialized if this is the first report from a device.
-    /// </summary>
-    [HttpPost("Sessions/Playing")]
-    public async Task<IActionResult> ReportPlaybackStart()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            _logger.LogDebug("📻 Playback START reported");
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            string? itemName = null;
-            long? positionTicks = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
-            {
-                itemName = itemNameProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-            
-            // Track the playing item for scrobbling on session cleanup
-            var (deviceId, client, device, version) = ExtractDeviceInfo(Request.Headers);
-            if (!string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(itemId))
-            {
-                _sessionManager.UpdatePlayingItem(deviceId, itemId, positionTicks);
-            }
-
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    _logger.LogInformation("🎵 External track playback started: {Name} ({Provider}/{ExternalId})", 
-                        itemName ?? "Unknown", provider, externalId);
-                    
-                    // Proactively fetch lyrics in background for external tracks
-                    _ = Task.Run(async () =>
-                    {
-                        try
-                        {
-                            await PrefetchLyricsForTrackAsync(itemId, isExternal: true, provider, externalId);
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.LogDebug(ex, "Failed to prefetch lyrics for external track {ItemId}", itemId);
-                        }
-                    });
-                    
-                    // Create a ghost/fake item to report to Jellyfin so "Now Playing" shows up
-                    // Generate a deterministic UUID from the external ID
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    // Build minimal playback start with just the ghost UUID
-                    // Don't include the Item object - Jellyfin will just track the session without item details
-                    var playbackStart = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0,
-                        CanSeek = true,
-                        IsPaused = false,
-                        IsMuted = false,
-                        PlayMethod = "DirectPlay"
-                    };
-                    
-                    var playbackJson = JsonSerializer.Serialize(playbackStart);
-                    _logger.LogDebug("📤 Sending ghost playback start for external track: {Json}", playbackJson);
-                    
-                    // Forward to Jellyfin with ghost UUID
-                    var (ghostResult, ghostStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", playbackJson, Request.Headers);
-                    
-                    if (ghostStatusCode == 204 || ghostStatusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Ghost playback start forwarded to Jellyfin for external track ({StatusCode})", ghostStatusCode);
-                    }
-                    else
-                    {
-                        _logger.LogWarning("⚠️ Ghost playback start returned status {StatusCode} for external track", ghostStatusCode);
-                    }
-                    
-                    return NoContent();
-                }
-                
-                _logger.LogInformation("🎵 Local track playback started: {Name} (ID: {ItemId})", 
-                    itemName ?? "Unknown", itemId);
-                
-                // Proactively fetch lyrics in background for local tracks
-                _ = Task.Run(async () =>
-                {
-                    try
-                    {
-                        await PrefetchLyricsForTrackAsync(itemId, isExternal: false, null, null);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogDebug(ex, "Failed to prefetch lyrics for local track {ItemId}", itemId);
-                    }
-                });
-            }
-
-            // For local tracks, forward playback start to Jellyfin FIRST
-            _logger.LogDebug("Forwarding playback start to Jellyfin...");
-            
-            // Fetch full item details to include in playback report
-            try
-            {
-                var (itemResult, itemStatus) = await _proxyService.GetJsonAsync($"Items/{itemId}", null, Request.Headers);
-                if (itemResult != null && itemStatus == 200)
-                {
-                    var item = itemResult.RootElement;
-                    _logger.LogInformation("📦 Fetched item details for playback report");
-                    
-                    // Build playback start info - Jellyfin will fetch item details itself
-                    var playbackStart = new
-                    {
-                        ItemId = itemId,
-                        PositionTicks = positionTicks ?? 0,
-                        // Let Jellyfin fetch the item details - don't include NowPlayingItem
-                    };
-                    
-                    var playbackJson = JsonSerializer.Serialize(playbackStart);
-                    _logger.LogInformation("📤 Sending playback start: {Json}", playbackJson);
-                    
-                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", playbackJson, Request.Headers);
-                    
-                    if (statusCode == 204 || statusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                        
-                        // NOW ensure session exists with capabilities (after playback is reported)
-                        if (!string.IsNullOrEmpty(deviceId))
-                        {
-                            var sessionCreated = await _sessionManager.EnsureSessionAsync(deviceId, client ?? "Unknown", device ?? "Unknown", version ?? "1.0", Request.Headers);
-                            if (sessionCreated)
-                            {
-                                _logger.LogDebug("✓ SESSION: Session ensured for device {DeviceId} after playback start", deviceId);
-                            }
-                            else
-                            {
-                                _logger.LogWarning("⚠️ SESSION: Failed to ensure session for device {DeviceId}", deviceId);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("⚠️ SESSION: No device ID found in headers for playback start");
-                        }
-                    }
-                    else
-                    {
-                        _logger.LogWarning("⚠️  Playback start returned status {StatusCode}", statusCode);
-                    }
-                }
-                else
-                {
-                    _logger.LogWarning("⚠️  Could not fetch item details ({StatusCode}), sending basic playback start", itemStatus);
-                    // Fall back to basic playback start
-                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
-                    if (statusCode == 204 || statusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to send playback start, trying basic");
-                // Fall back to basic playback start
-                var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
-                if (statusCode == 204 || statusCode == 200)
-                {
-                    _logger.LogInformation("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
-                }
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to report playback start");
-            return NoContent(); // Return success anyway to not break playback
-        }
-    }
-
-    /// <summary>
-    /// Reports playback progress. Handles both local and external tracks.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Progress")]
-    public async Task<IActionResult> ReportPlaybackProgress()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            // Update session activity
-            var (deviceId, _, _, _) = ExtractDeviceInfo(Request.Headers);
-            if (!string.IsNullOrEmpty(deviceId))
-            {
-                _sessionManager.UpdateActivity(deviceId);
-            }
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            long? positionTicks = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-            
-            // Track the playing item for scrobbling on session cleanup
-            if (!string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(itemId))
-            {
-                _sessionManager.UpdatePlayingItem(deviceId, itemId, positionTicks);
-            }
-            
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    // For external tracks, report progress with ghost UUID to Jellyfin
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    // Build progress report with ghost UUID
-                    var progressReport = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0,
-                        IsPaused = false,
-                        IsMuted = false,
-                        CanSeek = true,
-                        PlayMethod = "DirectPlay"
-                    };
-                    
-                    var progressJson = JsonSerializer.Serialize(progressReport);
-                    
-                    // Forward to Jellyfin with ghost UUID
-                    var (progressResult, progressStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Progress", progressJson, Request.Headers);
-                    
-                    // Log progress occasionally for debugging (every ~30 seconds)
-                    if (positionTicks.HasValue)
-                    {
-                        var position = TimeSpan.FromTicks(positionTicks.Value);
-                        if (position.Seconds % 30 == 0 && position.Milliseconds < 500)
-                        {
-                            _logger.LogDebug("▶️ External track progress: {Position:mm\\:ss} ({Provider}/{ExternalId}) - Status: {StatusCode}", 
-                                position, provider, externalId, progressStatusCode);
-                        }
-                    }
-                    
-                    return NoContent();
-                }
-                
-                // Log progress for local tracks (only every ~10 seconds to avoid spam)
-                if (positionTicks.HasValue)
-                {
-                    var position = TimeSpan.FromTicks(positionTicks.Value);
-                    // Only log at 10-second intervals
-                    if (position.Seconds % 10 == 0 && position.Milliseconds < 500)
-                    {
-                        _logger.LogDebug("▶️ Progress: {Position:mm\\:ss} for item {ItemId}", position, itemId);
-                    }
-                }
-            }
-
-            // For local tracks, forward to Jellyfin
-            _logger.LogDebug("📤 Sending playback progress body: {Body}", body);
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Progress", body, Request.Headers);
-            
-            if (statusCode != 204 && statusCode != 200)
-            {
-                _logger.LogWarning("⚠️ Progress report returned {StatusCode} for item {ItemId}", statusCode, itemId);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogDebug(ex, "Failed to report playback progress");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Reports playback stopped. Handles both local and external tracks.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Stopped")]
-    public async Task<IActionResult> ReportPlaybackStopped()
-    {
-        try
-        {
-            Request.EnableBuffering();
-            string body;
-            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-            {
-                body = await reader.ReadToEndAsync();
-            }
-            Request.Body.Position = 0;
-
-            _logger.LogDebug("⏹️  Playback STOPPED reported");
-
-            // Parse the body to check if it's an external track
-            var doc = JsonDocument.Parse(body);
-            string? itemId = null;
-            string? itemName = null;
-            long? positionTicks = null;
-            string? deviceId = null;
-            
-            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
-            {
-                itemId = itemIdProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
-            {
-                itemName = itemNameProp.GetString();
-            }
-            
-            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
-            {
-                positionTicks = posProp.GetInt64();
-            }
-
-            // Try to get device ID from headers for session management
-            if (Request.Headers.TryGetValue("X-Emby-Device-Id", out var deviceIdHeader))
-            {
-                deviceId = deviceIdHeader.FirstOrDefault();
-            }
-
-            if (!string.IsNullOrEmpty(itemId))
-            {
-                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-
-                if (isExternal)
-                {
-                    var position = positionTicks.HasValue 
-                        ? TimeSpan.FromTicks(positionTicks.Value).ToString(@"mm\:ss")
-                        : "unknown";
-                    _logger.LogInformation("🎵 External track playback stopped: {Name} at {Position} ({Provider}/{ExternalId})", 
-                        itemName ?? "Unknown", position, provider, externalId);
-                    
-                    // Report stop to Jellyfin with ghost UUID
-                    var ghostUuid = GenerateUuidFromString(itemId);
-                    
-                    var stopInfo = new
-                    {
-                        ItemId = ghostUuid,
-                        PositionTicks = positionTicks ?? 0
-                    };
-                    
-                    var stopJson = JsonSerializer.Serialize(stopInfo);
-                    _logger.LogDebug("📤 Sending ghost playback stop for external track: {Json}", stopJson);
-                    
-                    var (stopResult, stopStatusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", stopJson, Request.Headers);
-                    
-                    if (stopStatusCode == 204 || stopStatusCode == 200)
-                    {
-                        _logger.LogDebug("✓ Ghost playback stop forwarded to Jellyfin ({StatusCode})", stopStatusCode);
-                    }
-                    
-                    return NoContent();
-                }
-                
-                _logger.LogInformation("🎵 Local track playback stopped: {Name} (ID: {ItemId})", 
-                    itemName ?? "Unknown", itemId);
-            }
-
-            // For local tracks, forward to Jellyfin
-            _logger.LogDebug("Forwarding playback stop to Jellyfin...");
-            
-            // Log the body being sent for debugging
-            _logger.LogInformation("📤 Sending playback stop body: {Body}", body);
-            
-            // Validate that body is not empty
-            if (string.IsNullOrWhiteSpace(body) || body == "{}")
-            {
-                _logger.LogWarning("⚠️  Playback stop body is empty, building minimal valid payload");
-                // Build a minimal valid PlaybackStopInfo
-                var stopInfo = new
-                {
-                    ItemId = itemId,
-                    PositionTicks = positionTicks ?? 0
-                };
-                body = JsonSerializer.Serialize(stopInfo);
-                _logger.LogInformation("📤 Built playback stop body: {Body}", body);
-            }
-            
-            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", body, Request.Headers);
-            
-            if (statusCode == 204 || statusCode == 200)
-            {
-                _logger.LogDebug("✓ Playback stop forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogDebug("Playback stop returned 401 (token expired)");
-            }
-            else
-            {
-                _logger.LogWarning("Playback stop forward failed with status {StatusCode}", statusCode);
-            }
-            
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to report playback stopped");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Pings a playback session to keep it alive.
-    /// </summary>
-    [HttpPost("Sessions/Playing/Ping")]
-    public async Task<IActionResult> PingPlaybackSession([FromQuery] string playSessionId)
-    {
-        try
-        {
-            _logger.LogDebug("Playback session ping: {SessionId}", playSessionId);
-            
-            // Forward to Jellyfin
-            var endpoint = $"Sessions/Playing/Ping?playSessionId={Uri.EscapeDataString(playSessionId)}";
-            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, "{}", Request.Headers);
-            return NoContent();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogDebug(ex, "Failed to ping playback session");
-            return NoContent();
-        }
-    }
-
-    /// <summary>
-    /// Catch-all for any other session-related requests.
-    /// <summary>
-    /// Catch-all proxy for any other session-related endpoints we haven't explicitly implemented.
-    /// This ensures all session management calls get proxied to Jellyfin.
-    /// Examples: GET /Sessions, POST /Sessions/Logout, etc.
-    /// </summary>
-    [HttpGet("Sessions")]
-    [HttpPost("Sessions")]
-    [HttpGet("Sessions/{**path}")]
-    [HttpPost("Sessions/{**path}")]
-    [HttpPut("Sessions/{**path}")]
-    [HttpDelete("Sessions/{**path}")]
-    public async Task<IActionResult> ProxySessionRequest(string? path = null)
-    {
-        try
-        {
-            var method = Request.Method;
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            var endpoint = string.IsNullOrEmpty(path) ? $"Sessions{queryString}" : $"Sessions/{path}{queryString}";
-            
-            _logger.LogDebug("🔄 Proxying session request: {Method} {Endpoint}", method, endpoint);
-            _logger.LogDebug("Session proxy headers: {Headers}", 
-                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase))
-                    .Select(h => $"{h.Key}={h.Value}")));
-            
-            // Read body if present
-            string body = "{}";
-            if ((method == "POST" || method == "PUT") && Request.ContentLength > 0)
-            {
-                Request.EnableBuffering();
-                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
-                {
-                    body = await reader.ReadToEndAsync();
-                }
-                Request.Body.Position = 0;
-                _logger.LogDebug("Session proxy body: {Body}", body);
-            }
-            
-            // Forward to Jellyfin
-            var (result, statusCode) = method switch
-            {
-                "GET" => await _proxyService.GetJsonAsync(endpoint, null, Request.Headers),
-                "POST" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers),
-                "PUT" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for PUT
-                "DELETE" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for DELETE
-                _ => (null, 405)
-            };
-            
-            if (result != null)
-            {
-                _logger.LogDebug("✓ Session request proxied successfully ({StatusCode})", statusCode);
-                return new JsonResult(result.RootElement.Clone());
-            }
-            
-            _logger.LogDebug("✓ Session request proxied ({StatusCode}, no body)", statusCode);
-            return StatusCode(statusCode);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to proxy session request: {Path}", path);
-            return StatusCode(500);
-        }
-    }
-
-    #endregion // Session Management
-
-    #endregion // Playback Session Reporting
-
-=======
->>>>>>> beta
    #region System & Proxy

    /// <summary>
@@ -4967,13 +1010,7 @@ public partial class JellyfinController : ControllerBase
        {
            LocalAddress = Request.Host.ToString(),
            ServerName = serverName ?? "Allstarr",
-<<<<<<< HEAD
-            Version = version ?? "1.0.1",
-||||||| f68706f
-            Version = version ?? "1.0.0",
-=======
            Version = version ?? AppVersion.Version,
->>>>>>> beta
            ProductName = "Allstarr (Jellyfin Proxy)",
            OperatingSystem = Environment.OSVersion.Platform.ToString(),
            Id = _settings.DeviceId,
@@ -5300,867 +1337,13 @@ public partial class JellyfinController : ControllerBase
    {
        switch (element.ValueKind)
        {
-<<<<<<< HEAD
-            if (!response.RootElement.TryGetProperty("Items", out var items))
-            {
-                return response;
-            }
-
-            var itemsArray = items.EnumerateArray().ToList();
-            var modified = false;
-            var updatedItems = new List<Dictionary<string, object>>();
-
-            _logger.LogDebug("Checking {Count} items for Spotify playlists", itemsArray.Count);
-
-            foreach (var item in itemsArray)
-            {
-                var itemDict = JsonSerializer.Deserialize<Dictionary<string, object>>(item.GetRawText());
-                if (itemDict == null)
-||||||| f68706f
-            if (!response.RootElement.TryGetProperty("Items", out var items))
-            {
-                return response;
-            }
-
-            var itemsArray = items.EnumerateArray().ToList();
-            var modified = false;
-            var updatedItems = new List<Dictionary<string, object>>();
-
-            _logger.LogInformation("Checking {Count} items for Spotify playlists", itemsArray.Count);
-
-            foreach (var item in itemsArray)
-            {
-                var itemDict = JsonSerializer.Deserialize<Dictionary<string, object>>(item.GetRawText());
-                if (itemDict == null)
-=======
            case JsonValueKind.Object:
                var dict = new Dictionary<string, object?>();
                foreach (var property in element.EnumerateObject())
->>>>>>> beta
                {
                    dict[property.Name] = ConvertJsonElement(property.Value);
                }
-<<<<<<< HEAD
-
-                // Check if this is a Spotify playlist
-                if (item.TryGetProperty("Id", out var idProp))
-                {
-                    var playlistId = idProp.GetString();
-                    _logger.LogDebug("Checking item with ID: {Id}", playlistId);
-                    
-                    if (!string.IsNullOrEmpty(playlistId) && _spotifySettings.IsSpotifyPlaylist(playlistId))
-                    {
-                        _logger.LogInformation("Found Spotify playlist: {Id}", playlistId);
-                        
-                        // This is a Spotify playlist - get the actual track count
-                        var playlistConfig = _spotifySettings.GetPlaylistByJellyfinId(playlistId);
-                        
-                        if (playlistConfig != null)
-                        {
-                            _logger.LogInformation("Found playlist config for Jellyfin ID {JellyfinId}: {Name} (Spotify ID: {SpotifyId})", 
-                                playlistId, playlistConfig.Name, playlistConfig.Id);
-                            var playlistName = playlistConfig.Name;
-                            
-                            // Get matched external tracks (tracks that were successfully downloaded/matched)
-                            var matchedTracksKey = $"spotify:matched:ordered:{playlistName}";
-                            var matchedTracks = await _cache.GetAsync<List<MatchedTrack>>(matchedTracksKey);
-                            
-                            _logger.LogInformation("Cache lookup for {Key}: {Count} matched tracks", 
-                                matchedTracksKey, matchedTracks?.Count ?? 0);
-                            
-                            // Fallback to legacy cache format
-                            if (matchedTracks == null || matchedTracks.Count == 0)
-                            {
-                                var legacyKey = $"spotify:matched:{playlistName}";
-                                var legacySongs = await _cache.GetAsync<List<Song>>(legacyKey);
-                                if (legacySongs != null && legacySongs.Count > 0)
-                                {
-                                    matchedTracks = legacySongs.Select((s, i) => new MatchedTrack
-                                    {
-                                        Position = i,
-                                        MatchedSong = s
-                                    }).ToList();
-                                    _logger.LogDebug("Loaded {Count} tracks from legacy cache", matchedTracks.Count);
-                                }
-                            }
-                            
-                            // Try loading from file cache if Redis is empty
-                            if (matchedTracks == null || matchedTracks.Count == 0)
-                            {
-                                var fileItems = await LoadPlaylistItemsFromFile(playlistName);
-                                if (fileItems != null && fileItems.Count > 0)
-                                {
-                                    _logger.LogDebug("💿 Loaded {Count} playlist items from file cache for count update", fileItems.Count);
-                                    // Use file cache count directly
-                                    itemDict["ChildCount"] = fileItems.Count;
-                                    modified = true;
-                                }
-                            }
-                            
-                            // Only fetch from Jellyfin if we didn't get count from file cache
-                            if (!itemDict.ContainsKey("ChildCount") || 
-                                (itemDict["ChildCount"] is JsonElement childCountElement && childCountElement.GetInt32() == 0) ||
-                                (itemDict["ChildCount"] is int childCountInt && childCountInt == 0))
-                            {
-                                // Get local tracks count from Jellyfin
-                                var localTracksCount = 0;
-                                try
-                                {
-                                    // Include UserId parameter to avoid 401 Unauthorized
-                                    var userId = _settings.UserId;
-                                    var playlistItemsUrl = $"Playlists/{playlistId}/Items";
-                                    var queryParams = new Dictionary<string, string>();
-                                    if (!string.IsNullOrEmpty(userId))
-                                    {
-                                        queryParams["UserId"] = userId;
-                                    }
-                                    
-                                    var (localTracksResponse, _) = await _proxyService.GetJsonAsyncInternal(
-                                        playlistItemsUrl, 
-                                        queryParams);
-                                    
-                                    if (localTracksResponse != null && 
-                                        localTracksResponse.RootElement.TryGetProperty("Items", out var localItems))
-                                    {
-                                        localTracksCount = localItems.GetArrayLength();
-                                        _logger.LogDebug("Found {Count} total items in Jellyfin playlist {Name}", 
-                                            localTracksCount, playlistName);
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    _logger.LogError(ex, "Failed to get local tracks count for {Name}", playlistName);
-                                }
-                                
-                                // Count external matched tracks (not local)
-                                var externalMatchedCount = 0;
-                                if (matchedTracks != null)
-                                {
-                                    externalMatchedCount = matchedTracks.Count(t => t.MatchedSong != null && !t.MatchedSong.IsLocal);
-                                }
-                                
-                                // Total available tracks = local tracks in Jellyfin + external matched tracks
-                                // This represents what users will actually hear when playing the playlist
-                                var totalAvailableCount = localTracksCount + externalMatchedCount;
-                                
-                                if (totalAvailableCount > 0)
-                                {
-                                    // Update ChildCount to show actual available tracks
-                                    itemDict["ChildCount"] = totalAvailableCount;
-                                    modified = true;
-                                    _logger.LogDebug("✓ Updated ChildCount for Spotify playlist {Name} to {Total} ({Local} local + {External} external)", 
-                                        playlistName, totalAvailableCount, localTracksCount, externalMatchedCount);
-                                }
-                                else
-                                {
-                                    _logger.LogWarning("No tracks found for {Name} ({Local} local + {External} external = {Total} total)", 
-                                        playlistName, localTracksCount, externalMatchedCount, totalAvailableCount);
-                                }
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("No playlist config found for Jellyfin ID {JellyfinId} - skipping count update", playlistId);
-                        }
-                    }
-                }
-
-                updatedItems.Add(itemDict);
-            }
-
-            if (!modified)
-            {
-                _logger.LogInformation("No Spotify playlists found to update");
-                return response;
-            }
-
-            _logger.LogDebug("Modified {Count} Spotify playlists, rebuilding response", 
-                updatedItems.Count(i => i.ContainsKey("ChildCount")));
-
-            // Rebuild the response with updated items
-            var responseDict = JsonSerializer.Deserialize<Dictionary<string, object>>(response.RootElement.GetRawText());
-            if (responseDict != null)
-            {
-                responseDict["Items"] = updatedItems;
-                var updatedJson = JsonSerializer.Serialize(responseDict);
-                return JsonDocument.Parse(updatedJson);
-            }
-
-            return response;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to update Spotify playlist counts");
-            return response;
-        }
-    }
-
-    /// <summary>
-    /// Logs endpoint usage to a file for analysis.
-    /// Creates a CSV file with timestamp, method, path, and query string.
-    /// </summary>
-    private async Task LogEndpointUsageAsync(string path, string method)
-    {
-        try
-        {
-            var logDir = "/app/cache/endpoint-usage";
-            Directory.CreateDirectory(logDir);
-            
-            var logFile = Path.Combine(logDir, "endpoints.csv");
-            var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            
-            // Sanitize path and query for CSV (remove commas, quotes, newlines)
-            var sanitizedPath = path.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
-            var sanitizedQuery = queryString.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
-            
-            var logLine = $"{timestamp},{method},{sanitizedPath},{sanitizedQuery}\n";
-            
-            // Append to file (thread-safe)
-            await System.IO.File.AppendAllTextAsync(logFile, logLine);
-        }
-        catch (Exception ex)
-        {
-            // Don't let logging failures break the request
-            _logger.LogError(ex, "Failed to log endpoint usage");
-        }
-    }
-
-    private static string[]? ParseItemTypes(string? includeItemTypes)
-    {
-        if (string.IsNullOrWhiteSpace(includeItemTypes))
-        {
-            return null;
-        }
-
-        return includeItemTypes.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-    }
-
-    private static string GetContentType(string filePath)
-    {
-        var extension = Path.GetExtension(filePath).ToLowerInvariant();
-        return extension switch
-        {
-            ".mp3" => "audio/mpeg",
-            ".flac" => "audio/flac",
-            ".ogg" => "audio/ogg",
-            ".m4a" => "audio/mp4",
-            ".wav" => "audio/wav",
-            ".aac" => "audio/aac",
-            _ => "audio/mpeg"
-        };
-    }
-
-    /// <summary>
-    /// Scores search results based on fuzzy matching against the query.
-    /// Returns items with their relevance scores.
-    /// External results get a small boost to prioritize the larger catalog.
-    /// </summary>
-    private static List<(T Item, int Score)> ScoreSearchResults<T>(
-        string query,
-        List<T> items,
-        Func<T, string> titleField,
-        Func<T, string?> artistField,
-        Func<T, string?> albumField,
-        bool isExternal = false)
-    {
-        return items.Select(item =>
-        {
-            var title = titleField(item) ?? "";
-            var artist = artistField(item) ?? "";
-            var album = albumField(item) ?? "";
-
-            // Token-based fuzzy matching: split query and fields into words
-            var queryTokens = query.ToLower()
-                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
-                .ToList();
-
-            var fieldText = $"{title} {artist} {album}".ToLower();
-            var fieldTokens = fieldText
-                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
-                .ToList();
-
-            if (queryTokens.Count == 0) return (item, 0);
-
-            // Count how many query tokens match field tokens (with fuzzy tolerance)
-            var matchedTokens = 0;
-            foreach (var queryToken in queryTokens)
-            {
-                // Check if any field token matches this query token
-                var hasMatch = fieldTokens.Any(fieldToken =>
-                {
-                    // Exact match or substring match
-                    if (fieldToken.Contains(queryToken) || queryToken.Contains(fieldToken))
-                        return true;
-
-                    // Fuzzy match with Levenshtein distance
-                    var similarity = FuzzyMatcher.CalculateSimilarity(queryToken, fieldToken);
-                    return similarity >= 70; // 70% similarity threshold for individual words
-                });
-
-                if (hasMatch) matchedTokens++;
-            }
-
-            // Score = percentage of query tokens that matched
-            var baseScore = (matchedTokens * 100) / queryTokens.Count;
-
-            // Give external results a small boost (+5 points) to prioritize the larger catalog
-            var finalScore = isExternal ? Math.Min(100, baseScore + 5) : baseScore;
-
-            return (item, finalScore);
-        }).ToList();
-    }
-
-    #endregion
-
-    #region Spotify Playlist Injection
-
-    /// <summary>
-    /// Gets tracks for a Spotify playlist by matching missing tracks against external providers
-    /// and merging with existing local tracks from Jellyfin.
-    /// 
-    /// Supports two modes:
-    /// 1. Direct Spotify API (new): Uses SpotifyPlaylistFetcher for ordered tracks with ISRC matching
-    /// 2. Jellyfin Plugin (legacy): Uses MissingTrack data from Jellyfin Spotify Import plugin
-    /// </summary>
-    private async Task<IActionResult> GetSpotifyPlaylistTracksAsync(string spotifyPlaylistName, string playlistId)
-    {
-        try
-        {
-            // Try ordered cache first (from direct Spotify API mode)
-            if (_spotifyApiSettings.Enabled && _spotifyPlaylistFetcher != null)
-            {
-                var orderedResult = await GetSpotifyPlaylistTracksOrderedAsync(spotifyPlaylistName, playlistId);
-                if (orderedResult != null) return orderedResult;
-            }
-            
-            // Fall back to legacy unordered mode
-            return await GetSpotifyPlaylistTracksLegacyAsync(spotifyPlaylistName, playlistId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting Spotify playlist tracks {PlaylistName}", spotifyPlaylistName);
-            return _responseBuilder.CreateError(500, "Failed to get Spotify playlist tracks");
-        }
-    }
-    
-    /// <summary>
-    /// New mode: Gets playlist tracks with correct ordering using direct Spotify API data.
-    /// Optimized to only re-match when Jellyfin playlist changes (cheap check).
-    /// </summary>
-    private async Task<IActionResult?> GetSpotifyPlaylistTracksOrderedAsync(string spotifyPlaylistName, string playlistId)
-    {
-        // Check if Jellyfin playlist has changed (cheap API call)
-        var jellyfinSignatureCacheKey = $"spotify:playlist:jellyfin-signature:{spotifyPlaylistName}";
-        var currentJellyfinSignature = await GetJellyfinPlaylistSignatureAsync(playlistId);
-        var cachedJellyfinSignature = await _cache.GetAsync<string>(jellyfinSignatureCacheKey);
-        
-        var jellyfinPlaylistChanged = cachedJellyfinSignature != currentJellyfinSignature;
-        
-        // Check Redis cache first for fast serving (only if Jellyfin playlist hasn't changed)
-        var cacheKey = $"spotify:playlist:items:{spotifyPlaylistName}";
-        var cachedItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(cacheKey);
-        
-        if (cachedItems != null && cachedItems.Count > 0 && !jellyfinPlaylistChanged)
-        {
-            _logger.LogDebug("✅ Loaded {Count} playlist items from Redis cache for {Playlist} (Jellyfin unchanged)", 
-                cachedItems.Count, spotifyPlaylistName);
-            
-            return new JsonResult(new
-            {
-                Items = cachedItems,
-                TotalRecordCount = cachedItems.Count,
-                StartIndex = 0
-            });
-        }
-        
-        if (jellyfinPlaylistChanged)
-        {
-            _logger.LogInformation("🔄 Jellyfin playlist changed for {Playlist} - re-matching tracks", spotifyPlaylistName);
-        }
-        
-        // Check file cache as fallback
-        var fileItems = await LoadPlaylistItemsFromFile(spotifyPlaylistName);
-        if (fileItems != null && fileItems.Count > 0)
-        {
-            _logger.LogDebug("✅ Loaded {Count} playlist items from file cache for {Playlist}", 
-                fileItems.Count, spotifyPlaylistName);
-            
-            // Restore to Redis cache
-            await _cache.SetAsync(cacheKey, fileItems, CacheExtensions.SpotifyPlaylistItemsTTL);
-            
-            return new JsonResult(new
-            {
-                Items = fileItems,
-                TotalRecordCount = fileItems.Count,
-                StartIndex = 0
-            });
-        }
-        
-        // Check for ordered matched tracks from SpotifyTrackMatchingService
-        var orderedCacheKey = $"spotify:matched:ordered:{spotifyPlaylistName}";
-        var orderedTracks = await _cache.GetAsync<List<MatchedTrack>>(orderedCacheKey);
-        
-        if (orderedTracks == null || orderedTracks.Count == 0)
-        {
-            _logger.LogInformation("No ordered matched tracks in cache for {Playlist}, checking if we can fetch", 
-                spotifyPlaylistName);
-            return null; // Fall back to legacy mode
-        }
-        
-        _logger.LogInformation("Using {Count} ordered matched tracks for {Playlist}", 
-            orderedTracks.Count, spotifyPlaylistName);
-        
-        // Get existing Jellyfin playlist items (RAW - don't convert!)
-        // CRITICAL: Must include UserId parameter or Jellyfin returns empty results
-        var userId = _settings.UserId;
-        if (string.IsNullOrEmpty(userId))
-        {
-            _logger.LogError("❌ JELLYFIN_USER_ID is NOT configured! Cannot fetch playlist tracks. Set it in .env or admin UI.");
-            return null; // Fall back to legacy mode
-        }
-        
-        // Pass through all requested fields from the original request
-        var queryString = Request.QueryString.Value ?? "";
-        var playlistItemsUrl = $"Playlists/{playlistId}/Items?UserId={userId}";
-        
-        // Append the original query string (which includes Fields parameter)
-        if (!string.IsNullOrEmpty(queryString))
-        {
-            // Remove the leading ? if present
-            queryString = queryString.TrimStart('?');
-            playlistItemsUrl = $"{playlistItemsUrl}&{queryString}";
-        }
-        
-        _logger.LogInformation("🔍 Fetching existing tracks from Jellyfin playlist {PlaylistId} with UserId {UserId}", 
-            playlistId, userId);
-        
-        var (existingTracksResponse, statusCode) = await _proxyService.GetJsonAsync(
-            playlistItemsUrl, 
-            null, 
-            Request.Headers);
-        
-        if (statusCode != 200)
-        {
-            _logger.LogError("❌ Failed to fetch Jellyfin playlist items: HTTP {StatusCode}. Check JELLYFIN_USER_ID is correct.", statusCode);
-            return null;
-        }
-        
-        // Keep raw Jellyfin items - don't convert to Song objects!
-        var jellyfinItems = new List<JsonElement>();
-        var jellyfinItemsByName = new Dictionary<string, JsonElement>();
-        
-        if (existingTracksResponse != null && 
-            existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
-        {
-            foreach (var item in items.EnumerateArray())
-            {
-                jellyfinItems.Add(item);
-||||||| f68706f
-
-                // Check if this is a Spotify playlist
-                if (item.TryGetProperty("Id", out var idProp))
-                {
-                    var playlistId = idProp.GetString();
-                    _logger.LogDebug("Checking item with ID: {Id}", playlistId);
-                    
-                    if (!string.IsNullOrEmpty(playlistId) && _spotifySettings.IsSpotifyPlaylist(playlistId))
-                    {
-                        _logger.LogInformation("Found Spotify playlist: {Id}", playlistId);
-                        
-                        // This is a Spotify playlist - get the actual track count
-                        var playlistConfig = _spotifySettings.GetPlaylistByJellyfinId(playlistId);
-                        
-                        if (playlistConfig != null)
-                        {
-                            _logger.LogInformation("Found playlist config for Jellyfin ID {JellyfinId}: {Name} (Spotify ID: {SpotifyId})", 
-                                playlistId, playlistConfig.Name, playlistConfig.Id);
-                            var playlistName = playlistConfig.Name;
-                            
-                            // Get matched external tracks (tracks that were successfully downloaded/matched)
-                            var matchedTracksKey = $"spotify:matched:ordered:{playlistName}";
-                            var matchedTracks = await _cache.GetAsync<List<MatchedTrack>>(matchedTracksKey);
-                            
-                            _logger.LogDebug("Cache lookup for {Key}: {Count} matched tracks", 
-                                matchedTracksKey, matchedTracks?.Count ?? 0);
-                            
-                            // Fallback to legacy cache format
-                            if (matchedTracks == null || matchedTracks.Count == 0)
-                            {
-                                var legacyKey = $"spotify:matched:{playlistName}";
-                                var legacySongs = await _cache.GetAsync<List<Song>>(legacyKey);
-                                if (legacySongs != null && legacySongs.Count > 0)
-                                {
-                                    matchedTracks = legacySongs.Select((s, i) => new MatchedTrack
-                                    {
-                                        Position = i,
-                                        MatchedSong = s
-                                    }).ToList();
-                                    _logger.LogDebug("Loaded {Count} tracks from legacy cache", matchedTracks.Count);
-                                }
-                            }
-                            
-                            // Try loading from file cache if Redis is empty
-                            if (matchedTracks == null || matchedTracks.Count == 0)
-                            {
-                                var fileItems = await LoadPlaylistItemsFromFile(playlistName);
-                                if (fileItems != null && fileItems.Count > 0)
-                                {
-                                    _logger.LogInformation("💿 Loaded {Count} playlist items from file cache for count update", fileItems.Count);
-                                    // Use file cache count directly
-                                    itemDict["ChildCount"] = fileItems.Count;
-                                    modified = true;
-                                }
-                            }
-                            
-                            // Only fetch from Jellyfin if we didn't get count from file cache
-                            if (!itemDict.ContainsKey("ChildCount") || 
-                                (itemDict["ChildCount"] is JsonElement childCountElement && childCountElement.GetInt32() == 0) ||
-                                (itemDict["ChildCount"] is int childCountInt && childCountInt == 0))
-                            {
-                                // Get local tracks count from Jellyfin
-                                var localTracksCount = 0;
-                                try
-                                {
-                                    // Include UserId parameter to avoid 401 Unauthorized
-                                    var userId = _settings.UserId;
-                                    var playlistItemsUrl = $"Playlists/{playlistId}/Items";
-                                    var queryParams = new Dictionary<string, string>();
-                                    if (!string.IsNullOrEmpty(userId))
-                                    {
-                                        queryParams["UserId"] = userId;
-                                    }
-                                    
-                                    var (localTracksResponse, _) = await _proxyService.GetJsonAsyncInternal(
-                                        playlistItemsUrl, 
-                                        queryParams);
-                                    
-                                    if (localTracksResponse != null && 
-                                        localTracksResponse.RootElement.TryGetProperty("Items", out var localItems))
-                                    {
-                                        localTracksCount = localItems.GetArrayLength();
-                                        _logger.LogInformation("Found {Count} total items in Jellyfin playlist {Name}", 
-                                            localTracksCount, playlistName);
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    _logger.LogWarning(ex, "Failed to get local tracks count for {Name}", playlistName);
-                                }
-                                
-                                // Count external matched tracks (not local)
-                                var externalMatchedCount = 0;
-                                if (matchedTracks != null)
-                                {
-                                    externalMatchedCount = matchedTracks.Count(t => t.MatchedSong != null && !t.MatchedSong.IsLocal);
-                                }
-                                
-                                // Total available tracks = local tracks in Jellyfin + external matched tracks
-                                // This represents what users will actually hear when playing the playlist
-                                var totalAvailableCount = localTracksCount + externalMatchedCount;
-                                
-                                if (totalAvailableCount > 0)
-                                {
-                                    // Update ChildCount to show actual available tracks
-                                    itemDict["ChildCount"] = totalAvailableCount;
-                                    modified = true;
-                                    _logger.LogInformation("✓ Updated ChildCount for Spotify playlist {Name} to {Total} ({Local} local + {External} external)", 
-                                        playlistName, totalAvailableCount, localTracksCount, externalMatchedCount);
-                                }
-                                else
-                                {
-                                    _logger.LogWarning("No tracks found for {Name} ({Local} local + {External} external = {Total} total)", 
-                                        playlistName, localTracksCount, externalMatchedCount, totalAvailableCount);
-                                }
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogWarning("No playlist config found for Jellyfin ID {JellyfinId} - skipping count update", playlistId);
-                        }
-                    }
-                }
-
-                updatedItems.Add(itemDict);
-            }
-
-            if (!modified)
-            {
-                _logger.LogInformation("No Spotify playlists found to update");
-                return response;
-            }
-
-            _logger.LogInformation("Modified {Count} Spotify playlists, rebuilding response", 
-                updatedItems.Count(i => i.ContainsKey("ChildCount")));
-
-            // Rebuild the response with updated items
-            var responseDict = JsonSerializer.Deserialize<Dictionary<string, object>>(response.RootElement.GetRawText());
-            if (responseDict != null)
-            {
-                responseDict["Items"] = updatedItems;
-                var updatedJson = JsonSerializer.Serialize(responseDict);
-                return JsonDocument.Parse(updatedJson);
-            }
-
-            return response;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to update Spotify playlist counts");
-            return response;
-        }
-    }
-
-    /// <summary>
-    /// Logs endpoint usage to a file for analysis.
-    /// Creates a CSV file with timestamp, method, path, and query string.
-    /// </summary>
-    private async Task LogEndpointUsageAsync(string path, string method)
-    {
-        try
-        {
-            var logDir = "/app/cache/endpoint-usage";
-            Directory.CreateDirectory(logDir);
-            
-            var logFile = Path.Combine(logDir, "endpoints.csv");
-            var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
-            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
-            
-            // Sanitize path and query for CSV (remove commas, quotes, newlines)
-            var sanitizedPath = path.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
-            var sanitizedQuery = queryString.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
-            
-            var logLine = $"{timestamp},{method},{sanitizedPath},{sanitizedQuery}\n";
-            
-            // Append to file (thread-safe)
-            await System.IO.File.AppendAllTextAsync(logFile, logLine);
-        }
-        catch (Exception ex)
-        {
-            // Don't let logging failures break the request
-            _logger.LogDebug(ex, "Failed to log endpoint usage");
-        }
-    }
-
-    private static string[]? ParseItemTypes(string? includeItemTypes)
-    {
-        if (string.IsNullOrWhiteSpace(includeItemTypes))
-        {
-            return null;
-        }
-
-        return includeItemTypes.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-    }
-
-    private static string GetContentType(string filePath)
-    {
-        var extension = Path.GetExtension(filePath).ToLowerInvariant();
-        return extension switch
-        {
-            ".mp3" => "audio/mpeg",
-            ".flac" => "audio/flac",
-            ".ogg" => "audio/ogg",
-            ".m4a" => "audio/mp4",
-            ".wav" => "audio/wav",
-            ".aac" => "audio/aac",
-            _ => "audio/mpeg"
-        };
-    }
-
-    /// <summary>
-    /// Scores search results based on fuzzy matching against the query.
-    /// Returns items with their relevance scores.
-    /// External results get a small boost to prioritize the larger catalog.
-    /// </summary>
-    private static List<(T Item, int Score)> ScoreSearchResults<T>(
-        string query,
-        List<T> items,
-        Func<T, string> titleField,
-        Func<T, string?> artistField,
-        Func<T, string?> albumField,
-        bool isExternal = false)
-    {
-        return items.Select(item =>
-        {
-            var title = titleField(item) ?? "";
-            var artist = artistField(item) ?? "";
-            var album = albumField(item) ?? "";
-
-            // Token-based fuzzy matching: split query and fields into words
-            var queryTokens = query.ToLower()
-                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
-                .ToList();
-
-            var fieldText = $"{title} {artist} {album}".ToLower();
-            var fieldTokens = fieldText
-                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
-                .ToList();
-
-            if (queryTokens.Count == 0) return (item, 0);
-
-            // Count how many query tokens match field tokens (with fuzzy tolerance)
-            var matchedTokens = 0;
-            foreach (var queryToken in queryTokens)
-            {
-                // Check if any field token matches this query token
-                var hasMatch = fieldTokens.Any(fieldToken =>
-                {
-                    // Exact match or substring match
-                    if (fieldToken.Contains(queryToken) || queryToken.Contains(fieldToken))
-                        return true;
-
-                    // Fuzzy match with Levenshtein distance
-                    var similarity = FuzzyMatcher.CalculateSimilarity(queryToken, fieldToken);
-                    return similarity >= 70; // 70% similarity threshold for individual words
-                });
-
-                if (hasMatch) matchedTokens++;
-            }
-
-            // Score = percentage of query tokens that matched
-            var baseScore = (matchedTokens * 100) / queryTokens.Count;
-
-            // Give external results a small boost (+5 points) to prioritize the larger catalog
-            var finalScore = isExternal ? Math.Min(100, baseScore + 5) : baseScore;
-
-            return (item, finalScore);
-        }).ToList();
-    }
-
-    #endregion
-
-    #region Spotify Playlist Injection
-
-    /// <summary>
-    /// Gets tracks for a Spotify playlist by matching missing tracks against external providers
-    /// and merging with existing local tracks from Jellyfin.
-    /// 
-    /// Supports two modes:
-    /// 1. Direct Spotify API (new): Uses SpotifyPlaylistFetcher for ordered tracks with ISRC matching
-    /// 2. Jellyfin Plugin (legacy): Uses MissingTrack data from Jellyfin Spotify Import plugin
-    /// </summary>
-    private async Task<IActionResult> GetSpotifyPlaylistTracksAsync(string spotifyPlaylistName, string playlistId)
-    {
-        try
-        {
-            // Try ordered cache first (from direct Spotify API mode)
-            if (_spotifyApiSettings.Enabled && _spotifyPlaylistFetcher != null)
-            {
-                var orderedResult = await GetSpotifyPlaylistTracksOrderedAsync(spotifyPlaylistName, playlistId);
-                if (orderedResult != null) return orderedResult;
-            }
-            
-            // Fall back to legacy unordered mode
-            return await GetSpotifyPlaylistTracksLegacyAsync(spotifyPlaylistName, playlistId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting Spotify playlist tracks {PlaylistName}", spotifyPlaylistName);
-            return _responseBuilder.CreateError(500, "Failed to get Spotify playlist tracks");
-        }
-    }
-    
-    /// <summary>
-    /// New mode: Gets playlist tracks with correct ordering using direct Spotify API data.
-    /// </summary>
-    private async Task<IActionResult?> GetSpotifyPlaylistTracksOrderedAsync(string spotifyPlaylistName, string playlistId)
-    {
-        // Check Redis cache first for fast serving
-        var cacheKey = $"spotify:playlist:items:{spotifyPlaylistName}";
-        var cachedItems = await _cache.GetAsync<List<Dictionary<string, object?>>>(cacheKey);
-        
-        if (cachedItems != null && cachedItems.Count > 0)
-        {
-            _logger.LogInformation("✅ Loaded {Count} playlist items from Redis cache for {Playlist}", 
-                cachedItems.Count, spotifyPlaylistName);
-            
-            // Log sample item to verify Spotify IDs are present
-            if (cachedItems.Count > 0 && cachedItems[0].ContainsKey("ProviderIds"))
-            {
-                var providerIds = cachedItems[0]["ProviderIds"] as Dictionary<string, object>;
-                var hasSpotifyId = providerIds?.ContainsKey("Spotify") ?? false;
-                _logger.LogDebug("Sample cached item has Spotify ID: {HasSpotifyId}", hasSpotifyId);
-            }
-            
-            return new JsonResult(new
-            {
-                Items = cachedItems,
-                TotalRecordCount = cachedItems.Count,
-                StartIndex = 0
-            });
-        }
-        
-        // Check file cache as fallback
-        var fileItems = await LoadPlaylistItemsFromFile(spotifyPlaylistName);
-        if (fileItems != null && fileItems.Count > 0)
-        {
-            _logger.LogInformation("✅ Loaded {Count} playlist items from file cache for {Playlist}", 
-                fileItems.Count, spotifyPlaylistName);
-            
-            // Restore to Redis cache
-            await _cache.SetAsync(cacheKey, fileItems, TimeSpan.FromHours(24));
-            
-            return new JsonResult(new
-            {
-                Items = fileItems,
-                TotalRecordCount = fileItems.Count,
-                StartIndex = 0
-            });
-        }
-        
-        // Check for ordered matched tracks from SpotifyTrackMatchingService
-        var orderedCacheKey = $"spotify:matched:ordered:{spotifyPlaylistName}";
-        var orderedTracks = await _cache.GetAsync<List<MatchedTrack>>(orderedCacheKey);
-        
-        if (orderedTracks == null || orderedTracks.Count == 0)
-        {
-            _logger.LogDebug("No ordered matched tracks in cache for {Playlist}, checking if we can fetch", 
-                spotifyPlaylistName);
-            return null; // Fall back to legacy mode
-        }
-        
-        _logger.LogDebug("Using {Count} ordered matched tracks for {Playlist}", 
-            orderedTracks.Count, spotifyPlaylistName);
-        
-        // Get existing Jellyfin playlist items (RAW - don't convert!)
-        // CRITICAL: Must include UserId parameter or Jellyfin returns empty results
-        var userId = _settings.UserId;
-        if (string.IsNullOrEmpty(userId))
-        {
-            _logger.LogError("❌ JELLYFIN_USER_ID is NOT configured! Cannot fetch playlist tracks. Set it in .env or admin UI.");
-            return null; // Fall back to legacy mode
-        }
-        
-        // Request MediaSources field to get bitrate info
-        var playlistItemsUrl = $"Playlists/{playlistId}/Items?UserId={userId}&Fields=MediaSources";
-        
-        _logger.LogInformation("🔍 Fetching existing tracks from Jellyfin playlist {PlaylistId} with UserId {UserId}", 
-            playlistId, userId);
-        
-        var (existingTracksResponse, statusCode) = await _proxyService.GetJsonAsync(
-            playlistItemsUrl, 
-            null, 
-            Request.Headers);
-        
-        if (statusCode != 200)
-        {
-            _logger.LogError("❌ Failed to fetch Jellyfin playlist items: HTTP {StatusCode}. Check JELLYFIN_USER_ID is correct.", statusCode);
-            return null;
-        }
-        
-        // Keep raw Jellyfin items - don't convert to Song objects!
-        var jellyfinItems = new List<JsonElement>();
-        var jellyfinItemsByName = new Dictionary<string, JsonElement>();
-        
-        if (existingTracksResponse != null && 
-            existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
-        {
-            foreach (var item in items.EnumerateArray())
-            {
-                jellyfinItems.Add(item);
-=======
                return dict;
->>>>>>> beta
                
            case JsonValueKind.Array:
                var list = new List<object?>();
@@ -6170,92 +1353,8 @@ public partial class JellyfinController : ControllerBase
                }
                return list;
                
-<<<<<<< HEAD
-                var key = $"{title}|{artist}".ToLowerInvariant();
-                if (!jellyfinItemsByName.ContainsKey(key))
-                {
-                    jellyfinItemsByName[key] = item;
-                }
-            }
-            
-            _logger.LogInformation("✅ Found {Count} existing LOCAL tracks in Jellyfin playlist", jellyfinItems.Count);
-        }
-        else
-        {
-            _logger.LogWarning("⚠️ No existing tracks found in Jellyfin playlist {PlaylistId} - playlist may be empty", playlistId);
-        }
-        
-        // Get the full playlist from Spotify to know the correct order
-        var spotifyTracks = await _spotifyPlaylistFetcher!.GetPlaylistTracksAsync(spotifyPlaylistName);
-        if (spotifyTracks.Count == 0)
-        {
-            _logger.LogWarning("Could not get Spotify playlist tracks for {Playlist}", spotifyPlaylistName);
-            return null; // Fall back to legacy
-        }
-        
-        // Build the final track list in correct Spotify order
-        var finalItems = new List<Dictionary<string, object?>>();
-        var usedJellyfinItems = new HashSet<string>();
-        var localUsedCount = 0;
-        var externalUsedCount = 0;
-        
-        _logger.LogDebug("🔍 Building playlist in Spotify order with {SpotifyCount} positions...", spotifyTracks.Count);
-        
-        foreach (var spotifyTrack in spotifyTracks.OrderBy(t => t.Position))
-        {
-            // Try to find matching Jellyfin item by fuzzy matching
-            JsonElement? matchedJellyfinItem = null;
-            string? matchedKey = null;
-            double bestScore = 0;
-            
-            foreach (var kvp in jellyfinItemsByName)
-            {
-                if (usedJellyfinItems.Contains(kvp.Key)) continue;
-||||||| f68706f
-                var key = $"{title}|{artist}".ToLowerInvariant();
-                if (!jellyfinItemsByName.ContainsKey(key))
-                {
-                    jellyfinItemsByName[key] = item;
-                }
-            }
-            
-            _logger.LogInformation("✅ Found {Count} existing LOCAL tracks in Jellyfin playlist", jellyfinItems.Count);
-        }
-        else
-        {
-            _logger.LogWarning("⚠️ No existing tracks found in Jellyfin playlist {PlaylistId} - playlist may be empty", playlistId);
-        }
-        
-        // Get the full playlist from Spotify to know the correct order
-        var spotifyTracks = await _spotifyPlaylistFetcher!.GetPlaylistTracksAsync(spotifyPlaylistName);
-        if (spotifyTracks.Count == 0)
-        {
-            _logger.LogWarning("Could not get Spotify playlist tracks for {Playlist}", spotifyPlaylistName);
-            return null; // Fall back to legacy
-        }
-        
-        // Build the final track list in correct Spotify order
-        var finalItems = new List<Dictionary<string, object?>>();
-        var usedJellyfinItems = new HashSet<string>();
-        var localUsedCount = 0;
-        var externalUsedCount = 0;
-        
-        _logger.LogInformation("🔍 Building playlist in Spotify order with {SpotifyCount} positions...", spotifyTracks.Count);
-        
-        foreach (var spotifyTrack in spotifyTracks.OrderBy(t => t.Position))
-        {
-            // Try to find matching Jellyfin item by fuzzy matching
-            JsonElement? matchedJellyfinItem = null;
-            string? matchedKey = null;
-            double bestScore = 0;
-            
-            foreach (var kvp in jellyfinItemsByName)
-            {
-                if (usedJellyfinItems.Contains(kvp.Key)) continue;
-=======
            case JsonValueKind.String:
                return element.GetString();
->>>>>>> beta
                
            case JsonValueKind.Number:
                if (element.TryGetInt32(out var intValue))
@@ -6269,1769 +1368,15 @@ public partial class JellyfinController : ControllerBase
            case JsonValueKind.True:
                return true;
                
-<<<<<<< HEAD
-                if (totalScore > bestScore && totalScore >= 70)
-                {
-                    bestScore = totalScore;
-                    matchedJellyfinItem = item;
-                    matchedKey = kvp.Key;
-                }
-            }
-            
-            if (matchedJellyfinItem.HasValue && matchedKey != null)
-            {
-                // Use the raw Jellyfin item (preserves ALL metadata including MediaSources!)
-                var itemDict = JsonSerializer.Deserialize<Dictionary<string, object?>>(matchedJellyfinItem.Value.GetRawText());
-                if (itemDict != null)
-                {
-                    finalItems.Add(itemDict);
-                    usedJellyfinItems.Add(matchedKey);
-                    localUsedCount++;
-                    _logger.LogDebug("✅ Position #{Pos}: '{Title}' → LOCAL (score: {Score:F1}%)", 
-                        spotifyTrack.Position, spotifyTrack.Title, bestScore);
-                }
-            }
-            else
-            {
-                // No local match - try to find external track
-                var matched = orderedTracks?.FirstOrDefault(t => t.SpotifyId == spotifyTrack.SpotifyId);
-                if (matched != null && matched.MatchedSong != null)
-                {
-                    // Convert external song to Jellyfin item format
-                    var externalItem = _responseBuilder.ConvertSongToJellyfinItem(matched.MatchedSong);
-                    
-                    // Add Spotify ID to ProviderIds so lyrics can work
-                    if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId))
-                    {
-                        if (!externalItem.ContainsKey("ProviderIds"))
-                        {
-                            externalItem["ProviderIds"] = new Dictionary<string, string>();
-                        }
-                        
-                        var providerIds = externalItem["ProviderIds"] as Dictionary<string, string>;
-                        if (providerIds != null && !providerIds.ContainsKey("Spotify"))
-                        {
-                            providerIds["Spotify"] = spotifyTrack.SpotifyId;
-                        }
-                    }
-                    
-                    finalItems.Add(externalItem);
-                    externalUsedCount++;
-                    _logger.LogDebug("📥 Position #{Pos}: '{Title}' → EXTERNAL: {Provider}/{Id} (Spotify ID: {SpotifyId})", 
-                        spotifyTrack.Position, spotifyTrack.Title,
-                        matched.MatchedSong.ExternalProvider, matched.MatchedSong.ExternalId, spotifyTrack.SpotifyId);
-                }
-                else
-                {
-                    _logger.LogDebug("❌ Position #{Pos}: '{Title}' → NO MATCH", 
-                        spotifyTrack.Position, spotifyTrack.Title);
-                }
-            }
-        }
-        
-        _logger.LogDebug("🎵 Final playlist '{Playlist}': {Total} tracks ({Local} LOCAL + {External} EXTERNAL)", 
-            spotifyPlaylistName, finalItems.Count, localUsedCount, externalUsedCount);
-        
-        // Save to file cache for persistence across restarts
-        await SavePlaylistItemsToFile(spotifyPlaylistName, finalItems);
-        
-        // Also cache in Redis for fast serving (reuse the same cache key from top of method)
-        await _cache.SetAsync(cacheKey, finalItems, CacheExtensions.SpotifyPlaylistItemsTTL);
-        
-        // Cache the Jellyfin playlist signature to detect future changes
-        await _cache.SetAsync(jellyfinSignatureCacheKey, currentJellyfinSignature, CacheExtensions.SpotifyPlaylistItemsTTL);
-        
-        // Return raw Jellyfin response format
-        return new JsonResult(new
-        {
-            Items = finalItems,
-            TotalRecordCount = finalItems.Count,
-            StartIndex = 0
-        });
-    }
-    
-    /// <summary>
-    /// Legacy mode: Gets playlist tracks without ordering (from Jellyfin Spotify Import plugin).
-    /// </summary>
-    private async Task<IActionResult> GetSpotifyPlaylistTracksLegacyAsync(string spotifyPlaylistName, string playlistId)
-    {
-        var cacheKey = $"spotify:matched:{spotifyPlaylistName}";
-        var cachedTracks = await _cache.GetAsync<List<Song>>(cacheKey);
-        
-        if (cachedTracks != null && cachedTracks.Count > 0)
-        {
-            _logger.LogInformation("Returning {Count} cached matched tracks from Redis for {Playlist}", 
-                cachedTracks.Count, spotifyPlaylistName);
-            return _responseBuilder.CreateItemsResponse(cachedTracks);
-        }
-        
-        // Try file cache if Redis is empty
-        if (cachedTracks == null || cachedTracks.Count == 0)
-        {
-            cachedTracks = await LoadMatchedTracksFromFile(spotifyPlaylistName);
-            if (cachedTracks != null && cachedTracks.Count > 0)
-            {
-                // Restore to Redis with configurable TTL
-                await _cache.SetAsync(cacheKey, cachedTracks, CacheExtensions.SpotifyMatchedTracksTTL);
-                _logger.LogInformation("Loaded {Count} matched tracks from file cache for {Playlist}", 
-                    cachedTracks.Count, spotifyPlaylistName);
-                return _responseBuilder.CreateItemsResponse(cachedTracks);
-            }
-        }
-
-        // Get existing Jellyfin playlist items (tracks the plugin already found)
-        // CRITICAL: Must include UserId parameter or Jellyfin returns empty results
-        var userId = _settings.UserId;
-        var playlistItemsUrl = $"Playlists/{playlistId}/Items";
-        if (!string.IsNullOrEmpty(userId))
-        {
-            playlistItemsUrl += $"?UserId={userId}";
-        }
-        else
-        {
-            _logger.LogInformation("No UserId configured - may not be able to fetch existing playlist tracks");
-        }
-        
-        var (existingTracksResponse, _) = await _proxyService.GetJsonAsync(
-            playlistItemsUrl, 
-            null, 
-            Request.Headers);
-        
-        var existingTracks = new List<Song>();
-        var existingSpotifyIds = new HashSet<string>();
-        
-        if (existingTracksResponse != null && 
-            existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
-        {
-            foreach (var item in items.EnumerateArray())
-            {
-                var song = _modelMapper.ParseSong(item);
-                existingTracks.Add(song);
-                
-                // Track Spotify IDs to avoid duplicates
-                if (item.TryGetProperty("ProviderIds", out var providerIds) &&
-                    providerIds.TryGetProperty("Spotify", out var spotifyId))
-                {
-                    existingSpotifyIds.Add(spotifyId.GetString() ?? "");
-                }
-            }
-            _logger.LogInformation("Found {Count} existing tracks in Jellyfin playlist", existingTracks.Count);
-        }
-        else
-        {
-            _logger.LogWarning("No existing tracks found in Jellyfin playlist - may need UserId parameter");
-        }
-
-        var missingTracksKey = $"spotify:missing:{spotifyPlaylistName}";
-        var missingTracks = await _cache.GetAsync<List<MissingTrack>>(missingTracksKey);
-        
-        // Fallback to file cache if Redis is empty
-        if (missingTracks == null || missingTracks.Count == 0)
-        {
-            missingTracks = await LoadMissingTracksFromFile(spotifyPlaylistName);
-            
-            // If we loaded from file, restore to Redis with no expiration
-            if (missingTracks != null && missingTracks.Count > 0)
-            {
-                await _cache.SetAsync(missingTracksKey, missingTracks, TimeSpan.FromDays(365));
-                _logger.LogDebug("Restored {Count} missing tracks from file cache for {Playlist} (no expiration)", 
-                    missingTracks.Count, spotifyPlaylistName);
-            }
-        }
-        
-        if (missingTracks == null || missingTracks.Count == 0)
-        {
-            _logger.LogInformation("No missing tracks found for {Playlist}, returning {Count} existing tracks", 
-                spotifyPlaylistName, existingTracks.Count);
-            return _responseBuilder.CreateItemsResponse(existingTracks);
-        }
-
-        _logger.LogDebug("Matching {Count} missing tracks for {Playlist}", 
-            missingTracks.Count, spotifyPlaylistName);
-
-        // Match missing tracks sequentially with rate limiting (excluding ones we already have locally)
-        var matchedBySpotifyId = new Dictionary<string, Song>();
-        var tracksToMatch = missingTracks
-            .Where(track => !existingSpotifyIds.Contains(track.SpotifyId))
-            .ToList();
-
-        foreach (var track in tracksToMatch)
-        {
-            try
-            {
-                // Search with just title and artist for better matching
-                var query = $"{track.Title} {track.PrimaryArtist}";
-                var results = await _metadataService.SearchSongsAsync(query, limit: 5);
-                
-                if (results.Count > 0)
-                {
-                    // Fuzzy match to find best result
-                    // Check that ALL artists match (not just some)
-                    var bestMatch = results
-                        .Select(song => new
-                        {
-                            Song = song,
-                            TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, song.Title),
-                            ArtistScore = FuzzyMatcher.CalculateArtistMatchScore(track.Artists, song.Artist, song.Contributors)
-                        })
-                        .Select(x => new
-                        {
-                            x.Song,
-                            x.TitleScore,
-                            x.ArtistScore,
-                            TotalScore = (x.TitleScore * 0.6) + (x.ArtistScore * 0.4) // Weight title more
-                        })
-                        .OrderByDescending(x => x.TotalScore)
-                        .FirstOrDefault();
-                    
-                    // Only add if match is good enough (>60% combined score)
-                    if (bestMatch != null && bestMatch.TotalScore >= 60)
-                    {
-                        _logger.LogDebug("Matched '{Title}' by {Artist} -> '{MatchTitle}' by {MatchArtist} (score: {Score:F1})",
-                            track.Title, track.PrimaryArtist, 
-                            bestMatch.Song.Title, bestMatch.Song.Artist, 
-                            bestMatch.TotalScore);
-                        matchedBySpotifyId[track.SpotifyId] = bestMatch.Song;
-                    }
-                    else
-                    {
-                        _logger.LogDebug("No good match for '{Title}' by {Artist} (best score: {Score:F1})",
-                            track.Title, track.PrimaryArtist, bestMatch?.TotalScore ?? 0);
-                    }
-                }
-                
-                // Rate limiting: small delay between searches to avoid overwhelming the service
-                await Task.Delay(100); // 100ms delay = max 10 searches/second
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to match track: {Title} - {Artist}", 
-                    track.Title, track.PrimaryArtist);
-            }
-        }
-
-        // Build final track list based on playlist configuration
-        // Local tracks position is configurable per-playlist
-        var playlistConfig = _spotifySettings.GetPlaylistByJellyfinId(playlistId);
-        var localTracksPosition = playlistConfig?.LocalTracksPosition ?? LocalTracksPosition.First;
-        
-        var finalTracks = new List<Song>();
-        if (localTracksPosition == LocalTracksPosition.First)
-        {
-            // Local tracks first, external tracks at the end
-            finalTracks.AddRange(existingTracks);
-            finalTracks.AddRange(matchedBySpotifyId.Values);
-        }
-        else
-        {
-            // External tracks first, local tracks at the end
-            finalTracks.AddRange(matchedBySpotifyId.Values);
-            finalTracks.AddRange(existingTracks);
-        }
-
-        await _cache.SetAsync(cacheKey, finalTracks, CacheExtensions.SpotifyMatchedTracksTTL);
-        
-        // Also save to file cache for persistence across restarts
-        await SaveMatchedTracksToFile(spotifyPlaylistName, finalTracks);
-
-        _logger.LogInformation("Final playlist: {Total} tracks ({Existing} local + {Matched} external, LocalTracksPosition: {Position})", 
-            finalTracks.Count,
-            existingTracks.Count,
-            matchedBySpotifyId.Count,
-            localTracksPosition);
-
-        return _responseBuilder.CreateItemsResponse(finalTracks);
-    }
-
-    /// <summary>
-    /// Copies an external track to the kept folder when favorited.
-    /// </summary>
-    private async Task CopyExternalTrackToKeptAsync(string itemId, string provider, string externalId)
-    {
-        try
-        {
-            // Check if already favorited (persistent tracking)
-            if (await IsTrackFavoritedAsync(itemId))
-            {
-                _logger.LogInformation("Track already favorited (persistent): {ItemId}", itemId);
-                return;
-            }
-
-            // Get the song metadata first to build paths
-            var song = await _metadataService.GetSongAsync(provider, externalId);
-            if (song == null)
-            {
-                _logger.LogWarning("Could not find song metadata for {ItemId}", itemId);
-                return;
-            }
-
-            // Build kept folder path: Artist/Album/
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            // Check if track already exists in kept folder
-            if (Directory.Exists(keptAlbumPath))
-            {
-                var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-                var existingFiles = Directory.GetFiles(keptAlbumPath, $"*{sanitizedTitle}*");
-                if (existingFiles.Length > 0)
-                {
-                    _logger.LogInformation("Track already exists in kept folder: {Path}", existingFiles[0]);
-                    // Mark as favorited even if we didn't download it
-                    await MarkTrackAsFavoritedAsync(itemId, song);
-                    return;
-                }
-            }
-
-            // Look for the track in cache folder first
-            var cacheBasePath = "/tmp/allstarr-cache";
-            var cacheArtistPath = Path.Combine(cacheBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var cacheAlbumPath = Path.Combine(cacheArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            string? sourceFilePath = null;
-            
-            if (Directory.Exists(cacheAlbumPath))
-            {
-                var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-                var cacheFiles = Directory.GetFiles(cacheAlbumPath, $"*{sanitizedTitle}*");
-                if (cacheFiles.Length > 0)
-                {
-                    sourceFilePath = cacheFiles[0];
-                    _logger.LogDebug("Found track in cache folder: {Path}", sourceFilePath);
-                }
-            }
-
-            // If not in cache, download it first
-            if (sourceFilePath == null)
-            {
-                _logger.LogInformation("Track not in cache, downloading: {ItemId}", itemId);
-                try
-                {
-                    sourceFilePath = await _downloadService.DownloadSongAsync(provider, externalId);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to download track {ItemId}", itemId);
-                    return;
-                }
-            }
-
-            // Create the kept folder structure
-            Directory.CreateDirectory(keptAlbumPath);
-
-            // Copy file to kept folder
-            var fileName = Path.GetFileName(sourceFilePath);
-            var keptFilePath = Path.Combine(keptAlbumPath, fileName);
-
-            // Double-check in case of race condition (multiple favorite clicks)
-            if (System.IO.File.Exists(keptFilePath))
-            {
-                _logger.LogInformation("Track already exists in kept folder (race condition): {Path}", keptFilePath);
-                await MarkTrackAsFavoritedAsync(itemId, song);
-                return;
-            }
-
-            System.IO.File.Copy(sourceFilePath, keptFilePath, overwrite: false);
-            _logger.LogDebug("✓ Copied track to kept folder: {Path}", keptFilePath);
-            
-            // Also copy cover art if it exists
-            var sourceCoverPath = Path.Combine(Path.GetDirectoryName(sourceFilePath)!, "cover.jpg");
-            if (System.IO.File.Exists(sourceCoverPath))
-            {
-                var keptCoverPath = Path.Combine(keptAlbumPath, "cover.jpg");
-                if (!System.IO.File.Exists(keptCoverPath))
-                {
-                    System.IO.File.Copy(sourceCoverPath, keptCoverPath, overwrite: false);
-                    _logger.LogDebug("Copied cover art to kept folder");
-                }
-            }
-
-            // Mark as favorited in persistent storage
-            await MarkTrackAsFavoritedAsync(itemId, song);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error copying external track {ItemId} to kept folder", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Removes an external track from the kept folder when unfavorited.
-    /// </summary>
-    private async Task RemoveExternalTrackFromKeptAsync(string itemId, string provider, string externalId)
-    {
-        try
-        {
-            // Mark for deletion instead of immediate deletion
-            await MarkTrackForDeletionAsync(itemId);
-            _logger.LogInformation("✓ Marked track for deletion: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error marking external track {ItemId} for deletion", itemId);
-        }
-    }
-
-    #region Persistent Favorites Tracking
-
-    private readonly string _favoritesFilePath = "/app/cache/favorites.json";
-
-    /// <summary>
-    /// Checks if a track is already favorited (persistent across restarts).
-    /// </summary>
-    private async Task<bool> IsTrackFavoritedAsync(string itemId)
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_favoritesFilePath))
-||||||| f68706f
-                if (totalScore > bestScore && totalScore >= 70)
-                {
-                    bestScore = totalScore;
-                    matchedJellyfinItem = item;
-                    matchedKey = kvp.Key;
-                }
-            }
-            
-            if (matchedJellyfinItem.HasValue && matchedKey != null)
-            {
-                // Use the raw Jellyfin item (preserves ALL metadata including MediaSources!)
-                var itemDict = JsonSerializer.Deserialize<Dictionary<string, object?>>(matchedJellyfinItem.Value.GetRawText());
-                if (itemDict != null)
-                {
-                    finalItems.Add(itemDict);
-                    usedJellyfinItems.Add(matchedKey);
-                    localUsedCount++;
-                    _logger.LogDebug("✅ Position #{Pos}: '{Title}' → LOCAL (score: {Score:F1}%)", 
-                        spotifyTrack.Position, spotifyTrack.Title, bestScore);
-                }
-            }
-            else
-            {
-                // No local match - try to find external track
-                var matched = orderedTracks?.FirstOrDefault(t => t.SpotifyId == spotifyTrack.SpotifyId);
-                if (matched != null && matched.MatchedSong != null)
-                {
-                    // Convert external song to Jellyfin item format
-                    var externalItem = _responseBuilder.ConvertSongToJellyfinItem(matched.MatchedSong);
-                    
-                    // Add Spotify ID to ProviderIds so lyrics can work
-                    if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId))
-                    {
-                        if (!externalItem.ContainsKey("ProviderIds"))
-                        {
-                            externalItem["ProviderIds"] = new Dictionary<string, string>();
-                        }
-                        
-                        var providerIds = externalItem["ProviderIds"] as Dictionary<string, string>;
-                        if (providerIds != null && !providerIds.ContainsKey("Spotify"))
-                        {
-                            providerIds["Spotify"] = spotifyTrack.SpotifyId;
-                        }
-                    }
-                    
-                    finalItems.Add(externalItem);
-                    externalUsedCount++;
-                    _logger.LogDebug("📥 Position #{Pos}: '{Title}' → EXTERNAL: {Provider}/{Id} (Spotify ID: {SpotifyId})", 
-                        spotifyTrack.Position, spotifyTrack.Title,
-                        matched.MatchedSong.ExternalProvider, matched.MatchedSong.ExternalId, spotifyTrack.SpotifyId);
-                }
-                else
-                {
-                    _logger.LogDebug("❌ Position #{Pos}: '{Title}' → NO MATCH", 
-                        spotifyTrack.Position, spotifyTrack.Title);
-                }
-            }
-        }
-        
-        _logger.LogInformation(
-            "🎵 Final playlist '{Playlist}': {Total} tracks ({Local} LOCAL + {External} EXTERNAL)", 
-            spotifyPlaylistName, finalItems.Count, localUsedCount, externalUsedCount);
-        
-        // Save to file cache for persistence across restarts
-        await SavePlaylistItemsToFile(spotifyPlaylistName, finalItems);
-        
-        // Also cache in Redis for fast serving (reuse the same cache key from top of method)
-        await _cache.SetAsync(cacheKey, finalItems, TimeSpan.FromHours(24));
-        
-        // Return raw Jellyfin response format
-        return new JsonResult(new
-        {
-            Items = finalItems,
-            TotalRecordCount = finalItems.Count,
-            StartIndex = 0
-        });
-    }
-    
-    /// <summary>
-    /// Legacy mode: Gets playlist tracks without ordering (from Jellyfin Spotify Import plugin).
-    /// </summary>
-    private async Task<IActionResult> GetSpotifyPlaylistTracksLegacyAsync(string spotifyPlaylistName, string playlistId)
-    {
-        var cacheKey = $"spotify:matched:{spotifyPlaylistName}";
-        var cachedTracks = await _cache.GetAsync<List<Song>>(cacheKey);
-        
-        if (cachedTracks != null && cachedTracks.Count > 0)
-        {
-            _logger.LogDebug("Returning {Count} cached matched tracks from Redis for {Playlist}", 
-                cachedTracks.Count, spotifyPlaylistName);
-            return _responseBuilder.CreateItemsResponse(cachedTracks);
-        }
-        
-        // Try file cache if Redis is empty
-        if (cachedTracks == null || cachedTracks.Count == 0)
-        {
-            cachedTracks = await LoadMatchedTracksFromFile(spotifyPlaylistName);
-            if (cachedTracks != null && cachedTracks.Count > 0)
-            {
-                // Restore to Redis with 1 hour TTL
-                await _cache.SetAsync(cacheKey, cachedTracks, TimeSpan.FromHours(1));
-                _logger.LogInformation("Loaded {Count} matched tracks from file cache for {Playlist}", 
-                    cachedTracks.Count, spotifyPlaylistName);
-                return _responseBuilder.CreateItemsResponse(cachedTracks);
-            }
-        }
-
-        // Get existing Jellyfin playlist items (tracks the plugin already found)
-        // CRITICAL: Must include UserId parameter or Jellyfin returns empty results
-        var userId = _settings.UserId;
-        var playlistItemsUrl = $"Playlists/{playlistId}/Items";
-        if (!string.IsNullOrEmpty(userId))
-        {
-            playlistItemsUrl += $"?UserId={userId}";
-        }
-        else
-        {
-            _logger.LogWarning("No UserId configured - may not be able to fetch existing playlist tracks");
-        }
-        
-        var (existingTracksResponse, _) = await _proxyService.GetJsonAsync(
-            playlistItemsUrl, 
-            null, 
-            Request.Headers);
-        
-        var existingTracks = new List<Song>();
-        var existingSpotifyIds = new HashSet<string>();
-        
-        if (existingTracksResponse != null && 
-            existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
-        {
-            foreach (var item in items.EnumerateArray())
-            {
-                var song = _modelMapper.ParseSong(item);
-                existingTracks.Add(song);
-                
-                // Track Spotify IDs to avoid duplicates
-                if (item.TryGetProperty("ProviderIds", out var providerIds) &&
-                    providerIds.TryGetProperty("Spotify", out var spotifyId))
-                {
-                    existingSpotifyIds.Add(spotifyId.GetString() ?? "");
-                }
-            }
-            _logger.LogInformation("Found {Count} existing tracks in Jellyfin playlist", existingTracks.Count);
-        }
-        else
-        {
-            _logger.LogWarning("No existing tracks found in Jellyfin playlist - may need UserId parameter");
-        }
-
-        var missingTracksKey = $"spotify:missing:{spotifyPlaylistName}";
-        var missingTracks = await _cache.GetAsync<List<MissingTrack>>(missingTracksKey);
-        
-        // Fallback to file cache if Redis is empty
-        if (missingTracks == null || missingTracks.Count == 0)
-        {
-            missingTracks = await LoadMissingTracksFromFile(spotifyPlaylistName);
-            
-            // If we loaded from file, restore to Redis with no expiration
-            if (missingTracks != null && missingTracks.Count > 0)
-            {
-                await _cache.SetAsync(missingTracksKey, missingTracks, TimeSpan.FromDays(365));
-                _logger.LogInformation("Restored {Count} missing tracks from file cache for {Playlist} (no expiration)", 
-                    missingTracks.Count, spotifyPlaylistName);
-            }
-        }
-        
-        if (missingTracks == null || missingTracks.Count == 0)
-        {
-            _logger.LogInformation("No missing tracks found for {Playlist}, returning {Count} existing tracks", 
-                spotifyPlaylistName, existingTracks.Count);
-            return _responseBuilder.CreateItemsResponse(existingTracks);
-        }
-
-        _logger.LogInformation("Matching {Count} missing tracks for {Playlist}", 
-            missingTracks.Count, spotifyPlaylistName);
-
-        // Match missing tracks sequentially with rate limiting (excluding ones we already have locally)
-        var matchedBySpotifyId = new Dictionary<string, Song>();
-        var tracksToMatch = missingTracks
-            .Where(track => !existingSpotifyIds.Contains(track.SpotifyId))
-            .ToList();
-
-        foreach (var track in tracksToMatch)
-        {
-            try
-            {
-                // Search with just title and artist for better matching
-                var query = $"{track.Title} {track.PrimaryArtist}";
-                var results = await _metadataService.SearchSongsAsync(query, limit: 5);
-                
-                if (results.Count > 0)
-                {
-                    // Fuzzy match to find best result
-                    // Check that ALL artists match (not just some)
-                    var bestMatch = results
-                        .Select(song => new
-                        {
-                            Song = song,
-                            TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, song.Title),
-                            ArtistScore = FuzzyMatcher.CalculateArtistMatchScore(track.Artists, song.Artist, song.Contributors)
-                        })
-                        .Select(x => new
-                        {
-                            x.Song,
-                            x.TitleScore,
-                            x.ArtistScore,
-                            TotalScore = (x.TitleScore * 0.6) + (x.ArtistScore * 0.4) // Weight title more
-                        })
-                        .OrderByDescending(x => x.TotalScore)
-                        .FirstOrDefault();
-                    
-                    // Only add if match is good enough (>60% combined score)
-                    if (bestMatch != null && bestMatch.TotalScore >= 60)
-                    {
-                        _logger.LogDebug("Matched '{Title}' by {Artist} -> '{MatchTitle}' by {MatchArtist} (score: {Score:F1})",
-                            track.Title, track.PrimaryArtist, 
-                            bestMatch.Song.Title, bestMatch.Song.Artist, 
-                            bestMatch.TotalScore);
-                        matchedBySpotifyId[track.SpotifyId] = bestMatch.Song;
-                    }
-                    else
-                    {
-                        _logger.LogDebug("No good match for '{Title}' by {Artist} (best score: {Score:F1})",
-                            track.Title, track.PrimaryArtist, bestMatch?.TotalScore ?? 0);
-                    }
-                }
-                
-                // Rate limiting: small delay between searches to avoid overwhelming the service
-                await Task.Delay(100); // 100ms delay = max 10 searches/second
-            }
-            catch (Exception ex)
-            {
-                _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", 
-                    track.Title, track.PrimaryArtist);
-            }
-        }
-
-        // Build final track list based on playlist configuration
-        // Local tracks position is configurable per-playlist
-        var playlistConfig = _spotifySettings.GetPlaylistByJellyfinId(playlistId);
-        var localTracksPosition = playlistConfig?.LocalTracksPosition ?? LocalTracksPosition.First;
-        
-        var finalTracks = new List<Song>();
-        if (localTracksPosition == LocalTracksPosition.First)
-        {
-            // Local tracks first, external tracks at the end
-            finalTracks.AddRange(existingTracks);
-            finalTracks.AddRange(matchedBySpotifyId.Values);
-        }
-        else
-        {
-            // External tracks first, local tracks at the end
-            finalTracks.AddRange(matchedBySpotifyId.Values);
-            finalTracks.AddRange(existingTracks);
-        }
-
-        await _cache.SetAsync(cacheKey, finalTracks, TimeSpan.FromHours(1));
-        
-        // Also save to file cache for persistence across restarts
-        await SaveMatchedTracksToFile(spotifyPlaylistName, finalTracks);
-
-        _logger.LogInformation("Final playlist: {Total} tracks ({Existing} local + {Matched} external, LocalTracksPosition: {Position})", 
-            finalTracks.Count,
-            existingTracks.Count,
-            matchedBySpotifyId.Count,
-            localTracksPosition);
-
-        return _responseBuilder.CreateItemsResponse(finalTracks);
-    }
-
-    /// <summary>
-    /// Copies an external track to the kept folder when favorited.
-    /// </summary>
-    private async Task CopyExternalTrackToKeptAsync(string itemId, string provider, string externalId)
-    {
-        try
-        {
-            // Check if already favorited (persistent tracking)
-            if (await IsTrackFavoritedAsync(itemId))
-            {
-                _logger.LogInformation("Track already favorited (persistent): {ItemId}", itemId);
-                return;
-            }
-
-            // Get the song metadata first to build paths
-            var song = await _metadataService.GetSongAsync(provider, externalId);
-            if (song == null)
-            {
-                _logger.LogWarning("Could not find song metadata for {ItemId}", itemId);
-                return;
-            }
-
-            // Build kept folder path: Artist/Album/
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            // Check if track already exists in kept folder
-            if (Directory.Exists(keptAlbumPath))
-            {
-                var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-                var existingFiles = Directory.GetFiles(keptAlbumPath, $"*{sanitizedTitle}*");
-                if (existingFiles.Length > 0)
-                {
-                    _logger.LogInformation("Track already exists in kept folder: {Path}", existingFiles[0]);
-                    // Mark as favorited even if we didn't download it
-                    await MarkTrackAsFavoritedAsync(itemId, song);
-                    return;
-                }
-            }
-
-            // Look for the track in cache folder first
-            var cacheBasePath = "/tmp/allstarr-cache";
-            var cacheArtistPath = Path.Combine(cacheBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var cacheAlbumPath = Path.Combine(cacheArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            string? sourceFilePath = null;
-            
-            if (Directory.Exists(cacheAlbumPath))
-            {
-                var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-                var cacheFiles = Directory.GetFiles(cacheAlbumPath, $"*{sanitizedTitle}*");
-                if (cacheFiles.Length > 0)
-                {
-                    sourceFilePath = cacheFiles[0];
-                    _logger.LogInformation("Found track in cache folder: {Path}", sourceFilePath);
-                }
-            }
-
-            // If not in cache, download it first
-            if (sourceFilePath == null)
-            {
-                _logger.LogInformation("Track not in cache, downloading: {ItemId}", itemId);
-                try
-                {
-                    sourceFilePath = await _downloadService.DownloadSongAsync(provider, externalId);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to download track {ItemId}", itemId);
-                    return;
-                }
-            }
-
-            // Create the kept folder structure
-            Directory.CreateDirectory(keptAlbumPath);
-
-            // Copy file to kept folder
-            var fileName = Path.GetFileName(sourceFilePath);
-            var keptFilePath = Path.Combine(keptAlbumPath, fileName);
-
-            // Double-check in case of race condition (multiple favorite clicks)
-            if (System.IO.File.Exists(keptFilePath))
-            {
-                _logger.LogInformation("Track already exists in kept folder (race condition): {Path}", keptFilePath);
-                await MarkTrackAsFavoritedAsync(itemId, song);
-                return;
-            }
-
-            System.IO.File.Copy(sourceFilePath, keptFilePath, overwrite: false);
-            _logger.LogInformation("✓ Copied track to kept folder: {Path}", keptFilePath);
-            
-            // Also copy cover art if it exists
-            var sourceCoverPath = Path.Combine(Path.GetDirectoryName(sourceFilePath)!, "cover.jpg");
-            if (System.IO.File.Exists(sourceCoverPath))
-            {
-                var keptCoverPath = Path.Combine(keptAlbumPath, "cover.jpg");
-                if (!System.IO.File.Exists(keptCoverPath))
-                {
-                    System.IO.File.Copy(sourceCoverPath, keptCoverPath, overwrite: false);
-                    _logger.LogDebug("Copied cover art to kept folder");
-                }
-            }
-
-            // Mark as favorited in persistent storage
-            await MarkTrackAsFavoritedAsync(itemId, song);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error copying external track {ItemId} to kept folder", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Removes an external track from the kept folder when unfavorited.
-    /// </summary>
-    private async Task RemoveExternalTrackFromKeptAsync(string itemId, string provider, string externalId)
-    {
-        try
-        {
-            // Mark for deletion instead of immediate deletion
-            await MarkTrackForDeletionAsync(itemId);
-            _logger.LogInformation("✓ Marked track for deletion: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error marking external track {ItemId} for deletion", itemId);
-        }
-    }
-
-    #region Persistent Favorites Tracking
-
-    private readonly string _favoritesFilePath = "/app/cache/favorites.json";
-
-    /// <summary>
-    /// Checks if a track is already favorited (persistent across restarts).
-    /// </summary>
-    private async Task<bool> IsTrackFavoritedAsync(string itemId)
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_favoritesFilePath))
-=======
            case JsonValueKind.False:
->>>>>>> beta
                return false;
-<<<<<<< HEAD
-
-            var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-            var favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            
-            return favorites.ContainsKey(itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to check favorite status for {ItemId}", itemId);
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// Marks a track as favorited in persistent storage.
-    /// </summary>
-    private async Task MarkTrackAsFavoritedAsync(string itemId, Song song)
-    {
-        try
-        {
-            var favorites = new Dictionary<string, FavoriteTrackInfo>();
-            
-            if (System.IO.File.Exists(_favoritesFilePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-                favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            }
-
-            favorites[itemId] = new FavoriteTrackInfo
-            {
-                ItemId = itemId,
-                Title = song.Title,
-                Artist = song.Artist,
-                Album = song.Album,
-                FavoritedAt = DateTime.UtcNow
-            };
-
-            // Ensure cache directory exists
-            Directory.CreateDirectory(Path.GetDirectoryName(_favoritesFilePath)!);
-            
-            var updatedJson = JsonSerializer.Serialize(favorites, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(_favoritesFilePath, updatedJson);
-            
-            _logger.LogDebug("Marked track as favorited: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to mark track as favorited: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Removes a track from persistent favorites storage.
-    /// </summary>
-    private async Task UnmarkTrackAsFavoritedAsync(string itemId)
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_favoritesFilePath))
-                return;
-
-            var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-            var favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            
-            if (favorites.Remove(itemId))
-            {
-                var updatedJson = JsonSerializer.Serialize(favorites, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(_favoritesFilePath, updatedJson);
-                _logger.LogDebug("Removed track from favorites: {ItemId}", itemId);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to remove track from favorites: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Marks a track for deletion (delayed deletion for safety).
-    /// </summary>
-    private async Task MarkTrackForDeletionAsync(string itemId)
-    {
-        try
-        {
-            var deletionFilePath = "/app/cache/pending_deletions.json";
-            var pendingDeletions = new Dictionary<string, DateTime>();
-            
-            if (System.IO.File.Exists(deletionFilePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(deletionFilePath);
-                pendingDeletions = JsonSerializer.Deserialize<Dictionary<string, DateTime>>(json) ?? new();
-            }
-
-            // Mark for deletion 24 hours from now
-            pendingDeletions[itemId] = DateTime.UtcNow.AddHours(24);
-
-            // Ensure cache directory exists
-            Directory.CreateDirectory(Path.GetDirectoryName(deletionFilePath)!);
-            
-            var updatedJson = JsonSerializer.Serialize(pendingDeletions, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(deletionFilePath, updatedJson);
-            
-            // Also remove from favorites immediately
-            await UnmarkTrackAsFavoritedAsync(itemId);
-            
-            _logger.LogDebug("Marked track for deletion in 24 hours: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to mark track for deletion: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Information about a favorited track for persistent storage.
-    /// </summary>
-    private class FavoriteTrackInfo
-    {
-        public string ItemId { get; set; } = "";
-        public string Title { get; set; } = "";
-        public string Artist { get; set; } = "";
-        public string Album { get; set; } = "";
-        public DateTime FavoritedAt { get; set; }
-    }
-
-    /// <summary>
-    /// Processes pending deletions (called by cleanup service).
-    /// </summary>
-    public async Task ProcessPendingDeletionsAsync()
-    {
-        try
-        {
-            var deletionFilePath = "/app/cache/pending_deletions.json";
-            if (!System.IO.File.Exists(deletionFilePath))
-                return;
-
-            var json = await System.IO.File.ReadAllTextAsync(deletionFilePath);
-            var pendingDeletions = JsonSerializer.Deserialize<Dictionary<string, DateTime>>(json) ?? new();
-            
-            var now = DateTime.UtcNow;
-            var toDelete = pendingDeletions.Where(kvp => kvp.Value <= now).ToList();
-            var remaining = pendingDeletions.Where(kvp => kvp.Value > now).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
-
-            foreach (var (itemId, _) in toDelete)
-            {
-                await ActuallyDeleteTrackAsync(itemId);
-            }
-
-            if (toDelete.Count > 0)
-            {
-                // Update pending deletions file
-                var updatedJson = JsonSerializer.Serialize(remaining, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(deletionFilePath, updatedJson);
-||||||| f68706f
-
-            var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-            var favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            
-            return favorites.ContainsKey(itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to check favorite status for {ItemId}", itemId);
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// Marks a track as favorited in persistent storage.
-    /// </summary>
-    private async Task MarkTrackAsFavoritedAsync(string itemId, Song song)
-    {
-        try
-        {
-            var favorites = new Dictionary<string, FavoriteTrackInfo>();
-            
-            if (System.IO.File.Exists(_favoritesFilePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-                favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            }
-
-            favorites[itemId] = new FavoriteTrackInfo
-            {
-                ItemId = itemId,
-                Title = song.Title,
-                Artist = song.Artist,
-                Album = song.Album,
-                FavoritedAt = DateTime.UtcNow
-            };
-
-            // Ensure cache directory exists
-            Directory.CreateDirectory(Path.GetDirectoryName(_favoritesFilePath)!);
-            
-            var updatedJson = JsonSerializer.Serialize(favorites, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(_favoritesFilePath, updatedJson);
-            
-            _logger.LogDebug("Marked track as favorited: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to mark track as favorited: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Removes a track from persistent favorites storage.
-    /// </summary>
-    private async Task UnmarkTrackAsFavoritedAsync(string itemId)
-    {
-        try
-        {
-            if (!System.IO.File.Exists(_favoritesFilePath))
-                return;
-
-            var json = await System.IO.File.ReadAllTextAsync(_favoritesFilePath);
-            var favorites = JsonSerializer.Deserialize<Dictionary<string, FavoriteTrackInfo>>(json) ?? new();
-            
-            if (favorites.Remove(itemId))
-            {
-                var updatedJson = JsonSerializer.Serialize(favorites, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(_favoritesFilePath, updatedJson);
-                _logger.LogDebug("Removed track from favorites: {ItemId}", itemId);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to remove track from favorites: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Marks a track for deletion (delayed deletion for safety).
-    /// </summary>
-    private async Task MarkTrackForDeletionAsync(string itemId)
-    {
-        try
-        {
-            var deletionFilePath = "/app/cache/pending_deletions.json";
-            var pendingDeletions = new Dictionary<string, DateTime>();
-            
-            if (System.IO.File.Exists(deletionFilePath))
-            {
-                var json = await System.IO.File.ReadAllTextAsync(deletionFilePath);
-                pendingDeletions = JsonSerializer.Deserialize<Dictionary<string, DateTime>>(json) ?? new();
-            }
-
-            // Mark for deletion 24 hours from now
-            pendingDeletions[itemId] = DateTime.UtcNow.AddHours(24);
-
-            // Ensure cache directory exists
-            Directory.CreateDirectory(Path.GetDirectoryName(deletionFilePath)!);
-            
-            var updatedJson = JsonSerializer.Serialize(pendingDeletions, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(deletionFilePath, updatedJson);
-            
-            // Also remove from favorites immediately
-            await UnmarkTrackAsFavoritedAsync(itemId);
-            
-            _logger.LogDebug("Marked track for deletion in 24 hours: {ItemId}", itemId);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to mark track for deletion: {ItemId}", itemId);
-        }
-    }
-
-    /// <summary>
-    /// Information about a favorited track for persistent storage.
-    /// </summary>
-    private class FavoriteTrackInfo
-    {
-        public string ItemId { get; set; } = "";
-        public string Title { get; set; } = "";
-        public string Artist { get; set; } = "";
-        public string Album { get; set; } = "";
-        public DateTime FavoritedAt { get; set; }
-    }
-
-    /// <summary>
-    /// Processes pending deletions (called by cleanup service).
-    /// </summary>
-    public async Task ProcessPendingDeletionsAsync()
-    {
-        try
-        {
-            var deletionFilePath = "/app/cache/pending_deletions.json";
-            if (!System.IO.File.Exists(deletionFilePath))
-                return;
-
-            var json = await System.IO.File.ReadAllTextAsync(deletionFilePath);
-            var pendingDeletions = JsonSerializer.Deserialize<Dictionary<string, DateTime>>(json) ?? new();
-            
-            var now = DateTime.UtcNow;
-            var toDelete = pendingDeletions.Where(kvp => kvp.Value <= now).ToList();
-            var remaining = pendingDeletions.Where(kvp => kvp.Value > now).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
-
-            foreach (var (itemId, _) in toDelete)
-            {
-                await ActuallyDeleteTrackAsync(itemId);
-            }
-
-            if (toDelete.Count > 0)
-            {
-                // Update pending deletions file
-                var updatedJson = JsonSerializer.Serialize(remaining, new JsonSerializerOptions { WriteIndented = true });
-                await System.IO.File.WriteAllTextAsync(deletionFilePath, updatedJson);
-=======
->>>>>>> beta
                
-<<<<<<< HEAD
-                _logger.LogDebug("Processed {Count} pending deletions", toDelete.Count);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error processing pending deletions");
-        }
-    }
-
-    /// <summary>
-    /// Actually deletes a track from the kept folder.
-    /// </summary>
-    private async Task ActuallyDeleteTrackAsync(string itemId)
-    {
-        try
-        {
-            var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-            if (!isExternal) return;
-
-            var song = await _metadataService.GetSongAsync(provider!, externalId!);
-            if (song == null) return;
-
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            if (!Directory.Exists(keptAlbumPath)) return;
-
-            var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-            var trackFiles = Directory.GetFiles(keptAlbumPath, $"*{sanitizedTitle}*");
-            
-            foreach (var trackFile in trackFiles)
-            {
-                System.IO.File.Delete(trackFile);
-                _logger.LogDebug("✓ Deleted track from kept folder: {Path}", trackFile);
-            }
-
-            // Clean up empty directories
-            if (Directory.GetFiles(keptAlbumPath).Length == 0 && Directory.GetDirectories(keptAlbumPath).Length == 0)
-            {
-                Directory.Delete(keptAlbumPath);
-||||||| f68706f
-                _logger.LogInformation("Processed {Count} pending deletions", toDelete.Count);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error processing pending deletions");
-        }
-    }
-
-    /// <summary>
-    /// Actually deletes a track from the kept folder.
-    /// </summary>
-    private async Task ActuallyDeleteTrackAsync(string itemId)
-    {
-        try
-        {
-            var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
-            if (!isExternal) return;
-
-            var song = await _metadataService.GetSongAsync(provider!, externalId!);
-            if (song == null) return;
-
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
-            var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
-            var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
-            
-            if (!Directory.Exists(keptAlbumPath)) return;
-
-            var sanitizedTitle = PathHelper.SanitizeFileName(song.Title);
-            var trackFiles = Directory.GetFiles(keptAlbumPath, $"*{sanitizedTitle}*");
-            
-            foreach (var trackFile in trackFiles)
-            {
-                System.IO.File.Delete(trackFile);
-                _logger.LogInformation("✓ Deleted track from kept folder: {Path}", trackFile);
-            }
-
-            // Clean up empty directories
-            if (Directory.GetFiles(keptAlbumPath).Length == 0 && Directory.GetDirectories(keptAlbumPath).Length == 0)
-            {
-                Directory.Delete(keptAlbumPath);
-=======
            case JsonValueKind.Null:
                return null;
->>>>>>> beta
                
-<<<<<<< HEAD
-                if (Directory.Exists(keptArtistPath) && 
-                    Directory.GetFiles(keptArtistPath).Length == 0 && 
-                    Directory.GetDirectories(keptArtistPath).Length == 0)
-                {
-                    Directory.Delete(keptArtistPath);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to delete track {ItemId}", itemId);
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Loads missing tracks from file cache as fallback when Redis is empty.
-    /// </summary>
-    private async Task<List<allstarr.Models.Spotify.MissingTrack>?> LoadMissingTracksFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_missing.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogDebug("No file cache found for {Playlist} at {Path}", playlistName, filePath);
-||||||| f68706f
-                if (Directory.Exists(keptArtistPath) && 
-                    Directory.GetFiles(keptArtistPath).Length == 0 && 
-                    Directory.GetDirectories(keptArtistPath).Length == 0)
-                {
-                    Directory.Delete(keptArtistPath);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to delete track {ItemId}", itemId);
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Loads missing tracks from file cache as fallback when Redis is empty.
-    /// </summary>
-    private async Task<List<allstarr.Models.Spotify.MissingTrack>?> LoadMissingTracksFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_missing.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogDebug("No file cache found for {Playlist} at {Path}", playlistName, filePath);
-=======
            default:
->>>>>>> beta
                return null;
-<<<<<<< HEAD
-            }
-            
-            // No expiration check - cache persists until next Jellyfin job generates new file
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            _logger.LogDebug("File cache for {Playlist} age: {Age:F1}h (no expiration)", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var tracks = JsonSerializer.Deserialize<List<allstarr.Models.Spotify.MissingTrack>>(json);
-            
-            _logger.LogDebug("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)", 
-                tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return tracks;
-||||||| f68706f
-            }
-            
-            // No expiration check - cache persists until next Jellyfin job generates new file
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            _logger.LogDebug("File cache for {Playlist} age: {Age:F1}h (no expiration)", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var tracks = JsonSerializer.Deserialize<List<allstarr.Models.Spotify.MissingTrack>>(json);
-            
-            _logger.LogInformation("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)", 
-                tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return tracks;
-=======
->>>>>>> beta
        }
-<<<<<<< HEAD
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to load missing tracks from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// Loads matched/combined tracks from file cache as fallback when Redis is empty.
-    /// </summary>
-    private async Task<List<Song>?> LoadMatchedTracksFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_matched.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogInformation("No matched tracks file cache found for {Playlist} at {Path}", playlistName, filePath);
-                return null;
-            }
-            
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            
-            // Check if cache is too old (more than 24 hours)
-            if (fileAge.TotalHours > 24)
-            {
-                _logger.LogInformation("Matched tracks file cache for {Playlist} is too old ({Age:F1}h), will rebuild", 
-                    playlistName, fileAge.TotalHours);
-                return null;
-            }
-            
-            _logger.LogInformation("Matched tracks file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var tracks = JsonSerializer.Deserialize<List<Song>>(json);
-            
-            _logger.LogInformation("Loaded {Count} matched tracks from file cache for {Playlist} (age: {Age:F1}h)", 
-                tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return tracks;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to load matched tracks from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// Saves matched/combined tracks to file cache for persistence across restarts.
-    /// </summary>
-    private async Task SaveMatchedTracksToFile(string playlistName, List<Song> tracks)
-    {
-        try
-        {
-            var cacheDir = "/app/cache/spotify";
-            Directory.CreateDirectory(cacheDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(cacheDir, $"{safeName}_matched.json");
-            
-            var json = JsonSerializer.Serialize(tracks, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, json);
-            
-            _logger.LogInformation("Saved {Count} matched tracks to file cache for {Playlist}", 
-                tracks.Count, playlistName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save matched tracks to file for {Playlist}", playlistName);
-        }
-    }
-
-    /// <summary>
-    /// Gets a signature (hash) of the Jellyfin playlist to detect changes.
-    /// This is a cheap operation compared to re-matching all tracks.
-    /// Signature includes: track count + concatenated track IDs.
-    /// </summary>
-    private async Task<string> GetJellyfinPlaylistSignatureAsync(string playlistId)
-    {
-        try
-        {
-            var userId = _settings.UserId;
-            var playlistItemsUrl = $"Playlists/{playlistId}/Items?Fields=Id";
-            if (!string.IsNullOrEmpty(userId))
-            {
-                playlistItemsUrl += $"&UserId={userId}";
-            }
-            
-            var (response, _) = await _proxyService.GetJsonAsync(playlistItemsUrl, null, Request.Headers);
-            
-            if (response != null && response.RootElement.TryGetProperty("Items", out var items))
-            {
-                var trackIds = new List<string>();
-                foreach (var item in items.EnumerateArray())
-                {
-                    if (item.TryGetProperty("Id", out var idEl))
-                    {
-                        trackIds.Add(idEl.GetString() ?? "");
-                    }
-                }
-                
-                // Create signature: count + sorted IDs (sorted for consistency)
-                trackIds.Sort();
-                var signature = $"{trackIds.Count}:{string.Join(",", trackIds)}";
-                
-                // Hash it to keep it compact
-                using var sha256 = System.Security.Cryptography.SHA256.Create();
-                var hashBytes = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(signature));
-                return Convert.ToHexString(hashBytes);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to get Jellyfin playlist signature for {PlaylistId}", playlistId);
-        }
-        
-        // Return empty string if failed (will trigger re-match)
-        return string.Empty;
-    }
-
-    /// <summary>
-    /// Saves playlist items (raw Jellyfin JSON) to file cache for persistence across restarts.
-    /// </summary>
-    private async Task SavePlaylistItemsToFile(string playlistName, List<Dictionary<string, object?>> items)
-    {
-        try
-        {
-            var cacheDir = "/app/cache/spotify";
-            Directory.CreateDirectory(cacheDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(cacheDir, $"{safeName}_items.json");
-            
-            var json = JsonSerializer.Serialize(items, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, json);
-            
-            _logger.LogDebug("💾 Saved {Count} playlist items to file cache for {Playlist}", 
-                items.Count, playlistName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save playlist items to file for {Playlist}", playlistName);
-        }
-    }
-
-    /// <summary>
-    /// Loads playlist items (raw Jellyfin JSON) from file cache.
-    /// </summary>
-    private async Task<List<Dictionary<string, object?>>?> LoadPlaylistItemsFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_items.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogDebug("No playlist items file cache found for {Playlist} at {Path}", playlistName, filePath);
-                return null;
-            }
-            
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            
-            // Check if cache is too old (more than 24 hours)
-            if (fileAge.TotalHours > 24)
-            {
-                _logger.LogDebug("Playlist items file cache for {Playlist} is too old ({Age:F1}h), will rebuild", 
-                    playlistName, fileAge.TotalHours);
-                return null;
-            }
-            
-            _logger.LogDebug("Playlist items file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var items = JsonSerializer.Deserialize<List<Dictionary<string, object?>>>(json);
-            
-            _logger.LogDebug("💿 Loaded {Count} playlist items from file cache for {Playlist} (age: {Age:F1}h)", 
-                items?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return items;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to load playlist items from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Calculates artist match score ensuring ALL artists are present.
-    /// Penalizes if artist counts don't match or if any artist is missing.
-    /// </summary>
-    private static double CalculateArtistMatchScore(List<string> spotifyArtists, string songMainArtist, List<string> songContributors)
-    {
-        if (spotifyArtists.Count == 0 || string.IsNullOrEmpty(songMainArtist))
-            return 0;
-        
-        // Build list of all song artists (main + contributors)
-        var allSongArtists = new List<string> { songMainArtist };
-        allSongArtists.AddRange(songContributors);
-        
-        // If artist counts differ significantly, penalize
-        var countDiff = Math.Abs(spotifyArtists.Count - allSongArtists.Count);
-        if (countDiff > 1) // Allow 1 artist difference (sometimes features are listed differently)
-            return 0;
-        
-        // Check that each Spotify artist has a good match in song artists
-        var spotifyScores = new List<double>();
-        foreach (var spotifyArtist in spotifyArtists)
-        {
-            var bestMatch = allSongArtists.Max(songArtist => 
-                FuzzyMatcher.CalculateSimilarity(spotifyArtist, songArtist));
-            spotifyScores.Add(bestMatch);
-        }
-        
-        // Check that each song artist has a good match in Spotify artists
-        var songScores = new List<double>();
-        foreach (var songArtist in allSongArtists)
-        {
-            var bestMatch = spotifyArtists.Max(spotifyArtist => 
-                FuzzyMatcher.CalculateSimilarity(songArtist, spotifyArtist));
-            songScores.Add(bestMatch);
-        }
-        
-        // Average all scores - this ensures ALL artists must match well
-        var allScores = spotifyScores.Concat(songScores);
-        var avgScore = allScores.Average();
-        
-        // Penalize if any individual artist match is poor (< 70)
-        var minScore = allScores.Min();
-        if (minScore < 70)
-            avgScore *= 0.7; // 30% penalty for poor individual match
-        
-        return avgScore;
-||||||| f68706f
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to load missing tracks from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// Loads matched/combined tracks from file cache as fallback when Redis is empty.
-    /// </summary>
-    private async Task<List<Song>?> LoadMatchedTracksFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_matched.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogDebug("No matched tracks file cache found for {Playlist} at {Path}", playlistName, filePath);
-                return null;
-            }
-            
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            
-            // Check if cache is too old (more than 24 hours)
-            if (fileAge.TotalHours > 24)
-            {
-                _logger.LogInformation("Matched tracks file cache for {Playlist} is too old ({Age:F1}h), will rebuild", 
-                    playlistName, fileAge.TotalHours);
-                return null;
-            }
-            
-            _logger.LogDebug("Matched tracks file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var tracks = JsonSerializer.Deserialize<List<Song>>(json);
-            
-            _logger.LogInformation("Loaded {Count} matched tracks from file cache for {Playlist} (age: {Age:F1}h)", 
-                tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return tracks;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to load matched tracks from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// Saves matched/combined tracks to file cache for persistence across restarts.
-    /// </summary>
-    private async Task SaveMatchedTracksToFile(string playlistName, List<Song> tracks)
-    {
-        try
-        {
-            var cacheDir = "/app/cache/spotify";
-            Directory.CreateDirectory(cacheDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(cacheDir, $"{safeName}_matched.json");
-            
-            var json = JsonSerializer.Serialize(tracks, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, json);
-            
-            _logger.LogInformation("Saved {Count} matched tracks to file cache for {Playlist}", 
-                tracks.Count, playlistName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save matched tracks to file for {Playlist}", playlistName);
-        }
-    }
-
-    /// <summary>
-    /// Saves playlist items (raw Jellyfin JSON) to file cache for persistence across restarts.
-    /// </summary>
-    private async Task SavePlaylistItemsToFile(string playlistName, List<Dictionary<string, object?>> items)
-    {
-        try
-        {
-            var cacheDir = "/app/cache/spotify";
-            Directory.CreateDirectory(cacheDir);
-            
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine(cacheDir, $"{safeName}_items.json");
-            
-            var json = JsonSerializer.Serialize(items, new JsonSerializerOptions { WriteIndented = true });
-            await System.IO.File.WriteAllTextAsync(filePath, json);
-            
-            _logger.LogInformation("💾 Saved {Count} playlist items to file cache for {Playlist}", 
-                items.Count, playlistName);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to save playlist items to file for {Playlist}", playlistName);
-        }
-    }
-
-    /// <summary>
-    /// Loads playlist items (raw Jellyfin JSON) from file cache.
-    /// </summary>
-    private async Task<List<Dictionary<string, object?>>?> LoadPlaylistItemsFromFile(string playlistName)
-    {
-        try
-        {
-            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
-            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_items.json");
-            
-            if (!System.IO.File.Exists(filePath))
-            {
-                _logger.LogDebug("No playlist items file cache found for {Playlist} at {Path}", playlistName, filePath);
-                return null;
-            }
-            
-            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
-            
-            // Check if cache is too old (more than 24 hours)
-            if (fileAge.TotalHours > 24)
-            {
-                _logger.LogInformation("Playlist items file cache for {Playlist} is too old ({Age:F1}h), will rebuild", 
-                    playlistName, fileAge.TotalHours);
-                return null;
-            }
-            
-            _logger.LogDebug("Playlist items file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours);
-            
-            var json = await System.IO.File.ReadAllTextAsync(filePath);
-            var items = JsonSerializer.Deserialize<List<Dictionary<string, object?>>>(json);
-            
-            _logger.LogInformation("💿 Loaded {Count} playlist items from file cache for {Playlist} (age: {Age:F1}h)", 
-                items?.Count ?? 0, playlistName, fileAge.TotalHours);
-            
-            return items;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to load playlist items from file for {Playlist}", playlistName);
-            return null;
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Calculates artist match score ensuring ALL artists are present.
-    /// Penalizes if artist counts don't match or if any artist is missing.
-    /// </summary>
-    private static double CalculateArtistMatchScore(List<string> spotifyArtists, string songMainArtist, List<string> songContributors)
-    {
-        if (spotifyArtists.Count == 0 || string.IsNullOrEmpty(songMainArtist))
-            return 0;
-        
-        // Build list of all song artists (main + contributors)
-        var allSongArtists = new List<string> { songMainArtist };
-        allSongArtists.AddRange(songContributors);
-        
-        // If artist counts differ significantly, penalize
-        var countDiff = Math.Abs(spotifyArtists.Count - allSongArtists.Count);
-        if (countDiff > 1) // Allow 1 artist difference (sometimes features are listed differently)
-            return 0;
-        
-        // Check that each Spotify artist has a good match in song artists
-        var spotifyScores = new List<double>();
-        foreach (var spotifyArtist in spotifyArtists)
-        {
-            var bestMatch = allSongArtists.Max(songArtist => 
-                FuzzyMatcher.CalculateSimilarity(spotifyArtist, songArtist));
-            spotifyScores.Add(bestMatch);
-        }
-        
-        // Check that each song artist has a good match in Spotify artists
-        var songScores = new List<double>();
-        foreach (var songArtist in allSongArtists)
-        {
-            var bestMatch = spotifyArtists.Max(spotifyArtist => 
-                FuzzyMatcher.CalculateSimilarity(songArtist, spotifyArtist));
-            songScores.Add(bestMatch);
-        }
-        
-        // Average all scores - this ensures ALL artists must match well
-        var allScores = spotifyScores.Concat(songScores);
-        var avgScore = allScores.Average();
-        
-        // Penalize if any individual artist match is poor (< 70)
-        var minScore = allScores.Min();
-        if (minScore < 70)
-            avgScore *= 0.7; // 30% penalty for poor individual match
-        
-        return avgScore;
-=======
->>>>>>> beta
    }

    /// <summary>
@@ -141,13 +141,7 @@ public class WebSocketProxyMiddleware
            }

            // Set user agent
-<<<<<<< HEAD
-            serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0.1");
-||||||| f68706f
-            serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0");
-=======
            serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0.3");
->>>>>>> beta

            await serverWebSocket.ConnectAsync(new Uri(jellyfinWsUrl), context.RequestAborted);
            _logger.LogInformation("✓ WEBSOCKET: Connected to Jellyfin WebSocket");
@@ -43,13 +43,7 @@ public class JellyfinSettings
    /// <summary>
    /// Client version reported to Jellyfin
    /// </summary>
-<<<<<<< HEAD
-    public string ClientVersion { get; set; } = "1.0.1";
-||||||| f68706f
-    public string ClientVersion { get; set; } = "1.0.0";
-=======
    public string ClientVersion { get; set; } = AppVersion.Version;
->>>>>>> beta
    
    /// <summary>
    /// Device ID reported to Jellyfin
@@ -45,17 +45,6 @@ public class SpotifyPlaylistConfig
    /// Where to position local tracks: "first" or "last"
    /// </summary>
    public LocalTracksPosition LocalTracksPosition { get; set; } = LocalTracksPosition.First;
-<<<<<<< HEAD
-    
-    /// <summary>
-    /// Cron schedule for syncing this playlist with Spotify
-    /// Format: minute hour day month dayofweek
-    /// Example: "0 8 * * 1" = 8 AM every Monday
-    /// Default: "0 8 * * 1" (weekly on Monday at 8 AM)
-    /// </summary>
-    public string SyncSchedule { get; set; } = "0 8 * * 1";
-||||||| f68706f
-=======
    
    /// <summary>
    /// Cron schedule for syncing this playlist with Spotify
@@ -64,7 +53,6 @@ public class SpotifyPlaylistConfig
    /// Default: "0 8 * * *" (daily at 8 AM)
    /// </summary>
    public string SyncSchedule { get; set; } = "0 8 * * *";
->>>>>>> beta
 }

 /// <summary>
@@ -584,15 +584,6 @@ builder.Services.AddSingleton<allstarr.Services.Spotify.SpotifyApiClient>();
 // Register Spotify lyrics service (uses Spotify's color-lyrics API)
 builder.Services.AddSingleton<allstarr.Services.Lyrics.SpotifyLyricsService>();

-<<<<<<< HEAD
-// Register LyricsPlus service (multi-source lyrics API)
-builder.Services.AddSingleton<allstarr.Services.Lyrics.LyricsPlusService>();
-
-// Register Lyrics Orchestrator (manages priority-based lyrics fetching)
-builder.Services.AddSingleton<allstarr.Services.Lyrics.LyricsOrchestrator>();
-
-||||||| f68706f
-=======
 // Register LyricsPlus service (multi-source lyrics API)
 builder.Services.AddSingleton<allstarr.Services.Lyrics.LyricsPlusService>();

@@ -608,7 +599,6 @@ builder.Services.AddSingleton<allstarr.Services.Spotify.SpotifyMappingValidation
 // Register Spotify mapping migration service (migrates legacy per-playlist mappings to global format)
 builder.Services.AddHostedService<allstarr.Services.Spotify.SpotifyMappingMigrationService>();

->>>>>>> beta
 // Register Spotify playlist fetcher (uses direct Spotify API when SpotifyApi is enabled)
 builder.Services.AddSingleton<allstarr.Services.Spotify.SpotifyPlaylistFetcher>();
 builder.Services.AddHostedService(sp => sp.GetRequiredService<allstarr.Services.Spotify.SpotifyPlaylistFetcher>());
@@ -746,14 +736,6 @@ catch (Exception ex)
 }

 // Configure the HTTP request pipeline.
-<<<<<<< HEAD
-
-// IMPORTANT: UseForwardedHeaders must be called BEFORE other middleware
-// This processes X-Forwarded-For, X-Real-IP, etc. from nginx
-app.UseForwardedHeaders();
-
-||||||| f68706f
-=======

 // IMPORTANT: UseForwardedHeaders must be called BEFORE other middleware
 // This processes X-Forwarded-For, X-Real-IP, etc. from nginx
@@ -762,7 +744,6 @@ app.UseForwardedHeaders();
 // Request logging middleware (when DEBUG_LOG_ALL_REQUESTS=true)
 app.UseMiddleware<RequestLoggingMiddleware>();

->>>>>>> beta
 app.UseExceptionHandler(_ => { }); // Global exception handler

 // Enable response compression EARLY in the pipeline
@@ -101,31 +101,12 @@ public abstract class BaseDownloadService : IDownloadService
    
    public async Task<Stream> DownloadAndStreamAsync(string externalProvider, string externalId, CancellationToken cancellationToken = default)
        {
-<<<<<<< HEAD
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
-            Logger.LogInformation("Streaming from local cache ({ElapsedMs}ms): {Path}", elapsed, localPath);
-            
-            // Update write time for cache cleanup (extends cache lifetime)
-            if (SubsonicSettings.StorageMode == StorageMode.Cache)
-||||||| f68706f
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
-            Logger.LogInformation("Streaming from local cache ({ElapsedMs}ms): {Path}", elapsed, localPath);
-            
-            // Update access time for cache cleanup
-            if (SubsonicSettings.StorageMode == StorageMode.Cache)
-=======
            var startTime = DateTime.UtcNow;

            // Check if already downloaded locally
            var localPath = await LocalLibraryService.GetLocalPathForExternalSongAsync(externalProvider, externalId);
            if (localPath != null && IOFile.Exists(localPath))
->>>>>>> beta
            {
-<<<<<<< HEAD
-                IOFile.SetLastWriteTime(localPath, DateTime.UtcNow);
-||||||| f68706f
-                IOFile.SetLastAccessTime(localPath, DateTime.UtcNow);
-=======
                var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
                Logger.LogInformation("Streaming from local cache ({ElapsedMs}ms): {Path}", elapsed, localPath);

@@ -173,7 +154,6 @@ public abstract class BaseDownloadService : IDownloadService
                var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
                Logger.LogError(ex, "Download failed after {ElapsedMs}ms for {Provider}:{ExternalId}", elapsed, externalProvider, externalId);
                throw;
->>>>>>> beta
            }
        }

@@ -161,16 +161,8 @@ public class CacheWarmingService : IHostedService
                    var fileName = Path.GetFileNameWithoutExtension(file);
                    var playlistName = fileName.Replace("_items", "");

-<<<<<<< HEAD
-                    var redisKey = $"spotify:playlist:items:{playlistName}";
-                    await _cache.SetAsync(redisKey, items, CacheExtensions.SpotifyPlaylistItemsTTL);
-||||||| f68706f
-                    var redisKey = $"spotify:playlist:items:{playlistName}";
-                    await _cache.SetAsync(redisKey, items, TimeSpan.FromHours(24));
-=======
                    var redisKey = CacheKeyBuilder.BuildSpotifyPlaylistItemsKey(playlistName);
                    await _cache.SetAsync(redisKey, items, CacheExtensions.SpotifyPlaylistItemsTTL);
->>>>>>> beta
                    warmedCount++;

                    _logger.LogDebug("🔥 Warmed playlist items cache for {Playlist} ({Count} items)", 
@@ -207,16 +199,8 @@ public class CacheWarmingService : IHostedService
                    var fileName = Path.GetFileNameWithoutExtension(file);
                    var playlistName = fileName.Replace("_matched", "");

-<<<<<<< HEAD
-                    var redisKey = $"spotify:matched:ordered:{playlistName}";
-                    await _cache.SetAsync(redisKey, matchedTracks, CacheExtensions.SpotifyMatchedTracksTTL);
-||||||| f68706f
-                    var redisKey = $"spotify:matched:ordered:{playlistName}";
-                    await _cache.SetAsync(redisKey, matchedTracks, TimeSpan.FromHours(1));
-=======
                    var redisKey = CacheKeyBuilder.BuildSpotifyMatchedTracksKey(playlistName);
                    await _cache.SetAsync(redisKey, matchedTracks, CacheExtensions.SpotifyMatchedTracksTTL);
->>>>>>> beta
                    warmedCount++;

                    _logger.LogInformation("🔥 Warmed matched tracks cache for {Playlist} ({Count} tracks)", 
@@ -1,86 +1,3 @@
-<<<<<<< HEAD
-namespace allstarr.Services.Common;
-
-/// <summary>
-/// Service that runs on startup to migrate old .env file format to new format
-/// </summary>
-public class EnvMigrationService
-{
-    private readonly ILogger<EnvMigrationService> _logger;
-    private readonly string _envFilePath;
-
-    public EnvMigrationService(ILogger<EnvMigrationService> logger)
-    {
-        _logger = logger;
-        _envFilePath = Path.Combine(Directory.GetCurrentDirectory(), ".env");
-    }
-
-    public void MigrateEnvFile()
-    {
-        if (!File.Exists(_envFilePath))
-        {
-            _logger.LogWarning("No .env file found, skipping migration");
-            return;
-        }
-
-        try
-        {
-            var lines = File.ReadAllLines(_envFilePath);
-            var modified = false;
-
-            for (int i = 0; i < lines.Length; i++)
-            {
-                var line = lines[i].Trim();
-                
-                // Skip comments and empty lines
-                if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
-                    continue;
-
-                // Migrate DOWNLOAD_PATH to Library__DownloadPath
-                if (line.StartsWith("DOWNLOAD_PATH="))
-                {
-                    var value = line.Substring("DOWNLOAD_PATH=".Length);
-                    lines[i] = $"Library__DownloadPath={value}";
-                    modified = true;
-                    _logger.LogDebug("Migrated DOWNLOAD_PATH to Library__DownloadPath in .env file");
-                }
-                
-                // Migrate old SquidWTF quality values to new format
-                if (line.StartsWith("SQUIDWTF_QUALITY="))
-                {
-                    var value = line.Substring("SQUIDWTF_QUALITY=".Length).Trim();
-                    var newValue = value.ToUpperInvariant() switch
-                    {
-                        "FLAC" => "LOSSLESS",
-                        "HI_RES" => "HI_RES_LOSSLESS",
-                        "MP3_320" => "HIGH",
-                        "MP3_128" => "LOW",
-                        _ => null // Keep as-is if already correct
-                    };
-                    
-                    if (newValue != null)
-                    {
-                        lines[i] = $"SQUIDWTF_QUALITY={newValue}";
-                        modified = true;
-                        _logger.LogInformation("Migrated SQUIDWTF_QUALITY from {Old} to {New} in .env file", value, newValue);
-                    }
-                }
-            }
-
-            if (modified)
-            {
-                File.WriteAllLines(_envFilePath, lines);
-                _logger.LogInformation("✅ .env file migration completed successfully");
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to migrate .env file - please manually update DOWNLOAD_PATH to Library__DownloadPath");
-        }
-    }
-}
-||||||| f68706f
-=======
 namespace allstarr.Services.Common;

 /// <summary>
@@ -194,4 +111,3 @@ public class EnvMigrationService
        }
    }
 }
->>>>>>> beta
@@ -41,14 +41,6 @@ public static class PathHelper
        var albumFolder = Path.Combine(artistFolder, safeAlbum);
        
        var trackPrefix = trackNumber.HasValue ? $"{trackNumber:D2} - " : "";
-<<<<<<< HEAD
-        var idSuffix = !string.IsNullOrEmpty(provider) && !string.IsNullOrEmpty(externalId) 
-            ? $" [{provider}-{externalId}]" 
-            : "";
-        var fileName = $"{trackPrefix}{safeTitle}{idSuffix}{extension}";
-||||||| f68706f
-        var fileName = $"{trackPrefix}{safeTitle}{extension}";
-=======
        // Sanitize provider and external id to avoid path traversal or invalid filename segments
        string? safeProvider = null;
        string? safeExternalId = null;
@@ -67,7 +59,6 @@ public static class PathHelper
            ? $" [{safeProvider}-{safeExternalId}]"
            : "";
        var fileName = $"{trackPrefix}{safeTitle}{idSuffix}{extension}";
->>>>>>> beta
        
        return Path.Combine(albumFolder, fileName);
    }
@@ -104,14 +104,8 @@ public class RoundRobinFallbackHelper
        }
        catch (Exception ex)
        {
-<<<<<<< HEAD
-            _logger.LogError(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl);
-||||||| f68706f
-            _logger.LogDebug(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl);
-=======
            // Unexpected errors - still log at debug level for health checks
            _logger.LogDebug(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl);
->>>>>>> beta
            
            // Cache as unhealthy
            lock (_healthCacheLock)
@@ -244,66 +238,8 @@ public class RoundRobinFallbackHelper
        {
            if (_apiUrls.Count == 1 || topN <= 1)
            {
-<<<<<<< HEAD
-                try
-                {
-                    _logger.LogDebug("Racing {Service} endpoint {Endpoint}", _serviceName, baseUrl);
-                    var result = await action(baseUrl, raceCts.Token);
-                    return (result, baseUrl, true);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "{Service} race failed for endpoint {Endpoint}", _serviceName, baseUrl);
-                    return (default(T)!, baseUrl, false);
-                }
-            }, raceCts.Token);
-            
-            tasks.Add(task);
-        }
-
-        // Wait for first successful completion
-        while (tasks.Count > 0)
-        {
-            var completedTask = await Task.WhenAny(tasks);
-            var (result, endpoint, success) = await completedTask;
-            
-            if (success)
-            {
-                _logger.LogDebug("🏁 {Service} race won by {Endpoint}, canceling others", _serviceName, endpoint);
-                raceCts.Cancel(); // Cancel all other requests
-                return result;
-||||||| f68706f
-                try
-                {
-                    _logger.LogDebug("Racing {Service} endpoint {Endpoint}", _serviceName, baseUrl);
-                    var result = await action(baseUrl, raceCts.Token);
-                    return (result, baseUrl, true);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogDebug(ex, "{Service} race failed for endpoint {Endpoint}", _serviceName, baseUrl);
-                    return (default(T)!, baseUrl, false);
-                }
-            }, raceCts.Token);
-            
-            tasks.Add(task);
-        }
-
-        // Wait for first successful completion
-        while (tasks.Count > 0)
-        {
-            var completedTask = await Task.WhenAny(tasks);
-            var (result, endpoint, success) = await completedTask;
-            
-            if (success)
-            {
-                _logger.LogInformation("🏁 {Service} race won by {Endpoint}, canceling others", _serviceName, endpoint);
-                raceCts.Cancel(); // Cancel all other requests
-                return result;
-=======
                // No point racing with one endpoint - use fallback instead
                return await TryWithFallbackAsync(baseUrl => action(baseUrl, cancellationToken));
->>>>>>> beta
            }

            // Get top N fastest healthy endpoints
@@ -180,95 +180,7 @@ public class JellyfinProxyService
            
            if (authHeaderAdded)
            {
-<<<<<<< HEAD
-                foreach (var header in clientHeaders)
-                {
-                    if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var headerValue = header.Value.ToString();
-                        request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                        authHeaderAdded = true;
-                        _logger.LogTrace("Forwarded X-Emby-Token header");
-                        break;
-                    }
-                }
-            }
-            
-            // If no X-Emby-Authorization, check if Authorization header contains MediaBrowser format
-            // Some clients send it as "Authorization" instead of "X-Emby-Authorization"
-            if (!authHeaderAdded)
-            {
-                foreach (var header in clientHeaders)
-                {
-                    if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var headerValue = header.Value.ToString();
-                        
-                        // Check if it's MediaBrowser/Jellyfin format (contains "MediaBrowser" or "Token=")
-                        if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
-                            headerValue.Contains("Token=", StringComparison.OrdinalIgnoreCase))
-                        {
-                            // Forward as X-Emby-Authorization (Jellyfin's expected header)
-                            request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
-                            authHeaderAdded = true;
-                            _logger.LogDebug("Converted Authorization to X-Emby-Authorization");
-                        }
-                        else
-                        {
-                            // Standard Bearer token - forward as-is
-                            request.Headers.TryAddWithoutValidation("Authorization", headerValue);
-                            authHeaderAdded = true;
-                            _logger.LogTrace("Forwarded Authorization header");
-                        }
-                        break;
-                    }
-                }
-||||||| f68706f
-                foreach (var header in clientHeaders)
-                {
-                    if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var headerValue = header.Value.ToString();
-                        request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                        authHeaderAdded = true;
-                        _logger.LogTrace("Forwarded X-Emby-Token header");
-                        break;
-                    }
-                }
-            }
-            
-            // If no X-Emby-Authorization, check if Authorization header contains MediaBrowser format
-            // Some clients send it as "Authorization" instead of "X-Emby-Authorization"
-            if (!authHeaderAdded)
-            {
-                foreach (var header in clientHeaders)
-                {
-                    if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var headerValue = header.Value.ToString();
-                        
-                        // Check if it's MediaBrowser/Jellyfin format (contains "MediaBrowser" or "Token=")
-                        if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
-                            headerValue.Contains("Token=", StringComparison.OrdinalIgnoreCase))
-                        {
-                            // Forward as X-Emby-Authorization (Jellyfin's expected header)
-                            request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
-                            authHeaderAdded = true;
-                            _logger.LogTrace("Converted Authorization to X-Emby-Authorization");
-                        }
-                        else
-                        {
-                            // Standard Bearer token - forward as-is
-                            request.Headers.TryAddWithoutValidation("Authorization", headerValue);
-                            authHeaderAdded = true;
-                            _logger.LogTrace("Forwarded Authorization header");
-                        }
-                        break;
-                    }
-                }
-=======
                _logger.LogTrace("Forwarded authentication headers");
->>>>>>> beta
            }
            
            // Check for api_key query parameter (some clients use this)
@@ -369,91 +281,7 @@ public class JellyfinProxyService
        
        if (authHeaderAdded)
        {
-<<<<<<< HEAD
-            foreach (var header in clientHeaders)
-            {
-                if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                {
-                    var headerValue = header.Value.ToString();
-                    request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                    authHeaderAdded = true;
-                    _logger.LogTrace("Forwarded X-Emby-Token header");
-                    break;
-                }
-            }
-        }
-        
-        // Try Authorization header
-        if (!authHeaderAdded)
-        {
-            foreach (var header in clientHeaders)
-            {
-                if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
-                {
-                    var headerValue = header.Value.ToString();
-                    
-                    // Check if it's MediaBrowser/Jellyfin format
-                    if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
-                        headerValue.Contains("Client=", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // Forward as X-Emby-Authorization
-                        request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
-                        _logger.LogDebug("Converted Authorization to X-Emby-Authorization");
-                    }
-                    else
-                    {
-                        // Standard Bearer token
-                        request.Headers.TryAddWithoutValidation("Authorization", headerValue);
-                        _logger.LogTrace("Forwarded Authorization header");
-                    }
-                    authHeaderAdded = true;
-                    break;
-                }
-            }
-||||||| f68706f
-            foreach (var header in clientHeaders)
-            {
-                if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                {
-                    var headerValue = header.Value.ToString();
-                    request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                    authHeaderAdded = true;
-                    _logger.LogTrace("Forwarded X-Emby-Token header");
-                    break;
-                }
-            }
-        }
-        
-        // Try Authorization header
-        if (!authHeaderAdded)
-        {
-            foreach (var header in clientHeaders)
-            {
-                if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
-                {
-                    var headerValue = header.Value.ToString();
-                    
-                    // Check if it's MediaBrowser/Jellyfin format
-                    if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
-                        headerValue.Contains("Client=", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // Forward as X-Emby-Authorization
-                        request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
-                        _logger.LogTrace("Converted Authorization to X-Emby-Authorization");
-                    }
-                    else
-                    {
-                        // Standard Bearer token
-                        request.Headers.TryAddWithoutValidation("Authorization", headerValue);
-                        _logger.LogTrace("Forwarded Authorization header");
-                    }
-                    authHeaderAdded = true;
-                    break;
-                }
-            }
-=======
            _logger.LogTrace("Forwarded authentication headers");
->>>>>>> beta
        }
        
        // For authentication endpoints, credentials are in the body, not headers
@@ -613,13 +441,7 @@ public class JellyfinProxyService
        }
        else
        {
-<<<<<<< HEAD
-            _logger.LogDebug("No client auth provided for DELETE {Url} - forwarding without auth", url);
-||||||| f68706f
-            _logger.LogInformation("No client auth provided for DELETE {Url} - forwarding without auth", url);
-=======
            _logger.LogTrace("Forwarded authentication headers");
->>>>>>> beta
        }
        
        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
@@ -675,14 +497,8 @@ public class JellyfinProxyService
        }
        catch (Exception ex)
        {
-<<<<<<< HEAD
-            _logger.LogError(ex, "Failed to get bytes from {Endpoint}", endpoint);
-||||||| f68706f
-            _logger.LogWarning(ex, "Failed to get bytes from {Endpoint}", endpoint);
-=======
            // Actual errors should still be logged
            _logger.LogError(ex, "Failed to get bytes from {Endpoint}", endpoint);
->>>>>>> beta
            return (null, null, false);
        }
    }
@@ -711,24 +527,8 @@ public class JellyfinProxyService
            queryParams["userId"] = _settings.UserId;
        }

-<<<<<<< HEAD
-        // Only filter search to music library if explicitly configured
-        if (!string.IsNullOrEmpty(_settings.LibraryId))
-        {
-            queryParams["parentId"] = _settings.LibraryId;
-            _logger.LogInformation("Searching within configured LibraryId {LibraryId}", _settings.LibraryId);
-        }
-||||||| f68706f
-        // Only filter search to music library if explicitly configured
-        if (!string.IsNullOrEmpty(_settings.LibraryId))
-        {
-            queryParams["parentId"] = _settings.LibraryId;
-            _logger.LogDebug("Searching within configured LibraryId {LibraryId}", _settings.LibraryId);
-        }
-=======
        // Note: We don't force parentId here - let clients specify which library to search
        // The controller will detect music library searches and add external results
->>>>>>> beta

        if (includeItemTypes != null && includeItemTypes.Length > 0)
        {
@@ -18,13 +18,7 @@ public class LrclibService
        ILogger<LrclibService> logger)
    {
        _httpClient = httpClientFactory.CreateClient();
-<<<<<<< HEAD
-        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)");
-||||||| f68706f
-        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.0 (https://github.com/SoPat712/allstarr)");
-=======
        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.3 (https://github.com/SoPat712/allstarr)");
->>>>>>> beta
        _cache = cache;
        _logger = logger;
    }
@@ -1,234 +1,3 @@
-<<<<<<< HEAD
-using allstarr.Models.Lyrics;
-using allstarr.Models.Settings;
-using Microsoft.Extensions.Options;
-
-namespace allstarr.Services.Lyrics;
-
-/// <summary>
-/// Orchestrates lyrics fetching from multiple sources with priority-based fallback.
-/// Priority order: Spotify → LyricsPlus → LRCLib
-/// Note: Jellyfin local lyrics are handled by the controller before calling this orchestrator.
-/// </summary>
-public class LyricsOrchestrator
-{
-    private readonly SpotifyLyricsService _spotifyLyrics;
-    private readonly LyricsPlusService _lyricsPlus;
-    private readonly LrclibService _lrclib;
-    private readonly SpotifyApiSettings _spotifySettings;
-    private readonly ILogger<LyricsOrchestrator> _logger;
-
-    public LyricsOrchestrator(
-        SpotifyLyricsService spotifyLyrics,
-        LyricsPlusService lyricsPlus,
-        LrclibService lrclib,
-        IOptions<SpotifyApiSettings> spotifySettings,
-        ILogger<LyricsOrchestrator> logger)
-    {
-        _spotifyLyrics = spotifyLyrics;
-        _lyricsPlus = lyricsPlus;
-        _lrclib = lrclib;
-        _spotifySettings = spotifySettings.Value;
-        _logger = logger;
-    }
-
-    /// <summary>
-    /// Fetches lyrics with automatic fallback through all available sources.
-    /// Note: Jellyfin local lyrics are handled by the controller before calling this.
-    /// </summary>
-    /// <param name="trackName">Track title</param>
-    /// <param name="artistNames">Artist names (can be multiple)</param>
-    /// <param name="albumName">Album name</param>
-    /// <param name="durationSeconds">Track duration in seconds</param>
-    /// <param name="spotifyTrackId">Spotify track ID (if available)</param>
-    /// <returns>Lyrics info or null if not found</returns>
-    public async Task<LyricsInfo?> GetLyricsAsync(
-        string trackName,
-        string[] artistNames,
-        string? albumName,
-        int durationSeconds,
-        string? spotifyTrackId = null)
-    {
-        var artistName = string.Join(", ", artistNames);
-        
-        _logger.LogInformation("🎵 Fetching lyrics for: {Artist} - {Track}", artistName, trackName);
-
-        // 1. Try Spotify lyrics (if Spotify ID provided)
-        if (!string.IsNullOrEmpty(spotifyTrackId))
-        {
-            var spotifyLyrics = await TrySpotifyLyrics(spotifyTrackId, artistName, trackName);
-            if (spotifyLyrics != null)
-            {
-                return spotifyLyrics;
-            }
-        }
-
-        // 2. Try LyricsPlus
-        var lyricsPlusLyrics = await TryLyricsPlusLyrics(trackName, artistNames, albumName, durationSeconds, artistName);
-        if (lyricsPlusLyrics != null)
-        {
-            return lyricsPlusLyrics;
-        }
-
-        // 3. Try LRCLib
-        var lrclibLyrics = await TryLrclibLyrics(trackName, artistNames, albumName, durationSeconds, artistName);
-        if (lrclibLyrics != null)
-        {
-            return lrclibLyrics;
-        }
-
-        _logger.LogInformation("❌ No lyrics found for: {Artist} - {Track}", artistName, trackName);
-        return null;
-    }
-
-    /// <summary>
-    /// Prefetches lyrics in the background (for cache warming).
-    /// Skips Jellyfin local since we don't have an itemId.
-    /// </summary>
-    public async Task<bool> PrefetchLyricsAsync(
-        string trackName,
-        string[] artistNames,
-        string? albumName,
-        int durationSeconds,
-        string? spotifyTrackId = null)
-    {
-        var artistName = string.Join(", ", artistNames);
-        
-        _logger.LogDebug("🎵 Prefetching lyrics for: {Artist} - {Track}", artistName, trackName);
-
-        // 1. Try Spotify lyrics (if Spotify ID provided)
-        if (!string.IsNullOrEmpty(spotifyTrackId))
-        {
-            var spotifyLyrics = await TrySpotifyLyrics(spotifyTrackId, artistName, trackName);
-            if (spotifyLyrics != null)
-            {
-                return true;
-            }
-        }
-
-        // 2. Try LyricsPlus
-        var lyricsPlusLyrics = await TryLyricsPlusLyrics(trackName, artistNames, albumName, durationSeconds, artistName);
-        if (lyricsPlusLyrics != null)
-        {
-            return true;
-        }
-
-        // 3. Try LRCLib
-        var lrclibLyrics = await TryLrclibLyrics(trackName, artistNames, albumName, durationSeconds, artistName);
-        if (lrclibLyrics != null)
-        {
-            return true;
-        }
-
-        _logger.LogDebug("No lyrics found for prefetch: {Artist} - {Track}", artistName, trackName);
-        return false;
-    }
-
-    #region Private Helper Methods
-
-    private async Task<LyricsInfo?> TrySpotifyLyrics(string spotifyTrackId, string artistName, string trackName)
-    {
-        if (!_spotifySettings.Enabled)
-        {
-            _logger.LogWarning("Spotify API not enabled, skipping Spotify lyrics");
-            return null;
-        }
-
-        try
-        {
-            // Validate Spotify ID format
-            var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim();
-            
-            if (cleanSpotifyId.Length != 22 || cleanSpotifyId.Contains(":") || cleanSpotifyId.Contains("local"))
-            {
-                _logger.LogWarning("Invalid Spotify ID format: {SpotifyId}, skipping", spotifyTrackId);
-                return null;
-            }
-
-            _logger.LogDebug("→ Trying Spotify lyrics for track ID: {SpotifyId}", cleanSpotifyId);
-            
-            var spotifyLyrics = await _spotifyLyrics.GetLyricsByTrackIdAsync(cleanSpotifyId);
-            
-            if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0)
-            {
-                _logger.LogDebug("✓ Found Spotify lyrics for {Artist} - {Track} ({LineCount} lines, type: {SyncType})", 
-                    artistName, trackName, spotifyLyrics.Lines.Count, spotifyLyrics.SyncType);
-                
-                return _spotifyLyrics.ToLyricsInfo(spotifyLyrics);
-            }
-            
-            _logger.LogDebug("No Spotify lyrics found for track ID {SpotifyId}", cleanSpotifyId);
-            return null;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching Spotify lyrics for track ID {SpotifyId}", spotifyTrackId);
-            return null;
-        }
-    }
-
-    private async Task<LyricsInfo?> TryLyricsPlusLyrics(
-        string trackName, 
-        string[] artistNames, 
-        string? albumName, 
-        int durationSeconds,
-        string artistName)
-    {
-        try
-        {
-            _logger.LogDebug("→ Trying LyricsPlus for: {Artist} - {Track}", artistName, trackName);
-            
-            var lyrics = await _lyricsPlus.GetLyricsAsync(trackName, artistNames, albumName, durationSeconds);
-            
-            if (lyrics != null)
-            {
-                _logger.LogInformation("✓ Found LyricsPlus lyrics for {Artist} - {Track}", artistName, trackName);
-                return lyrics;
-            }
-            
-            _logger.LogDebug("No LyricsPlus lyrics found for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching LyricsPlus lyrics for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-    }
-
-    private async Task<LyricsInfo?> TryLrclibLyrics(
-        string trackName, 
-        string[] artistNames, 
-        string? albumName, 
-        int durationSeconds,
-        string artistName)
-    {
-        try
-        {
-            _logger.LogDebug("→ Trying LRCLib for: {Artist} - {Track}", artistName, trackName);
-            
-            var lyrics = await _lrclib.GetLyricsAsync(trackName, artistNames, albumName ?? string.Empty, durationSeconds);
-            
-            if (lyrics != null)
-            {
-                _logger.LogInformation("✓ Found LRCLib lyrics for {Artist} - {Track}", artistName, trackName);
-                return lyrics;
-            }
-            
-            _logger.LogDebug("No LRCLib lyrics found for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching LRCLib lyrics for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-    }
-
-    #endregion
-}
-||||||| f68706f
-=======
 using allstarr.Models.Lyrics;
 using allstarr.Models.Settings;
 using Microsoft.Extensions.Options;
@@ -463,4 +232,3 @@ public class LyricsOrchestrator

    #endregion
 }
->>>>>>> beta
@@ -1,260 +1,3 @@
-<<<<<<< HEAD
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using allstarr.Models.Lyrics;
-using allstarr.Services.Common;
-
-namespace allstarr.Services.Lyrics;
-
-/// <summary>
-/// Service for fetching lyrics from LyricsPlus API (https://lyricsplus.prjktla.workers.dev)
-/// Supports multiple sources: Apple Music, Spotify, Musixmatch, and more
-/// </summary>
-public class LyricsPlusService
-{
-    private readonly HttpClient _httpClient;
-    private readonly RedisCacheService _cache;
-    private readonly ILogger<LyricsPlusService> _logger;
-    private const string BaseUrl = "https://lyricsplus.prjktla.workers.dev/v2/lyrics/get";
-
-    public LyricsPlusService(
-        IHttpClientFactory httpClientFactory,
-        RedisCacheService cache,
-        ILogger<LyricsPlusService> logger)
-    {
-        _httpClient = httpClientFactory.CreateClient();
-        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)");
-        _cache = cache;
-        _logger = logger;
-    }
-
-    public async Task<LyricsInfo?> GetLyricsAsync(string trackName, string artistName, string? albumName, int durationSeconds)
-    {
-        return await GetLyricsAsync(trackName, new[] { artistName }, albumName, durationSeconds);
-    }
-
-    public async Task<LyricsInfo?> GetLyricsAsync(string trackName, string[] artistNames, string? albumName, int durationSeconds)
-    {
-        // Validate input parameters
-        if (string.IsNullOrWhiteSpace(trackName) || artistNames == null || artistNames.Length == 0)
-        {
-            _logger.LogDebug("Invalid parameters for LyricsPlus search: trackName={TrackName}, artistCount={ArtistCount}", 
-                trackName, artistNames?.Length ?? 0);
-            return null;
-        }
-        
-        var artistName = string.Join(", ", artistNames);
-        var cacheKey = $"lyricsplus:{artistName}:{trackName}:{albumName}:{durationSeconds}";
-        
-        // Check cache
-        var cached = await _cache.GetStringAsync(cacheKey);
-        if (!string.IsNullOrEmpty(cached))
-        {
-            try
-            {
-                return JsonSerializer.Deserialize<LyricsInfo>(cached, JsonOptions);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Failed to deserialize cached LyricsPlus lyrics");
-            }
-        }
-
-        try
-        {
-            // Build URL with query parameters
-            var url = $"{BaseUrl}?title={Uri.EscapeDataString(trackName)}&artist={Uri.EscapeDataString(artistName)}";
-            
-            if (!string.IsNullOrEmpty(albumName))
-            {
-                url += $"&album={Uri.EscapeDataString(albumName)}";
-            }
-            
-            if (durationSeconds > 0)
-            {
-                url += $"&duration={durationSeconds}";
-            }
-            
-            // Add sources: apple, lyricsplus, musixmatch, spotify, musixmatch-word
-            url += "&source=apple,lyricsplus,musixmatch,spotify,musixmatch-word";
-
-            _logger.LogDebug("Fetching lyrics from LyricsPlus: {Url}", url);
-
-            var response = await _httpClient.GetAsync(url);
-            
-            if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
-            {
-                _logger.LogDebug("Lyrics not found on LyricsPlus for {Artist} - {Track}", artistName, trackName);
-                return null;
-            }
-
-            response.EnsureSuccessStatusCode();
-            
-            var json = await response.Content.ReadAsStringAsync();
-            var lyricsResponse = JsonSerializer.Deserialize<LyricsPlusResponse>(json, JsonOptions);
-
-            if (lyricsResponse == null || lyricsResponse.Lyrics == null || lyricsResponse.Lyrics.Count == 0)
-            {
-                _logger.LogDebug("Empty lyrics response from LyricsPlus for {Artist} - {Track}", artistName, trackName);
-                return null;
-            }
-
-            // Convert to LyricsInfo format
-            var result = ConvertToLyricsInfo(lyricsResponse, trackName, artistName, albumName, durationSeconds);
-            
-            if (result != null)
-            {
-                await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), CacheExtensions.LyricsTTL);
-                _logger.LogInformation("✓ Retrieved lyrics from LyricsPlus for {Artist} - {Track} (type: {Type}, source: {Source})", 
-                    artistName, trackName, lyricsResponse.Type, lyricsResponse.Metadata?.Source);
-            }
-            
-            return result;
-        }
-        catch (HttpRequestException ex)
-        {
-            _logger.LogError(ex, "Failed to fetch lyrics from LyricsPlus for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error fetching lyrics from LyricsPlus for {Artist} - {Track}", artistName, trackName);
-            return null;
-        }
-    }
-
-    private LyricsInfo? ConvertToLyricsInfo(LyricsPlusResponse response, string trackName, string artistName, string? albumName, int durationSeconds)
-    {
-        if (response.Lyrics == null || response.Lyrics.Count == 0)
-        {
-            return null;
-        }
-
-        string? syncedLyrics = null;
-        string? plainLyrics = null;
-
-        // Convert based on type
-        if (response.Type == "Word")
-        {
-            // Word-level timing - convert to line-level LRC
-            syncedLyrics = ConvertWordTimingToLrc(response.Lyrics);
-            plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text));
-        }
-        else if (response.Type == "Line")
-        {
-            // Line-level timing - convert to LRC
-            syncedLyrics = ConvertLineTimingToLrc(response.Lyrics);
-            plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text));
-        }
-        else
-        {
-            // Static or unknown type - just plain text
-            plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text));
-        }
-
-        return new LyricsInfo
-        {
-            TrackName = trackName,
-            ArtistName = artistName,
-            AlbumName = albumName ?? string.Empty,
-            Duration = durationSeconds,
-            Instrumental = false,
-            PlainLyrics = plainLyrics,
-            SyncedLyrics = syncedLyrics
-        };
-    }
-
-    private string ConvertLineTimingToLrc(List<LyricsPlusLine> lines)
-    {
-        var lrcLines = new List<string>();
-        
-        foreach (var line in lines)
-        {
-            if (line.Time.HasValue)
-            {
-                var timestamp = TimeSpan.FromMilliseconds(line.Time.Value);
-                var mm = (int)timestamp.TotalMinutes;
-                var ss = timestamp.Seconds;
-                var cs = timestamp.Milliseconds / 10; // Convert to centiseconds
-                
-                lrcLines.Add($"[{mm:D2}:{ss:D2}.{cs:D2}]{line.Text}");
-            }
-            else
-            {
-                // No timing, just add the text
-                lrcLines.Add(line.Text);
-            }
-        }
-        
-        return string.Join("\n", lrcLines);
-    }
-
-    private string ConvertWordTimingToLrc(List<LyricsPlusLine> lines)
-    {
-        // For word-level timing, we use the line start time
-        // (word-level detail is in syllabus array but we simplify to line-level for LRC)
-        return ConvertLineTimingToLrc(lines);
-    }
-
-    private static readonly JsonSerializerOptions JsonOptions = new()
-    {
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
-    };
-
-    private class LyricsPlusResponse
-    {
-        [JsonPropertyName("type")]
-        public string Type { get; set; } = string.Empty; // "Word", "Line", or "Static"
-        
-        [JsonPropertyName("metadata")]
-        public LyricsPlusMetadata? Metadata { get; set; }
-        
-        [JsonPropertyName("lyrics")]
-        public List<LyricsPlusLine> Lyrics { get; set; } = new();
-    }
-
-    private class LyricsPlusMetadata
-    {
-        [JsonPropertyName("source")]
-        public string? Source { get; set; }
-        
-        [JsonPropertyName("title")]
-        public string? Title { get; set; }
-        
-        [JsonPropertyName("language")]
-        public string? Language { get; set; }
-    }
-
-    private class LyricsPlusLine
-    {
-        [JsonPropertyName("time")]
-        public long? Time { get; set; } // Milliseconds
-        
-        [JsonPropertyName("duration")]
-        public long? Duration { get; set; }
-        
-        [JsonPropertyName("text")]
-        public string Text { get; set; } = string.Empty;
-        
-        [JsonPropertyName("syllabus")]
-        public List<LyricsPlusSyllable>? Syllabus { get; set; }
-    }
-
-    private class LyricsPlusSyllable
-    {
-        [JsonPropertyName("time")]
-        public long Time { get; set; }
-        
-        [JsonPropertyName("duration")]
-        public long Duration { get; set; }
-        
-        [JsonPropertyName("text")]
-        public string Text { get; set; } = string.Empty;
-    }
-}
-||||||| f68706f
-=======
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using allstarr.Models.Lyrics;
@@ -509,4 +252,3 @@ public class LyricsPlusService
        public string Text { get; set; } = string.Empty;
    }
 }
->>>>>>> beta
@@ -30,13 +30,7 @@ public class MusicBrainzService
        ILogger<MusicBrainzService> logger)
    {
        _httpClient = httpClientFactory.CreateClient();
-<<<<<<< HEAD
-        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)");
-||||||| f68706f
-        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.0 (https://github.com/SoPat712/allstarr)");
-=======
        _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.3 (https://github.com/SoPat712/allstarr)");
->>>>>>> beta
        _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        
        _settings = settings.Value;
@@ -180,56 +174,6 @@ public class MusicBrainzService
    }
    
    /// <summary>
-<<<<<<< HEAD
-    /// Looks up a recording by MBID to get full details including genres.
-    /// </summary>
-    public async Task<MusicBrainzRecording?> LookupByMbidAsync(string mbid)
-    {
-        if (!_settings.Enabled)
-        {
-            return null;
-        }
-
-        await RateLimitAsync();
-
-        try
-        {
-            var url = $"{_settings.BaseUrl}/recording/{mbid}?fmt=json&inc=artists+releases+release-groups+genres+tags";
-            _logger.LogDebug("MusicBrainz MBID lookup: {Url}", url);
-
-            var response = await _httpClient.GetAsync(url);
-            
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogWarning("MusicBrainz MBID lookup failed: {StatusCode}", response.StatusCode);
-                return null;
-            }
-
-            var json = await response.Content.ReadAsStringAsync();
-            var recording = JsonSerializer.Deserialize<MusicBrainzRecording>(json, JsonOptions);
-
-            if (recording == null)
-            {
-                _logger.LogDebug("No MusicBrainz recording found for MBID: {Mbid}", mbid);
-                return null;
-            }
-
-            var genres = recording.Genres?.Select(g => g.Name).Where(n => !string.IsNullOrEmpty(n)).ToList() ?? new List<string?>();
-            _logger.LogInformation("✓ Found MusicBrainz recording for MBID {Mbid}: {Title} by {Artist} (Genres: {Genres})",
-                mbid, recording.Title, recording.ArtistCredit?[0]?.Name ?? "Unknown", string.Join(", ", genres));
-
-            return recording;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error looking up MBID {Mbid} in MusicBrainz", mbid);
-            return null;
-        }
-    }
-    
-    /// <summary>
-||||||| f68706f
-=======
    /// Looks up a recording by MBID to get full details including genres.
    /// </summary>
    public async Task<MusicBrainzRecording?> LookupByMbidAsync(string mbid)
@@ -289,7 +233,6 @@ public class MusicBrainzService
    }
    
    /// <summary>
->>>>>>> beta
    /// Enriches a song with genre information from MusicBrainz.
    /// First tries ISRC lookup, then falls back to title/artist search + MBID lookup.
    /// </summary>
@@ -261,15 +261,8 @@ public class SpotifyPlaylistFetcher : BackgroundService
        
        foreach (var playlist in _spotifyImportSettings.Playlists)
        {
-<<<<<<< HEAD
-            var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * 1" : playlist.SyncSchedule;
-            _logger.LogInformation("  - {Name}: {Schedule}", playlist.Name, schedule);
-||||||| f68706f
-            _logger.LogInformation("  - {Name}", playlist.Name);
-=======
            var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * *" : playlist.SyncSchedule;
            _logger.LogInformation("  - {Name}: {Schedule}", playlist.Name, schedule);
->>>>>>> beta
        }
        
        _logger.LogInformation("========================================");
@@ -280,81 +273,6 @@ public class SpotifyPlaylistFetcher : BackgroundService
        {
            try
            {
-<<<<<<< HEAD
-                // Check each playlist to see if it needs refreshing based on cron schedule
-                var now = DateTime.UtcNow;
-                var needsRefresh = new List<string>();
-                
-                foreach (var config in _spotifyImportSettings.Playlists)
-                {
-                    var schedule = string.IsNullOrEmpty(config.SyncSchedule) ? "0 8 * * 1" : config.SyncSchedule;
-                    
-                    try
-                    {
-                        var cron = CronExpression.Parse(schedule);
-                        
-                        // Check if we have cached data
-                        var cacheKey = $"{CacheKeyPrefix}{config.Name}";
-                        var cached = await _cache.GetAsync<SpotifyPlaylist>(cacheKey);
-                        
-                        if (cached != null)
-                        {
-                            // Calculate when the next run should be after the last fetch
-                            var nextRun = cron.GetNextOccurrence(cached.FetchedAt, TimeZoneInfo.Utc);
-                            
-                            if (nextRun.HasValue && now >= nextRun.Value)
-                            {
-                                needsRefresh.Add(config.Name);
-                                _logger.LogInformation("Playlist '{Name}' needs refresh - last fetched {Age:F1}h ago, next run was {NextRun}", 
-                                    config.Name, (now - cached.FetchedAt).TotalHours, nextRun.Value);
-                            }
-                        }
-                        else
-                        {
-                            // No cache, fetch it
-                            needsRefresh.Add(config.Name);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Invalid cron schedule for playlist {Name}: {Schedule}", config.Name, schedule);
-                    }
-                }
-                
-                // Fetch playlists that need refreshing
-                if (needsRefresh.Count > 0)
-                {
-                    _logger.LogInformation("=== CRON TRIGGER: Fetching {Count} playlists ===", needsRefresh.Count);
-                    
-                    foreach (var playlistName in needsRefresh)
-                    {
-                        if (stoppingToken.IsCancellationRequested) break;
-                        
-                        try
-                        {
-                            await GetPlaylistTracksAsync(playlistName);
-                            
-                            // Rate limiting between playlists
-                            if (playlistName != needsRefresh.Last())
-                            {
-                                _logger.LogWarning("Finished fetching '{Name}' - waiting 3 seconds before next playlist to avoid rate limits...", playlistName);
-                                await Task.Delay(TimeSpan.FromSeconds(3), stoppingToken);
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.LogError(ex, "Error fetching playlist '{Name}'", playlistName);
-                        }
-                    }
-                    
-                    _logger.LogInformation("=== FINISHED FETCHING PLAYLISTS ===");
-                }
-                
-                // Sleep for 1 hour before checking again
-                await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
-||||||| f68706f
-                await FetchAllPlaylistsAsync(stoppingToken);
-=======
                // Check each playlist to see if it needs refreshing based on cron schedule
                var now = DateTime.UtcNow;
                var needsRefresh = new List<string>();
@@ -426,7 +344,6 @@ public class SpotifyPlaylistFetcher : BackgroundService
                
                // Sleep for 1 hour before checking again
                await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
->>>>>>> beta
            }
            catch (Exception ex)
            {
@@ -112,85 +112,6 @@ public class SpotifyTrackMatchingService : BackgroundService
        {
            try
            {
-<<<<<<< HEAD
-                // Calculate next run time for each playlist
-                var now = DateTime.UtcNow;
-                var nextRuns = new List<(string PlaylistName, DateTime NextRun, CronExpression Cron)>();
-                
-                foreach (var playlist in _spotifySettings.Playlists)
-                {
-                    var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * 1" : playlist.SyncSchedule;
-                    
-                    try
-                    {
-                        var cron = CronExpression.Parse(schedule);
-                        var nextRun = cron.GetNextOccurrence(now, TimeZoneInfo.Utc);
-                        
-                        if (nextRun.HasValue)
-                        {
-                            nextRuns.Add((playlist.Name, nextRun.Value, cron));
-                        }
-                        else
-                        {
-                            _logger.LogWarning("Could not calculate next run for playlist {Name} with schedule {Schedule}", 
-                                playlist.Name, schedule);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Invalid cron schedule for playlist {Name}: {Schedule}", 
-                            playlist.Name, schedule);
-                    }
-                }
-                
-                if (nextRuns.Count == 0)
-                {
-                    _logger.LogWarning("No valid cron schedules found, sleeping for 1 hour");
-                    await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
-                    continue;
-                }
-                
-                // Find the next playlist that needs to run
-                var nextPlaylist = nextRuns.OrderBy(x => x.NextRun).First();
-                var waitTime = nextPlaylist.NextRun - now;
-                
-                if (waitTime.TotalSeconds > 0)
-                {
-                    _logger.LogInformation("Next scheduled run: {Playlist} at {Time} UTC (in {Minutes:F1} minutes)", 
-                        nextPlaylist.PlaylistName, nextPlaylist.NextRun, waitTime.TotalMinutes);
-                    
-                    // Wait until next run (or max 1 hour to re-check schedules)
-                    var maxWait = TimeSpan.FromHours(1);
-                    var actualWait = waitTime > maxWait ? maxWait : waitTime;
-                    await Task.Delay(actualWait, stoppingToken);
-                    continue;
-                }
-                
-                // Time to run this playlist
-                _logger.LogInformation("=== CRON TRIGGER: Running scheduled match for {Playlist} ===", nextPlaylist.PlaylistName);
-                
-                // Check cooldown to prevent duplicate runs
-                if (_lastRunTimes.TryGetValue(nextPlaylist.PlaylistName, out var lastRun))
-                {
-                    var timeSinceLastRun = now - lastRun;
-                    if (timeSinceLastRun < _minimumRunInterval)
-                    {
-                        _logger.LogWarning("Skipping {Playlist} - last run was {Seconds}s ago (cooldown: {Cooldown}s)", 
-                            nextPlaylist.PlaylistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds);
-                        await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
-                        continue;
-                    }
-                }
-                
-                // Run matching for this playlist
-                await MatchSinglePlaylistAsync(nextPlaylist.PlaylistName, stoppingToken);
-                _lastRunTimes[nextPlaylist.PlaylistName] = DateTime.UtcNow;
-                
-                _logger.LogInformation("=== FINISHED: {Playlist} - Next run at {NextRun} UTC ===", 
-                    nextPlaylist.PlaylistName, nextPlaylist.Cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc));
-||||||| f68706f
-                await MatchAllPlaylistsAsync(stoppingToken);
-=======
                // Calculate next run time for each playlist
                var now = DateTime.UtcNow;
                var nextRuns = new List<(string PlaylistName, DateTime NextRun, CronExpression Cron)>();
@@ -266,7 +187,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                
                _logger.LogInformation("=== FINISHED: {Playlist} - Next run at {NextRun} UTC ===", 
                    nextPlaylist.PlaylistName, nextPlaylist.Cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc));
->>>>>>> beta
            }
            catch (Exception ex)
            {
@@ -277,33 +197,16 @@ public class SpotifyTrackMatchingService : BackgroundService
    }
    
    /// <summary>
-<<<<<<< HEAD
-    /// Matches tracks for a single playlist (called by cron scheduler or manual trigger).
-||||||| f68706f
-    /// Public method to trigger matching for a specific playlist (called from controller).
-=======
    /// Rebuilds a single playlist from scratch (clears cache, fetches fresh data, re-matches).
    /// This is the unified method used by both cron scheduler and "Rebuild All Remote" button.
->>>>>>> beta
    /// </summary>
-<<<<<<< HEAD
-    private async Task MatchSinglePlaylistAsync(string playlistName, CancellationToken cancellationToken)
-||||||| f68706f
-    public async Task TriggerMatchingForPlaylistAsync(string playlistName)
-=======
    private async Task RebuildSinglePlaylistAsync(string playlistName, CancellationToken cancellationToken)
->>>>>>> beta
    {
        var playlist = _spotifySettings.Playlists
            .FirstOrDefault(p => p.Name.Equals(playlistName, StringComparison.OrdinalIgnoreCase));
        
        if (playlist == null)
        {
-<<<<<<< HEAD
-            _logger.LogInformation("Playlist {Playlist} not found in configuration", playlistName);
-||||||| f68706f
-            _logger.LogWarning("Playlist {Playlist} not found in configuration", playlistName);
-=======
            _logger.LogInformation("Playlist {Playlist} not found in configuration", playlistName);
            return;
        }
@@ -382,7 +285,6 @@ public class SpotifyTrackMatchingService : BackgroundService
        if (playlist == null)
        {
            _logger.LogInformation("Playlist {Playlist} not found in configuration", playlistName);
->>>>>>> beta
            return;
        }
        
@@ -418,42 +320,12 @@ public class SpotifyTrackMatchingService : BackgroundService
        }
    }

-<<<<<<< HEAD
-    /// <summary>
-    /// Public method to trigger matching manually for all playlists (called from controller).
-    /// This bypasses cron schedules and runs immediately.
-    /// </summary>
-    public async Task TriggerMatchingAsync()
-||||||| f68706f
-    private async Task MatchAllPlaylistsAsync(CancellationToken cancellationToken)
-=======
    /// <summary>
    /// Public method to trigger full rebuild for all playlists (called from "Rebuild All Remote" button).
    /// This clears caches, fetches fresh data, and re-matches everything - same as cron job.
    /// </summary>
    public async Task TriggerRebuildAllAsync()
->>>>>>> beta
    {
-<<<<<<< HEAD
-        _logger.LogInformation("Manual track matching triggered for all playlists (bypassing cron schedules)");
-        await MatchAllPlaylistsAsync(CancellationToken.None);
-    }
-    
-    /// <summary>
-    /// Public method to trigger matching for a specific playlist (called from controller).
-    /// This bypasses cron schedules and runs immediately.
-    /// </summary>
-    public async Task TriggerMatchingForPlaylistAsync(string playlistName)
-    {
-        _logger.LogInformation("Manual track matching triggered for playlist: {Playlist} (bypassing cron schedule)", playlistName);
-        
-        // Check cooldown to prevent abuse
-        if (_lastRunTimes.TryGetValue(playlistName, out var lastRun))
-||||||| f68706f
-        // Check if we've run too recently (cooldown period)
-        var timeSinceLastRun = DateTime.UtcNow - _lastMatchingRun;
-        if (timeSinceLastRun < _minimumMatchingInterval)
-=======
        _logger.LogInformation("Manual full rebuild triggered for all playlists (same as cron job)");
        await RebuildAllPlaylistsAsync(CancellationToken.None);
    }
@@ -468,21 +340,7 @@ public class SpotifyTrackMatchingService : BackgroundService
        
        // Check cooldown to prevent abuse
        if (_lastRunTimes.TryGetValue(playlistName, out var lastRun))
->>>>>>> beta
        {
-<<<<<<< HEAD
-            var timeSinceLastRun = DateTime.UtcNow - lastRun;
-            if (timeSinceLastRun < _minimumRunInterval)
-            {
-                _logger.LogWarning("Skipping manual refresh for {Playlist} - last run was {Seconds}s ago (cooldown: {Cooldown}s)", 
-                    playlistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds);
-                throw new InvalidOperationException($"Please wait {(int)(_minimumRunInterval - timeSinceLastRun).TotalSeconds} more seconds before refreshing again");
-            }
-||||||| f68706f
-            _logger.LogInformation("Skipping track matching - last run was {Seconds}s ago (minimum interval: {MinSeconds}s)", 
-                (int)timeSinceLastRun.TotalSeconds, (int)_minimumMatchingInterval.TotalSeconds);
-            return;
-=======
            var timeSinceLastRun = DateTime.UtcNow - lastRun;
            if (timeSinceLastRun < _minimumRunInterval)
            {
@@ -490,21 +348,8 @@ public class SpotifyTrackMatchingService : BackgroundService
                    playlistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds);
                throw new InvalidOperationException($"Please wait {(int)(_minimumRunInterval - timeSinceLastRun).TotalSeconds} more seconds before rebuilding again");
            }
->>>>>>> beta
        }
        
-<<<<<<< HEAD
-        await MatchSinglePlaylistAsync(playlistName, CancellationToken.None);
-        _lastRunTimes[playlistName] = DateTime.UtcNow;
-    }
-
-    private async Task MatchAllPlaylistsAsync(CancellationToken cancellationToken)
-    {
-        _logger.LogInformation("=== STARTING TRACK MATCHING FOR ALL PLAYLISTS ===");
-||||||| f68706f
-        _logger.LogInformation("=== STARTING TRACK MATCHING ===");
-        _lastMatchingRun = DateTime.UtcNow;
-=======
        await RebuildSinglePlaylistAsync(playlistName, CancellationToken.None);
        _lastRunTimes[playlistName] = DateTime.UtcNow;
    }
@@ -544,35 +389,10 @@ public class SpotifyTrackMatchingService : BackgroundService
        await MatchSinglePlaylistAsync(playlistName, CancellationToken.None);
        _lastRunTimes[playlistName] = DateTime.UtcNow;
    }
-    
-    /// <summary>
-    /// Public method to trigger matching for a specific playlist (called from controller).
-    /// This bypasses cron schedules and runs immediately.
-    /// </summary>
-    public async Task TriggerMatchingForPlaylistAsync(string playlistName)
-    {
-        _logger.LogInformation("Manual track matching triggered for playlist: {Playlist} (bypassing cron schedule)", playlistName);
-        
-        // Check cooldown to prevent abuse
-        if (_lastRunTimes.TryGetValue(playlistName, out var lastRun))
-        {
-            var timeSinceLastRun = DateTime.UtcNow - lastRun;
-            if (timeSinceLastRun < _minimumRunInterval)
-            {
-                _logger.LogWarning("Skipping manual refresh for {Playlist} - last run was {Seconds}s ago (cooldown: {Cooldown}s)", 
-                    playlistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds);
-                throw new InvalidOperationException($"Please wait {(int)(_minimumRunInterval - timeSinceLastRun).TotalSeconds} more seconds before refreshing again");
-            }
-        }
-        
-        await MatchSinglePlaylistAsync(playlistName, CancellationToken.None);
-        _lastRunTimes[playlistName] = DateTime.UtcNow;
-    }

    private async Task RebuildAllPlaylistsAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("=== STARTING FULL REBUILD FOR ALL PLAYLISTS ===");
->>>>>>> beta
        
        var playlists = _spotifySettings.Playlists;
        if (playlists.Count == 0)
@@ -587,22 +407,6 @@ public class SpotifyTrackMatchingService : BackgroundService
            
            try
            {
-<<<<<<< HEAD
-                await MatchSinglePlaylistAsync(playlist.Name, cancellationToken);
-||||||| f68706f
-                if (playlistFetcher != null)
-                {
-                    // Use new direct API mode with ISRC support
-                    await MatchPlaylistTracksWithIsrcAsync(
-                        playlist.Name, playlistFetcher, metadataService, cancellationToken);
-                }
-                else
-                {
-                    // Fall back to legacy mode
-                    await MatchPlaylistTracksLegacyAsync(
-                        playlist.Name, metadataService, cancellationToken);
-                }
-=======
                await RebuildSinglePlaylistAsync(playlist.Name, cancellationToken);
            }
            catch (Exception ex)
@@ -632,7 +436,6 @@ public class SpotifyTrackMatchingService : BackgroundService
            try
            {
                await MatchSinglePlaylistAsync(playlist.Name, cancellationToken);
->>>>>>> beta
            }
            catch (Exception ex)
            {
@@ -959,15 +762,7 @@ public class SpotifyTrackMatchingService : BackgroundService
                }
                catch (Exception ex)
                {
-<<<<<<< HEAD
-                    _logger.LogError(ex, "Failed to match track: {Title} - {Artist}", 
-                        spotifyTrack.Title, spotifyTrack.PrimaryArtist);
-||||||| f68706f
-                    _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", 
-                        spotifyTrack.Title, spotifyTrack.PrimaryArtist);
-=======
                    _logger.LogError(ex, "Failed to match track: {Title}", spotifyTrack.Title);
->>>>>>> beta
                    return (spotifyTrack, new List<(Song, double, string)>());
                }
            }).ToList();
@@ -1070,42 +865,6 @@ public class SpotifyTrackMatchingService : BackgroundService

        if (matchedTracks.Count > 0)
        {
-<<<<<<< HEAD
-            // Calculate cache expiration: until next cron run (not just cache duration from settings)
-            var playlist = _spotifySettings.Playlists
-                .FirstOrDefault(p => p.Name.Equals(playlistName, StringComparison.OrdinalIgnoreCase));
-            
-            var cacheExpiration = TimeSpan.FromHours(24); // Default 24 hours
-            
-            if (playlist != null && !string.IsNullOrEmpty(playlist.SyncSchedule))
-            {
-                try
-                {
-                    var cron = CronExpression.Parse(playlist.SyncSchedule);
-                    var nextRun = cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc);
-                    
-                    if (nextRun.HasValue)
-                    {
-                        var timeUntilNextRun = nextRun.Value - DateTime.UtcNow;
-                        // Add 5 minutes buffer to ensure cache doesn't expire before next run
-                        cacheExpiration = timeUntilNextRun + TimeSpan.FromMinutes(5);
-                        
-                        _logger.LogInformation("Cache will persist until next cron run: {NextRun} UTC (in {Hours:F1} hours)", 
-                            nextRun.Value, timeUntilNextRun.TotalHours);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Could not calculate next cron run for {Playlist}, using default cache duration", playlistName);
-                }
-            }
-            
-            // Cache matched tracks with position data until next cron run
-            await _cache.SetAsync(matchedTracksKey, matchedTracks, cacheExpiration);
-||||||| f68706f
-            // Cache matched tracks with position data
-            await _cache.SetAsync(matchedTracksKey, matchedTracks, TimeSpan.FromHours(1));
-=======
            // UPDATE STATS CACHE: Calculate and cache stats immediately after matching
            var statsLocalCount = localMatches.Count;
            var statsExternalCount = externalAssignments.Count;
@@ -1155,7 +914,6 @@ public class SpotifyTrackMatchingService : BackgroundService
            
            // Cache matched tracks with position data until next cron run
            await _cache.SetAsync(matchedTracksKey, matchedTracks, cacheExpiration);
->>>>>>> beta
            
            // Save matched tracks to file for persistence across restarts
            await SaveMatchedTracksToFileAsync(playlistName, matchedTracks);
@@ -1878,47 +1636,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                            var jellyfinId = jellyfinIdObj.ToString();
                            if (!string.IsNullOrEmpty(jellyfinId))
                            {
-<<<<<<< HEAD
-                                if (!itemDict.ContainsKey("ProviderIds"))
-                                {
-                                    itemDict["ProviderIds"] = new Dictionary<string, string>();
-                                }
-                                
-                                // Handle ProviderIds which might be a JsonElement or Dictionary
-                                Dictionary<string, string>? providerIds = null;
-                                
-                                if (itemDict["ProviderIds"] is Dictionary<string, string> dict)
-                                {
-                                    providerIds = dict;
-                                }
-                                else if (itemDict["ProviderIds"] is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object)
-                                {
-                                    // Convert JsonElement to Dictionary
-                                    providerIds = new Dictionary<string, string>();
-                                    foreach (var prop in jsonEl.EnumerateObject())
-                                    {
-                                        providerIds[prop.Name] = prop.Value.GetString() ?? "";
-                                    }
-                                    // Replace the JsonElement with the Dictionary
-                                    itemDict["ProviderIds"] = providerIds;
-                                }
-                                
-                                if (providerIds != null && !providerIds.ContainsKey("Jellyfin"))
-                                {
-                                    providerIds["Jellyfin"] = jellyfinId;
-                                    _logger.LogDebug("Fuzzy matched local track {Title} with Jellyfin ID {Id} (score: {Score:F1})", 
-                                        spotifyTrack.Title, jellyfinId, bestScore);
-                                }
-||||||| f68706f
-                                itemDict["ProviderIds"] = new Dictionary<string, string>();
-                            }
-                            
-                            var providerIds = itemDict["ProviderIds"] as Dictionary<string, string>;
-                            if (providerIds != null && !providerIds.ContainsKey("Spotify"))
-                            {
-                                providerIds["Spotify"] = spotifyTrack.SpotifyId;
-                                _logger.LogDebug("Added Spotify ID {SpotifyId} to fuzzy-matched local track for lyrics support", spotifyTrack.SpotifyId);
-=======
                                if (!itemDict.ContainsKey("ProviderIds"))
                                {
                                    itemDict["ProviderIds"] = new Dictionary<string, string>();
@@ -1959,7 +1676,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                                    _logger.LogDebug("Fuzzy matched local track {Title} with Jellyfin ID {Id} (score: {Score:F1})", 
                                        spotifyTrack.Title, jellyfinId, bestScore);
                                }
->>>>>>> beta
                            }
                        }
                        
@@ -1981,24 +1697,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                        // Convert external song to Jellyfin item format
                        var externalItem = responseBuilder.ConvertSongToJellyfinItem(matched.MatchedSong);
                        
-<<<<<<< HEAD
-||||||| f68706f
-                        // Add Spotify ID to ProviderIds so lyrics can work
-                        if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId))
-                        {
-                            if (!externalItem.ContainsKey("ProviderIds"))
-                            {
-                                externalItem["ProviderIds"] = new Dictionary<string, string>();
-                            }
-                            
-                            var providerIds = externalItem["ProviderIds"] as Dictionary<string, string>;
-                            if (providerIds != null && !providerIds.ContainsKey("Spotify"))
-                            {
-                                providerIds["Spotify"] = spotifyTrack.SpotifyId;
-                            }
-                        }
-                        
-=======
                        // Add Spotify ID to ProviderIds for matching in track details endpoint
                        if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId))
                        {
@@ -2014,7 +1712,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                            }
                        }
                        
->>>>>>> beta
                        finalItems.Add(externalItem);
                        matchedSpotifyIds.Add(spotifyTrack.SpotifyId); // Mark as matched (external)
                        externalUsedCount++;
@@ -2028,88 +1725,6 @@ public class SpotifyTrackMatchingService : BackgroundService
            
            if (finalItems.Count > 0)
            {
-<<<<<<< HEAD
-                // Enrich external tracks with genres from MusicBrainz
-                if (externalUsedCount > 0)
-                {
-                    try
-                    {
-                        var genreEnrichment = _serviceProvider.GetService<GenreEnrichmentService>();
-                        if (genreEnrichment != null)
-                        {
-                            _logger.LogDebug("🎨 Enriching {Count} external tracks with genres from MusicBrainz...", externalUsedCount);
-                            
-                            // Extract external songs from externalMatchedTracks that were actually used
-                            var usedExternalSpotifyIds = finalItems
-                                .Where(item => item.TryGetValue("Id", out var idObj) && 
-                                              idObj is string id && id.StartsWith("ext-"))
-                                .Select(item =>
-                                {
-                                    // Try to get Spotify ID from ProviderIds
-                                    if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj is Dictionary<string, string> providerIds)
-                                    {
-                                        providerIds.TryGetValue("Spotify", out var spotifyId);
-                                        return spotifyId;
-                                    }
-                                    return null;
-                                })
-                                .Where(id => !string.IsNullOrEmpty(id))
-                                .ToHashSet();
-                            
-                            var externalSongs = externalMatchedTracks
-                                .Where(t => t.MatchedSong != null && 
-                                           !t.MatchedSong.IsLocal && 
-                                           usedExternalSpotifyIds.Contains(t.SpotifyId))
-                                .Select(t => t.MatchedSong!)
-                                .ToList();
-                            
-                            // Enrich genres in parallel
-                            await genreEnrichment.EnrichSongsGenresAsync(externalSongs);
-                            
-                            // Update the genres in finalItems
-                            foreach (var item in finalItems)
-                            {
-                                if (item.TryGetValue("Id", out var idObj) && idObj is string id && id.StartsWith("ext-"))
-                                {
-                                    // Find the corresponding song
-                                    var song = externalSongs.FirstOrDefault(s => s.Id == id);
-                                    if (song != null && !string.IsNullOrEmpty(song.Genre))
-                                    {
-                                        // Update Genres array
-                                        item["Genres"] = new[] { song.Genre };
-                                        
-                                        // Update GenreItems array
-                                        item["GenreItems"] = new[]
-                                        {
-                                            new Dictionary<string, object?>
-                                            {
-                                                ["Name"] = song.Genre,
-                                                ["Id"] = $"genre-{song.Genre.ToLowerInvariant()}"
-                                            }
-                                        };
-                                        
-                                        _logger.LogDebug("✓ Enriched {Title} with genre: {Genre}", song.Title, song.Genre);
-                                    }
-                                }
-                            }
-                            
-                            _logger.LogInformation("✅ Genre enrichment complete for {Playlist}", playlistName);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to enrich genres for {Playlist}, continuing without genres", playlistName);
-                    }
-                }
-                
-                // Save to Redis cache with same expiration as matched tracks (until next cron run)
-                var cacheKey = $"spotify:playlist:items:{playlistName}";
-                await _cache.SetAsync(cacheKey, finalItems, cacheExpiration);
-||||||| f68706f
-                // Save to Redis cache
-                var cacheKey = $"spotify:playlist:items:{playlistName}";
-                await _cache.SetAsync(cacheKey, finalItems, TimeSpan.FromHours(24));
-=======
                // Enrich external tracks with genres from MusicBrainz
                if (externalUsedCount > 0)
                {
@@ -2186,7 +1801,6 @@ public class SpotifyTrackMatchingService : BackgroundService
                // Save to Redis cache with same expiration as matched tracks (until next cron run)
                var cacheKey = CacheKeyBuilder.BuildSpotifyPlaylistItemsKey(playlistName);
                await _cache.SetAsync(cacheKey, finalItems, cacheExpiration);
->>>>>>> beta
                
                // Save to file cache for persistence
                await SavePlaylistItemsToFileAsync(playlistName, finalItems);
@@ -85,83 +85,15 @@ public class SquidWTFMetadataService : IMusicMetadataService
    
 	
    public async Task<List<Song>> SearchSongsAsync(string query, int limit = 20)
-<<<<<<< HEAD
-    {
-        // Use round-robin to distribute load across endpoints (allows parallel processing of multiple tracks)
-        return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) =>
-||||||| f68706f
-    {
-        // Race all endpoints for fastest search results
-        return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) =>
-=======
->>>>>>> beta
        {
-<<<<<<< HEAD
-            // Use 's' parameter for track search as per hifi-api spec
-            var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}";
-            var response = await _httpClient.GetAsync(url);
-            
-            if (!response.IsSuccessStatusCode)
-||||||| f68706f
-            // Use 's' parameter for track search as per hifi-api spec
-            var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}";
-            var response = await _httpClient.GetAsync(url, ct);
-            
-            if (!response.IsSuccessStatusCode)
-=======
            // Race top 3 fastest endpoints for search (latency-sensitive)
            return await _fallbackHelper.RaceTopEndpointsAsync(3, async (baseUrl, ct) =>
->>>>>>> beta
            {
-<<<<<<< HEAD
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            
-            // Check for error in response body
-            var result = JsonDocument.Parse(json);
-            if (result.RootElement.TryGetProperty("detail", out _) || 
-                result.RootElement.TryGetProperty("error", out _))
-            {
-                throw new HttpRequestException("API returned error response");
-            }
-            
-            var songs = new List<Song>();
-            // Per hifi-api spec: track search returns data.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var track in items.EnumerateArray())
-||||||| f68706f
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync(ct);
-            
-            // Check for error in response body
-            var result = JsonDocument.Parse(json);
-            if (result.RootElement.TryGetProperty("detail", out _) || 
-                result.RootElement.TryGetProperty("error", out _))
-            {
-                throw new HttpRequestException("API returned error response");
-            }
-            
-            var songs = new List<Song>();
-            // Per hifi-api spec: track search returns data.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var track in items.EnumerateArray())
-=======
                // Use 's' parameter for track search as per hifi-api spec
                var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}";
                var response = await _httpClient.GetAsync(url, ct);

                if (!response.IsSuccessStatusCode)
->>>>>>> beta
                {
                    throw new HttpRequestException($"HTTP {response.StatusCode}");
                }
@@ -199,72 +131,16 @@ public class SquidWTFMetadataService : IMusicMetadataService
        }
 	
    public async Task<List<Album>> SearchAlbumsAsync(string query, int limit = 20)
-<<<<<<< HEAD
-    {
-        // Use round-robin to distribute load across endpoints (allows parallel processing)
-        return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) =>
-||||||| f68706f
-    {
-        // Race all endpoints for fastest search results
-        return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) =>
-=======
->>>>>>> beta
        {
-<<<<<<< HEAD
-            // Note: hifi-api doesn't document album search, but 'al' parameter is commonly used
-            var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}";
-            var response = await _httpClient.GetAsync(url);
-            
-            if (!response.IsSuccessStatusCode)
-||||||| f68706f
-            // Note: hifi-api doesn't document album search, but 'al' parameter is commonly used
-            var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}";
-            var response = await _httpClient.GetAsync(url, ct);
-            
-            if (!response.IsSuccessStatusCode)
-=======
            // Race top 3 fastest endpoints for search (latency-sensitive)
            return await _fallbackHelper.RaceTopEndpointsAsync(3, async (baseUrl, ct) =>
->>>>>>> beta
            {
-<<<<<<< HEAD
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            var result = JsonDocument.Parse(json);
-            
-            var albums = new List<Album>();
-            // Per hifi-api spec: album search returns data.albums.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("albums", out var albumsObj) &&
-                albumsObj.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var album in items.EnumerateArray())
-||||||| f68706f
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync(ct);
-            var result = JsonDocument.Parse(json);
-            
-            var albums = new List<Album>();
-            // Per hifi-api spec: album search returns data.albums.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("albums", out var albumsObj) &&
-                albumsObj.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var album in items.EnumerateArray())
-=======
                // Use 'al' parameter for album search
                // a= is for artists, al= is for albums, p= is for playlists
                var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}";
                var response = await _httpClient.GetAsync(url, ct);

                if (!response.IsSuccessStatusCode)
->>>>>>> beta
                {
                    throw new HttpRequestException($"HTTP {response.StatusCode}");
                }
@@ -293,93 +169,13 @@ public class SquidWTFMetadataService : IMusicMetadataService
        }

    public async Task<List<Artist>> SearchArtistsAsync(string query, int limit = 20)
-<<<<<<< HEAD
-    {
-        // Use round-robin to distribute load across endpoints (allows parallel processing)
-        return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) =>
-||||||| f68706f
-    {
-        // Race all endpoints for fastest search results
-        return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) =>
-=======
->>>>>>> beta
        {
-<<<<<<< HEAD
-            // Per hifi-api spec: use 'a' parameter for artist search
-            var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}";
-            _logger.LogDebug("🔍 SQUIDWTF: Searching artists with URL: {Url}", url);
-            
-            var response = await _httpClient.GetAsync(url);
-            
-            if (!response.IsSuccessStatusCode)
-||||||| f68706f
-            // Per hifi-api spec: use 'a' parameter for artist search
-            var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}";
-            _logger.LogInformation("🔍 SQUIDWTF: Searching artists with URL: {Url}", url);
-            
-            var response = await _httpClient.GetAsync(url, ct);
-            
-            if (!response.IsSuccessStatusCode)
-=======
            // Race top 3 fastest endpoints for search (latency-sensitive)
            return await _fallbackHelper.RaceTopEndpointsAsync(3, async (baseUrl, ct) =>
->>>>>>> beta
            {
-<<<<<<< HEAD
-                _logger.LogWarning("⚠️ SQUIDWTF: Artist search failed with status {StatusCode}", response.StatusCode);
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync();
-            var result = JsonDocument.Parse(json);
-            
-            var artists = new List<Artist>();
-            // Per hifi-api spec: artist search returns data.artists.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("artists", out var artistsObj) &&
-                artistsObj.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var artist in items.EnumerateArray())
-                {
-                    if (count >= limit) break;
-                    
-                    var parsedArtist = ParseTidalArtist(artist);
-                    artists.Add(parsedArtist);
-                    _logger.LogDebug("🎤 SQUIDWTF: Found artist: {Name} (ID: {Id})", parsedArtist.Name, parsedArtist.ExternalId);
-                    count++;
-                }
-            }
-||||||| f68706f
-                _logger.LogWarning("⚠️ SQUIDWTF: Artist search failed with status {StatusCode}", response.StatusCode);
-                throw new HttpRequestException($"HTTP {response.StatusCode}");
-            }
-            
-            var json = await response.Content.ReadAsStringAsync(ct);
-            var result = JsonDocument.Parse(json);
-            
-            var artists = new List<Artist>();
-            // Per hifi-api spec: artist search returns data.artists.items array
-            if (result.RootElement.TryGetProperty("data", out var data) &&
-                data.TryGetProperty("artists", out var artistsObj) &&
-                artistsObj.TryGetProperty("items", out var items))
-            {
-                int count = 0;
-                foreach (var artist in items.EnumerateArray())
-                {
-                    if (count >= limit) break;
-                    
-                    var parsedArtist = ParseTidalArtist(artist);
-                    artists.Add(parsedArtist);
-                    _logger.LogDebug("🎤 SQUIDWTF: Found artist: {Name} (ID: {Id})", parsedArtist.Name, parsedArtist.ExternalId);
-                    count++;
-                }
-            }
-=======
                // Per hifi-api spec: use 'a' parameter for artist search
                var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}";
                _logger.LogDebug("🔍 SQUIDWTF: Searching artists with URL: {Url}", url);
->>>>>>> beta

                var response = await _httpClient.GetAsync(url, ct);

@@ -579,13 +375,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
        var cached = await _cache.GetAsync<Artist>(cacheKey);
        if (cached != null)
        {
-<<<<<<< HEAD
-            _logger.LogDebug("Returning cached artist {ArtistName}", cached.Name);
-||||||| f68706f
-            _logger.LogInformation("Returning cached artist {ArtistName}", cached.Name);
-=======
            _logger.LogDebug("Returning cached artist {ArtistName}, ImageUrl: {ImageUrl}", cached.Name, cached.ImageUrl ?? "NULL");
->>>>>>> beta
            return cached;
        }
  
@@ -5,19 +5,9 @@
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
        <RootNamespace>allstarr</RootNamespace>
-<<<<<<< HEAD
-        <Version>1.0.1</Version>
-        <AssemblyVersion>1.0.1.0</AssemblyVersion>
-        <FileVersion>1.0.1.0</FileVersion>
-||||||| f68706f
-        <Version>1.0.0</Version>
-        <AssemblyVersion>1.0.0.0</AssemblyVersion>
-        <FileVersion>1.0.0.0</FileVersion>
-=======
        <Version>1.1.1</Version>
        <AssemblyVersion>1.1.1.0</AssemblyVersion>
        <FileVersion>1.1.1.0</FileVersion>
->>>>>>> beta
    </PropertyGroup>

    <ItemGroup>
@@ -5,1028 +5,7 @@
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Allstarr Dashboard</title>
-<<<<<<< HEAD
-    <style>
-        :root {
-            --bg-primary: #0d1117;
-            --bg-secondary: #161b22;
-            --bg-tertiary: #21262d;
-            --text-primary: #f0f6fc;
-            --text-secondary: #8b949e;
-            --accent: #58a6ff;
-            --accent-hover: #79c0ff;
-            --success: #3fb950;
-            --warning: #d29922;
-            --error: #f85149;
-            --border: #30363d;
-        }
-        
-        * {
-            box-sizing: border-box;
-            margin: 0;
-            padding: 0;
-        }
-        
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
-            background: var(--bg-primary);
-            color: var(--text-primary);
-            line-height: 1.5;
-            min-height: 100vh;
-        }
-        
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        
-        header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            padding: 20px 0;
-            border-bottom: 1px solid var(--border);
-            margin-bottom: 30px;
-        }
-        
-        h1 {
-            font-size: 1.8rem;
-            font-weight: 600;
-            display: flex;
-            align-items: center;
-            gap: 10px;
-        }
-        
-        h1 .version {
-            font-size: 0.8rem;
-            color: var(--text-secondary);
-            font-weight: normal;
-        }
-        
-        .status-badge {
-            display: inline-flex;
-            align-items: center;
-            gap: 6px;
-            padding: 4px 12px;
-            border-radius: 20px;
-            font-size: 0.85rem;
-            font-weight: 500;
-        }
-        
-        .status-badge.success { background: rgba(63, 185, 80, 0.2); color: var(--success); }
-        .status-badge.warning { background: rgba(210, 153, 34, 0.2); color: var(--warning); }
-        .status-badge.error { background: rgba(248, 81, 73, 0.2); color: var(--error); }
-        .status-badge.info { background: rgba(59, 130, 246, 0.2); color: #3b82f6; }
-        
-        .status-dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            background: currentColor;
-        }
-        
-        .card {
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }
-        
-        .card h2 {
-            font-size: 1.1rem;
-            font-weight: 600;
-            margin-bottom: 16px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-        }
-        
-        .card h2 .actions {
-            display: flex;
-            gap: 8px;
-        }
-        
-        .grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 20px;
-        }
-        
-        .stat-row {
-            display: flex;
-            justify-content: space-between;
-            padding: 8px 0;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .stat-row:last-child {
-            border-bottom: none;
-        }
-        
-        .stat-label {
-            color: var(--text-secondary);
-        }
-        
-        .stat-value {
-            font-weight: 500;
-        }
-        
-        .stat-value.success { color: var(--success); }
-        .stat-value.warning { color: var(--warning); }
-        .stat-value.error { color: var(--error); }
-        
-        button {
-            background: var(--bg-tertiary);
-            color: var(--text-primary);
-            border: 1px solid var(--border);
-            padding: 8px 16px;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.9rem;
-            transition: all 0.2s;
-        }
-        
-        button:hover {
-            background: var(--border);
-        }
-        
-        button.primary {
-            background: var(--accent);
-            border-color: var(--accent);
-            color: white;
-        }
-        
-        button.primary:hover {
-            background: var(--accent-hover);
-        }
-        
-        button.danger {
-            background: rgba(248, 81, 73, 0.15);
-            border-color: var(--error);
-            color: var(--error);
-        }
-        
-        button.danger:hover {
-            background: rgba(248, 81, 73, 0.3);
-        }
-        
-        .playlist-table {
-            width: 100%;
-            border-collapse: collapse;
-        }
-        
-        .playlist-table th,
-        .playlist-table td {
-            padding: 12px;
-            text-align: left;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .playlist-table th {
-            color: var(--text-secondary);
-            font-weight: 500;
-            font-size: 0.85rem;
-        }
-        
-        .playlist-table tr:hover td {
-            background: var(--bg-tertiary);
-        }
-        
-        .playlist-table .track-count {
-            font-family: monospace;
-            color: var(--accent);
-        }
-        
-        .playlist-table .cache-age {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-        }
-        
-        .input-group {
-            display: flex;
-            gap: 8px;
-            margin-top: 16px;
-        }
-        
-        input, select {
-            background: var(--bg-tertiary);
-            border: 1px solid var(--border);
-            color: var(--text-primary);
-            padding: 8px 12px;
-            border-radius: 6px;
-            font-size: 0.9rem;
-        }
-        
-        input:focus, select:focus {
-            outline: none;
-            border-color: var(--accent);
-        }
-        
-        input::placeholder {
-            color: var(--text-secondary);
-        }
-        
-        .form-row {
-            display: grid;
-            grid-template-columns: 1fr 1fr 120px auto;
-            gap: 8px;
-            align-items: end;
-        }
-        
-        .form-row label {
-            display: block;
-            font-size: 0.8rem;
-            color: var(--text-secondary);
-            margin-bottom: 4px;
-        }
-        
-        .config-section {
-            margin-bottom: 24px;
-        }
-        
-        .config-section h3 {
-            font-size: 0.95rem;
-            color: var(--text-secondary);
-            margin-bottom: 12px;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-        }
-        
-        .config-item {
-            display: grid;
-            grid-template-columns: 200px 1fr auto;
-            gap: 16px;
-            align-items: center;
-            padding: 12px;
-            background: var(--bg-tertiary);
-            border-radius: 6px;
-            margin-bottom: 8px;
-        }
-        
-        .config-item .label {
-            font-weight: 500;
-        }
-        
-        .config-item .value {
-            font-family: monospace;
-            color: var(--text-secondary);
-        }
-        
-        .toast {
-            position: fixed;
-            bottom: 20px;
-            right: 20px;
-            padding: 12px 20px;
-            border-radius: 8px;
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
-            z-index: 1000;
-            animation: slideIn 0.3s ease;
-        }
-        
-        .toast.success { border-color: var(--success); }
-        .toast.error { border-color: var(--error); }
-        .toast.warning { border-color: var(--warning); }
-        .toast.info { border-color: var(--accent); }
-        
-        @keyframes slideIn {
-            from { transform: translateX(100%); opacity: 0; }
-            to { transform: translateX(0); opacity: 1; }
-        }
-        
-        .restart-overlay {
-            display: none;
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: var(--bg-primary);
-            z-index: 9999;
-            justify-content: center;
-            align-items: center;
-            flex-direction: column;
-            gap: 20px;
-        }
-        
-        .restart-overlay.active {
-            display: flex;
-        }
-        
-        .restart-overlay .spinner-large {
-            width: 48px;
-            height: 48px;
-            border: 3px solid var(--border);
-            border-top-color: var(--accent);
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-        }
-        
-        .restart-overlay h2 {
-            color: var(--text-primary);
-            font-size: 1.5rem;
-        }
-        
-        .restart-overlay p {
-            color: var(--text-secondary);
-        }
-        
-        .restart-banner {
-            position: fixed;
-            top: 0;
-            left: 0;
-            right: 0;
-            background: var(--warning);
-            color: var(--bg-primary);
-            padding: 12px 20px;
-            text-align: center;
-            font-weight: 500;
-            z-index: 9998;
-            display: none;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.3);
-        }
-        
-        .restart-banner.active {
-            display: block;
-        }
-        
-        .restart-banner button {
-            margin-left: 16px;
-            background: var(--bg-primary);
-            color: var(--text-primary);
-            border: none;
-            padding: 6px 16px;
-            border-radius: 4px;
-            cursor: pointer;
-            font-weight: 500;
-        }
-        
-        .restart-banner button:hover {
-            background: var(--bg-secondary);
-        }
-        
-        .modal {
-            display: none;
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0,0,0,0.7);
-            z-index: 1000;
-            justify-content: center;
-            align-items: center;
-        }
-        
-        .modal.active {
-            display: flex;
-        }
-        
-        .modal-content {
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            border-radius: 12px;
-            padding: 24px;
-            max-width: 75%;
-            width: 75%;
-            max-height: 65vh;
-            overflow-y: auto;
-        }
-        
-        .modal-content h3 {
-            margin-bottom: 20px;
-        }
-        
-        .modal-content .form-group {
-            margin-bottom: 16px;
-        }
-        
-        .modal-content .form-group label {
-            display: block;
-            margin-bottom: 6px;
-            color: var(--text-secondary);
-        }
-        
-        .modal-content .form-group input,
-        .modal-content .form-group select {
-            width: 100%;
-        }
-        
-        .modal-actions {
-            display: flex;
-            justify-content: flex-end;
-            gap: 8px;
-            margin-top: 24px;
-        }
-        
-        .tabs {
-            display: flex;
-            border-bottom: 1px solid var(--border);
-            margin-bottom: 20px;
-        }
-        
-        .tab {
-            padding: 12px 20px;
-            cursor: pointer;
-            color: var(--text-secondary);
-            border-bottom: 2px solid transparent;
-            transition: all 0.2s;
-        }
-        
-        .tab:hover {
-            color: var(--text-primary);
-        }
-        
-        .tab.active {
-            color: var(--accent);
-            border-bottom-color: var(--accent);
-        }
-        
-        .tab-content {
-            display: none;
-        }
-        
-        .tab-content.active {
-            display: block;
-        }
-        
-        .tracks-list {
-            max-height: 400px;
-            overflow-y: auto;
-        }
-        
-        .track-item {
-            display: grid;
-            grid-template-columns: 40px 1fr auto;
-            gap: 12px;
-            align-items: center;
-            padding: 8px;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .track-item:hover {
-            background: var(--bg-tertiary);
-        }
-        
-        .track-position {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-            text-align: center;
-        }
-        
-        .track-info h4 {
-            font-weight: 500;
-            font-size: 0.95rem;
-        }
-        
-        .track-info .artists {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-        }
-        
-        .track-meta {
-            text-align: right;
-            color: var(--text-secondary);
-            font-size: 0.8rem;
-        }
-
-        .loading {
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-            color: var(--text-secondary);
-        }
-        
-        .spinner {
-            width: 24px;
-            height: 24px;
-            border: 2px solid var(--border);
-            border-top-color: var(--accent);
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-            margin-right: 12px;
-        }
-        
-        @keyframes spin {
-            to { transform: rotate(360deg); }
-        }
-    </style>
-||||||| f68706f
-    <style>
-        :root {
-            --bg-primary: #0d1117;
-            --bg-secondary: #161b22;
-            --bg-tertiary: #21262d;
-            --text-primary: #f0f6fc;
-            --text-secondary: #8b949e;
-            --accent: #58a6ff;
-            --accent-hover: #79c0ff;
-            --success: #3fb950;
-            --warning: #d29922;
-            --error: #f85149;
-            --border: #30363d;
-        }
-        
-        * {
-            box-sizing: border-box;
-            margin: 0;
-            padding: 0;
-        }
-        
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
-            background: var(--bg-primary);
-            color: var(--text-primary);
-            line-height: 1.5;
-            min-height: 100vh;
-        }
-        
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        
-        header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            padding: 20px 0;
-            border-bottom: 1px solid var(--border);
-            margin-bottom: 30px;
-        }
-        
-        h1 {
-            font-size: 1.8rem;
-            font-weight: 600;
-            display: flex;
-            align-items: center;
-            gap: 10px;
-        }
-        
-        h1 .version {
-            font-size: 0.8rem;
-            color: var(--text-secondary);
-            font-weight: normal;
-        }
-        
-        .status-badge {
-            display: inline-flex;
-            align-items: center;
-            gap: 6px;
-            padding: 4px 12px;
-            border-radius: 20px;
-            font-size: 0.85rem;
-            font-weight: 500;
-        }
-        
-        .status-badge.success { background: rgba(63, 185, 80, 0.2); color: var(--success); }
-        .status-badge.warning { background: rgba(210, 153, 34, 0.2); color: var(--warning); }
-        .status-badge.error { background: rgba(248, 81, 73, 0.2); color: var(--error); }
-        
-        .status-dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            background: currentColor;
-        }
-        
-        .card {
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }
-        
-        .card h2 {
-            font-size: 1.1rem;
-            font-weight: 600;
-            margin-bottom: 16px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-        }
-        
-        .card h2 .actions {
-            display: flex;
-            gap: 8px;
-        }
-        
-        .grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 20px;
-        }
-        
-        .stat-row {
-            display: flex;
-            justify-content: space-between;
-            padding: 8px 0;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .stat-row:last-child {
-            border-bottom: none;
-        }
-        
-        .stat-label {
-            color: var(--text-secondary);
-        }
-        
-        .stat-value {
-            font-weight: 500;
-        }
-        
-        .stat-value.success { color: var(--success); }
-        .stat-value.warning { color: var(--warning); }
-        .stat-value.error { color: var(--error); }
-        
-        button {
-            background: var(--bg-tertiary);
-            color: var(--text-primary);
-            border: 1px solid var(--border);
-            padding: 8px 16px;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.9rem;
-            transition: all 0.2s;
-        }
-        
-        button:hover {
-            background: var(--border);
-        }
-        
-        button.primary {
-            background: var(--accent);
-            border-color: var(--accent);
-            color: white;
-        }
-        
-        button.primary:hover {
-            background: var(--accent-hover);
-        }
-        
-        button.danger {
-            background: rgba(248, 81, 73, 0.15);
-            border-color: var(--error);
-            color: var(--error);
-        }
-        
-        button.danger:hover {
-            background: rgba(248, 81, 73, 0.3);
-        }
-        
-        .playlist-table {
-            width: 100%;
-            border-collapse: collapse;
-        }
-        
-        .playlist-table th,
-        .playlist-table td {
-            padding: 12px;
-            text-align: left;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .playlist-table th {
-            color: var(--text-secondary);
-            font-weight: 500;
-            font-size: 0.85rem;
-        }
-        
-        .playlist-table tr:hover td {
-            background: var(--bg-tertiary);
-        }
-        
-        .playlist-table .track-count {
-            font-family: monospace;
-            color: var(--accent);
-        }
-        
-        .playlist-table .cache-age {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-        }
-        
-        .input-group {
-            display: flex;
-            gap: 8px;
-            margin-top: 16px;
-        }
-        
-        input, select {
-            background: var(--bg-tertiary);
-            border: 1px solid var(--border);
-            color: var(--text-primary);
-            padding: 8px 12px;
-            border-radius: 6px;
-            font-size: 0.9rem;
-        }
-        
-        input:focus, select:focus {
-            outline: none;
-            border-color: var(--accent);
-        }
-        
-        input::placeholder {
-            color: var(--text-secondary);
-        }
-        
-        .form-row {
-            display: grid;
-            grid-template-columns: 1fr 1fr 120px auto;
-            gap: 8px;
-            align-items: end;
-        }
-        
-        .form-row label {
-            display: block;
-            font-size: 0.8rem;
-            color: var(--text-secondary);
-            margin-bottom: 4px;
-        }
-        
-        .config-section {
-            margin-bottom: 24px;
-        }
-        
-        .config-section h3 {
-            font-size: 0.95rem;
-            color: var(--text-secondary);
-            margin-bottom: 12px;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-        }
-        
-        .config-item {
-            display: grid;
-            grid-template-columns: 200px 1fr auto;
-            gap: 16px;
-            align-items: center;
-            padding: 12px;
-            background: var(--bg-tertiary);
-            border-radius: 6px;
-            margin-bottom: 8px;
-        }
-        
-        .config-item .label {
-            font-weight: 500;
-        }
-        
-        .config-item .value {
-            font-family: monospace;
-            color: var(--text-secondary);
-        }
-        
-        .toast {
-            position: fixed;
-            bottom: 20px;
-            right: 20px;
-            padding: 12px 20px;
-            border-radius: 8px;
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
-            z-index: 1000;
-            animation: slideIn 0.3s ease;
-        }
-        
-        .toast.success { border-color: var(--success); }
-        .toast.error { border-color: var(--error); }
-        .toast.warning { border-color: var(--warning); }
-        .toast.info { border-color: var(--accent); }
-        
-        @keyframes slideIn {
-            from { transform: translateX(100%); opacity: 0; }
-            to { transform: translateX(0); opacity: 1; }
-        }
-        
-        .restart-overlay {
-            display: none;
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: var(--bg-primary);
-            z-index: 9999;
-            justify-content: center;
-            align-items: center;
-            flex-direction: column;
-            gap: 20px;
-        }
-        
-        .restart-overlay.active {
-            display: flex;
-        }
-        
-        .restart-overlay .spinner-large {
-            width: 48px;
-            height: 48px;
-            border: 3px solid var(--border);
-            border-top-color: var(--accent);
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-        }
-        
-        .restart-overlay h2 {
-            color: var(--text-primary);
-            font-size: 1.5rem;
-        }
-        
-        .restart-overlay p {
-            color: var(--text-secondary);
-        }
-        
-        .restart-banner {
-            position: fixed;
-            top: 0;
-            left: 0;
-            right: 0;
-            background: var(--warning);
-            color: var(--bg-primary);
-            padding: 12px 20px;
-            text-align: center;
-            font-weight: 500;
-            z-index: 9998;
-            display: none;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.3);
-        }
-        
-        .restart-banner.active {
-            display: block;
-        }
-        
-        .restart-banner button {
-            margin-left: 16px;
-            background: var(--bg-primary);
-            color: var(--text-primary);
-            border: none;
-            padding: 6px 16px;
-            border-radius: 4px;
-            cursor: pointer;
-            font-weight: 500;
-        }
-        
-        .restart-banner button:hover {
-            background: var(--bg-secondary);
-        }
-        
-        .modal {
-            display: none;
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0,0,0,0.7);
-            z-index: 1000;
-            justify-content: center;
-            align-items: center;
-        }
-        
-        .modal.active {
-            display: flex;
-        }
-        
-        .modal-content {
-            background: var(--bg-secondary);
-            border: 1px solid var(--border);
-            border-radius: 12px;
-            padding: 24px;
-            max-width: 75%;
-            width: 75%;
-            max-height: 65vh;
-            overflow-y: auto;
-        }
-        
-        .modal-content h3 {
-            margin-bottom: 20px;
-        }
-        
-        .modal-content .form-group {
-            margin-bottom: 16px;
-        }
-        
-        .modal-content .form-group label {
-            display: block;
-            margin-bottom: 6px;
-            color: var(--text-secondary);
-        }
-        
-        .modal-content .form-group input,
-        .modal-content .form-group select {
-            width: 100%;
-        }
-        
-        .modal-actions {
-            display: flex;
-            justify-content: flex-end;
-            gap: 8px;
-            margin-top: 24px;
-        }
-        
-        .tabs {
-            display: flex;
-            border-bottom: 1px solid var(--border);
-            margin-bottom: 20px;
-        }
-        
-        .tab {
-            padding: 12px 20px;
-            cursor: pointer;
-            color: var(--text-secondary);
-            border-bottom: 2px solid transparent;
-            transition: all 0.2s;
-        }
-        
-        .tab:hover {
-            color: var(--text-primary);
-        }
-        
-        .tab.active {
-            color: var(--accent);
-            border-bottom-color: var(--accent);
-        }
-        
-        .tab-content {
-            display: none;
-        }
-        
-        .tab-content.active {
-            display: block;
-        }
-        
-        .tracks-list {
-            max-height: 400px;
-            overflow-y: auto;
-        }
-        
-        .track-item {
-            display: grid;
-            grid-template-columns: 40px 1fr auto;
-            gap: 12px;
-            align-items: center;
-            padding: 8px;
-            border-bottom: 1px solid var(--border);
-        }
-        
-        .track-item:hover {
-            background: var(--bg-tertiary);
-        }
-        
-        .track-position {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-            text-align: center;
-        }
-        
-        .track-info h4 {
-            font-weight: 500;
-            font-size: 0.95rem;
-        }
-        
-        .track-info .artists {
-            color: var(--text-secondary);
-            font-size: 0.85rem;
-        }
-        
-        .track-meta {
-            text-align: right;
-            color: var(--text-secondary);
-            font-size: 0.8rem;
-        }
-
-        .loading {
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-            color: var(--text-secondary);
-        }
-        
-        .spinner {
-            width: 24px;
-            height: 24px;
-            border: 2px solid var(--border);
-            border-top-color: var(--accent);
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-            margin-right: 12px;
-        }
-        
-        @keyframes spin {
-            to { transform: rotate(360deg); }
-        }
-    </style>
-=======
    <link rel="stylesheet" href="styles.css">
->>>>>>> beta
 </head>

 <body>
@@ -1054,15 +33,9 @@
        <div class="tabs">
            <div class="tab active" data-tab="dashboard">Dashboard</div>
            <div class="tab" data-tab="jellyfin-playlists">Link Playlists</div>
-<<<<<<< HEAD
-            <div class="tab" data-tab="playlists">Injected Playlists</div>
-||||||| f68706f
-            <div class="tab" data-tab="playlists">Active Playlists</div>
-=======
            <div class="tab" data-tab="playlists">Injected Playlists</div>
            <div class="tab" data-tab="kept">Kept Downloads</div>
            <div class="tab" data-tab="scrobbling">Scrobbling</div>
->>>>>>> beta
            <div class="tab" data-tab="config">Configuration</div>
            <div class="tab" data-tab="endpoints">API Analytics</div>
        </div>
@@ -1201,15 +174,6 @@
                <h2>
                    Injected Spotify Playlists
                    <div class="actions">
-<<<<<<< HEAD
-                        <button onclick="matchAllPlaylists()" title="Re-match tracks when local library changed (uses cached Spotify data)">Re-match All Local</button>
-                        <button onclick="refreshPlaylists()" title="Fetch the latest playlist data from Spotify without re-matching tracks.">Refresh All</button>
-                        <button onclick="refreshAndMatchAll()" title="Rebuild all playlists when Spotify playlists changed (fetches fresh data and re-matches)" style="background:var(--accent);border-color:var(--accent);">Rebuild All Remote</button>
-||||||| f68706f
-                        <button onclick="matchAllPlaylists()" title="Match tracks for all playlists against your local library and external providers. This may take several minutes.">Match All Tracks</button>
-                        <button onclick="refreshPlaylists()" title="Fetch the latest playlist data from Spotify without re-matching tracks.">Refresh All</button>
-                        <button onclick="refreshAndMatchAll()" title="Clear caches, fetch fresh data from Spotify, and match all tracks. This is a full rebuild and may take several minutes." style="background:var(--accent);border-color:var(--accent);">Refresh & Match All</button>
-=======
                        <button onclick="matchAllPlaylists()"
                            title="Re-match tracks when local library changed (uses cached Spotify data)">Rematch All</button>
                        <button onclick="refreshPlaylists()"
@@ -1217,7 +181,6 @@
                        <button onclick="refreshAndMatchAll()"
                            title="Rebuild all playlists when Spotify playlists changed (clears cache, fetches fresh data, re-matches)"
                            style="background:var(--accent);border-color:var(--accent);">Rebuild All</button>
->>>>>>> beta
                    </div>
                </h2>
                
@@ -1232,14 +195,8 @@
                </div>
                
                <p style="color: var(--text-secondary); margin-bottom: 12px;">
-<<<<<<< HEAD
-                    These are the Spotify playlists currently being injected into Jellyfin with tracks from your music service.
-||||||| f68706f
-                    These are the Spotify playlists currently being monitored and filled with tracks from your music service.
-=======
                    These are the Spotify playlists currently being injected into Jellyfin with tracks from your music
                    service.
->>>>>>> beta
                </p>
                <table class="playlist-table">
                    <thead>
@@ -1497,60 +454,6 @@
        <!-- Configuration Tab -->
        <div class="tab-content" id="tab-config">
            <div class="card">
-<<<<<<< HEAD
-                <h2>Core Settings</h2>
-                <div class="config-section">
-                    <div class="config-item">
-                        <span class="label">Backend Type <span style="color: var(--error);">*</span></span>
-                        <span class="value" id="config-backend-type">-</span>
-                        <button onclick="openEditSetting('BACKEND_TYPE', 'Backend Type', 'select', 'Choose your media server backend', ['Jellyfin', 'Subsonic'])">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Music Service <span style="color: var(--error);">*</span></span>
-                        <span class="value" id="config-music-service">-</span>
-                        <button onclick="openEditSetting('MUSIC_SERVICE', 'Music Service', 'select', 'Choose your music download provider', ['SquidWTF', 'Deezer', 'Qobuz'])">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Storage Mode</span>
-                        <span class="value" id="config-storage-mode">-</span>
-                        <button onclick="openEditSetting('STORAGE_MODE', 'Storage Mode', 'select', 'Permanent keeps files forever, Cache auto-deletes after duration', ['Permanent', 'Cache'])">Edit</button>
-                    </div>
-                    <div class="config-item" id="cache-duration-row" style="display: none;">
-                        <span class="label">Cache Duration (hours)</span>
-                        <span class="value" id="config-cache-duration-hours">-</span>
-                        <button onclick="openEditSetting('CACHE_DURATION_HOURS', 'Cache Duration (hours)', 'number', 'How long to keep cached files before deletion')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Download Mode</span>
-                        <span class="value" id="config-download-mode">-</span>
-                        <button onclick="openEditSetting('DOWNLOAD_MODE', 'Download Mode', 'select', 'Download individual tracks or full albums', ['Track', 'Album'])">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Explicit Filter</span>
-                        <span class="value" id="config-explicit-filter">-</span>
-                        <button onclick="openEditSetting('EXPLICIT_FILTER', 'Explicit Filter', 'select', 'Filter explicit content', ['All', 'Explicit', 'Clean'])">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Enable External Playlists</span>
-                        <span class="value" id="config-enable-external-playlists">-</span>
-                        <button onclick="openEditSetting('ENABLE_EXTERNAL_PLAYLISTS', 'Enable External Playlists', 'toggle')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Playlists Directory</span>
-                        <span class="value" id="config-playlists-directory">-</span>
-                        <button onclick="openEditSetting('PLAYLISTS_DIRECTORY', 'Playlists Directory', 'text', 'Directory path for external playlists')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Redis Enabled</span>
-                        <span class="value" id="config-redis-enabled">-</span>
-                        <button onclick="openEditSetting('REDIS_ENABLED', 'Redis Enabled', 'toggle')">Edit</button>
-                    </div>
-                </div>
-            </div>
-            
-            <div class="card">
-||||||| f68706f
-=======
                <h2>Core Settings</h2>
                <div class="config-section">
                    <div class="config-item">
@@ -1624,19 +527,11 @@
            </div>

            <div class="card">
->>>>>>> beta
                <h2>Spotify API Settings</h2>
-<<<<<<< HEAD
-                <div style="background: rgba(248, 81, 73, 0.15); border: 1px solid var(--error); border-radius: 6px; padding: 12px; margin-bottom: 16px; color: var(--text-primary);">
-                    ⚠️ For active playlists and link functionality to work, sp_dc session cookie must be set!
-                </div>
-||||||| f68706f
-=======
                <div
                    style="background: rgba(248, 81, 73, 0.15); border: 1px solid var(--error); border-radius: 6px; padding: 12px; margin-bottom: 16px; color: var(--text-primary);">
                    ⚠️ For active playlists and link functionality to work, sp_dc session cookie must be set!
                </div>
->>>>>>> beta
                <div class="config-section">
                    <div class="config-item">
                        <span class="label">API Enabled</span>
@@ -1693,14 +588,8 @@
                    <div class="config-item">
                        <span class="label">Quality</span>
                        <span class="value" id="config-squid-quality">-</span>
-<<<<<<< HEAD
-                        <button onclick="openEditSetting('SQUIDWTF_QUALITY', 'SquidWTF Quality', 'select', 'HI_RES_LOSSLESS: 24-bit/192kHz FLAC (highest)\\nLOSSLESS: 16-bit/44.1kHz FLAC (default)\\nHIGH: 320kbps AAC\\nLOW: 96kbps AAC', ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'])">Edit</button>
-||||||| f68706f
-                        <button onclick="openEditSetting('SQUIDWTF_QUALITY', 'SquidWTF Quality', 'select', '', ['LOSSLESS', 'HIGH', 'LOW'])">Edit</button>
-=======
                        <button
                            onclick="openEditSetting('SQUIDWTF_QUALITY', 'SquidWTF Quality', 'select', 'HI_RES_LOSSLESS: 24-bit/192kHz FLAC (highest)\\nLOSSLESS: 16-bit/44.1kHz FLAC (default)\\nHIGH: 320kbps AAC\\nLOW: 96kbps AAC', ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'])">Edit</button>
->>>>>>> beta
                    </div>
                </div>
            </div>
@@ -1791,90 +680,16 @@
                <h2>Spotify Import Settings</h2>
                <div class="config-section">
                    <div class="config-item">
-<<<<<<< HEAD
-                        <span class="label">Spotify Import Enabled</span>
-                        <span class="value" id="config-spotify-import-enabled">-</span>
-                        <button onclick="openEditSetting('SPOTIFY_IMPORT_ENABLED', 'Spotify Import Enabled', 'toggle')">Edit</button>
-||||||| f68706f
-                        <span class="label">Sync Start Time</span>
-                        <span class="value" id="config-sync-time">-</span>
-                        <button onclick="openEditSetting('SPOTIFY_IMPORT_SYNC_START_HOUR', 'Sync Start Hour (0-23)', 'number')">Edit</button>
-=======
                        <span class="label">Spotify Import Enabled</span>
                        <span class="value" id="config-spotify-import-enabled">-</span>
                        <button
                            onclick="openEditSetting('SPOTIFY_IMPORT_ENABLED', 'Spotify Import Enabled', 'toggle')">Edit</button>
->>>>>>> beta
                    </div>
                    <div class="config-item">
-<<<<<<< HEAD
-                        <span class="label">Matching Interval (hours)</span>
-                        <span class="value" id="config-matching-interval">-</span>
-                        <button onclick="openEditSetting('SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS', 'Matching Interval (hours)', 'number', 'How often to check for playlist updates')">Edit</button>
-                    </div>
-                </div>
-            </div>
-            
-            <div class="card">
-                <h2>Cache Settings</h2>
-                <p style="color: var(--text-secondary); margin-bottom: 16px;">
-                    Configure how long different types of data are cached. Longer durations reduce API calls but may show stale data.
-                </p>
-                <div class="config-section">
-                    <div class="config-item">
-                        <span class="label">Search Results (minutes)</span>
-                        <span class="value" id="config-cache-search">-</span>
-                        <button onclick="openEditCacheSetting('SearchResultsMinutes', 'Search Results Cache (minutes)', 'How long to cache search results')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Playlist Images (hours)</span>
-                        <span class="value" id="config-cache-playlist-images">-</span>
-                        <button onclick="openEditCacheSetting('PlaylistImagesHours', 'Playlist Images Cache (hours)', 'How long to cache playlist cover images')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Spotify Playlist Items (hours)</span>
-                        <span class="value" id="config-cache-spotify-items">-</span>
-                        <button onclick="openEditCacheSetting('SpotifyPlaylistItemsHours', 'Spotify Playlist Items Cache (hours)', 'How long to cache Spotify playlist data')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Spotify Matched Tracks (days)</span>
-                        <span class="value" id="config-cache-matched-tracks">-</span>
-                        <button onclick="openEditCacheSetting('SpotifyMatchedTracksDays', 'Matched Tracks Cache (days)', 'How long to cache Spotify ID to track mappings')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Lyrics (days)</span>
-                        <span class="value" id="config-cache-lyrics">-</span>
-                        <button onclick="openEditCacheSetting('LyricsDays', 'Lyrics Cache (days)', 'How long to cache fetched lyrics')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Genre Data (days)</span>
-                        <span class="value" id="config-cache-genres">-</span>
-                        <button onclick="openEditCacheSetting('GenreDays', 'Genre Cache (days)', 'How long to cache genre information')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">External Metadata (days)</span>
-                        <span class="value" id="config-cache-metadata">-</span>
-                        <button onclick="openEditCacheSetting('MetadataDays', 'Metadata Cache (days)', 'How long to cache SquidWTF/Deezer/Qobuz metadata')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Odesli Lookups (days)</span>
-                        <span class="value" id="config-cache-odesli">-</span>
-                        <button onclick="openEditCacheSetting('OdesliLookupDays', 'Odesli Lookup Cache (days)', 'How long to cache Odesli URL conversions')">Edit</button>
-                    </div>
-                    <div class="config-item">
-                        <span class="label">Proxy Images (days)</span>
-                        <span class="value" id="config-cache-proxy-images">-</span>
-                        <button onclick="openEditCacheSetting('ProxyImagesDays', 'Proxy Images Cache (days)', 'How long to cache proxied Jellyfin images')">Edit</button>
-||||||| f68706f
-                        <span class="label">Sync Window</span>
-                        <span class="value" id="config-sync-window">-</span>
-                        <button onclick="openEditSetting('SPOTIFY_IMPORT_SYNC_WINDOW_HOURS', 'Sync Window (hours)', 'number')">Edit</button>
-=======
                        <span class="label">Matching Interval (hours)</span>
                        <span class="value" id="config-matching-interval">-</span>
                        <button
                            onclick="openEditSetting('SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS', 'Matching Interval (hours)', 'number', 'How often to check for playlist updates')">Edit</button>
->>>>>>> beta
                    </div>
                </div>
            </div>
@@ -2118,14 +933,8 @@
        <div class="modal-content" style="max-width: 600px;">
            <h3>Map Track to External Provider</h3>
            <p style="color: var(--text-secondary); margin-bottom: 16px;">
-<<<<<<< HEAD
-                Map this track to an external provider (SquidWTF, Deezer, or Qobuz). For local Jellyfin tracks, use the Jellyfin mapping modal instead.
-||||||| f68706f
-                Map this track to an external provider (SquidWTF, Deezer, or Qobuz). For local Jellyfin tracks, use the Spotify Import plugin instead.
-=======
                Map this track to an external provider (SquidWTF, Deezer, or Qobuz). For local Jellyfin tracks, use the
                Jellyfin mapping modal instead.
->>>>>>> beta
            </p>

            <!-- Track Info -->
@@ -2167,48 +976,6 @@
            </div>
        </div>
    </div>
-<<<<<<< HEAD
-    
-    <!-- Local Jellyfin Track Mapping Modal -->
-    <div class="modal" id="local-map-modal">
-        <div class="modal-content" style="max-width: 700px;">
-            <h3>Map Track to Local Jellyfin Track</h3>
-            <p style="color: var(--text-secondary); margin-bottom: 16px;">
-                Search your Jellyfin library and select a local track to map to this Spotify track.
-            </p>
-            
-            <!-- Track Info -->
-            <div class="form-group">
-                <label>Spotify Track (Position <span id="local-map-position"></span>)</label>
-                <div style="background: var(--bg-primary); padding: 12px; border-radius: 8px; margin-bottom: 16px;">
-                    <strong id="local-map-spotify-title"></strong><br>
-                    <span style="color: var(--text-secondary);" id="local-map-spotify-artist"></span>
-                </div>
-            </div>
-            
-            <!-- Search Section -->
-            <div class="form-group">
-                <label>Search Jellyfin Library</label>
-                <input type="text" id="local-map-search" placeholder="Search for track name or artist...">
-                <button onclick="searchJellyfinTracks()" style="margin-top: 8px; width: 100%;">🔍 Search</button>
-            </div>
-            
-            <!-- Search Results -->
-            <div id="local-map-results" style="max-height: 300px; overflow-y: auto; margin-top: 16px;"></div>
-            
-            <input type="hidden" id="local-map-playlist-name">
-            <input type="hidden" id="local-map-spotify-id">
-            <input type="hidden" id="local-map-jellyfin-id">
-            <div class="modal-actions">
-                <button onclick="closeModal('local-map-modal')">Cancel</button>
-                <button class="primary" onclick="saveLocalMapping()" id="local-map-save-btn" disabled>Save Mapping</button>
-            </div>
-        </div>
-    </div>
-    
-||||||| f68706f
-    
-=======

    <!-- Local Jellyfin Track Mapping Modal -->
    <div class="modal" id="local-map-modal">
@@ -2248,54 +1015,19 @@
        </div>
    </div>

->>>>>>> beta
    <!-- Link Playlist Modal -->
    <div class="modal" id="link-playlist-modal">
        <div class="modal-content">
            <h3>Link to Spotify Playlist</h3>
            <p style="color: var(--text-secondary); margin-bottom: 16px;">
-<<<<<<< HEAD
-                Select a playlist from your Spotify library or enter a playlist ID/URL manually. Allstarr will automatically download missing tracks from your configured music service.
-||||||| f68706f
-                Enter the Spotify playlist ID or URL. Allstarr will automatically download missing tracks from your configured music service.
-=======
                Select a playlist from your Spotify library or enter a playlist ID/URL manually. Allstarr will
                automatically download missing tracks from your configured music service.
->>>>>>> beta
            </p>
            <div class="form-group">
                <label>Jellyfin Playlist</label>
                <input type="text" id="link-jellyfin-name" readonly style="background: var(--bg-primary);">
                <input type="hidden" id="link-jellyfin-id">
            </div>
-<<<<<<< HEAD
-            
-            <!-- Toggle between select and manual input -->
-            <div style="display: flex; gap: 8px; margin-bottom: 16px;">
-                <button type="button" id="select-mode-btn" class="primary" onclick="switchLinkMode('select')" style="flex: 1;">Select from My Playlists</button>
-                <button type="button" id="manual-mode-btn" onclick="switchLinkMode('manual')" style="flex: 1;">Enter Manually</button>
-            </div>
-            
-            <!-- Select from user playlists -->
-            <div class="form-group" id="link-select-group">
-                <label>Your Spotify Playlists</label>
-                <select id="link-spotify-select" style="width: 100%;">
-                    <option value="">Loading playlists...</option>
-                </select>
-                <small style="color: var(--text-secondary); display: block; margin-top: 4px;">
-                    Select a playlist from your Spotify library
-                </small>
-            </div>
-            
-            <!-- Manual input -->
-            <div class="form-group" id="link-manual-group" style="display: none;">
-                <label>Spotify Playlist ID or URL</label>
-                <input type="text" id="link-spotify-id" placeholder="37i9dQZF1DXcBWIGoYBM5M or spotify:playlist:... or full URL">
-||||||| f68706f
-            <div class="form-group">
-                <label>Spotify Playlist ID or URL</label>
-                <input type="text" id="link-spotify-id" placeholder="37i9dQZF1DXcBWIGoYBM5M or spotify:playlist:... or full URL">
-=======

            <!-- Toggle between select and manual input -->
            <div style="display: flex; gap: 8px; margin-bottom: 16px;">
@@ -2311,27 +1043,10 @@
                <select id="link-spotify-select" style="width: 100%;">
                    <option value="">Loading playlists...</option>
                </select>
->>>>>>> beta
                <small style="color: var(--text-secondary); display: block; margin-top: 4px;">
                    Select a playlist from your Spotify library
                </small>
            </div>
-<<<<<<< HEAD
-            
-            <!-- Sync Schedule -->
-            <div class="form-group">
-                <label>Sync Schedule (Cron)</label>
-                <input type="text" id="link-sync-schedule" placeholder="0 8 * * 1" value="0 8 * * 1" style="font-family: monospace;">
-                <small style="color: var(--text-secondary); display: block; margin-top: 4px;">
-                    Cron format: <code>minute hour day month dayofweek</code><br>
-                    Default: <code>0 8 * * 1</code> = 8 AM every Monday<br>
-                    Examples: <code>0 6 * * *</code> = daily at 6 AM, <code>0 20 * * 5</code> = Fridays at 8 PM<br>
-                    <a href="https://crontab.guru/" target="_blank" style="color: var(--primary);">Use crontab.guru to build your schedule</a>
-                </small>
-            </div>
-            
-||||||| f68706f
-=======

            <!-- Manual input -->
            <div class="form-group" id="link-manual-group" style="display: none;">
@@ -2358,7 +1073,6 @@
                </small>
            </div>

->>>>>>> beta
            <div class="modal-actions">
                <button onclick="closeModal('link-playlist-modal')">Cancel</button>
                <button class="primary" onclick="linkPlaylist()">Link Playlist</button>
@@ -2413,4011 +1127,7 @@
        <h2>Restarting Container</h2>
        <p id="restart-status">Applying configuration changes...</p>
    </div>
-<<<<<<< HEAD
-    
-    <script>
-        // Current edit setting state
-        let currentEditKey = null;
-        let currentEditType = null;
-        let currentEditOptions = null;
-        
-        // Track if we've already initialized the cookie date to prevent infinite loop
-        let cookieDateInitialized = false;
-        
-        // Track if restart is required
-        let restartRequired = false;
-        
-        function showRestartBanner() {
-            restartRequired = true;
-            document.getElementById('restart-banner').classList.add('active');
-        }
-        
-        function dismissRestartBanner() {
-            document.getElementById('restart-banner').classList.remove('active');
-        }
-        
-        // Tab switching with URL hash support
-        function switchTab(tabName) {
-            document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-            document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
-            
-            const tab = document.querySelector(`.tab[data-tab="${tabName}"]`);
-            const content = document.getElementById('tab-' + tabName);
-            
-            if (tab && content) {
-                tab.classList.add('active');
-                content.classList.add('active');
-                window.location.hash = tabName;
-            }
-        }
-        
-        document.querySelectorAll('.tab').forEach(tab => {
-            tab.addEventListener('click', () => {
-                switchTab(tab.dataset.tab);
-            });
-        });
-        
-        // Restore tab from URL hash on page load
-        window.addEventListener('load', () => {
-            const hash = window.location.hash.substring(1);
-            if (hash) {
-                switchTab(hash);
-            }
-            
-            // Start auto-refresh for playlists tab (every 5 seconds)
-            startPlaylistAutoRefresh();
-        });
-        
-        // Auto-refresh functionality for playlists
-        let playlistAutoRefreshInterval = null;
-        
-        function startPlaylistAutoRefresh() {
-            // Clear any existing interval
-            if (playlistAutoRefreshInterval) {
-                clearInterval(playlistAutoRefreshInterval);
-            }
-            
-            // Refresh every 5 seconds when on playlists tab
-            playlistAutoRefreshInterval = setInterval(() => {
-                const playlistsTab = document.getElementById('tab-playlists');
-                if (playlistsTab && playlistsTab.classList.contains('active')) {
-                    // Silently refresh without showing loading state
-                    fetchPlaylists(true);
-                }
-            }, 5000);
-        }
-        
-        function stopPlaylistAutoRefresh() {
-            if (playlistAutoRefreshInterval) {
-                clearInterval(playlistAutoRefreshInterval);
-                playlistAutoRefreshInterval = null;
-            }
-        }
-        
-        // Toast notification
-        function showToast(message, type = 'success', duration = 3000) {
-            const toast = document.createElement('div');
-            toast.className = 'toast ' + type;
-            toast.textContent = message;
-            document.body.appendChild(toast);
-            setTimeout(() => toast.remove(), duration);
-        }
-        
-        // Modal helpers
-        function openModal(id) {
-            document.getElementById(id).classList.add('active');
-        }
-        
-        function closeModal(id) {
-            document.getElementById(id).classList.remove('active');
-        }
-        
-        // Close modals on backdrop click
-        document.querySelectorAll('.modal').forEach(modal => {
-            modal.addEventListener('click', e => {
-                if (e.target === modal) closeModal(modal.id);
-            });
-        });
-        
-        // Format cookie age with color coding
-        function formatCookieAge(setDateStr, hasCookie = false) {
-            if (!setDateStr) {
-                if (hasCookie) {
-                    return { text: 'Unknown age', class: 'warning', detail: 'Cookie date not tracked', needsInit: true };
-                }
-                return { text: 'No cookie', class: '', detail: '', needsInit: false };
-            }
-            
-            const setDate = new Date(setDateStr);
-            const now = new Date();
-            const diffMs = now - setDate;
-            const daysAgo = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-            const monthsAgo = daysAgo / 30;
-            
-            let status = 'success';  // green: < 6 months
-            if (monthsAgo >= 10) status = 'error';  // red: > 10 months
-            else if (monthsAgo >= 6) status = 'warning';  // yellow: 6-10 months
-            
-            let text;
-            if (daysAgo === 0) text = 'Set today';
-            else if (daysAgo === 1) text = 'Set yesterday';
-            else if (daysAgo < 30) text = `Set ${daysAgo} days ago`;
-            else if (daysAgo < 60) text = 'Set ~1 month ago';
-            else text = `Set ~${Math.floor(monthsAgo)} months ago`;
-            
-            const remaining = 12 - monthsAgo;
-            let detail;
-            if (remaining > 6) detail = 'Cookie typically lasts ~1 year';
-            else if (remaining > 2) detail = `~${Math.floor(remaining)} months until expiration`;
-            else if (remaining > 0) detail = 'Cookie may expire soon!';
-            else detail = 'Cookie may have expired - update if having issues';
-            
-            return { text, class: status, detail, needsInit: false };
-        }
-        
-        // Initialize cookie date if cookie exists but date is not set
-        async function initCookieDate() {
-            if (cookieDateInitialized) {
-                console.log('Cookie date already initialized, skipping');
-                return;
-            }
-            
-            cookieDateInitialized = true;
-            
-            try {
-                const res = await fetch('/api/admin/config/init-cookie-date', { method: 'POST' });
-                if (res.ok) {
-                    console.log('Cookie date initialized successfully - restart container to apply');
-                    showToast('Cookie date set. Restart container to apply changes.', 'success');
-                } else {
-                    const data = await res.json();
-                    console.log('Cookie date init response:', data);
-                }
-            } catch (error) {
-                console.error('Failed to init cookie date:', error);
-                cookieDateInitialized = false; // Allow retry on error
-            }
-        }
-        
-        // API calls
-        async function fetchStatus() {
-            try {
-                const res = await fetch('/api/admin/status');
-                const data = await res.json();
-                
-                document.getElementById('version').textContent = 'v' + data.version;
-                document.getElementById('backend-type').textContent = data.backendType;
-                document.getElementById('jellyfin-url').textContent = data.jellyfinUrl || '-';
-                document.getElementById('playlist-count').textContent = data.spotifyImport.playlistCount;
-                document.getElementById('cache-duration').textContent = data.spotify.cacheDurationMinutes + ' min';
-                document.getElementById('isrc-matching').textContent = data.spotify.preferIsrcMatching ? 'Enabled' : 'Disabled';
-                document.getElementById('spotify-user').textContent = data.spotify.user || '-';
-                
-                // Update status badge and cookie age
-                const statusBadge = document.getElementById('spotify-status');
-                const authStatus = document.getElementById('spotify-auth-status');
-                const cookieAgeEl = document.getElementById('spotify-cookie-age');
-                
-                if (data.spotify.authStatus === 'configured') {
-                    statusBadge.className = 'status-badge success';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Spotify Ready';
-                    authStatus.textContent = 'Cookie Set';
-                    authStatus.className = 'stat-value success';
-                } else if (data.spotify.authStatus === 'missing_cookie') {
-                    statusBadge.className = 'status-badge warning';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Cookie Missing';
-                    authStatus.textContent = 'No Cookie';
-                    authStatus.className = 'stat-value warning';
-                } else {
-                    statusBadge.className = 'status-badge';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Not Configured';
-                    authStatus.textContent = 'Not Configured';
-                    authStatus.className = 'stat-value';
-                }
-                
-                // Update cookie age display
-                if (cookieAgeEl) {
-                    const hasCookie = data.spotify.hasCookie;
-                    const age = formatCookieAge(data.spotify.cookieSetDate, hasCookie);
-                    cookieAgeEl.innerHTML = `<span class="${age.class}">${age.text}</span><br><small style="color:var(--text-secondary)">${age.detail}</small>`;
-                    
-                    // Auto-init cookie date if cookie exists but date is not set
-                    if (age.needsInit) {
-                        console.log('Cookie exists but date not set, initializing...');
-                        initCookieDate();
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to fetch status:', error);
-                showToast('Failed to fetch status', 'error');
-            }
-        }
-        
-        async function fetchPlaylists(silent = false) {
-            try {
-                const res = await fetch('/api/admin/playlists');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('playlist-table-body');
-                
-                if (data.playlists.length === 0) {
-                    if (!silent) {
-                        tbody.innerHTML = '<tr><td colspan="7" style="text-align:center;color:var(--text-secondary);padding:40px;">No playlists configured. Link playlists from the Jellyfin Playlists tab.</td></tr>';
-                    }
-                    return;
-                }
-                
-                tbody.innerHTML = data.playlists.map(p => {
-                    // Enhanced statistics display
-                    const spotifyTotal = p.trackCount || 0;
-                    const localCount = p.localTracks || 0;
-                    const externalMatched = p.externalMatched || 0;
-                    const externalMissing = p.externalMissing || 0;
-                    const totalInJellyfin = p.totalInJellyfin || 0;
-                    const totalPlayable = p.totalPlayable || (localCount + externalMatched); // Total tracks that will be served
-                    
-                    // Debug: Log the raw data
-                    console.log(`Playlist ${p.name}:`, {
-                        spotifyTotal,
-                        localCount,
-                        externalMatched,
-                        externalMissing,
-                        totalInJellyfin,
-                        totalPlayable,
-                        rawData: p
-                    });
-                    
-                    // Build detailed stats string - show total playable tracks prominently
-                    let statsHtml = `<span class="track-count">${totalPlayable}/${spotifyTotal}</span>`;
-                    
-                    // Show breakdown with color coding
-                    let breakdownParts = [];
-                    if (localCount > 0) {
-                        breakdownParts.push(`<span style="color:var(--success)">${localCount} Local</span>`);
-                    }
-                    if (externalMatched > 0) {
-                        breakdownParts.push(`<span style="color:var(--accent)">${externalMatched} External</span>`);
-                    }
-                    if (externalMissing > 0) {
-                        breakdownParts.push(`<span style="color:var(--warning)">${externalMissing} Missing</span>`);
-                    }
-                    
-                    const breakdown = breakdownParts.length > 0 
-                        ? `<br><small style="color:var(--text-secondary)">${breakdownParts.join(' • ')}</small>`
-                        : '';
-                    
-                    // Calculate completion percentage based on playable tracks
-                    const completionPct = spotifyTotal > 0 ? Math.round((totalPlayable / spotifyTotal) * 100) : 0;
-                    const localPct = spotifyTotal > 0 ? Math.round((localCount / spotifyTotal) * 100) : 0;
-                    const externalPct = spotifyTotal > 0 ? Math.round((externalMatched / spotifyTotal) * 100) : 0;
-                    const missingPct = spotifyTotal > 0 ? Math.round((externalMissing / spotifyTotal) * 100) : 0;
-                    const completionColor = completionPct === 100 ? 'var(--success)' : completionPct >= 80 ? 'var(--accent)' : 'var(--warning)';
-                    
-                    // Debug logging
-                    console.log(`Progress bar for ${p.name}: local=${localPct}%, external=${externalPct}%, missing=${missingPct}%, total=${completionPct}%`);
-                    
-                    const syncSchedule = p.syncSchedule || '0 8 * * 1';
-                    
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(p.name)}</strong></td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${p.id || '-'}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;">
-                                ${escapeHtml(syncSchedule)}
-                                <button onclick="editPlaylistSchedule('${escapeJs(p.name)}', '${escapeJs(syncSchedule)}')" style="margin-left:4px;font-size:0.75rem;padding:2px 6px;">Edit</button>
-                            </td>
-                            <td>${statsHtml}${breakdown}</td>
-                            <td>
-                                <div style="display:flex;align-items:center;gap:8px;">
-                                    <div style="flex:1;background:var(--bg-tertiary);height:12px;border-radius:6px;overflow:hidden;display:flex;">
-                                        <div style="width:${localPct}%;height:100%;background:#10b981;transition:width 0.3s;" title="${localCount} local tracks"></div>
-                                        <div style="width:${externalPct}%;height:100%;background:#3b82f6;transition:width 0.3s;" title="${externalMatched} external tracks"></div>
-                                        <div style="width:${missingPct}%;height:100%;background:#f59e0b;transition:width 0.3s;" title="${externalMissing} missing tracks"></div>
-                                    </div>
-                                    <span style="font-size:0.85rem;color:${completionColor};font-weight:500;min-width:40px;">${completionPct}%</span>
-                                </div>
-                            </td>
-                            <td class="cache-age">${p.cacheAge || '-'}</td>
-                            <td>
-                                <button onclick="matchPlaylistTracks('${escapeJs(p.name)}')" title="Re-match when local library changed (uses cached Spotify data)">Re-match Local</button>
-                                <button onclick="clearPlaylistCache('${escapeJs(p.name)}')" title="Rebuild when Spotify playlist changed (fetches fresh data)" style="background:var(--accent);border-color:var(--accent);">Rebuild Remote</button>
-                                <button onclick="viewTracks('${escapeJs(p.name)}')">View</button>
-                                <button class="danger" onclick="removePlaylist('${escapeJs(p.name)}')">Remove</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch playlists:', error);
-                showToast('Failed to fetch playlists', 'error');
-            }
-        }
-        
-        async function fetchTrackMappings() {
-            try {
-                const res = await fetch('/api/admin/mappings/tracks');
-                const data = await res.json();
-                
-                // Update summary (only external now)
-                document.getElementById('mappings-total').textContent = data.externalCount || 0;
-                document.getElementById('mappings-external').textContent = data.externalCount || 0;
-                
-                const tbody = document.getElementById('mappings-table-body');
-                
-                if (data.mappings.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No manual mappings found.</td></tr>';
-                    return;
-                }
-                
-                // Filter to only show external mappings
-                const externalMappings = data.mappings.filter(m => m.type === 'external');
-                
-                if (externalMappings.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No external mappings found. Local Jellyfin mappings should be managed via Spotify Import plugin.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = externalMappings.map((m, index) => {
-                    const typeColor = 'var(--success)';
-                    const typeBadge = `<span style="display:inline-block;padding:2px 8px;border-radius:4px;font-size:0.8rem;background:${typeColor}20;color:${typeColor};font-weight:500;">external</span>`;
-                    
-                    const targetDisplay = `<span style="font-family:monospace;font-size:0.85rem;color:var(--success);">${m.externalProvider}/${m.externalId}</span>`;
-                    
-                    const createdDate = m.createdAt ? new Date(m.createdAt).toLocaleString() : '-';
-                    
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(m.playlist)}</strong></td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${m.spotifyId}</td>
-                            <td>${typeBadge}</td>
-                            <td>${targetDisplay}</td>
-                            <td style="color:var(--text-secondary);font-size:0.85rem;">${createdDate}</td>
-                            <td>
-                                <button class="danger delete-mapping-btn" style="padding:4px 12px;font-size:0.8rem;" data-playlist="${escapeHtml(m.playlist)}" data-spotify-id="${m.spotifyId}">Remove</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-                
-                // Add event listeners to all delete buttons
-                document.querySelectorAll('.delete-mapping-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlist = this.getAttribute('data-playlist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        deleteTrackMapping(playlist, spotifyId);
-                    });
-                });
-            } catch (error) {
-                console.error('Failed to fetch track mappings:', error);
-                showToast('Failed to fetch track mappings', 'error');
-            }
-        }
-        
-        async function deleteTrackMapping(playlist, spotifyId) {
-            if (!confirm(`Remove manual external mapping for ${spotifyId} in playlist "${playlist}"?\n\nThis will:\n• Delete the manual mapping from the cache\n• Allow the track to be matched automatically again\n• The track may be re-matched with potentially better results\n\nThis action cannot be undone.`)) {
-                return;
-            }
-            
-            try {
-                const res = await fetch(`/api/admin/mappings/tracks?playlist=${encodeURIComponent(playlist)}&spotifyId=${encodeURIComponent(spotifyId)}`, {
-                    method: 'DELETE'
-                });
-                
-                if (res.ok) {
-                    showToast('Mapping removed successfully', 'success');
-                    await fetchTrackMappings();
-                } else {
-                    const error = await res.json();
-                    showToast(error.error || 'Failed to remove mapping', 'error');
-                }
-            } catch (error) {
-                console.error('Failed to delete mapping:', error);
-                showToast('Failed to remove mapping', 'error');
-            }
-        }
-        
-        async function fetchMissingTracks() {
-            try {
-                const res = await fetch('/api/admin/playlists');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('missing-tracks-table-body');
-                const missingTracks = [];
-                
-                // Collect all missing tracks from all playlists
-                for (const playlist of data.playlists) {
-                    if (playlist.externalMissing > 0) {
-                        // Fetch tracks for this playlist
-                        try {
-                            const tracksRes = await fetch(`/api/admin/playlists/${encodeURIComponent(playlist.name)}/tracks`);
-                            const tracksData = await tracksRes.json();
-                            
-                            // Filter to only missing tracks (isLocal === null)
-                            const missing = tracksData.tracks.filter(t => t.isLocal === null);
-                            missing.forEach(t => {
-                                missingTracks.push({
-                                    playlist: playlist.name,
-                                    ...t
-                                });
-                            });
-                        } catch (err) {
-                            console.error(`Failed to fetch tracks for ${playlist.name}:`, err);
-                        }
-                    }
-                }
-                
-                // Update summary
-                document.getElementById('missing-total').textContent = missingTracks.length;
-                
-                if (missingTracks.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="5" style="text-align:center;color:var(--text-secondary);padding:40px;">🎉 No missing tracks! All tracks are matched.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = missingTracks.map(t => {
-                    const artist = (t.artists && t.artists.length > 0) ? t.artists.join(', ') : '';
-                    const searchQuery = `${t.title} ${artist}`;
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(t.playlist)}</strong></td>
-                            <td>${escapeHtml(t.title)}</td>
-                            <td>${escapeHtml(artist)}</td>
-                            <td style="color:var(--text-secondary);">${t.album ? escapeHtml(t.album) : '-'}</td>
-                            <td>
-                                <button onclick="searchProvider('${escapeJs(searchQuery)}', 'squidwtf')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:#3b82f6;border-color:#3b82f6;color:white;">🔍 Search</button>
-                                <button onclick="openMapToLocal('${escapeJs(t.playlist)}', '${escapeJs(t.spotifyId)}', '${escapeJs(t.title)}', '${escapeJs(artist)}')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:var(--success);border-color:var(--success);">Map to Local</button>
-                                <button onclick="openMapToExternal('${escapeJs(t.playlist)}', '${escapeJs(t.spotifyId)}', '${escapeJs(t.title)}', '${escapeJs(artist)}')" 
-                                    style="font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch missing tracks:', error);
-                showToast('Failed to fetch missing tracks', 'error');
-            }
-        }
-        
-        async function fetchDownloads() {
-            try {
-                const res = await fetch('/api/admin/downloads');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('downloads-table-body');
-                
-                // Update summary
-                document.getElementById('downloads-count').textContent = data.count;
-                document.getElementById('downloads-size').textContent = data.totalSizeFormatted;
-                
-                if (data.count === 0) {
-                    tbody.innerHTML = '<tr><td colspan="5" style="text-align:center;color:var(--text-secondary);padding:40px;">No downloaded files found.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.files.map(f => {
-                    return `
-                        <tr data-path="${escapeHtml(f.path)}">
-                            <td><strong>${escapeHtml(f.artist)}</strong></td>
-                            <td>${escapeHtml(f.album)}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;">${escapeHtml(f.fileName)}</td>
-                            <td style="color:var(--text-secondary);">${f.sizeFormatted}</td>
-                            <td>
-                                <button onclick="downloadFile('${escapeJs(f.path)}')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:var(--accent);border-color:var(--accent);">Download</button>
-                                <button onclick="deleteDownload('${escapeJs(f.path)}')" 
-                                    class="danger" style="font-size:0.75rem;padding:4px 8px;">Delete</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch downloads:', error);
-                showToast('Failed to fetch downloads', 'error');
-            }
-        }
-        
-        async function downloadFile(path) {
-            try {
-                window.open(`/api/admin/downloads/file?path=${encodeURIComponent(path)}`, '_blank');
-            } catch (error) {
-                console.error('Failed to download file:', error);
-                showToast('Failed to download file', 'error');
-            }
-        }
-        
-        async function deleteDownload(path) {
-            if (!confirm(`Delete this file?\n\n${path}\n\nThis action cannot be undone.`)) {
-                return;
-            }
-            
-            try {
-                const res = await fetch(`/api/admin/downloads?path=${encodeURIComponent(path)}`, {
-                    method: 'DELETE'
-                });
-                
-                if (res.ok) {
-                    showToast('File deleted successfully', 'success');
-                    
-                    // Remove the row immediately for live update
-                    const escapedPath = path.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-                    const row = document.querySelector(`tr[data-path="${escapedPath}"]`);
-                    if (row) {
-                        row.remove();
-                    }
-                    
-                    // Refresh to update counts
-                    await fetchDownloads();
-                } else {
-                    const error = await res.json();
-                    showToast(error.error || 'Failed to delete file', 'error');
-                }
-            } catch (error) {
-                console.error('Failed to delete file:', error);
-                showToast('Failed to delete file', 'error');
-            }
-        }
-        
-        async function fetchConfig() {
-            try {
-                const res = await fetch('/api/admin/config');
-                const data = await res.json();
-                
-                // Core settings
-                document.getElementById('config-backend-type').textContent = data.backendType || 'Jellyfin';
-                document.getElementById('config-music-service').textContent = data.musicService || 'SquidWTF';
-                document.getElementById('config-storage-mode').textContent = data.library?.storageMode || 'Cache';
-                document.getElementById('config-cache-duration-hours').textContent = data.library?.cacheDurationHours || '24';
-                document.getElementById('config-download-mode').textContent = data.library?.downloadMode || 'Track';
-                document.getElementById('config-explicit-filter').textContent = data.explicitFilter || 'All';
-                document.getElementById('config-enable-external-playlists').textContent = data.enableExternalPlaylists ? 'Yes' : 'No';
-                document.getElementById('config-playlists-directory').textContent = data.playlistsDirectory || '(not set)';
-                document.getElementById('config-redis-enabled').textContent = data.redisEnabled ? 'Yes' : 'No';
-                
-                // Show/hide cache duration based on storage mode
-                const cacheDurationRow = document.getElementById('cache-duration-row');
-                if (cacheDurationRow) {
-                    cacheDurationRow.style.display = data.library?.storageMode === 'Cache' ? 'grid' : 'none';
-                }
-                
-                // Spotify API settings
-                document.getElementById('config-spotify-enabled').textContent = data.spotifyApi.enabled ? 'Yes' : 'No';
-                document.getElementById('config-spotify-cookie').textContent = data.spotifyApi.sessionCookie;
-                document.getElementById('config-cache-duration').textContent = data.spotifyApi.cacheDurationMinutes + ' minutes';
-                document.getElementById('config-isrc-matching').textContent = data.spotifyApi.preferIsrcMatching ? 'Enabled' : 'Disabled';
-                
-                // Cookie age in config tab
-                const configCookieAge = document.getElementById('config-cookie-age');
-                if (configCookieAge) {
-                    const hasCookie = data.spotifyApi.sessionCookie && data.spotifyApi.sessionCookie !== '(not set)';
-                    const age = formatCookieAge(data.spotifyApi.sessionCookieSetDate, hasCookie);
-                    configCookieAge.innerHTML = `<span class="${age.class}">${age.text}</span> - ${age.detail}`;
-                }
-                
-                // Deezer settings
-                document.getElementById('config-deezer-arl').textContent = data.deezer.arl || '(not set)';
-                document.getElementById('config-deezer-quality').textContent = data.deezer.quality;
-                
-                // SquidWTF settings
-                document.getElementById('config-squid-quality').textContent = data.squidWtf.quality;
-                
-                // MusicBrainz settings
-                document.getElementById('config-musicbrainz-enabled').textContent = data.musicBrainz.enabled ? 'Yes' : 'No';
-                document.getElementById('config-musicbrainz-username').textContent = data.musicBrainz.username || '(not set)';
-                document.getElementById('config-musicbrainz-password').textContent = data.musicBrainz.password || '(not set)';
-                
-                // Qobuz settings
-                document.getElementById('config-qobuz-token').textContent = data.qobuz.userAuthToken || '(not set)';
-                document.getElementById('config-qobuz-quality').textContent = data.qobuz.quality || 'FLAC';
-                
-                // Jellyfin settings
-                document.getElementById('config-jellyfin-url').textContent = data.jellyfin.url || '-';
-                document.getElementById('config-jellyfin-api-key').textContent = data.jellyfin.apiKey;
-                document.getElementById('config-jellyfin-user-id').textContent = data.jellyfin.userId || '(not set)';
-                document.getElementById('config-jellyfin-library-id').textContent = data.jellyfin.libraryId || '-';
-                
-                // Library settings
-                document.getElementById('config-download-path').textContent = data.library?.downloadPath || './downloads';
-                document.getElementById('config-kept-path').textContent = data.library?.keptPath || '/app/kept';
-                
-                // Sync settings
-                document.getElementById('config-spotify-import-enabled').textContent = data.spotifyImport?.enabled ? 'Yes' : 'No';
-                document.getElementById('config-matching-interval').textContent = (data.spotifyImport?.matchingIntervalHours || 24) + ' hours';
-                
-                // Cache settings
-                if (data.cache) {
-                    document.getElementById('config-cache-search').textContent = data.cache.searchResultsMinutes || '120';
-                    document.getElementById('config-cache-playlist-images').textContent = data.cache.playlistImagesHours || '168';
-                    document.getElementById('config-cache-spotify-items').textContent = data.cache.spotifyPlaylistItemsHours || '168';
-                    document.getElementById('config-cache-matched-tracks').textContent = data.cache.spotifyMatchedTracksDays || '30';
-                    document.getElementById('config-cache-lyrics').textContent = data.cache.lyricsDays || '14';
-                    document.getElementById('config-cache-genres').textContent = data.cache.genreDays || '30';
-                    document.getElementById('config-cache-metadata').textContent = data.cache.metadataDays || '7';
-                    document.getElementById('config-cache-odesli').textContent = data.cache.odesliLookupDays || '60';
-                    document.getElementById('config-cache-proxy-images').textContent = data.cache.proxyImagesDays || '14';
-                }
-            } catch (error) {
-                console.error('Failed to fetch config:', error);
-            }
-        }
-        
-        async function fetchJellyfinUsers() {
-            try {
-                const res = await fetch('/api/admin/jellyfin/users');
-                if (!res.ok) return;
-                const data = await res.json();
-                const select = document.getElementById('jellyfin-user-select');
-                select.innerHTML = '<option value="">All Users</option>' + 
-                    data.users.map(u => `<option value="${u.id}">${escapeHtml(u.name)}</option>`).join('');
-            } catch (error) {
-                console.error('Failed to fetch users:', error);
-            }
-        }
-        
-        
-        async function fetchJellyfinPlaylists() {
-            const tbody = document.getElementById('jellyfin-playlist-table-body');
-            tbody.innerHTML = '<tr><td colspan="6" class="loading"><span class="spinner"></span> Loading Jellyfin playlists...</td></tr>';
-            
-            try {
-                // Build URL with optional user filter
-                const userId = document.getElementById('jellyfin-user-select').value;
-                
-                let url = '/api/admin/jellyfin/playlists';
-                if (userId) url += '?userId=' + encodeURIComponent(userId);
-                
-                const res = await fetch(url);
-                
-                if (!res.ok) {
-                    const errorData = await res.json();
-                    tbody.innerHTML = `<tr><td colspan="6" style="text-align:center;color:var(--error);padding:40px;">${errorData.error || 'Failed to fetch playlists'}</td></tr>`;
-                    return;
-                }
-                
-                const data = await res.json();
-                
-                if (data.playlists.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No playlists found in Jellyfin</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.playlists.map(p => {
-                    const statusBadge = p.isConfigured 
-                        ? '<span class="status-badge success"><span class="status-dot"></span>Linked</span>'
-                        : '<span class="status-badge"><span class="status-dot"></span>Not Linked</span>';
-                    
-                    const actionButton = p.isConfigured
-                        ? `<button class="danger" onclick="unlinkPlaylist('${escapeJs(p.name)}')">Unlink</button>`
-                        : `<button class="primary" onclick="openLinkPlaylist('${escapeJs(p.id)}', '${escapeJs(p.name)}')">Link to Spotify</button>`;
-                    
-                    const localCount = p.localTracks || 0;
-                    const externalCount = p.externalTracks || 0;
-                    const externalAvail = p.externalAvailable || 0;
-                    
-                    return `
-                        <tr data-playlist-id="${escapeHtml(p.id)}">
-                            <td><strong>${escapeHtml(p.name)}</strong></td>
-                            <td class="track-count">${localCount}</td>
-                            <td class="track-count">${externalCount > 0 ? `${externalAvail}/${externalCount}` : '-'}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${p.linkedSpotifyId || '-'}</td>
-                            <td>${statusBadge}</td>
-                            <td>${actionButton}</td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch Jellyfin playlists:', error);
-                tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--error);padding:40px;">Failed to fetch playlists</td></tr>';
-            }
-        }
-        
-        let currentLinkMode = 'select'; // 'select' or 'manual'
-        let spotifyUserPlaylists = []; // Cache of user playlists
-        
-        function switchLinkMode(mode) {
-            currentLinkMode = mode;
-            
-            const selectGroup = document.getElementById('link-select-group');
-            const manualGroup = document.getElementById('link-manual-group');
-            const selectBtn = document.getElementById('select-mode-btn');
-            const manualBtn = document.getElementById('manual-mode-btn');
-            
-            if (mode === 'select') {
-                selectGroup.style.display = 'block';
-                manualGroup.style.display = 'none';
-                selectBtn.classList.add('primary');
-                manualBtn.classList.remove('primary');
-            } else {
-                selectGroup.style.display = 'none';
-                manualGroup.style.display = 'block';
-                selectBtn.classList.remove('primary');
-                manualBtn.classList.add('primary');
-            }
-        }
-        
-        async function fetchSpotifyUserPlaylists() {
-            try {
-                const res = await fetch('/api/admin/spotify/user-playlists');
-                if (!res.ok) {
-                    const error = await res.json();
-                    console.error('Failed to fetch Spotify playlists:', res.status, error);
-                    
-                    // Show user-friendly error message
-                    if (res.status === 429) {
-                        showToast('Spotify rate limit reached. Please wait a moment and try again.', 'warning', 5000);
-                    } else if (res.status === 401) {
-                        showToast('Spotify authentication failed. Check your sp_dc cookie.', 'error', 5000);
-                    }
-                    return [];
-                }
-                const data = await res.json();
-                return data.playlists || [];
-            } catch (error) {
-                console.error('Failed to fetch Spotify playlists:', error);
-                return [];
-            }
-        }
-        
-        async function openLinkPlaylist(jellyfinId, name) {
-            document.getElementById('link-jellyfin-id').value = jellyfinId;
-            document.getElementById('link-jellyfin-name').value = name;
-            document.getElementById('link-spotify-id').value = '';
-            
-            // Reset to select mode
-            switchLinkMode('select');
-            
-            // Fetch user playlists if not already cached
-            if (spotifyUserPlaylists.length === 0) {
-                const select = document.getElementById('link-spotify-select');
-                select.innerHTML = '<option value="">Loading playlists...</option>';
-                
-                spotifyUserPlaylists = await fetchSpotifyUserPlaylists();
-                
-                // Filter out already-linked playlists
-                const availablePlaylists = spotifyUserPlaylists.filter(p => !p.isLinked);
-                
-                if (availablePlaylists.length === 0) {
-                    if (spotifyUserPlaylists.length > 0) {
-                        select.innerHTML = '<option value="">All your playlists are already linked</option>';
-                    } else {
-                        select.innerHTML = '<option value="">No playlists found or Spotify not configured</option>';
-                    }
-                    // Switch to manual mode if no available playlists
-                    switchLinkMode('manual');
-                } else {
-                    // Populate dropdown with only unlinked playlists
-                    select.innerHTML = '<option value="">-- Select a playlist --</option>' +
-                        availablePlaylists.map(p => 
-                            `<option value="${escapeHtml(p.id)}">${escapeHtml(p.name)} (${p.trackCount} tracks)</option>`
-                        ).join('');
-                }
-            } else {
-                // Re-filter in case playlists were linked since last fetch
-                const select = document.getElementById('link-spotify-select');
-                const availablePlaylists = spotifyUserPlaylists.filter(p => !p.isLinked);
-                
-                if (availablePlaylists.length === 0) {
-                    select.innerHTML = '<option value="">All your playlists are already linked</option>';
-                    switchLinkMode('manual');
-                } else {
-                    select.innerHTML = '<option value="">-- Select a playlist --</option>' +
-                        availablePlaylists.map(p => 
-                            `<option value="${escapeHtml(p.id)}">${escapeHtml(p.name)} (${p.trackCount} tracks)</option>`
-                        ).join('');
-                }
-            }
-            
-            openModal('link-playlist-modal');
-        }
-        
-        async function linkPlaylist() {
-            const jellyfinId = document.getElementById('link-jellyfin-id').value;
-            const name = document.getElementById('link-jellyfin-name').value;
-            const syncSchedule = document.getElementById('link-sync-schedule').value.trim();
-            
-            // Validate sync schedule (basic cron format check)
-            if (!syncSchedule) {
-                showToast('Sync schedule is required', 'error');
-                return;
-            }
-            
-            const cronParts = syncSchedule.split(/\s+/);
-            if (cronParts.length !== 5) {
-                showToast('Invalid cron format. Expected: minute hour day month dayofweek', 'error');
-                return;
-            }
-            
-            // Get Spotify ID based on current mode
-            let spotifyId = '';
-            if (currentLinkMode === 'select') {
-                spotifyId = document.getElementById('link-spotify-select').value;
-                if (!spotifyId) {
-                    showToast('Please select a Spotify playlist', 'error');
-                    return;
-                }
-            } else {
-                spotifyId = document.getElementById('link-spotify-id').value.trim();
-                if (!spotifyId) {
-                    showToast('Spotify Playlist ID is required', 'error');
-                    return;
-                }
-            }
-            
-            // Extract ID from various Spotify formats:
-            // - spotify:playlist:37i9dQZF1DXcBWIGoYBM5M
-            // - https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M
-            // - 37i9dQZF1DXcBWIGoYBM5M
-            let cleanSpotifyId = spotifyId;
-            
-            // Handle spotify: URI format
-            if (spotifyId.startsWith('spotify:playlist:')) {
-                cleanSpotifyId = spotifyId.replace('spotify:playlist:', '');
-            }
-            // Handle URL format
-            else if (spotifyId.includes('spotify.com/playlist/')) {
-                const match = spotifyId.match(/playlist\/([a-zA-Z0-9]+)/);
-                if (match) cleanSpotifyId = match[1];
-            }
-            // Remove any query parameters or trailing slashes
-            cleanSpotifyId = cleanSpotifyId.split('?')[0].split('#')[0].replace(/\/$/, '');
-            
-            try {
-                const res = await fetch(`/api/admin/jellyfin/playlists/${encodeURIComponent(jellyfinId)}/link`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ 
-                        name, 
-                        spotifyPlaylistId: cleanSpotifyId,
-                        syncSchedule: syncSchedule
-                    })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist linked!', 'success');
-                    showRestartBanner();
-                    closeModal('link-playlist-modal');
-                    
-                    // Clear the Spotify playlists cache so it refreshes next time
-                    spotifyUserPlaylists = [];
-                    
-                    // Update UI state without refetching all playlists
-                    const playlistsTable = document.getElementById('jellyfinPlaylistsTable');
-                    if (playlistsTable) {
-                        const rows = playlistsTable.querySelectorAll('tr');
-                        rows.forEach(row => {
-                            if (row.dataset.playlistId === jellyfinId) {
-                                const actionCell = row.querySelector('td:last-child');
-                                if (actionCell) {
-                                    actionCell.innerHTML = `<button class="danger" onclick="unlinkPlaylist('${escapeJs(name)}')">Unlink</button>`;
-                                }
-                            }
-                        });
-                    }
-                    
-                    fetchPlaylists(); // Only refresh the Active Playlists tab
-                } else {
-                    showToast(data.error || 'Failed to link playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to link playlist', 'error');
-            }
-        }
-        
-        async function unlinkPlaylist(name) {
-            if (!confirm(`Unlink playlist "${name}"? This will stop filling in missing tracks.`)) return;
-            
-            try {
-                const res = await fetch(`/api/admin/jellyfin/playlists/${encodeURIComponent(name)}/unlink`, {
-                    method: 'DELETE'
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist unlinked.', 'success');
-                    showRestartBanner();
-                    
-                    // Clear the Spotify playlists cache so it refreshes next time
-                    spotifyUserPlaylists = [];
-                    
-                    // Update UI state without refetching all playlists
-                    const playlistsTable = document.getElementById('jellyfinPlaylistsTable');
-                    if (playlistsTable) {
-                        const rows = playlistsTable.querySelectorAll('tr');
-                        rows.forEach(row => {
-                            const nameCell = row.querySelector('td:first-child');
-                            if (nameCell && nameCell.textContent === name) {
-                                const actionCell = row.querySelector('td:last-child');
-                                if (actionCell) {
-                                    const playlistId = row.dataset.playlistId;
-                                    actionCell.innerHTML = `<button class="primary" onclick="openLinkPlaylist('${escapeJs(playlistId)}', '${escapeJs(name)}')">Link to Spotify</button>`;
-                                }
-                            }
-                        });
-                    }
-                    
-                    fetchPlaylists(); // Only refresh the Active Playlists tab
-                } else {
-                    showToast(data.error || 'Failed to unlink playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to unlink playlist', 'error');
-            }
-        }
-        
-        async function refreshPlaylists() {
-            try {
-                showToast('Refreshing playlists...', 'success');
-                const res = await fetch('/api/admin/playlists/refresh', { method: 'POST' });
-                const data = await res.json();
-                showToast(data.message, 'success');
-                setTimeout(fetchPlaylists, 2000);
-            } catch (error) {
-                showToast('Failed to refresh playlists', 'error');
-            }
-        }
-        
-        async function clearPlaylistCache(name) {
-            if (!confirm(`Rebuild "${name}" from scratch?\n\nThis will:\n• Fetch fresh Spotify playlist data\n• Clear all caches\n• Re-match all tracks\n\nUse this when the Spotify playlist has changed.\n\nThis may take a minute.`)) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast(`Rebuilding ${name} from scratch...`, 'info');
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/clear-cache`, { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message}`, 'success', 5000);
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 3000);
-                } else {
-                    showToast(data.error || 'Failed to rebuild playlist', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to clear cache', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function matchPlaylistTracks(name) {
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast(`Re-matching local tracks for ${name}...`, 'info');
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/match`, { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message}`, 'success');
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 2000);
-                } else {
-                    showToast(data.error || 'Failed to re-match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to re-match tracks', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function matchAllPlaylists() {
-            if (!confirm('Re-match local tracks for ALL playlists?\n\nUse this when your local library has changed.\n\nThis may take a few minutes.')) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast('Matching tracks for all playlists...', 'success');
-                const res = await fetch('/api/admin/playlists/match-all', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message}`, 'success');
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 2000);
-                } else {
-                    showToast(data.error || 'Failed to match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to match tracks', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function refreshAndMatchAll() {
-            if (!confirm('Clear caches, refresh from Spotify, and match all tracks?\n\nThis will:\n• Clear all playlist caches\n• Fetch fresh data from Spotify\n• Match all tracks against local library and external providers\n\nThis may take several minutes.')) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast('Starting full refresh and match...', 'info', 3000);
-                
-                // Step 1: Clear all caches
-                showToast('Step 1/3: Clearing caches...', 'info', 2000);
-                await fetch('/api/admin/cache/clear', { method: 'POST' });
-                
-                // Wait for cache to be fully cleared
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                
-                // Step 2: Refresh playlists from Spotify
-                showToast('Step 2/3: Fetching from Spotify...', 'info', 2000);
-                await fetch('/api/admin/playlists/refresh', { method: 'POST' });
-                
-                // Wait for Spotify fetch to complete
-                await new Promise(resolve => setTimeout(resolve, 5000));
-                
-                // Step 3: Match all tracks
-                showToast('Step 3/3: Matching all tracks (this may take several minutes)...', 'info', 3000);
-                const res = await fetch('/api/admin/playlists/match-all', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ Full refresh and match complete!`, 'success', 5000);
-                    // Refresh the playlists table after a delay
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 3000);
-                } else {
-                    showToast(data.error || 'Failed to match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to complete refresh and match', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        
-        async function searchProvider(query, provider) {
-            // Use SquidWTF HiFi API with round-robin base URLs for all searches
-            // Get a random base URL from the backend
-            try {
-                const response = await fetch('/api/admin/squidwtf-base-url');
-                const data = await response.json();
-                
-                if (data.baseUrl) {
-                    // Use the HiFi API search endpoint: /search/?s=query
-                    const searchUrl = `${data.baseUrl}/search/?s=${encodeURIComponent(query)}`;
-                    window.open(searchUrl, '_blank');
-                } else {
-                    showToast('Failed to get search URL', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to get search URL', 'error');
-            }
-        }
-        
-        function capitalizeProvider(provider) {
-            // Capitalize provider names for display
-            const providerMap = {
-                'squidwtf': 'SquidWTF',
-                'deezer': 'Deezer',
-                'qobuz': 'Qobuz'
-            };
-            return providerMap[provider?.toLowerCase()] || provider;
-        }
-        
-        async function clearCache() {
-            if (!confirm('Clear all cached playlist data?')) return;
-            
-            try {
-                const res = await fetch('/api/admin/cache/clear', { method: 'POST' });
-                const data = await res.json();
-                showToast(data.message, 'success');
-                fetchPlaylists();
-            } catch (error) {
-                showToast('Failed to clear cache', 'error');
-            }
-        }
-        
-        async function exportEnv() {
-            try {
-                const res = await fetch('/api/admin/export-env');
-                if (!res.ok) {
-                    throw new Error('Export failed');
-                }
-                
-                const blob = await res.blob();
-                const url = window.URL.createObjectURL(blob);
-                const a = document.createElement('a');
-                a.href = url;
-                a.download = `.env.backup.${new Date().toISOString().split('T')[0]}`;
-                document.body.appendChild(a);
-                a.click();
-                window.URL.revokeObjectURL(url);
-                document.body.removeChild(a);
-                
-                showToast('.env file exported successfully', 'success');
-            } catch (error) {
-                showToast('Failed to export .env file', 'error');
-            }
-        }
-        
-        async function importEnv(event) {
-            const file = event.target.files[0];
-            if (!file) return;
-            
-            if (!confirm('Import this .env file? This will replace your current configuration.\n\nA backup will be created automatically.\n\nYou will need to restart the container for changes to take effect.')) {
-                event.target.value = '';
-                return;
-            }
-            
-            try {
-                const formData = new FormData();
-                formData.append('file', file);
-                
-                const res = await fetch('/api/admin/import-env', {
-                    method: 'POST',
-                    body: formData
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(data.message, 'success');
-                } else {
-                    showToast(data.error || 'Failed to import .env file', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to import .env file', 'error');
-            }
-            
-            event.target.value = '';
-        }
-        
-        async function restartContainer() {
-            if (!confirm('Restart the container to apply configuration changes?\n\nThe dashboard will be temporarily unavailable.')) {
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/restart', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    // Show the restart overlay
-                    document.getElementById('restart-overlay').classList.add('active');
-                    document.getElementById('restart-status').textContent = 'Stopping container...';
-                    
-                    // Wait a bit then start checking if the server is back
-                    setTimeout(() => {
-                        document.getElementById('restart-status').textContent = 'Waiting for server to come back...';
-                        checkServerAndReload();
-                    }, 3000);
-                } else {
-                    showToast(data.message || data.error || 'Failed to restart', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to restart container', 'error');
-            }
-        }
-        
-        async function checkServerAndReload() {
-            let attempts = 0;
-            const maxAttempts = 60; // Try for 60 seconds
-            
-            const checkHealth = async () => {
-                try {
-                    const res = await fetch('/api/admin/status', { 
-                        method: 'GET',
-                        cache: 'no-store'
-                    });
-                    if (res.ok) {
-                        document.getElementById('restart-status').textContent = 'Server is back! Reloading...';
-                        dismissRestartBanner();
-                        setTimeout(() => window.location.reload(), 500);
-                        return;
-                    }
-                } catch (e) {
-                    // Server still restarting
-                }
-                
-                attempts++;
-                document.getElementById('restart-status').textContent = `Waiting for server to come back... (${attempts}s)`;
-                
-                if (attempts < maxAttempts) {
-                    setTimeout(checkHealth, 1000);
-                } else {
-                    document.getElementById('restart-overlay').classList.remove('active');
-                    showToast('Server may still be restarting. Please refresh manually.', 'warning');
-                }
-            };
-            
-            checkHealth();
-        }
-        
-        function openAddPlaylist() {
-            document.getElementById('new-playlist-name').value = '';
-            document.getElementById('new-playlist-id').value = '';
-            openModal('add-playlist-modal');
-        }
-        
-        async function addPlaylist() {
-            const name = document.getElementById('new-playlist-name').value.trim();
-            const id = document.getElementById('new-playlist-id').value.trim();
-            
-            if (!name || !id) {
-                showToast('Name and ID are required', 'error');
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/playlists', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, spotifyId: id })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist added.', 'success');
-                    showRestartBanner();
-                    closeModal('add-playlist-modal');
-                } else {
-                    showToast(data.error || 'Failed to add playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to add playlist', 'error');
-            }
-        }
-        
-        async function editPlaylistSchedule(playlistName, currentSchedule) {
-            const newSchedule = prompt(`Edit sync schedule for "${playlistName}"\n\nCron format: minute hour day month dayofweek\nExamples:\n• 0 8 * * 1 = Monday 8 AM\n• 0 6 * * * = Daily 6 AM\n• 0 20 * * 5 = Friday 8 PM\n\nUse https://crontab.guru/ to build your schedule`, currentSchedule);
-            
-            if (!newSchedule || newSchedule === currentSchedule) return;
-            
-            // Validate cron format
-            const cronParts = newSchedule.trim().split(/\s+/);
-            if (cronParts.length !== 5) {
-                showToast('Invalid cron format. Expected: minute hour day month dayofweek', 'error');
-                return;
-            }
-            
-            try {
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(playlistName)}/schedule`, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ syncSchedule: newSchedule.trim() })
-                });
-                
-                if (res.ok) {
-                    showToast('Sync schedule updated!', 'success');
-                    showRestartBanner();
-                    fetchPlaylists();
-                } else {
-                    const error = await res.json();
-                    showToast(error.error || 'Failed to update schedule', 'error');
-                }
-            } catch (error) {
-                console.error('Failed to update schedule:', error);
-                showToast('Failed to update schedule', 'error');
-            }
-        }
-        
-        async function removePlaylist(name) {
-            if (!confirm(`Remove playlist "${name}"?`)) return;
-            
-            try {
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(name), {
-                    method: 'DELETE'
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist removed.', 'success');
-                    showRestartBanner();
-                    fetchPlaylists();
-                } else {
-                    showToast(data.error || 'Failed to remove playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to remove playlist', 'error');
-            }
-        }
-        
-        async function viewTracks(name) {
-            document.getElementById('tracks-modal-title').textContent = name + ' - Tracks';
-            document.getElementById('tracks-list').innerHTML = '<div class="loading"><span class="spinner"></span> Loading tracks...</div>';
-            openModal('tracks-modal');
-            
-            try {
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(name) + '/tracks');
-                
-                if (!res.ok) {
-                    console.error('Failed to fetch tracks:', res.status, res.statusText);
-                    document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--error);padding:40px;">Failed to load tracks: ' + res.status + ' ' + res.statusText + '</p>';
-                    return;
-                }
-                
-                const data = await res.json();
-                
-                console.log('Tracks data received:', data);
-                
-                if (!data || !data.tracks) {
-                    console.error('Invalid data structure:', data);
-                    document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--error);padding:40px;">Invalid data received from server</p>';
-                    return;
-                }
-                
-                if (data.tracks.length === 0) {
-                    document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--text-secondary);padding:40px;">No tracks found</p>';
-                    return;
-                }
-                
-                document.getElementById('tracks-list').innerHTML = data.tracks.map(t => {
-                    let statusBadge = '';
-                    let mapButton = '';
-                    let lyricsBadge = '';
-                    
-                    // Add lyrics status badge
-                    if (t.hasLyrics) {
-                        lyricsBadge = '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:#3b82f6;color:white;"><span class="status-dot" style="background:white;"></span>Lyrics</span>';
-                    }
-                    
-                    if (t.isLocal === true) {
-                        statusBadge = '<span class="status-badge success" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>Local</span>';
-                        // Add manual mapping indicator for local tracks
-                        if (t.isManualMapping && t.manualMappingType === 'jellyfin') {
-                            statusBadge += '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:var(--info);color:white;"><span class="status-dot" style="background:white;"></span>Manual</span>';
-                        }
-                    } else if (t.isLocal === false) {
-                        const provider = capitalizeProvider(t.externalProvider) || 'External';
-                        statusBadge = `<span class="status-badge info" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>${escapeHtml(provider)}</span>`;
-                        // Add manual mapping indicator for external tracks
-                        if (t.isManualMapping && t.manualMappingType === 'external') {
-                            statusBadge += '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:var(--info);color:white;"><span class="status-dot" style="background:white;"></span>Manual</span>';
-                        }
-                        // Add both mapping buttons for external tracks using data attributes
-                        const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                        mapButton = `<button class="small map-track-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:8px;font-size:0.75rem;padding:4px 8px;">Map to Local</button>
-                            <button class="small map-external-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>`;
-                    } else {
-                        // isLocal is null/undefined - track is missing (not found locally or externally)
-                        statusBadge = '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;background:rgba(245, 158, 11, 0.2);color:#f59e0b;"><span class="status-dot" style="background:#f59e0b;"></span>Missing</span>';
-                        // Add both mapping buttons for missing tracks
-                        const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                        mapButton = `<button class="small map-track-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:8px;font-size:0.75rem;padding:4px 8px;">Map to Local</button>
-                            <button class="small map-external-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>`;
-                    }
-                    
-                    // Build search link with track name and artist
-                    const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                    const searchLinkText = `${t.title} - ${firstArtist}`;
-                    const durationSeconds = Math.floor((t.durationMs || 0) / 1000);
-                    
-                    // Add lyrics mapping button
-                    const lyricsMapButton = `<button class="small" onclick="openLyricsMap('${escapeJs(firstArtist)}', '${escapeJs(t.title)}', '${escapeJs(t.album || '')}', ${durationSeconds})" style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:#3b82f6;border-color:#3b82f6;color:white;">Map Lyrics ID</button>`;
-                    
-                    return `
-                        <div class="track-item" data-position="${t.position}">
-                            <span class="track-position">${t.position + 1}</span>
-                            <div class="track-info">
-                                <h4>${escapeHtml(t.title)}${statusBadge}${lyricsBadge}${mapButton}${lyricsMapButton}</h4>
-                                <span class="artists">${escapeHtml((t.artists || []).join(', '))}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${t.album ? escapeHtml(t.album) : ''}
-                                ${t.isrc ? '<br><small>ISRC: ' + t.isrc + '</small>' : ''}
-                                ${t.isLocal === false && t.searchQuery && t.externalProvider ? '<br><small style="color:var(--accent)"><a href="#" onclick="searchProvider(\'' + escapeJs(t.searchQuery) + '\', \'' + escapeJs(t.externalProvider) + '\'); return false;" style="color:var(--accent);text-decoration:underline;">🔍 Search: ' + escapeHtml(searchLinkText) + '</a></small>' : ''}
-                                ${t.isLocal === null && t.searchQuery ? '<br><small style="color:var(--text-secondary)"><a href="#" onclick="searchProvider(\'' + escapeJs(t.searchQuery) + '\', \'squidwtf\'); return false;" style="color:var(--text-secondary);text-decoration:underline;">🔍 Search: ' + escapeHtml(searchLinkText) + '</a></small>' : ''}
-                            </div>
-                        </div>
-                    `;
-                }).join('');
-                
-                // Add event listeners to map buttons
-                document.querySelectorAll('.map-track-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlistName = this.getAttribute('data-playlist-name');
-                        const position = parseInt(this.getAttribute('data-position'));
-                        const title = this.getAttribute('data-title');
-                        const artist = this.getAttribute('data-artist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        openManualMap(playlistName, position, title, artist, spotifyId);
-                    });
-                });
-                
-                // Add event listeners to external map buttons
-                document.querySelectorAll('.map-external-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlistName = this.getAttribute('data-playlist-name');
-                        const position = parseInt(this.getAttribute('data-position'));
-                        const title = this.getAttribute('data-title');
-                        const artist = this.getAttribute('data-artist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        openExternalMap(playlistName, position, title, artist, spotifyId);
-                    });
-                });
-            } catch (error) {
-                console.error('Error in viewTracks:', error);
-                document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--error);padding:40px;">Failed to load tracks: ' + error.message + '</p>';
-            }
-        }
-        
-        // Generic edit setting modal
-        function openEditSetting(envKey, label, inputType, helpText = '', options = []) {
-            currentEditKey = envKey;
-            currentEditType = inputType;
-            currentEditOptions = options;
-            
-            document.getElementById('edit-setting-title').textContent = 'Edit ' + label;
-            document.getElementById('edit-setting-label').textContent = label;
-            
-            const helpEl = document.getElementById('edit-setting-help');
-            if (helpText) {
-                helpEl.textContent = helpText;
-                helpEl.style.display = 'block';
-            } else {
-                helpEl.style.display = 'none';
-            }
-            
-            const container = document.getElementById('edit-setting-input-container');
-            
-            if (inputType === 'toggle') {
-                container.innerHTML = `
-                    <select id="edit-setting-value">
-                        <option value="true">Enabled</option>
-                        <option value="false">Disabled</option>
-                    </select>
-                `;
-            } else if (inputType === 'select') {
-                container.innerHTML = `
-                    <select id="edit-setting-value">
-                        ${options.map(opt => `<option value="${opt}">${opt}</option>`).join('')}
-                    </select>
-                `;
-            } else if (inputType === 'password') {
-                container.innerHTML = `<input type="password" id="edit-setting-value" placeholder="Enter new value" autocomplete="off">`;
-            } else if (inputType === 'number') {
-                container.innerHTML = `<input type="number" id="edit-setting-value" placeholder="Enter value">`;
-            } else {
-                container.innerHTML = `<input type="text" id="edit-setting-value" placeholder="Enter value">`;
-            }
-            
-            openModal('edit-setting-modal');
-        }
-        
-        async function saveEditSetting() {
-            const value = document.getElementById('edit-setting-value').value.trim();
-            
-            if (!value && currentEditType !== 'toggle') {
-                showToast('Value is required', 'error');
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/config', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ updates: { [currentEditKey]: value } })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Setting updated.', 'success');
-                    showRestartBanner();
-                    closeModal('edit-setting-modal');
-                    fetchConfig();
-                    fetchStatus();
-                } else {
-                    showToast(data.error || 'Failed to update setting', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to update setting', 'error');
-            }
-        }
-        
-        // Cache setting editor (uses appsettings.json instead of .env)
-        function openEditCacheSetting(settingKey, label, helpText) {
-            currentEditKey = settingKey;
-            currentEditType = 'number';
-            
-            document.getElementById('edit-setting-title').textContent = 'Edit ' + label;
-            document.getElementById('edit-setting-label').textContent = label;
-            
-            const helpEl = document.getElementById('edit-setting-help');
-            if (helpText) {
-                helpEl.textContent = helpText + ' (Requires restart to apply)';
-                helpEl.style.display = 'block';
-            } else {
-                helpEl.style.display = 'none';
-            }
-            
-            const container = document.getElementById('edit-setting-input-container');
-            container.innerHTML = `<input type="number" id="edit-setting-value" placeholder="Enter value" min="1">`;
-            
-            openModal('edit-setting-modal');
-        }
-        
-        function escapeHtml(text) {
-            const div = document.createElement('div');
-            div.textContent = text;
-            return div.innerHTML;
-        }
-        
-        // Manual track mapping
-        let searchTimeout = null;
-        
-        async function searchJellyfinTracks() {
-            const query = document.getElementById('map-search-query').value.trim();
-            
-            if (!query) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">Type to search for local tracks or paste a Jellyfin URL...</p>';
-                return;
-            }
-            
-            // Clear URL input when searching
-            document.getElementById('map-jellyfin-url').value = '';
-            
-            // Debounce search
-            clearTimeout(searchTimeout);
-            searchTimeout = setTimeout(async () => {
-                document.getElementById('map-search-results').innerHTML = '<div class="loading"><span class="spinner"></span> Searching...</div>';
-                
-                try {
-                    const res = await fetch('/api/admin/jellyfin/search?query=' + encodeURIComponent(query));
-                    const data = await res.json();
-                    
-                    if (data.tracks.length === 0) {
-                        document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">No tracks found</p>';
-                        return;
-                    }
-                    
-                    document.getElementById('map-search-results').innerHTML = data.tracks.map(t => `
-                        <div class="track-item" style="cursor: pointer; border: 2px solid transparent;" onclick="selectJellyfinTrack('${t.id}', this)">
-                            <div class="track-info">
-                                <h4>${escapeHtml(t.title)}</h4>
-                                <span class="artists">${escapeHtml(t.artist)}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${t.album ? escapeHtml(t.album) : ''}
-                            </div>
-                        </div>
-                    `).join('');
-                } catch (error) {
-                    document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Search failed</p>';
-                }
-            }, 300);
-        }
-        
-        async function extractJellyfinId() {
-            const url = document.getElementById('map-jellyfin-url').value.trim();
-            
-            if (!url) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">Type to search for local tracks or paste a Jellyfin URL...</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-                return;
-            }
-            
-            // Clear search input when using URL
-            document.getElementById('map-search-query').value = '';
-            
-            // Extract ID from URL patterns:
-            // https://jellyfin.example.com/web/#/details?id=XXXXX&serverId=...
-            // https://jellyfin.example.com/web/index.html#!/details?id=XXXXX
-            let jellyfinId = null;
-            
-            try {
-                const idMatch = url.match(/[?&]id=([a-f0-9]+)/i);
-                if (idMatch) {
-                    jellyfinId = idMatch[1];
-                }
-            } catch (e) {
-                // Invalid URL format
-            }
-            
-            if (!jellyfinId) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Could not extract track ID from URL. Make sure it contains "?id=..."</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-                return;
-            }
-            
-            // Fetch track details to show preview
-            document.getElementById('map-search-results').innerHTML = '<div class="loading"><span class="spinner"></span> Loading track details...</div>';
-            
-            try {
-                const res = await fetch('/api/admin/jellyfin/track/' + jellyfinId);
-                const track = await res.json();
-                
-                if (res.ok && track.id) {
-                    document.getElementById('map-selected-jellyfin-id').value = track.id;
-                    document.getElementById('map-save-btn').disabled = false;
-                    
-                    document.getElementById('map-search-results').innerHTML = `
-                        <div class="track-item" style="border: 2px solid var(--accent); background: var(--bg-tertiary);">
-                            <div class="track-info">
-                                <h4>${escapeHtml(track.title)}</h4>
-                                <span class="artists">${escapeHtml(track.artist)}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${track.album ? escapeHtml(track.album) : ''}
-                            </div>
-                        </div>
-                        <p style="text-align: center; color: var(--success); padding: 12px; margin-top: 8px;">
-                            ✓ Track loaded from URL. Click "Save Mapping" to confirm.
-                        </p>
-                    `;
-                } else {
-                    document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Track not found in Jellyfin</p>';
-                    document.getElementById('map-selected-jellyfin-id').value = '';
-                    document.getElementById('map-save-btn').disabled = true;
-                }
-            } catch (error) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Failed to load track details</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-            }
-        }
-        
-        function selectJellyfinTrack(jellyfinId, element) {
-            // Remove selection from all tracks
-            document.querySelectorAll('#map-search-results .track-item').forEach(el => {
-                el.style.border = '2px solid transparent';
-                el.style.background = '';
-            });
-            
-            // Highlight selected track
-            element.style.border = '2px solid var(--accent)';
-            element.style.background = 'var(--bg-tertiary)';
-            
-            // Store selected ID and enable save button
-            document.getElementById('map-selected-jellyfin-id').value = jellyfinId;
-            document.getElementById('map-save-btn').disabled = false;
-        }
-        
-        // Validate external mapping input
-        function validateExternalMapping() {
-            const externalId = document.getElementById('map-external-id').value.trim();
-            const saveBtn = document.getElementById('map-save-btn');
-            
-            // Enable save button if external ID is provided
-            saveBtn.disabled = !externalId;
-        }
-        
-        // Open local Jellyfin mapping modal
-        function openManualMap(playlistName, position, title, artist, spotifyId) {
-            document.getElementById('local-map-playlist-name').value = playlistName;
-            document.getElementById('local-map-position').textContent = position + 1;
-            document.getElementById('local-map-spotify-title').textContent = title;
-            document.getElementById('local-map-spotify-artist').textContent = artist;
-            document.getElementById('local-map-spotify-id').value = spotifyId;
-            
-            // Pre-fill search with track info
-            document.getElementById('local-map-search').value = `${title} ${artist}`;
-            
-            // Reset fields
-            document.getElementById('local-map-results').innerHTML = '';
-            document.getElementById('local-map-jellyfin-id').value = '';
-            document.getElementById('local-map-save-btn').disabled = true;
-            
-            openModal('local-map-modal');
-        }
-        
-        // Open external mapping modal
-        function openExternalMap(playlistName, position, title, artist, spotifyId) {
-            document.getElementById('map-playlist-name').value = playlistName;
-            document.getElementById('map-position').textContent = position + 1;
-            document.getElementById('map-spotify-title').textContent = title;
-            document.getElementById('map-spotify-artist').textContent = artist;
-            document.getElementById('map-spotify-id').value = spotifyId;
-            
-            // Reset fields
-            document.getElementById('map-external-id').value = '';
-            document.getElementById('map-external-provider').value = 'SquidWTF';
-            document.getElementById('map-save-btn').disabled = true;
-            
-            openModal('manual-map-modal');
-        }
-        
-        // Search Jellyfin tracks for local mapping
-        async function searchJellyfinTracks() {
-            const query = document.getElementById('local-map-search').value.trim();
-            if (!query) {
-                showToast('Please enter a search query', 'error');
-                return;
-            }
-            
-            const resultsDiv = document.getElementById('local-map-results');
-            resultsDiv.innerHTML = '<p style="text-align:center;padding:20px;">Searching...</p>';
-            
-            try {
-                const res = await fetch('/api/admin/jellyfin/search?query=' + encodeURIComponent(query));
-                const data = await res.json();
-                
-                if (!res.ok) {
-                    resultsDiv.innerHTML = '<p style="text-align:center;color:var(--error);padding:20px;">Search failed</p>';
-                    return;
-                }
-                
-                if (!data.tracks || data.tracks.length === 0) {
-                    resultsDiv.innerHTML = '<p style="text-align:center;color:var(--text-secondary);padding:20px;">No tracks found</p>';
-                    return;
-                }
-                
-                resultsDiv.innerHTML = data.tracks.map(track => `
-                    <div style="padding: 12px; border: 1px solid var(--border); border-radius: 8px; margin-bottom: 8px; cursor: pointer; transition: background 0.2s;" 
-                         onclick="selectJellyfinTrack('${escapeJs(track.id)}', '${escapeJs(track.name)}', '${escapeJs(track.artist)}')"
-                         onmouseover="this.style.background='var(--bg-primary)'" 
-                         onmouseout="this.style.background='transparent'">
-                        <strong>${escapeHtml(track.name)}</strong><br>
-                        <span style="color: var(--text-secondary); font-size: 0.9em;">${escapeHtml(track.artist)}</span>
-                        ${track.album ? '<br><span style="color: var(--text-secondary); font-size: 0.85em;">' + escapeHtml(track.album) + '</span>' : ''}
-                    </div>
-                `).join('');
-            } catch (error) {
-                console.error('Search error:', error);
-                resultsDiv.innerHTML = '<p style="text-align:center;color:var(--error);padding:20px;">Search failed</p>';
-            }
-        }
-        
-        // Select a Jellyfin track for mapping
-        function selectJellyfinTrack(jellyfinId, name, artist) {
-            document.getElementById('local-map-jellyfin-id').value = jellyfinId;
-            document.getElementById('local-map-save-btn').disabled = false;
-            
-            // Highlight selected track
-            document.querySelectorAll('#local-map-results > div').forEach(div => {
-                div.style.background = 'transparent';
-                div.style.border = '1px solid var(--border)';
-            });
-            event.target.closest('div').style.background = 'var(--primary)';
-            event.target.closest('div').style.border = '1px solid var(--primary)';
-        }
-        
-        // Save local Jellyfin mapping
-        async function saveLocalMapping() {
-            const playlistName = document.getElementById('local-map-playlist-name').value;
-            const spotifyId = document.getElementById('local-map-spotify-id').value;
-            const jellyfinId = document.getElementById('local-map-jellyfin-id').value;
-            
-            if (!jellyfinId) {
-                showToast('Please select a Jellyfin track', 'error');
-                return;
-            }
-            
-            const requestBody = {
-                spotifyId,
-                jellyfinId
-            };
-            
-            // Show loading state
-            const saveBtn = document.getElementById('local-map-save-btn');
-            const originalText = saveBtn.textContent;
-            saveBtn.textContent = 'Saving...';
-            saveBtn.disabled = true;
-            
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000);
-                
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(playlistName)}/map`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(requestBody),
-                    signal: controller.signal
-                });
-                
-                clearTimeout(timeoutId);
-                
-                if (res.ok) {
-                    showToast('Track mapped successfully!', 'success');
-                    closeModal('local-map-modal');
-                    
-                    // Refresh the tracks view if it's open
-                    const tracksModal = document.getElementById('tracks-modal');
-                    if (tracksModal.style.display === 'flex') {
-                        await viewTracks(playlistName);
-                    }
-                } else {
-                    const data = await res.json();
-                    showToast(data.error || 'Failed to save mapping', 'error');
-                    saveBtn.textContent = originalText;
-                    saveBtn.disabled = false;
-                }
-            } catch (error) {
-                if (error.name === 'AbortError') {
-                    showToast('Request timed out. The mapping may still be processing.', 'warning');
-                } else {
-                    showToast('Failed to save mapping', 'error');
-                }
-                saveBtn.textContent = originalText;
-                saveBtn.disabled = false;
-            }
-        }
-        
-        // Save manual mapping (external only) - kept for backward compatibility
-        async function saveManualMapping() {
-            const playlistName = document.getElementById('map-playlist-name').value;
-            const spotifyId = document.getElementById('map-spotify-id').value;
-            const position = parseInt(document.getElementById('map-position').textContent) - 1; // Convert back to 0-indexed
-            
-            const externalProvider = document.getElementById('map-external-provider').value;
-            const externalId = document.getElementById('map-external-id').value.trim();
-            
-            if (!externalId) {
-                showToast('Please enter an external provider ID', 'error');
-                return;
-            }
-            
-            const requestBody = {
-                spotifyId,
-                externalProvider,
-                externalId
-            };
-            
-            // Show loading state
-            const saveBtn = document.getElementById('map-save-btn');
-            const originalText = saveBtn.textContent;
-            saveBtn.textContent = 'Saving...';
-            saveBtn.disabled = true;
-            
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-                
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(playlistName) + '/map', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(requestBody),
-                    signal: controller.signal
-                });
-                
-                clearTimeout(timeoutId);
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ Track mapped to ${requestBody.externalProvider} - rebuilding playlist...`, 'success');
-                    closeModal('manual-map-modal');
-                    
-                    // Show rebuilding indicator
-                    showPlaylistRebuildingIndicator(playlistName);
-                    
-                    // Show detailed info toast after a moment
-                    setTimeout(() => {
-                        showToast(`🔄 Rebuilding playlist with your ${requestBody.externalProvider} mapping...`, 'info', 8000);
-                    }, 1000);
-                    
-                    // Update the track in the UI without refreshing
-                    const trackItem = document.querySelector(`.track-item[data-position="${position}"]`);
-                    if (trackItem) {
-                        const titleEl = trackItem.querySelector('.track-info h4');
-                        if (titleEl) {
-                            // Update status badge to show provider
-                            const currentTitle = titleEl.textContent.split(' - ')[0]; // Remove old status
-                            const capitalizedProvider = capitalizeProvider(requestBody.externalProvider);
-                            const newStatusBadge = `<span class="status-badge warning" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>${escapeHtml(capitalizedProvider)}</span>`;
-                            titleEl.innerHTML = escapeHtml(currentTitle) + newStatusBadge;
-                        }
-                        
-                        // Remove search link since it's now mapped
-                        const searchLink = trackItem.querySelector('.track-meta a');
-                        if (searchLink) {
-                            searchLink.remove();
-                        }
-                    }
-                    
-                    // Also refresh the playlist counts in the background
-                    fetchPlaylists();
-                } else {
-                    showToast(data.error || 'Failed to save mapping', 'error');
-                }
-            } catch (error) {
-                if (error.name === 'AbortError') {
-                    showToast('Request timed out - mapping may still be processing', 'warning');
-                } else {
-                    showToast('Failed to save mapping', 'error');
-                }
-            } finally {
-                // Reset button state
-                saveBtn.textContent = originalText;
-                saveBtn.disabled = false;
-            }
-        }
-        
-        function showPlaylistRebuildingIndicator(playlistName) {
-            // Find the playlist in the UI and show rebuilding state
-            const playlistCards = document.querySelectorAll('.playlist-card');
-            for (const card of playlistCards) {
-                const nameEl = card.querySelector('h3');
-                if (nameEl && nameEl.textContent.trim() === playlistName) {
-                    // Add rebuilding indicator
-                    const existingIndicator = card.querySelector('.rebuilding-indicator');
-                    if (!existingIndicator) {
-                        const indicator = document.createElement('div');
-                        indicator.className = 'rebuilding-indicator';
-                        indicator.style.cssText = `
-                            position: absolute;
-                            top: 8px;
-                            right: 8px;
-                            background: var(--warning);
-                            color: white;
-                            padding: 4px 8px;
-                            border-radius: 12px;
-                            font-size: 0.7rem;
-                            font-weight: 500;
-                            display: flex;
-                            align-items: center;
-                            gap: 4px;
-                            z-index: 10;
-                        `;
-                        indicator.innerHTML = '<span class="spinner" style="width: 10px; height: 10px;"></span>Rebuilding...';
-                        card.style.position = 'relative';
-                        card.appendChild(indicator);
-                        
-                        // Auto-remove after 30 seconds and refresh
-                        setTimeout(() => {
-                            indicator.remove();
-                            fetchPlaylists(); // Refresh to get updated counts
-                        }, 30000);
-                    }
-                    break;
-                }
-            }
-        }
-        
-        function escapeJs(text) {
-            if (!text) return '';
-            return text.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
-        }
-        
-        // Lyrics ID mapping functions
-        function openLyricsMap(artist, title, album, durationSeconds) {
-            document.getElementById('lyrics-map-artist').textContent = artist;
-            document.getElementById('lyrics-map-title').textContent = title;
-            document.getElementById('lyrics-map-album').textContent = album || '(No album)';
-            document.getElementById('lyrics-map-artist-value').value = artist;
-            document.getElementById('lyrics-map-title-value').value = title;
-            document.getElementById('lyrics-map-album-value').value = album || '';
-            document.getElementById('lyrics-map-duration').value = durationSeconds;
-            document.getElementById('lyrics-map-id').value = '';
-            
-            openModal('lyrics-map-modal');
-        }
-        
-        async function saveLyricsMapping() {
-            const artist = document.getElementById('lyrics-map-artist-value').value;
-            const title = document.getElementById('lyrics-map-title-value').value;
-            const album = document.getElementById('lyrics-map-album-value').value;
-            const durationSeconds = parseInt(document.getElementById('lyrics-map-duration').value);
-            const lyricsId = parseInt(document.getElementById('lyrics-map-id').value);
-            
-            if (!lyricsId || lyricsId <= 0) {
-                showToast('Please enter a valid lyrics ID', 'error');
-                return;
-            }
-            
-            const saveBtn = document.getElementById('lyrics-map-save-btn');
-            const originalText = saveBtn.textContent;
-            saveBtn.textContent = 'Saving...';
-            saveBtn.disabled = true;
-            
-            try {
-                const res = await fetch('/api/admin/lyrics/map', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        artist,
-                        title,
-                        album,
-                        durationSeconds,
-                        lyricsId
-                    })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    if (data.cached && data.lyrics) {
-                        showToast(`✓ Lyrics mapped and cached: ${data.lyrics.trackName} by ${data.lyrics.artistName}`, 'success', 5000);
-                    } else {
-                        showToast('✓ Lyrics mapping saved successfully', 'success');
-                    }
-                    closeModal('lyrics-map-modal');
-                } else {
-                    showToast(data.error || 'Failed to save lyrics mapping', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to save lyrics mapping', 'error');
-            } finally {
-                saveBtn.textContent = originalText;
-                saveBtn.disabled = false;
-            }
-        }
-        
-        // Initial load
-        fetchStatus();
-        fetchPlaylists();
-        fetchTrackMappings();
-        fetchMissingTracks();
-        fetchDownloads();
-        fetchJellyfinUsers();
-        fetchJellyfinPlaylists();
-        fetchConfig();
-        fetchEndpointUsage();
-        
-        // Auto-refresh every 30 seconds
-        setInterval(() => {
-            fetchStatus();
-            fetchPlaylists();
-            fetchTrackMappings();
-            fetchMissingTracks();
-            fetchDownloads();
-            
-            // Refresh endpoint usage if on that tab
-            const endpointsTab = document.getElementById('tab-endpoints');
-            if (endpointsTab && endpointsTab.classList.contains('active')) {
-                fetchEndpointUsage();
-            }
-        }, 30000);
-        
-        // Endpoint Usage Functions
-        async function fetchEndpointUsage() {
-            try {
-                const topSelect = document.getElementById('endpoints-top-select');
-                const top = topSelect ? topSelect.value : 50;
-                
-                const res = await fetch(`/api/admin/debug/endpoint-usage?top=${top}`);
-                const data = await res.json();
-                
-                // Update summary stats
-                document.getElementById('endpoints-total-requests').textContent = data.totalRequests?.toLocaleString() || '0';
-                document.getElementById('endpoints-unique-count').textContent = data.totalEndpoints?.toLocaleString() || '0';
-                
-                const mostCalled = data.endpoints && data.endpoints.length > 0 
-                    ? data.endpoints[0].endpoint 
-                    : '-';
-                document.getElementById('endpoints-most-called').textContent = mostCalled;
-                
-                // Update table
-                const tbody = document.getElementById('endpoints-table-body');
-                
-                if (!data.endpoints || data.endpoints.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="4" style="text-align:center;color:var(--text-secondary);padding:40px;">No endpoint usage data available yet. Data will appear as clients make requests.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.endpoints.map((ep, index) => {
-                    const percentage = data.totalRequests > 0 
-                        ? ((ep.count / data.totalRequests) * 100).toFixed(1) 
-                        : '0.0';
-                    
-                    // Color code based on usage
-                    let countColor = 'var(--text-primary)';
-                    if (ep.count > 1000) countColor = 'var(--error)';
-                    else if (ep.count > 100) countColor = 'var(--warning)';
-                    else if (ep.count > 10) countColor = 'var(--accent)';
-                    
-                    // Highlight common patterns
-                    let endpointDisplay = ep.endpoint;
-                    if (ep.endpoint.includes('/stream')) {
-                        endpointDisplay = `<span style="color:var(--success)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else if (ep.endpoint.includes('/Playing')) {
-                        endpointDisplay = `<span style="color:var(--accent)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else if (ep.endpoint.includes('/Search')) {
-                        endpointDisplay = `<span style="color:var(--warning)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else {
-                        endpointDisplay = escapeHtml(ep.endpoint);
-                    }
-                    
-                    return `
-                        <tr>
-                            <td style="color:var(--text-secondary);text-align:center;">${index + 1}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;">${endpointDisplay}</td>
-                            <td style="text-align:right;font-weight:600;color:${countColor}">${ep.count.toLocaleString()}</td>
-                            <td style="text-align:right;color:var(--text-secondary)">${percentage}%</td>
-                        </tr>
-                    `;
-                }).join('');
-                
-            } catch (error) {
-                console.error('Failed to fetch endpoint usage:', error);
-                const tbody = document.getElementById('endpoints-table-body');
-                tbody.innerHTML = '<tr><td colspan="4" style="text-align:center;color:var(--error);padding:40px;">Failed to load endpoint usage data</td></tr>';
-            }
-        }
-        
-        async function clearEndpointUsage() {
-            if (!confirm('Are you sure you want to clear all endpoint usage data? This cannot be undone.')) {
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/debug/endpoint-usage', { method: 'DELETE' });
-                const data = await res.json();
-                
-                showToast(data.message || 'Endpoint usage data cleared', 'success');
-                fetchEndpointUsage();
-            } catch (error) {
-                console.error('Failed to clear endpoint usage:', error);
-                showToast('Failed to clear endpoint usage data', 'error');
-            }
-        }
-        
-        function escapeHtml(text) {
-            const div = document.createElement('div');
-            div.textContent = text;
-            return div.innerHTML;
-        }
-    </script>
-</body>
-</html>
-||||||| f68706f
-    
-    <script>
-        // Current edit setting state
-        let currentEditKey = null;
-        let currentEditType = null;
-        let currentEditOptions = null;
-        
-        // Track if we've already initialized the cookie date to prevent infinite loop
-        let cookieDateInitialized = false;
-        
-        // Track if restart is required
-        let restartRequired = false;
-        
-        function showRestartBanner() {
-            restartRequired = true;
-            document.getElementById('restart-banner').classList.add('active');
-        }
-        
-        function dismissRestartBanner() {
-            document.getElementById('restart-banner').classList.remove('active');
-        }
-        
-        // Tab switching with URL hash support
-        function switchTab(tabName) {
-            document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-            document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
-            
-            const tab = document.querySelector(`.tab[data-tab="${tabName}"]`);
-            const content = document.getElementById('tab-' + tabName);
-            
-            if (tab && content) {
-                tab.classList.add('active');
-                content.classList.add('active');
-                window.location.hash = tabName;
-            }
-        }
-        
-        document.querySelectorAll('.tab').forEach(tab => {
-            tab.addEventListener('click', () => {
-                switchTab(tab.dataset.tab);
-            });
-        });
-        
-        // Restore tab from URL hash on page load
-        window.addEventListener('load', () => {
-            const hash = window.location.hash.substring(1);
-            if (hash) {
-                switchTab(hash);
-            }
-            
-            // Start auto-refresh for playlists tab (every 5 seconds)
-            startPlaylistAutoRefresh();
-        });
-        
-        // Auto-refresh functionality for playlists
-        let playlistAutoRefreshInterval = null;
-        
-        function startPlaylistAutoRefresh() {
-            // Clear any existing interval
-            if (playlistAutoRefreshInterval) {
-                clearInterval(playlistAutoRefreshInterval);
-            }
-            
-            // Refresh every 5 seconds when on playlists tab
-            playlistAutoRefreshInterval = setInterval(() => {
-                const playlistsTab = document.getElementById('tab-playlists');
-                if (playlistsTab && playlistsTab.classList.contains('active')) {
-                    // Silently refresh without showing loading state
-                    fetchPlaylists(true);
-                }
-            }, 5000);
-        }
-        
-        function stopPlaylistAutoRefresh() {
-            if (playlistAutoRefreshInterval) {
-                clearInterval(playlistAutoRefreshInterval);
-                playlistAutoRefreshInterval = null;
-            }
-        }
-        
-        // Toast notification
-        function showToast(message, type = 'success', duration = 3000) {
-            const toast = document.createElement('div');
-            toast.className = 'toast ' + type;
-            toast.textContent = message;
-            document.body.appendChild(toast);
-            setTimeout(() => toast.remove(), duration);
-        }
-        
-        // Modal helpers
-        function openModal(id) {
-            document.getElementById(id).classList.add('active');
-        }
-        
-        function closeModal(id) {
-            document.getElementById(id).classList.remove('active');
-        }
-        
-        // Close modals on backdrop click
-        document.querySelectorAll('.modal').forEach(modal => {
-            modal.addEventListener('click', e => {
-                if (e.target === modal) closeModal(modal.id);
-            });
-        });
-        
-        // Format cookie age with color coding
-        function formatCookieAge(setDateStr, hasCookie = false) {
-            if (!setDateStr) {
-                if (hasCookie) {
-                    return { text: 'Unknown age', class: 'warning', detail: 'Cookie date not tracked', needsInit: true };
-                }
-                return { text: 'No cookie', class: '', detail: '', needsInit: false };
-            }
-            
-            const setDate = new Date(setDateStr);
-            const now = new Date();
-            const diffMs = now - setDate;
-            const daysAgo = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-            const monthsAgo = daysAgo / 30;
-            
-            let status = 'success';  // green: < 6 months
-            if (monthsAgo >= 10) status = 'error';  // red: > 10 months
-            else if (monthsAgo >= 6) status = 'warning';  // yellow: 6-10 months
-            
-            let text;
-            if (daysAgo === 0) text = 'Set today';
-            else if (daysAgo === 1) text = 'Set yesterday';
-            else if (daysAgo < 30) text = `Set ${daysAgo} days ago`;
-            else if (daysAgo < 60) text = 'Set ~1 month ago';
-            else text = `Set ~${Math.floor(monthsAgo)} months ago`;
-            
-            const remaining = 12 - monthsAgo;
-            let detail;
-            if (remaining > 6) detail = 'Cookie typically lasts ~1 year';
-            else if (remaining > 2) detail = `~${Math.floor(remaining)} months until expiration`;
-            else if (remaining > 0) detail = 'Cookie may expire soon!';
-            else detail = 'Cookie may have expired - update if having issues';
-            
-            return { text, class: status, detail, needsInit: false };
-        }
-        
-        // Initialize cookie date if cookie exists but date is not set
-        async function initCookieDate() {
-            if (cookieDateInitialized) {
-                console.log('Cookie date already initialized, skipping');
-                return;
-            }
-            
-            cookieDateInitialized = true;
-            
-            try {
-                const res = await fetch('/api/admin/config/init-cookie-date', { method: 'POST' });
-                if (res.ok) {
-                    console.log('Cookie date initialized successfully - restart container to apply');
-                    showToast('Cookie date set. Restart container to apply changes.', 'success');
-                } else {
-                    const data = await res.json();
-                    console.log('Cookie date init response:', data);
-                }
-            } catch (error) {
-                console.error('Failed to init cookie date:', error);
-                cookieDateInitialized = false; // Allow retry on error
-            }
-        }
-        
-        // API calls
-        async function fetchStatus() {
-            try {
-                const res = await fetch('/api/admin/status');
-                const data = await res.json();
-                
-                document.getElementById('version').textContent = 'v' + data.version;
-                document.getElementById('backend-type').textContent = data.backendType;
-                document.getElementById('jellyfin-url').textContent = data.jellyfinUrl || '-';
-                document.getElementById('playlist-count').textContent = data.spotifyImport.playlistCount;
-                document.getElementById('cache-duration').textContent = data.spotify.cacheDurationMinutes + ' min';
-                document.getElementById('isrc-matching').textContent = data.spotify.preferIsrcMatching ? 'Enabled' : 'Disabled';
-                document.getElementById('spotify-user').textContent = data.spotify.user || '-';
-                
-                // Update status badge and cookie age
-                const statusBadge = document.getElementById('spotify-status');
-                const authStatus = document.getElementById('spotify-auth-status');
-                const cookieAgeEl = document.getElementById('spotify-cookie-age');
-                
-                if (data.spotify.authStatus === 'configured') {
-                    statusBadge.className = 'status-badge success';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Spotify Ready';
-                    authStatus.textContent = 'Cookie Set';
-                    authStatus.className = 'stat-value success';
-                } else if (data.spotify.authStatus === 'missing_cookie') {
-                    statusBadge.className = 'status-badge warning';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Cookie Missing';
-                    authStatus.textContent = 'No Cookie';
-                    authStatus.className = 'stat-value warning';
-                } else {
-                    statusBadge.className = 'status-badge';
-                    statusBadge.innerHTML = '<span class="status-dot"></span>Not Configured';
-                    authStatus.textContent = 'Not Configured';
-                    authStatus.className = 'stat-value';
-                }
-                
-                // Update cookie age display
-                if (cookieAgeEl) {
-                    const hasCookie = data.spotify.hasCookie;
-                    const age = formatCookieAge(data.spotify.cookieSetDate, hasCookie);
-                    cookieAgeEl.innerHTML = `<span class="${age.class}">${age.text}</span><br><small style="color:var(--text-secondary)">${age.detail}</small>`;
-                    
-                    // Auto-init cookie date if cookie exists but date is not set
-                    if (age.needsInit) {
-                        console.log('Cookie exists but date not set, initializing...');
-                        initCookieDate();
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to fetch status:', error);
-                showToast('Failed to fetch status', 'error');
-            }
-        }
-        
-        async function fetchPlaylists(silent = false) {
-            try {
-                const res = await fetch('/api/admin/playlists');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('playlist-table-body');
-                
-                if (data.playlists.length === 0) {
-                    if (!silent) {
-                        tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No playlists configured. Link playlists from the Jellyfin Playlists tab.</td></tr>';
-                    }
-                    return;
-                }
-                
-                tbody.innerHTML = data.playlists.map(p => {
-                    // Enhanced statistics display
-                    const spotifyTotal = p.trackCount || 0;
-                    const localCount = p.localTracks || 0;
-                    const externalMatched = p.externalMatched || 0;
-                    const externalMissing = p.externalMissing || 0;
-                    const totalInJellyfin = p.totalInJellyfin || 0;
-                    const totalPlayable = p.totalPlayable || (localCount + externalMatched); // Total tracks that will be served
-                    
-                    // Debug: Log the raw data
-                    console.log(`Playlist ${p.name}:`, {
-                        spotifyTotal,
-                        localCount,
-                        externalMatched,
-                        externalMissing,
-                        totalInJellyfin,
-                        totalPlayable,
-                        rawData: p
-                    });
-                    
-                    // Build detailed stats string - show total playable tracks prominently
-                    let statsHtml = `<span class="track-count">${totalPlayable}/${spotifyTotal}</span>`;
-                    
-                    // Show breakdown with color coding
-                    let breakdownParts = [];
-                    if (localCount > 0) {
-                        breakdownParts.push(`<span style="color:var(--success)">${localCount} local</span>`);
-                    }
-                    if (externalMatched > 0) {
-                        breakdownParts.push(`<span style="color:var(--accent)">${externalMatched} matched</span>`);
-                    }
-                    if (externalMissing > 0) {
-                        breakdownParts.push(`<span style="color:var(--warning)">${externalMissing} missing</span>`);
-                    }
-                    
-                    const breakdown = breakdownParts.length > 0 
-                        ? `<br><small style="color:var(--text-secondary)">${breakdownParts.join(' • ')}</small>`
-                        : '';
-                    
-                    // Calculate completion percentage based on playable tracks
-                    const completionPct = spotifyTotal > 0 ? Math.round((totalPlayable / spotifyTotal) * 100) : 0;
-                    const localPct = spotifyTotal > 0 ? Math.round((localCount / spotifyTotal) * 100) : 0;
-                    const externalPct = spotifyTotal > 0 ? Math.round((externalMatched / spotifyTotal) * 100) : 0;
-                    const missingPct = spotifyTotal > 0 ? Math.round((externalMissing / spotifyTotal) * 100) : 0;
-                    const completionColor = completionPct === 100 ? 'var(--success)' : completionPct >= 80 ? 'var(--accent)' : 'var(--warning)';
-                    
-                    // Debug logging
-                    console.log(`Progress bar for ${p.name}: local=${localPct}%, external=${externalPct}%, missing=${missingPct}%, total=${completionPct}%`);
-                    
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(p.name)}</strong></td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${p.id || '-'}</td>
-                            <td>${statsHtml}${breakdown}</td>
-                            <td>
-                                <div style="display:flex;align-items:center;gap:8px;">
-                                    <div style="flex:1;background:var(--bg-tertiary);height:12px;border-radius:6px;overflow:hidden;display:flex;">
-                                        <div style="width:${localPct}%;height:100%;background:#10b981;transition:width 0.3s;" title="${localCount} local tracks"></div>
-                                        <div style="width:${externalPct}%;height:100%;background:#f59e0b;transition:width 0.3s;" title="${externalMatched} external matched tracks"></div>
-                                        <div style="width:${missingPct}%;height:100%;background:#6b7280;transition:width 0.3s;" title="${externalMissing} missing tracks"></div>
-                                    </div>
-                                    <span style="font-size:0.85rem;color:${completionColor};font-weight:500;min-width:40px;">${completionPct}%</span>
-                                </div>
-                            </td>
-                            <td class="cache-age">${p.cacheAge || '-'}</td>
-                            <td>
-                                <button onclick="clearPlaylistCache('${escapeJs(p.name)}')">Clear Cache & Rebuild</button>
-                                <button onclick="matchPlaylistTracks('${escapeJs(p.name)}')">Match Tracks</button>
-                                <button onclick="viewTracks('${escapeJs(p.name)}')">View</button>
-                                <button class="danger" onclick="removePlaylist('${escapeJs(p.name)}')">Remove</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch playlists:', error);
-                showToast('Failed to fetch playlists', 'error');
-            }
-        }
-        
-        async function fetchTrackMappings() {
-            try {
-                const res = await fetch('/api/admin/mappings/tracks');
-                const data = await res.json();
-                
-                // Update summary (only external now)
-                document.getElementById('mappings-total').textContent = data.externalCount || 0;
-                document.getElementById('mappings-external').textContent = data.externalCount || 0;
-                
-                const tbody = document.getElementById('mappings-table-body');
-                
-                if (data.mappings.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No manual mappings found.</td></tr>';
-                    return;
-                }
-                
-                // Filter to only show external mappings
-                const externalMappings = data.mappings.filter(m => m.type === 'external');
-                
-                if (externalMappings.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No external mappings found. Local Jellyfin mappings should be managed via Spotify Import plugin.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = externalMappings.map((m, index) => {
-                    const typeColor = 'var(--success)';
-                    const typeBadge = `<span style="display:inline-block;padding:2px 8px;border-radius:4px;font-size:0.8rem;background:${typeColor}20;color:${typeColor};font-weight:500;">external</span>`;
-                    
-                    const targetDisplay = `<span style="font-family:monospace;font-size:0.85rem;color:var(--success);">${m.externalProvider}/${m.externalId}</span>`;
-                    
-                    const createdDate = m.createdAt ? new Date(m.createdAt).toLocaleString() : '-';
-                    
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(m.playlist)}</strong></td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${m.spotifyId}</td>
-                            <td>${typeBadge}</td>
-                            <td>${targetDisplay}</td>
-                            <td style="color:var(--text-secondary);font-size:0.85rem;">${createdDate}</td>
-                            <td>
-                                <button class="danger delete-mapping-btn" style="padding:4px 12px;font-size:0.8rem;" data-playlist="${escapeHtml(m.playlist)}" data-spotify-id="${m.spotifyId}">Remove</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-                
-                // Add event listeners to all delete buttons
-                document.querySelectorAll('.delete-mapping-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlist = this.getAttribute('data-playlist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        deleteTrackMapping(playlist, spotifyId);
-                    });
-                });
-            } catch (error) {
-                console.error('Failed to fetch track mappings:', error);
-                showToast('Failed to fetch track mappings', 'error');
-            }
-        }
-        
-        async function deleteTrackMapping(playlist, spotifyId) {
-            if (!confirm(`Remove manual external mapping for ${spotifyId} in playlist "${playlist}"?\n\nThis will:\n• Delete the manual mapping from the cache\n• Allow the track to be matched automatically again\n• The track may be re-matched with potentially better results\n\nThis action cannot be undone.`)) {
-                return;
-            }
-            
-            try {
-                const res = await fetch(`/api/admin/mappings/tracks?playlist=${encodeURIComponent(playlist)}&spotifyId=${encodeURIComponent(spotifyId)}`, {
-                    method: 'DELETE'
-                });
-                
-                if (res.ok) {
-                    showToast('Mapping removed successfully', 'success');
-                    await fetchTrackMappings();
-                } else {
-                    const error = await res.json();
-                    showToast(error.error || 'Failed to remove mapping', 'error');
-                }
-            } catch (error) {
-                console.error('Failed to delete mapping:', error);
-                showToast('Failed to remove mapping', 'error');
-            }
-        }
-        
-        async function fetchMissingTracks() {
-            try {
-                const res = await fetch('/api/admin/playlists');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('missing-tracks-table-body');
-                const missingTracks = [];
-                
-                // Collect all missing tracks from all playlists
-                for (const playlist of data.playlists) {
-                    if (playlist.externalMissing > 0) {
-                        // Fetch tracks for this playlist
-                        try {
-                            const tracksRes = await fetch(`/api/admin/playlists/${encodeURIComponent(playlist.name)}/tracks`);
-                            const tracksData = await tracksRes.json();
-                            
-                            // Filter to only missing tracks (isLocal === null)
-                            const missing = tracksData.tracks.filter(t => t.isLocal === null);
-                            missing.forEach(t => {
-                                missingTracks.push({
-                                    playlist: playlist.name,
-                                    ...t
-                                });
-                            });
-                        } catch (err) {
-                            console.error(`Failed to fetch tracks for ${playlist.name}:`, err);
-                        }
-                    }
-                }
-                
-                // Update summary
-                document.getElementById('missing-total').textContent = missingTracks.length;
-                
-                if (missingTracks.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="5" style="text-align:center;color:var(--text-secondary);padding:40px;">🎉 No missing tracks! All tracks are matched.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = missingTracks.map(t => {
-                    const artist = (t.artists && t.artists.length > 0) ? t.artists.join(', ') : '';
-                    const searchQuery = `${t.title} ${artist}`;
-                    return `
-                        <tr>
-                            <td><strong>${escapeHtml(t.playlist)}</strong></td>
-                            <td>${escapeHtml(t.title)}</td>
-                            <td>${escapeHtml(artist)}</td>
-                            <td style="color:var(--text-secondary);">${t.album ? escapeHtml(t.album) : '-'}</td>
-                            <td>
-                                <button onclick="searchProvider('${escapeJs(searchQuery)}', 'squidwtf')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:#3b82f6;border-color:#3b82f6;color:white;">🔍 Search</button>
-                                <button onclick="openMapToLocal('${escapeJs(t.playlist)}', '${escapeJs(t.spotifyId)}', '${escapeJs(t.title)}', '${escapeJs(artist)}')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:var(--success);border-color:var(--success);">Map to Local</button>
-                                <button onclick="openMapToExternal('${escapeJs(t.playlist)}', '${escapeJs(t.spotifyId)}', '${escapeJs(t.title)}', '${escapeJs(artist)}')" 
-                                    style="font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch missing tracks:', error);
-                showToast('Failed to fetch missing tracks', 'error');
-            }
-        }
-        
-        async function fetchDownloads() {
-            try {
-                const res = await fetch('/api/admin/downloads');
-                const data = await res.json();
-                
-                const tbody = document.getElementById('downloads-table-body');
-                
-                // Update summary
-                document.getElementById('downloads-count').textContent = data.count;
-                document.getElementById('downloads-size').textContent = data.totalSizeFormatted;
-                
-                if (data.count === 0) {
-                    tbody.innerHTML = '<tr><td colspan="5" style="text-align:center;color:var(--text-secondary);padding:40px;">No downloaded files found.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.files.map(f => {
-                    return `
-                        <tr data-path="${escapeHtml(f.path)}">
-                            <td><strong>${escapeHtml(f.artist)}</strong></td>
-                            <td>${escapeHtml(f.album)}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;">${escapeHtml(f.fileName)}</td>
-                            <td style="color:var(--text-secondary);">${f.sizeFormatted}</td>
-                            <td>
-                                <button onclick="downloadFile('${escapeJs(f.path)}')" 
-                                    style="margin-right:4px;font-size:0.75rem;padding:4px 8px;background:var(--accent);border-color:var(--accent);">Download</button>
-                                <button onclick="deleteDownload('${escapeJs(f.path)}')" 
-                                    class="danger" style="font-size:0.75rem;padding:4px 8px;">Delete</button>
-                            </td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch downloads:', error);
-                showToast('Failed to fetch downloads', 'error');
-            }
-        }
-        
-        async function downloadFile(path) {
-            try {
-                window.open(`/api/admin/downloads/file?path=${encodeURIComponent(path)}`, '_blank');
-            } catch (error) {
-                console.error('Failed to download file:', error);
-                showToast('Failed to download file', 'error');
-            }
-        }
-        
-        async function deleteDownload(path) {
-            if (!confirm(`Delete this file?\n\n${path}\n\nThis action cannot be undone.`)) {
-                return;
-            }
-            
-            try {
-                const res = await fetch(`/api/admin/downloads?path=${encodeURIComponent(path)}`, {
-                    method: 'DELETE'
-                });
-                
-                if (res.ok) {
-                    showToast('File deleted successfully', 'success');
-                    
-                    // Remove the row immediately for live update
-                    const escapedPath = path.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-                    const row = document.querySelector(`tr[data-path="${escapedPath}"]`);
-                    if (row) {
-                        row.remove();
-                    }
-                    
-                    // Refresh to update counts
-                    await fetchDownloads();
-                } else {
-                    const error = await res.json();
-                    showToast(error.error || 'Failed to delete file', 'error');
-                }
-            } catch (error) {
-                console.error('Failed to delete file:', error);
-                showToast('Failed to delete file', 'error');
-            }
-        }
-        
-        async function fetchConfig() {
-            try {
-                const res = await fetch('/api/admin/config');
-                const data = await res.json();
-                
-                // Spotify API settings
-                document.getElementById('config-spotify-enabled').textContent = data.spotifyApi.enabled ? 'Yes' : 'No';
-                document.getElementById('config-spotify-cookie').textContent = data.spotifyApi.sessionCookie;
-                document.getElementById('config-cache-duration').textContent = data.spotifyApi.cacheDurationMinutes + ' minutes';
-                document.getElementById('config-isrc-matching').textContent = data.spotifyApi.preferIsrcMatching ? 'Enabled' : 'Disabled';
-                
-                // Cookie age in config tab
-                const configCookieAge = document.getElementById('config-cookie-age');
-                if (configCookieAge) {
-                    const hasCookie = data.spotifyApi.sessionCookie && data.spotifyApi.sessionCookie !== '(not set)';
-                    const age = formatCookieAge(data.spotifyApi.sessionCookieSetDate, hasCookie);
-                    configCookieAge.innerHTML = `<span class="${age.class}">${age.text}</span> - ${age.detail}`;
-                }
-                
-                // Deezer settings
-                document.getElementById('config-deezer-arl').textContent = data.deezer.arl || '(not set)';
-                document.getElementById('config-deezer-quality').textContent = data.deezer.quality;
-                
-                // SquidWTF settings
-                document.getElementById('config-squid-quality').textContent = data.squidWtf.quality;
-                
-                // MusicBrainz settings
-                document.getElementById('config-musicbrainz-enabled').textContent = data.musicBrainz.enabled ? 'Yes' : 'No';
-                document.getElementById('config-musicbrainz-username').textContent = data.musicBrainz.username || '(not set)';
-                document.getElementById('config-musicbrainz-password').textContent = data.musicBrainz.password || '(not set)';
-                
-                // Qobuz settings
-                document.getElementById('config-qobuz-token').textContent = data.qobuz.userAuthToken || '(not set)';
-                document.getElementById('config-qobuz-quality').textContent = data.qobuz.quality || 'FLAC';
-                
-                // Jellyfin settings
-                document.getElementById('config-jellyfin-url').textContent = data.jellyfin.url || '-';
-                document.getElementById('config-jellyfin-api-key').textContent = data.jellyfin.apiKey;
-                document.getElementById('config-jellyfin-user-id').textContent = data.jellyfin.userId || '(not set)';
-                document.getElementById('config-jellyfin-library-id').textContent = data.jellyfin.libraryId || '-';
-                
-                // Library settings
-                document.getElementById('config-download-path').textContent = data.library?.downloadPath || './downloads';
-                document.getElementById('config-kept-path').textContent = data.library?.keptPath || '/app/kept';
-                
-                // Sync settings
-                const syncHour = data.spotifyImport.syncStartHour;
-                const syncMin = data.spotifyImport.syncStartMinute;
-                document.getElementById('config-sync-time').textContent = `${String(syncHour).padStart(2, '0')}:${String(syncMin).padStart(2, '0')}`;
-                document.getElementById('config-sync-window').textContent = data.spotifyImport.syncWindowHours + ' hours';
-            } catch (error) {
-                console.error('Failed to fetch config:', error);
-            }
-        }
-        
-        async function fetchJellyfinUsers() {
-            try {
-                const res = await fetch('/api/admin/jellyfin/users');
-                if (!res.ok) return;
-                const data = await res.json();
-                const select = document.getElementById('jellyfin-user-select');
-                select.innerHTML = '<option value="">All Users</option>' + 
-                    data.users.map(u => `<option value="${u.id}">${escapeHtml(u.name)}</option>`).join('');
-            } catch (error) {
-                console.error('Failed to fetch users:', error);
-            }
-        }
-        
-        
-        async function fetchJellyfinPlaylists() {
-            const tbody = document.getElementById('jellyfin-playlist-table-body');
-            tbody.innerHTML = '<tr><td colspan="6" class="loading"><span class="spinner"></span> Loading Jellyfin playlists...</td></tr>';
-            
-            try {
-                // Build URL with optional user filter
-                const userId = document.getElementById('jellyfin-user-select').value;
-                
-                let url = '/api/admin/jellyfin/playlists';
-                if (userId) url += '?userId=' + encodeURIComponent(userId);
-                
-                const res = await fetch(url);
-                
-                if (!res.ok) {
-                    const errorData = await res.json();
-                    tbody.innerHTML = `<tr><td colspan="6" style="text-align:center;color:var(--error);padding:40px;">${errorData.error || 'Failed to fetch playlists'}</td></tr>`;
-                    return;
-                }
-                
-                const data = await res.json();
-                
-                if (data.playlists.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--text-secondary);padding:40px;">No playlists found in Jellyfin</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.playlists.map(p => {
-                    const statusBadge = p.isConfigured 
-                        ? '<span class="status-badge success"><span class="status-dot"></span>Linked</span>'
-                        : '<span class="status-badge"><span class="status-dot"></span>Not Linked</span>';
-                    
-                    const actionButton = p.isConfigured
-                        ? `<button class="danger" onclick="unlinkPlaylist('${escapeJs(p.name)}')">Unlink</button>`
-                        : `<button class="primary" onclick="openLinkPlaylist('${escapeJs(p.id)}', '${escapeJs(p.name)}')">Link to Spotify</button>`;
-                    
-                    const localCount = p.localTracks || 0;
-                    const externalCount = p.externalTracks || 0;
-                    const externalAvail = p.externalAvailable || 0;
-                    
-                    return `
-                        <tr data-playlist-id="${escapeHtml(p.id)}">
-                            <td><strong>${escapeHtml(p.name)}</strong></td>
-                            <td class="track-count">${localCount}</td>
-                            <td class="track-count">${externalCount > 0 ? `${externalAvail}/${externalCount}` : '-'}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;color:var(--text-secondary);">${p.linkedSpotifyId || '-'}</td>
-                            <td>${statusBadge}</td>
-                            <td>${actionButton}</td>
-                        </tr>
-                    `;
-                }).join('');
-            } catch (error) {
-                console.error('Failed to fetch Jellyfin playlists:', error);
-                tbody.innerHTML = '<tr><td colspan="6" style="text-align:center;color:var(--error);padding:40px;">Failed to fetch playlists</td></tr>';
-            }
-        }
-        
-        function openLinkPlaylist(jellyfinId, name) {
-            document.getElementById('link-jellyfin-id').value = jellyfinId;
-            document.getElementById('link-jellyfin-name').value = name;
-            document.getElementById('link-spotify-id').value = '';
-            openModal('link-playlist-modal');
-        }
-        
-        async function linkPlaylist() {
-            const jellyfinId = document.getElementById('link-jellyfin-id').value;
-            const name = document.getElementById('link-jellyfin-name').value;
-            const spotifyId = document.getElementById('link-spotify-id').value.trim();
-            
-            if (!spotifyId) {
-                showToast('Spotify Playlist ID is required', 'error');
-                return;
-            }
-            
-            // Extract ID from various Spotify formats:
-            // - spotify:playlist:37i9dQZF1DXcBWIGoYBM5M
-            // - https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M
-            // - 37i9dQZF1DXcBWIGoYBM5M
-            let cleanSpotifyId = spotifyId;
-            
-            // Handle spotify: URI format
-            if (spotifyId.startsWith('spotify:playlist:')) {
-                cleanSpotifyId = spotifyId.replace('spotify:playlist:', '');
-            }
-            // Handle URL format
-            else if (spotifyId.includes('spotify.com/playlist/')) {
-                const match = spotifyId.match(/playlist\/([a-zA-Z0-9]+)/);
-                if (match) cleanSpotifyId = match[1];
-            }
-            // Remove any query parameters or trailing slashes
-            cleanSpotifyId = cleanSpotifyId.split('?')[0].split('#')[0].replace(/\/$/, '');
-            
-            try {
-                const res = await fetch(`/api/admin/jellyfin/playlists/${encodeURIComponent(jellyfinId)}/link`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, spotifyPlaylistId: cleanSpotifyId })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist linked!', 'success');
-                    showRestartBanner();
-                    closeModal('link-playlist-modal');
-                    
-                    // Update UI state without refetching all playlists
-                    const playlistsTable = document.getElementById('jellyfinPlaylistsTable');
-                    if (playlistsTable) {
-                        const rows = playlistsTable.querySelectorAll('tr');
-                        rows.forEach(row => {
-                            if (row.dataset.playlistId === jellyfinId) {
-                                const actionCell = row.querySelector('td:last-child');
-                                if (actionCell) {
-                                    actionCell.innerHTML = `<button class="danger" onclick="unlinkPlaylist('${escapeJs(name)}')">Unlink</button>`;
-                                }
-                            }
-                        });
-                    }
-                    
-                    fetchPlaylists(); // Only refresh the Active Playlists tab
-                } else {
-                    showToast(data.error || 'Failed to link playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to link playlist', 'error');
-            }
-        }
-        
-        async function unlinkPlaylist(name) {
-            if (!confirm(`Unlink playlist "${name}"? This will stop filling in missing tracks.`)) return;
-            
-            try {
-                const res = await fetch(`/api/admin/jellyfin/playlists/${encodeURIComponent(name)}/unlink`, {
-                    method: 'DELETE'
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist unlinked.', 'success');
-                    showRestartBanner();
-                    
-                    // Update UI state without refetching all playlists
-                    const playlistsTable = document.getElementById('jellyfinPlaylistsTable');
-                    if (playlistsTable) {
-                        const rows = playlistsTable.querySelectorAll('tr');
-                        rows.forEach(row => {
-                            const nameCell = row.querySelector('td:first-child');
-                            if (nameCell && nameCell.textContent === name) {
-                                const actionCell = row.querySelector('td:last-child');
-                                if (actionCell) {
-                                    const playlistId = row.dataset.playlistId;
-                                    actionCell.innerHTML = `<button class="primary" onclick="openLinkPlaylist('${escapeJs(playlistId)}', '${escapeJs(name)}')">Link to Spotify</button>`;
-                                }
-                            }
-                        });
-                    }
-                    
-                    fetchPlaylists(); // Only refresh the Active Playlists tab
-                } else {
-                    showToast(data.error || 'Failed to unlink playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to unlink playlist', 'error');
-            }
-        }
-        
-        async function refreshPlaylists() {
-            try {
-                showToast('Refreshing playlists...', 'success');
-                const res = await fetch('/api/admin/playlists/refresh', { method: 'POST' });
-                const data = await res.json();
-                showToast(data.message, 'success');
-                setTimeout(fetchPlaylists, 2000);
-            } catch (error) {
-                showToast('Failed to refresh playlists', 'error');
-            }
-        }
-        
-        async function clearPlaylistCache(name) {
-            if (!confirm(`Clear cache and rebuild for "${name}"?\n\nThis will:\n• Clear Redis cache\n• Delete file caches\n• Rebuild with latest Spotify IDs\n\nThis may take a minute.`)) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast(`Clearing cache for ${name}...`, 'info');
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/clear-cache`, { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message} (Cleared ${data.clearedKeys} cache keys, ${data.clearedFiles} files)`, 'success', 5000);
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 3000);
-                } else {
-                    showToast(data.error || 'Failed to clear cache', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to clear cache', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function matchPlaylistTracks(name) {
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast(`Matching tracks for ${name}...`, 'success');
-                const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/match`, { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message}`, 'success');
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 2000);
-                } else {
-                    showToast(data.error || 'Failed to match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to match tracks', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function matchAllPlaylists() {
-            if (!confirm('Match tracks for ALL playlists? This may take a few minutes.')) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast('Matching tracks for all playlists...', 'success');
-                const res = await fetch('/api/admin/playlists/match-all', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ ${data.message}`, 'success');
-                    // Refresh the playlists table after a delay to show updated counts
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 2000);
-                } else {
-                    showToast(data.error || 'Failed to match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to match tracks', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        async function refreshAndMatchAll() {
-            if (!confirm('Clear caches, refresh from Spotify, and match all tracks?\n\nThis will:\n• Clear all playlist caches\n• Fetch fresh data from Spotify\n• Match all tracks against local library and external providers\n\nThis may take several minutes.')) return;
-            
-            try {
-                // Show warning banner
-                document.getElementById('matching-warning-banner').style.display = 'block';
-                
-                showToast('Starting full refresh and match...', 'info', 3000);
-                
-                // Step 1: Clear all caches
-                showToast('Step 1/3: Clearing caches...', 'info', 2000);
-                await fetch('/api/admin/cache/clear', { method: 'POST' });
-                
-                // Wait for cache to be fully cleared
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                
-                // Step 2: Refresh playlists from Spotify
-                showToast('Step 2/3: Fetching from Spotify...', 'info', 2000);
-                await fetch('/api/admin/playlists/refresh', { method: 'POST' });
-                
-                // Wait for Spotify fetch to complete
-                await new Promise(resolve => setTimeout(resolve, 5000));
-                
-                // Step 3: Match all tracks
-                showToast('Step 3/3: Matching all tracks (this may take several minutes)...', 'info', 3000);
-                const res = await fetch('/api/admin/playlists/match-all', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ Full refresh and match complete!`, 'success', 5000);
-                    // Refresh the playlists table after a delay
-                    setTimeout(() => {
-                        fetchPlaylists();
-                        // Hide warning banner after refresh
-                        document.getElementById('matching-warning-banner').style.display = 'none';
-                    }, 3000);
-                } else {
-                    showToast(data.error || 'Failed to match tracks', 'error');
-                    document.getElementById('matching-warning-banner').style.display = 'none';
-                }
-            } catch (error) {
-                showToast('Failed to complete refresh and match', 'error');
-                document.getElementById('matching-warning-banner').style.display = 'none';
-            }
-        }
-        
-        
-        async function searchProvider(query, provider) {
-            // Use SquidWTF HiFi API with round-robin base URLs for all searches
-            // Get a random base URL from the backend
-            try {
-                const response = await fetch('/api/admin/squidwtf-base-url');
-                const data = await response.json();
-                
-                if (data.baseUrl) {
-                    // Use the HiFi API search endpoint: /search/?s=query
-                    const searchUrl = `${data.baseUrl}/search/?s=${encodeURIComponent(query)}`;
-                    window.open(searchUrl, '_blank');
-                } else {
-                    showToast('Failed to get search URL', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to get search URL', 'error');
-            }
-        }
-        
-        function capitalizeProvider(provider) {
-            // Capitalize provider names for display
-            const providerMap = {
-                'squidwtf': 'SquidWTF',
-                'deezer': 'Deezer',
-                'qobuz': 'Qobuz'
-            };
-            return providerMap[provider?.toLowerCase()] || provider;
-        }
-        
-        async function clearCache() {
-            if (!confirm('Clear all cached playlist data?')) return;
-            
-            try {
-                const res = await fetch('/api/admin/cache/clear', { method: 'POST' });
-                const data = await res.json();
-                showToast(data.message, 'success');
-                fetchPlaylists();
-            } catch (error) {
-                showToast('Failed to clear cache', 'error');
-            }
-        }
-        
-        async function exportEnv() {
-            try {
-                const res = await fetch('/api/admin/export-env');
-                if (!res.ok) {
-                    throw new Error('Export failed');
-                }
-                
-                const blob = await res.blob();
-                const url = window.URL.createObjectURL(blob);
-                const a = document.createElement('a');
-                a.href = url;
-                a.download = `.env.backup.${new Date().toISOString().split('T')[0]}`;
-                document.body.appendChild(a);
-                a.click();
-                window.URL.revokeObjectURL(url);
-                document.body.removeChild(a);
-                
-                showToast('.env file exported successfully', 'success');
-            } catch (error) {
-                showToast('Failed to export .env file', 'error');
-            }
-        }
-        
-        async function importEnv(event) {
-            const file = event.target.files[0];
-            if (!file) return;
-            
-            if (!confirm('Import this .env file? This will replace your current configuration.\n\nA backup will be created automatically.\n\nYou will need to restart the container for changes to take effect.')) {
-                event.target.value = '';
-                return;
-            }
-            
-            try {
-                const formData = new FormData();
-                formData.append('file', file);
-                
-                const res = await fetch('/api/admin/import-env', {
-                    method: 'POST',
-                    body: formData
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(data.message, 'success');
-                } else {
-                    showToast(data.error || 'Failed to import .env file', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to import .env file', 'error');
-            }
-            
-            event.target.value = '';
-        }
-        
-        async function restartContainer() {
-            if (!confirm('Restart the container to apply configuration changes?\n\nThe dashboard will be temporarily unavailable.')) {
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/restart', { method: 'POST' });
-                const data = await res.json();
-                
-                if (res.ok) {
-                    // Show the restart overlay
-                    document.getElementById('restart-overlay').classList.add('active');
-                    document.getElementById('restart-status').textContent = 'Stopping container...';
-                    
-                    // Wait a bit then start checking if the server is back
-                    setTimeout(() => {
-                        document.getElementById('restart-status').textContent = 'Waiting for server to come back...';
-                        checkServerAndReload();
-                    }, 3000);
-                } else {
-                    showToast(data.message || data.error || 'Failed to restart', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to restart container', 'error');
-            }
-        }
-        
-        async function checkServerAndReload() {
-            let attempts = 0;
-            const maxAttempts = 60; // Try for 60 seconds
-            
-            const checkHealth = async () => {
-                try {
-                    const res = await fetch('/api/admin/status', { 
-                        method: 'GET',
-                        cache: 'no-store'
-                    });
-                    if (res.ok) {
-                        document.getElementById('restart-status').textContent = 'Server is back! Reloading...';
-                        dismissRestartBanner();
-                        setTimeout(() => window.location.reload(), 500);
-                        return;
-                    }
-                } catch (e) {
-                    // Server still restarting
-                }
-                
-                attempts++;
-                document.getElementById('restart-status').textContent = `Waiting for server to come back... (${attempts}s)`;
-                
-                if (attempts < maxAttempts) {
-                    setTimeout(checkHealth, 1000);
-                } else {
-                    document.getElementById('restart-overlay').classList.remove('active');
-                    showToast('Server may still be restarting. Please refresh manually.', 'warning');
-                }
-            };
-            
-            checkHealth();
-        }
-        
-        function openAddPlaylist() {
-            document.getElementById('new-playlist-name').value = '';
-            document.getElementById('new-playlist-id').value = '';
-            openModal('add-playlist-modal');
-        }
-        
-        async function addPlaylist() {
-            const name = document.getElementById('new-playlist-name').value.trim();
-            const id = document.getElementById('new-playlist-id').value.trim();
-            
-            if (!name || !id) {
-                showToast('Name and ID are required', 'error');
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/playlists', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, spotifyId: id })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist added.', 'success');
-                    showRestartBanner();
-                    closeModal('add-playlist-modal');
-                } else {
-                    showToast(data.error || 'Failed to add playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to add playlist', 'error');
-            }
-        }
-        
-        async function removePlaylist(name) {
-            if (!confirm(`Remove playlist "${name}"?`)) return;
-            
-            try {
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(name), {
-                    method: 'DELETE'
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Playlist removed.', 'success');
-                    showRestartBanner();
-                    fetchPlaylists();
-                } else {
-                    showToast(data.error || 'Failed to remove playlist', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to remove playlist', 'error');
-            }
-        }
-        
-        async function viewTracks(name) {
-            document.getElementById('tracks-modal-title').textContent = name + ' - Tracks';
-            document.getElementById('tracks-list').innerHTML = '<div class="loading"><span class="spinner"></span> Loading tracks...</div>';
-            openModal('tracks-modal');
-            
-            try {
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(name) + '/tracks');
-                const data = await res.json();
-                
-                if (data.tracks.length === 0) {
-                    document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--text-secondary);padding:40px;">No tracks found</p>';
-                    return;
-                }
-                
-                document.getElementById('tracks-list').innerHTML = data.tracks.map(t => {
-                    let statusBadge = '';
-                    let mapButton = '';
-                    let lyricsBadge = '';
-                    
-                    // Add lyrics status badge
-                    if (t.hasLyrics) {
-                        lyricsBadge = '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:#3b82f6;color:white;"><span class="status-dot" style="background:white;"></span>Lyrics</span>';
-                    }
-                    
-                    if (t.isLocal === true) {
-                        statusBadge = '<span class="status-badge success" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>Local</span>';
-                        // Add manual mapping indicator for local tracks
-                        if (t.isManualMapping && t.manualMappingType === 'jellyfin') {
-                            statusBadge += '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:var(--info);color:white;"><span class="status-dot" style="background:white;"></span>Manual</span>';
-                        }
-                    } else if (t.isLocal === false) {
-                        const provider = capitalizeProvider(t.externalProvider) || 'External';
-                        statusBadge = `<span class="status-badge warning" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>${escapeHtml(provider)}</span>`;
-                        // Add manual mapping indicator for external tracks
-                        if (t.isManualMapping && t.manualMappingType === 'external') {
-                            statusBadge += '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:4px;background:var(--info);color:white;"><span class="status-dot" style="background:white;"></span>Manual</span>';
-                        }
-                        // Add both mapping buttons for external tracks using data attributes
-                        const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                        mapButton = `<button class="small map-track-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:8px;font-size:0.75rem;padding:4px 8px;">Map to Local</button>
-                            <button class="small map-external-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>`;
-                    } else {
-                        // isLocal is null/undefined - track is missing (not found locally or externally)
-                        statusBadge = '<span class="status-badge" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;background:var(--bg-tertiary);color:var(--text-secondary);"><span class="status-dot" style="background:var(--text-secondary);"></span>Missing</span>';
-                        // Add both mapping buttons for missing tracks
-                        const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                        mapButton = `<button class="small map-track-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:8px;font-size:0.75rem;padding:4px 8px;">Map to Local</button>
-                            <button class="small map-external-btn" 
-                            data-playlist-name="${escapeHtml(name)}" 
-                            data-position="${t.position}" 
-                            data-title="${escapeHtml(t.title || '')}" 
-                            data-artist="${escapeHtml(firstArtist)}" 
-                            data-spotify-id="${escapeHtml(t.spotifyId || '')}" 
-                            style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External</button>`;
-                    }
-                    
-                    // Build search link with track name and artist
-                    const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : '';
-                    const searchLinkText = `${t.title} - ${firstArtist}`;
-                    const durationSeconds = Math.floor((t.durationMs || 0) / 1000);
-                    
-                    // Add lyrics mapping button
-                    const lyricsMapButton = `<button class="small" onclick="openLyricsMap('${escapeJs(firstArtist)}', '${escapeJs(t.title)}', '${escapeJs(t.album || '')}', ${durationSeconds})" style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:#3b82f6;border-color:#3b82f6;color:white;">Map Lyrics ID</button>`;
-                    
-                    return `
-                        <div class="track-item" data-position="${t.position}">
-                            <span class="track-position">${t.position + 1}</span>
-                            <div class="track-info">
-                                <h4>${escapeHtml(t.title)}${statusBadge}${lyricsBadge}${mapButton}${lyricsMapButton}</h4>
-                                <span class="artists">${escapeHtml((t.artists || []).join(', '))}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${t.album ? escapeHtml(t.album) : ''}
-                                ${t.isrc ? '<br><small>ISRC: ' + t.isrc + '</small>' : ''}
-                                ${t.isLocal === false && t.searchQuery && t.externalProvider ? '<br><small style="color:var(--accent)"><a href="#" onclick="searchProvider(\'' + escapeJs(t.searchQuery) + '\', \'' + escapeJs(t.externalProvider) + '\'); return false;" style="color:var(--accent);text-decoration:underline;">🔍 Search: ' + escapeHtml(searchLinkText) + '</a></small>' : ''}
-                                ${t.isLocal === null && t.searchQuery ? '<br><small style="color:var(--text-secondary)"><a href="#" onclick="searchProvider(\'' + escapeJs(t.searchQuery) + '\', \'squidwtf\'); return false;" style="color:var(--text-secondary);text-decoration:underline;">🔍 Search: ' + escapeHtml(searchLinkText) + '</a></small>' : ''}
-                            </div>
-                        </div>
-                    `;
-                }).join('');
-                
-                // Add event listeners to map buttons
-                document.querySelectorAll('.map-track-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlistName = this.getAttribute('data-playlist-name');
-                        const position = parseInt(this.getAttribute('data-position'));
-                        const title = this.getAttribute('data-title');
-                        const artist = this.getAttribute('data-artist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        openManualMap(playlistName, position, title, artist, spotifyId);
-                    });
-                });
-                
-                // Add event listeners to external map buttons
-                document.querySelectorAll('.map-external-btn').forEach(btn => {
-                    btn.addEventListener('click', function() {
-                        const playlistName = this.getAttribute('data-playlist-name');
-                        const position = parseInt(this.getAttribute('data-position'));
-                        const title = this.getAttribute('data-title');
-                        const artist = this.getAttribute('data-artist');
-                        const spotifyId = this.getAttribute('data-spotify-id');
-                        openExternalMap(playlistName, position, title, artist, spotifyId);
-                    });
-                });
-            } catch (error) {
-                document.getElementById('tracks-list').innerHTML = '<p style="text-align:center;color:var(--error);padding:40px;">Failed to load tracks</p>';
-            }
-        }
-        
-        // Generic edit setting modal
-        function openEditSetting(envKey, label, inputType, helpText = '', options = []) {
-            currentEditKey = envKey;
-            currentEditType = inputType;
-            currentEditOptions = options;
-            
-            document.getElementById('edit-setting-title').textContent = 'Edit ' + label;
-            document.getElementById('edit-setting-label').textContent = label;
-            
-            const helpEl = document.getElementById('edit-setting-help');
-            if (helpText) {
-                helpEl.textContent = helpText;
-                helpEl.style.display = 'block';
-            } else {
-                helpEl.style.display = 'none';
-            }
-            
-            const container = document.getElementById('edit-setting-input-container');
-            
-            if (inputType === 'toggle') {
-                container.innerHTML = `
-                    <select id="edit-setting-value">
-                        <option value="true">Enabled</option>
-                        <option value="false">Disabled</option>
-                    </select>
-                `;
-            } else if (inputType === 'select') {
-                container.innerHTML = `
-                    <select id="edit-setting-value">
-                        ${options.map(opt => `<option value="${opt}">${opt}</option>`).join('')}
-                    </select>
-                `;
-            } else if (inputType === 'password') {
-                container.innerHTML = `<input type="password" id="edit-setting-value" placeholder="Enter new value" autocomplete="off">`;
-            } else if (inputType === 'number') {
-                container.innerHTML = `<input type="number" id="edit-setting-value" placeholder="Enter value">`;
-            } else {
-                container.innerHTML = `<input type="text" id="edit-setting-value" placeholder="Enter value">`;
-            }
-            
-            openModal('edit-setting-modal');
-        }
-        
-        async function saveEditSetting() {
-            const value = document.getElementById('edit-setting-value').value.trim();
-            
-            if (!value && currentEditType !== 'toggle') {
-                showToast('Value is required', 'error');
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/config', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ updates: { [currentEditKey]: value } })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast('Setting updated.', 'success');
-                    showRestartBanner();
-                    closeModal('edit-setting-modal');
-                    fetchConfig();
-                    fetchStatus();
-                } else {
-                    showToast(data.error || 'Failed to update setting', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to update setting', 'error');
-            }
-        }
-        
-        function escapeHtml(text) {
-            const div = document.createElement('div');
-            div.textContent = text;
-            return div.innerHTML;
-        }
-        
-        // Manual track mapping
-        let searchTimeout = null;
-        
-        async function searchJellyfinTracks() {
-            const query = document.getElementById('map-search-query').value.trim();
-            
-            if (!query) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">Type to search for local tracks or paste a Jellyfin URL...</p>';
-                return;
-            }
-            
-            // Clear URL input when searching
-            document.getElementById('map-jellyfin-url').value = '';
-            
-            // Debounce search
-            clearTimeout(searchTimeout);
-            searchTimeout = setTimeout(async () => {
-                document.getElementById('map-search-results').innerHTML = '<div class="loading"><span class="spinner"></span> Searching...</div>';
-                
-                try {
-                    const res = await fetch('/api/admin/jellyfin/search?query=' + encodeURIComponent(query));
-                    const data = await res.json();
-                    
-                    if (data.tracks.length === 0) {
-                        document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">No tracks found</p>';
-                        return;
-                    }
-                    
-                    document.getElementById('map-search-results').innerHTML = data.tracks.map(t => `
-                        <div class="track-item" style="cursor: pointer; border: 2px solid transparent;" onclick="selectJellyfinTrack('${t.id}', this)">
-                            <div class="track-info">
-                                <h4>${escapeHtml(t.title)}</h4>
-                                <span class="artists">${escapeHtml(t.artist)}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${t.album ? escapeHtml(t.album) : ''}
-                            </div>
-                        </div>
-                    `).join('');
-                } catch (error) {
-                    document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Search failed</p>';
-                }
-            }, 300);
-        }
-        
-        async function extractJellyfinId() {
-            const url = document.getElementById('map-jellyfin-url').value.trim();
-            
-            if (!url) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--text-secondary); padding: 20px;">Type to search for local tracks or paste a Jellyfin URL...</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-                return;
-            }
-            
-            // Clear search input when using URL
-            document.getElementById('map-search-query').value = '';
-            
-            // Extract ID from URL patterns:
-            // https://jellyfin.example.com/web/#/details?id=XXXXX&serverId=...
-            // https://jellyfin.example.com/web/index.html#!/details?id=XXXXX
-            let jellyfinId = null;
-            
-            try {
-                const idMatch = url.match(/[?&]id=([a-f0-9]+)/i);
-                if (idMatch) {
-                    jellyfinId = idMatch[1];
-                }
-            } catch (e) {
-                // Invalid URL format
-            }
-            
-            if (!jellyfinId) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Could not extract track ID from URL. Make sure it contains "?id=..."</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-                return;
-            }
-            
-            // Fetch track details to show preview
-            document.getElementById('map-search-results').innerHTML = '<div class="loading"><span class="spinner"></span> Loading track details...</div>';
-            
-            try {
-                const res = await fetch('/api/admin/jellyfin/track/' + jellyfinId);
-                const track = await res.json();
-                
-                if (res.ok && track.id) {
-                    document.getElementById('map-selected-jellyfin-id').value = track.id;
-                    document.getElementById('map-save-btn').disabled = false;
-                    
-                    document.getElementById('map-search-results').innerHTML = `
-                        <div class="track-item" style="border: 2px solid var(--accent); background: var(--bg-tertiary);">
-                            <div class="track-info">
-                                <h4>${escapeHtml(track.title)}</h4>
-                                <span class="artists">${escapeHtml(track.artist)}</span>
-                            </div>
-                            <div class="track-meta">
-                                ${track.album ? escapeHtml(track.album) : ''}
-                            </div>
-                        </div>
-                        <p style="text-align: center; color: var(--success); padding: 12px; margin-top: 8px;">
-                            ✓ Track loaded from URL. Click "Save Mapping" to confirm.
-                        </p>
-                    `;
-                } else {
-                    document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Track not found in Jellyfin</p>';
-                    document.getElementById('map-selected-jellyfin-id').value = '';
-                    document.getElementById('map-save-btn').disabled = true;
-                }
-            } catch (error) {
-                document.getElementById('map-search-results').innerHTML = '<p style="text-align: center; color: var(--error); padding: 20px;">Failed to load track details</p>';
-                document.getElementById('map-selected-jellyfin-id').value = '';
-                document.getElementById('map-save-btn').disabled = true;
-            }
-        }
-        
-        function selectJellyfinTrack(jellyfinId, element) {
-            // Remove selection from all tracks
-            document.querySelectorAll('#map-search-results .track-item').forEach(el => {
-                el.style.border = '2px solid transparent';
-                el.style.background = '';
-            });
-            
-            // Highlight selected track
-            element.style.border = '2px solid var(--accent)';
-            element.style.background = 'var(--bg-tertiary)';
-            
-            // Store selected ID and enable save button
-            document.getElementById('map-selected-jellyfin-id').value = jellyfinId;
-            document.getElementById('map-save-btn').disabled = false;
-        }
-        
-        // Validate external mapping input
-        function validateExternalMapping() {
-            const externalId = document.getElementById('map-external-id').value.trim();
-            const saveBtn = document.getElementById('map-save-btn');
-            
-            // Enable save button if external ID is provided
-            saveBtn.disabled = !externalId;
-        }
-        
-        // Open manual mapping modal (external only)
-        function openManualMap(playlistName, position, title, artist, spotifyId) {
-            document.getElementById('map-playlist-name').value = playlistName;
-            document.getElementById('map-position').textContent = position + 1;
-            document.getElementById('map-spotify-title').textContent = title;
-            document.getElementById('map-spotify-artist').textContent = artist;
-            document.getElementById('map-spotify-id').value = spotifyId;
-            
-            // Reset fields
-            document.getElementById('map-external-id').value = '';
-            document.getElementById('map-external-provider').value = 'SquidWTF';
-            document.getElementById('map-save-btn').disabled = true;
-            
-            openModal('manual-map-modal');
-        }
-        
-        // Alias for backward compatibility
-        function openExternalMap(playlistName, position, title, artist, spotifyId) {
-            openManualMap(playlistName, position, title, artist, spotifyId);
-        }
-        
-        // Save manual mapping (external only)
-        async function saveManualMapping() {
-            const playlistName = document.getElementById('map-playlist-name').value;
-            const spotifyId = document.getElementById('map-spotify-id').value;
-            const position = parseInt(document.getElementById('map-position').textContent) - 1; // Convert back to 0-indexed
-            
-            const externalProvider = document.getElementById('map-external-provider').value;
-            const externalId = document.getElementById('map-external-id').value.trim();
-            
-            if (!externalId) {
-                showToast('Please enter an external provider ID', 'error');
-                return;
-            }
-            
-            const requestBody = {
-                spotifyId,
-                externalProvider,
-                externalId
-            };
-            
-            // Show loading state
-            const saveBtn = document.getElementById('map-save-btn');
-            const originalText = saveBtn.textContent;
-            saveBtn.textContent = 'Saving...';
-            saveBtn.disabled = true;
-            
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-                
-                const res = await fetch('/api/admin/playlists/' + encodeURIComponent(playlistName) + '/map', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(requestBody),
-                    signal: controller.signal
-                });
-                
-                clearTimeout(timeoutId);
-                const data = await res.json();
-                
-                if (res.ok) {
-                    showToast(`✓ Track mapped to ${requestBody.externalProvider} - rebuilding playlist...`, 'success');
-                    closeModal('manual-map-modal');
-                    
-                    // Show rebuilding indicator
-                    showPlaylistRebuildingIndicator(playlistName);
-                    
-                    // Show detailed info toast after a moment
-                    setTimeout(() => {
-                        showToast(`🔄 Rebuilding playlist with your ${requestBody.externalProvider} mapping...`, 'info', 8000);
-                    }, 1000);
-                    
-                    // Update the track in the UI without refreshing
-                    const trackItem = document.querySelector(`.track-item[data-position="${position}"]`);
-                    if (trackItem) {
-                        const titleEl = trackItem.querySelector('.track-info h4');
-                        if (titleEl) {
-                            // Update status badge to show provider
-                            const currentTitle = titleEl.textContent.split(' - ')[0]; // Remove old status
-                            const capitalizedProvider = capitalizeProvider(requestBody.externalProvider);
-                            const newStatusBadge = `<span class="status-badge warning" style="font-size:0.75rem;padding:2px 8px;margin-left:8px;"><span class="status-dot"></span>${escapeHtml(capitalizedProvider)}</span>`;
-                            titleEl.innerHTML = escapeHtml(currentTitle) + newStatusBadge;
-                        }
-                        
-                        // Remove search link since it's now mapped
-                        const searchLink = trackItem.querySelector('.track-meta a');
-                        if (searchLink) {
-                            searchLink.remove();
-                        }
-                    }
-                    
-                    // Also refresh the playlist counts in the background
-                    fetchPlaylists();
-                } else {
-                    showToast(data.error || 'Failed to save mapping', 'error');
-                }
-            } catch (error) {
-                if (error.name === 'AbortError') {
-                    showToast('Request timed out - mapping may still be processing', 'warning');
-                } else {
-                    showToast('Failed to save mapping', 'error');
-                }
-            } finally {
-                // Reset button state
-                saveBtn.textContent = originalText;
-                saveBtn.disabled = false;
-            }
-        }
-        
-        function showPlaylistRebuildingIndicator(playlistName) {
-            // Find the playlist in the UI and show rebuilding state
-            const playlistCards = document.querySelectorAll('.playlist-card');
-            for (const card of playlistCards) {
-                const nameEl = card.querySelector('h3');
-                if (nameEl && nameEl.textContent.trim() === playlistName) {
-                    // Add rebuilding indicator
-                    const existingIndicator = card.querySelector('.rebuilding-indicator');
-                    if (!existingIndicator) {
-                        const indicator = document.createElement('div');
-                        indicator.className = 'rebuilding-indicator';
-                        indicator.style.cssText = `
-                            position: absolute;
-                            top: 8px;
-                            right: 8px;
-                            background: var(--warning);
-                            color: white;
-                            padding: 4px 8px;
-                            border-radius: 12px;
-                            font-size: 0.7rem;
-                            font-weight: 500;
-                            display: flex;
-                            align-items: center;
-                            gap: 4px;
-                            z-index: 10;
-                        `;
-                        indicator.innerHTML = '<span class="spinner" style="width: 10px; height: 10px;"></span>Rebuilding...';
-                        card.style.position = 'relative';
-                        card.appendChild(indicator);
-                        
-                        // Auto-remove after 30 seconds and refresh
-                        setTimeout(() => {
-                            indicator.remove();
-                            fetchPlaylists(); // Refresh to get updated counts
-                        }, 30000);
-                    }
-                    break;
-                }
-            }
-        }
-        
-        function escapeJs(text) {
-            if (!text) return '';
-            return text.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
-        }
-        
-        // Lyrics ID mapping functions
-        function openLyricsMap(artist, title, album, durationSeconds) {
-            document.getElementById('lyrics-map-artist').textContent = artist;
-            document.getElementById('lyrics-map-title').textContent = title;
-            document.getElementById('lyrics-map-album').textContent = album || '(No album)';
-            document.getElementById('lyrics-map-artist-value').value = artist;
-            document.getElementById('lyrics-map-title-value').value = title;
-            document.getElementById('lyrics-map-album-value').value = album || '';
-            document.getElementById('lyrics-map-duration').value = durationSeconds;
-            document.getElementById('lyrics-map-id').value = '';
-            
-            openModal('lyrics-map-modal');
-        }
-        
-        async function saveLyricsMapping() {
-            const artist = document.getElementById('lyrics-map-artist-value').value;
-            const title = document.getElementById('lyrics-map-title-value').value;
-            const album = document.getElementById('lyrics-map-album-value').value;
-            const durationSeconds = parseInt(document.getElementById('lyrics-map-duration').value);
-            const lyricsId = parseInt(document.getElementById('lyrics-map-id').value);
-            
-            if (!lyricsId || lyricsId <= 0) {
-                showToast('Please enter a valid lyrics ID', 'error');
-                return;
-            }
-            
-            const saveBtn = document.getElementById('lyrics-map-save-btn');
-            const originalText = saveBtn.textContent;
-            saveBtn.textContent = 'Saving...';
-            saveBtn.disabled = true;
-            
-            try {
-                const res = await fetch('/api/admin/lyrics/map', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        artist,
-                        title,
-                        album,
-                        durationSeconds,
-                        lyricsId
-                    })
-                });
-                
-                const data = await res.json();
-                
-                if (res.ok) {
-                    if (data.cached && data.lyrics) {
-                        showToast(`✓ Lyrics mapped and cached: ${data.lyrics.trackName} by ${data.lyrics.artistName}`, 'success', 5000);
-                    } else {
-                        showToast('✓ Lyrics mapping saved successfully', 'success');
-                    }
-                    closeModal('lyrics-map-modal');
-                } else {
-                    showToast(data.error || 'Failed to save lyrics mapping', 'error');
-                }
-            } catch (error) {
-                showToast('Failed to save lyrics mapping', 'error');
-            } finally {
-                saveBtn.textContent = originalText;
-                saveBtn.disabled = false;
-            }
-        }
-        
-        // Initial load
-        fetchStatus();
-        fetchPlaylists();
-        fetchTrackMappings();
-        fetchMissingTracks();
-        fetchDownloads();
-        fetchJellyfinUsers();
-        fetchJellyfinPlaylists();
-        fetchConfig();
-        fetchEndpointUsage();
-        
-        // Auto-refresh every 30 seconds
-        setInterval(() => {
-            fetchStatus();
-            fetchPlaylists();
-            fetchTrackMappings();
-            fetchMissingTracks();
-            fetchDownloads();
-            
-            // Refresh endpoint usage if on that tab
-            const endpointsTab = document.getElementById('tab-endpoints');
-            if (endpointsTab && endpointsTab.classList.contains('active')) {
-                fetchEndpointUsage();
-            }
-        }, 30000);
-        
-        // Endpoint Usage Functions
-        async function fetchEndpointUsage() {
-            try {
-                const topSelect = document.getElementById('endpoints-top-select');
-                const top = topSelect ? topSelect.value : 50;
-                
-                const res = await fetch(`/api/admin/debug/endpoint-usage?top=${top}`);
-                const data = await res.json();
-                
-                // Update summary stats
-                document.getElementById('endpoints-total-requests').textContent = data.totalRequests?.toLocaleString() || '0';
-                document.getElementById('endpoints-unique-count').textContent = data.totalEndpoints?.toLocaleString() || '0';
-                
-                const mostCalled = data.endpoints && data.endpoints.length > 0 
-                    ? data.endpoints[0].endpoint 
-                    : '-';
-                document.getElementById('endpoints-most-called').textContent = mostCalled;
-                
-                // Update table
-                const tbody = document.getElementById('endpoints-table-body');
-                
-                if (!data.endpoints || data.endpoints.length === 0) {
-                    tbody.innerHTML = '<tr><td colspan="4" style="text-align:center;color:var(--text-secondary);padding:40px;">No endpoint usage data available yet. Data will appear as clients make requests.</td></tr>';
-                    return;
-                }
-                
-                tbody.innerHTML = data.endpoints.map((ep, index) => {
-                    const percentage = data.totalRequests > 0 
-                        ? ((ep.count / data.totalRequests) * 100).toFixed(1) 
-                        : '0.0';
-                    
-                    // Color code based on usage
-                    let countColor = 'var(--text-primary)';
-                    if (ep.count > 1000) countColor = 'var(--error)';
-                    else if (ep.count > 100) countColor = 'var(--warning)';
-                    else if (ep.count > 10) countColor = 'var(--accent)';
-                    
-                    // Highlight common patterns
-                    let endpointDisplay = ep.endpoint;
-                    if (ep.endpoint.includes('/stream')) {
-                        endpointDisplay = `<span style="color:var(--success)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else if (ep.endpoint.includes('/Playing')) {
-                        endpointDisplay = `<span style="color:var(--accent)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else if (ep.endpoint.includes('/Search')) {
-                        endpointDisplay = `<span style="color:var(--warning)">${escapeHtml(ep.endpoint)}</span>`;
-                    } else {
-                        endpointDisplay = escapeHtml(ep.endpoint);
-                    }
-                    
-                    return `
-                        <tr>
-                            <td style="color:var(--text-secondary);text-align:center;">${index + 1}</td>
-                            <td style="font-family:monospace;font-size:0.85rem;">${endpointDisplay}</td>
-                            <td style="text-align:right;font-weight:600;color:${countColor}">${ep.count.toLocaleString()}</td>
-                            <td style="text-align:right;color:var(--text-secondary)">${percentage}%</td>
-                        </tr>
-                    `;
-                }).join('');
-                
-            } catch (error) {
-                console.error('Failed to fetch endpoint usage:', error);
-                const tbody = document.getElementById('endpoints-table-body');
-                tbody.innerHTML = '<tr><td colspan="4" style="text-align:center;color:var(--error);padding:40px;">Failed to load endpoint usage data</td></tr>';
-            }
-        }
-        
-        async function clearEndpointUsage() {
-            if (!confirm('Are you sure you want to clear all endpoint usage data? This cannot be undone.')) {
-                return;
-            }
-            
-            try {
-                const res = await fetch('/api/admin/debug/endpoint-usage', { method: 'DELETE' });
-                const data = await res.json();
-                
-                showToast(data.message || 'Endpoint usage data cleared', 'success');
-                fetchEndpointUsage();
-            } catch (error) {
-                console.error('Failed to clear endpoint usage:', error);
-                showToast('Failed to clear endpoint usage data', 'error');
-            }
-        }
-        
-        function escapeHtml(text) {
-            const div = document.createElement('div');
-            div.textContent = text;
-            return div.innerHTML;
-        }
-    </script>
-</body>
-</html>
-=======

    <script type="module" src="js/main.js"></script>

-</html>
->>>>>>> beta
+</html>