Move shared infrastructure to a separate Infrastructure repo

Postgres, Zitadel, SeaweedFS, RabbitMQ and Jaeger no longer run as part
of this stack. They're shared services (used by Musify, Ping and
docker-manager) that now live in a separate Infrastructure repository
and must already be running.

deploy/compose.yml keeps only what's specific to Musify: its own
database connection, its own OIDC app and storage bucket (created
against the shared Zitadel/SeaweedFS via zitadel-init/seaweedfs-init),
and the application containers. A new wait-for-postgres one-shot
replaces the in-file Postgres health check, which no longer works now
that Postgres lives in a different compose project.

compose.prod.yml joins Infrastructure's infra-net network instead of
running its own copies. Docs and READMEs updated to match.

.claude/launch.json

@@ -4,14 +4,21 @@
 		{
 			"name": "musify-web",
 			"runtimeExecutable": "npm",
-			"runtimeArgs": ["--prefix", "web-player", "run", "dev", "--", "--port", "3000"],
-			"port": 3000
+			"runtimeArgs": ["--prefix", "web-player", "run", "dev"],
+			"port": 3000,
+			"autoPort": true
 		},
 		{
 			"name": "musify-api",
 			"runtimeExecutable": "dotnet",
 			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.Api"],
 			"port": 5111
+		},
+		{
+			"name": "musify-streaming-gateway",
+			"runtimeExecutable": "dotnet",
+			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.StreamingGateway"],
+			"port": 8081
 		}
 	]
 }

README.md

@@ -1,57 +1,55 @@
 # Musify
 
-Music streaming platform: upload your own tracks (or import them from YouTube),
-process them asynchronously (audio transcoded to `.m4a`, thumbnails generated)
-and stream them without the bytes ever going through the API.
+A music streaming app. Upload your own tracks, organize them into playlists
+and albums, and stream them back with a web player built around your
+listening habits: auto-generated mixes, a home feed, search, likes, and an
+Explore page for finding something new.
+
+## What it does
+
+- **Upload and organize your own music**: tracks, albums, cover art, artist credits.
+- **Playlists**, likes, and a "recently played" history.
+- **Mixes**, playlists generated automatically from what you actually listen to.
+- **Explore**, genre browsing and search across tracks, albums, playlists and people.
+- **Real streaming**, not just file downloads: seek, queue, shuffle, repeat.
+- **Accounts via OIDC login**, with an optional anonymous listening mode.
+- Light and dark themes, and a layout that works on both desktop and mobile.
+
+## How it's built
+
+**Backend**: .NET 10, split into a REST API, a background worker, and a
+dedicated streaming gateway.
+- Clean architecture (Domain / Application / Infrastructure) with CQRS (Mediator) and `ErrorOr` results.
+- PostgreSQL via EF Core for metadata. RabbitMQ and MassTransit handle async processing (audio transcoding, thumbnails) with saga-based rollback.
+- SeaweedFS (S3-compatible) for file storage. Uploads and downloads go straight between the client and storage, never through the API.
+- ffmpeg for audio transcoding, ImageSharp for thumbnails.
+- A YARP reverse proxy that streams the audio and checks a signed, short-lived ticket on every request.
+- Zitadel for login (OIDC/OAuth2).
+
+**Web client**: SvelteKit 2 on Svelte 5 (runes), TypeScript, Tailwind 4.
+The session lives on the server, so the backend access token never reaches the browser.
+
+**Infrastructure**: Musify's own apps run from Docker Compose (dev and
+production overlays). Postgres, RabbitMQ, SeaweedFS, Zitadel and Jaeger are
+shared infrastructure that lives in a separate `Infrastructure` git
+repository, used by Musify and by other projects that need the same OIDC
+provider and object storage.
+
+## Project layout
 
 ```
-backend/      .NET 10 — Domain / Application / Infrastructure / Api / Worker / StreamingGateway / Tests
-web-player/   SvelteKit 2 + Svelte 5 + Tailwind 4 web client
-deploy/       Docker Compose stacks — self-contained, no wrapper scripts
-docs/         What each piece does and why (in Spanish)
+backend/      .NET solution: Api, Worker, StreamingGateway, and the shared Domain/Application/Infrastructure
+web-player/   the SvelteKit web client
+deploy/       Docker Compose stacks for dev and production
+docs/         architecture notes, one file per area
 ```
 
-```sh
-dotnet test backend/Musify.slnx   # backend/Tests/ — Docker running (Testcontainers: Postgres, SeaweedFS)
-```
+Postgres, Zitadel, SeaweedFS, RabbitMQ and Jaeger are not part of this
+layout. They live in the separate `Infrastructure` repository instead.
 
-## Run it
+## Digging deeper
 
-Development (Docker Desktop):
-
-```sh
-docker compose -f deploy/compose.yml -f deploy/compose.dev.yml up -d
-```
-
-Infrastructure plus stream-ticket keys, database migrations and Zitadel OIDC
-provisioning — all as one-shot jobs baked into the compose file. Apps run from
-the IDE by default; add `--profile apps up -d --build` as a second command to
-run them in Docker instead.
-
-Production, on a server with a domain:
-
-```sh
-cp deploy/.env.prod.example deploy/.env.prod   # fill in the domain and secrets
-docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compose.prod.yml up -d
-docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compose.prod.yml --profile apps up -d --build
-```
-
-Idempotent — run the same commands again to deploy an update. See
-[deploy/README.md](deploy/README.md) for the details, the port map and the
-production prerequisites.
-
-## Components
-
-| Service | Port (dev) | Role |
-|---|---|---|
-| `Musify.Api` | 5111 | REST API, issues presigned upload URLs and stream tickets |
-| `Musify.StreamingGateway` | 8081 | YARP proxy that validates the stream ticket and serves the audio |
-| `Musify.Worker` | — | MassTransit consumers: transcoding, thumbnails, YouTube downloads |
-| `web-player` | 5173 / 3000 | Web client (SvelteKit, server-side OIDC session) |
-| Zitadel | 8080 | Identity (OIDC/OAuth2) |
-| PostgreSQL / RabbitMQ / SeaweedFS / Jaeger | 59000 / 5672 / 8333 / 16686 | Metadata, messaging, object storage, traces |
-
-More in [docs/](docs/README.md): [architecture](docs/architecture.md),
-[authentication](docs/authentication.md), [storage](docs/storage.md),
-[streaming](docs/streaming.md), [media processing](docs/media-processing.md),
-[development](docs/development.md).
+[docs/](docs/README.md) covers how each piece works and why: architecture,
+authentication, storage, streaming, media processing, and the local dev
+setup. [deploy/README.md](deploy/README.md) has the full instructions for
+running the stack, in development or on a production server.

backend/Core/Musify.Application/Albums/AddTrackToAlbum.cs

@@ -17,10 +17,10 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
+            if (album == null)
             {
                 logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                 return Error.NotFound();
@@ -32,19 +32,16 @@ namespace Musify.Application.Albums
                 return Error.Unauthorized();
             }
 
-            var trackExists = await database.Tracks
+            var track = await database.Tracks
                 .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (!trackExists)
+                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
+            if (track == null)
             {
                 logger.LogInformation("Track {TrackId} not found", request.TrackId);
                 return Error.NotFound(description: $"Track {request.TrackId} not found");
             }
 
-            var localTrack = await database.LocalTracks
-                .AsNoTracking()
-                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (localTrack is not null && localTrack.OwnerUserId != request.UserId)
+            if (track.OwnerUserId != request.UserId)
             {
                 logger.LogWarning("User {UserId} does not own track {TrackId}", request.UserId, request.TrackId);
                 return Error.Unauthorized();

backend/Core/Musify.Application/Albums/CreateAlbum.cs

@@ -50,7 +50,7 @@ namespace Musify.Application.Albums
             var intent = pictureIntent.Value;
             var title = request.Title.Trim();
 
-            var album = new UserAlbum
+            var album = new Album
             {
                 OwnerUserId = request.UserId,
                 Title = title,
@@ -66,7 +66,7 @@ namespace Musify.Application.Albums
                 }
             };
 
-            await database.UserAlbums.AddAsync(album, cancellationToken);
+            await database.Albums.AddAsync(album, cancellationToken);
 
             var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
             var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);

backend/Core/Musify.Application/Albums/DeleteAlbum.cs

@@ -16,9 +16,9 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
+            if (album == null)
             {
                 logger.LogDebug("Album {AlbumId} not found", request.AlbumId);
                 return Error.NotFound();
@@ -30,7 +30,7 @@ namespace Musify.Application.Albums
                 return Error.Unauthorized();
             }
 
-            database.UserAlbums.Remove(album);
+            database.Albums.Remove(album);
 
             try
             {

backend/Core/Musify.Application/Albums/GetAlbumById.cs

@@ -14,7 +14,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .Where(a => a.Id == request.Id)
                 .Select(a => new
@@ -29,7 +29,7 @@ namespace Musify.Application.Albums
                 })
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (album is null)
+            if (album == null)
                 return Error.NotFound();
 
             return AlbumApplicationResponse.FromEntity(album.Album, album.TrackCount, album.CoverTrackIds);

backend/Core/Musify.Application/Albums/GetAlbumCover.cs

@@ -25,7 +25,7 @@ namespace Musify.Application.Albums
                 .Select(a => a.Pictures)
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (pictures is null)
+            if (pictures == null)
                 return Error.NotFound();
 
             var routes = albumConfiguration.Routes;

backend/Core/Musify.Application/Albums/GetAlbumTracks.cs

@@ -4,7 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 using X.PagedList;
 using X.PagedList.EF;
 
@@ -29,9 +28,8 @@ namespace Musify.Application.Albums
 
             var tracksQuery = database.AlbumHasTracks
                 .AsNoTracking()
-                .Include(albumTrack => ((ExternalTrack)albumTrack.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(albumTrack => ((LocalTrack)albumTrack.Track).Owner)
+                .Include(albumTrack => albumTrack.Track.Owner)
+                .Include(albumTrack => albumTrack.Track.Tags)
                 .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
 
             var totalCount = await tracksQuery.CountAsync(cancellationToken);

backend/Core/Musify.Application/Albums/GetAlbums.cs

@@ -1,29 +1,19 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
 using X.PagedList;
 using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
-    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize, string? YoutubeContinuationToken = null)
+    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
         : IQuery<ErrorOr<AlbumsSearchResponse>>;
 
-    public class GetAlbumsQueryHandler(
-        IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
-        ILogger<GetAlbumsQueryHandler> logger)
+    public class GetAlbumsQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumsQuery, ErrorOr<AlbumsSearchResponse>>
     {
-        // Mirrors GetTracksQueryHandler's threshold: a title shorter than this is too likely to
-        // still be mid-keystroke to justify a live call to the external search API.
-        private const int MinTitleLengthForYouTubeSearch = 2;
-
         public async ValueTask<ErrorOr<AlbumsSearchResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
         {
             var albumsQuery = database.Albums
@@ -52,62 +42,19 @@ namespace Musify.Application.Albums
                 })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            var localItems = pagedEntities
+            var items = pagedEntities
                 .Select(entry => AlbumSearchItemResponse.FromAlbum(
                     AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)))
                 .ToList();
 
-            var knownExternalIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            foreach (var entry in pagedEntities)
-            {
-                if (entry.Album is ExternalAlbum { Source: TrackSource.YouTube } external)
-                    knownExternalIds.Add(external.ExternalId);
-            }
-
-            var youtubeItems = new List<AlbumSearchItemResponse>();
-            string? nextContinuationToken = null;
-            var youtubeUnavailable = false;
-
-            if (request.Title?.Trim().Length >= MinTitleLengthForYouTubeSearch)
-                (youtubeItems, nextContinuationToken, youtubeUnavailable) =
-                    await SearchYouTubeAsync(request.Title, request.YoutubeContinuationToken, knownExternalIds, cancellationToken);
-
-            return AlbumsSearchResponse.Create(
-                [.. localItems, .. youtubeItems],
+            return new AlbumsSearchResponse(
+                items,
                 pagedEntities.PageNumber,
                 pagedEntities.PageSize,
                 pagedEntities.PageCount,
                 pagedEntities.TotalItemCount,
                 pagedEntities.HasPreviousPage,
-                pagedEntities.HasNextPage,
-                nextContinuationToken,
-                youtubeUnavailable);
-        }
-
-        private async Task<(List<AlbumSearchItemResponse> Items, string? NextContinuationToken, bool Unavailable)> SearchYouTubeAsync(
-            string title,
-            string? continuationToken,
-            HashSet<string> knownExternalIds,
-            CancellationToken cancellationToken)
-        {
-            var searchResult = await youTubeMusicService.SearchAlbumsAsync(title, continuationToken ?? string.Empty, cancellationToken);
-            if (searchResult.IsError)
-            {
-                logger.LogInformation(
-                    "YouTube album search unavailable while combining album results: {Error}", searchResult.FirstError.Description);
-                return ([], null, true);
-            }
-
-            var items = searchResult.Value.Items
-                .Where(album => knownExternalIds.Add(album.AlbumId))
-                .Select(AlbumSearchItemResponse.FromYouTubeAlbum)
-                .ToList();
-
-            var nextToken = string.IsNullOrEmpty(searchResult.Value.ContinuationToken)
-                ? null
-                : searchResult.Value.ContinuationToken;
-
-            return (items, nextToken, false);
+                pagedEntities.HasNextPage);
         }
     }
 }

backend/Core/Musify.Application/Albums/GetAlbumsByUserId.cs

@@ -23,7 +23,7 @@ namespace Musify.Application.Albums
             if (!userExists)
                 return Error.NotFound(description: $"User {request.UserId} not found");
 
-            var albumsQuery = database.UserAlbums
+            var albumsQuery = database.Albums
                 .AsNoTracking()
                 .Where(album => album.OwnerUserId == request.UserId);
 

backend/Core/Musify.Application/Albums/GetRecentlyListenedAlbums.cs

@@ -7,7 +7,7 @@ using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
     public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
-        : IQuery<ErrorOr<IReadOnlyList<AlbumApplicationResponse> >>;
+        : IQuery<ErrorOr<IReadOnlyList<AlbumApplicationResponse>>>;
 
     public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
         : IQueryHandler<GetRecentlyListenedAlbumsQuery, ErrorOr<IReadOnlyList<AlbumApplicationResponse>>>
@@ -24,9 +24,9 @@ namespace Musify.Application.Albums
                     listenedTrackIds,
                     albumTrack => albumTrack.TrackId,
                     history => history.TrackId,
-                    (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt } )
+                    (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt })
                 .GroupBy(entry => entry.AlbumId)
-                .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) } )
+                .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) })
                 .OrderByDescending(entry => entry.LastListenedAt)
                 .Take(request.Limit)
                 .ToListAsync(cancellationToken);
@@ -48,7 +48,7 @@ namespace Musify.Application.Albums
                         .Take(AlbumApplicationResponse.CoverTrackCount)
                         .Select(albumTrack => albumTrack.TrackId)
                         .ToList()
-                } )
+                })
                 .ToDictionaryAsync(entry => entry.Album.Id, cancellationToken);
 
             return ranked

backend/Core/Musify.Application/Albums/RemoveTrackFromAlbum.cs

@@ -16,10 +16,10 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
+            if (album == null)
             {
                 logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                 return Error.NotFound();
@@ -37,7 +37,7 @@ namespace Musify.Application.Albums
                 .ToListAsync(cancellationToken);
 
             var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
-            if (link is null)
+            if (link == null)
             {
                 logger.LogInformation("Track {TrackId} not in album {AlbumId}", request.TrackId, request.AlbumId);
                 return Error.NotFound(description: "Track is not in the album.");

backend/Core/Musify.Application/Albums/RequestAlbumPictureUpload.cs

@@ -42,7 +42,7 @@ namespace Musify.Application.Albums
             var effectiveSizeBytes = request.ExpectedSizeBytes
                 ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
 
-            var objectName = $"{Guid.NewGuid() }.{request.FileType.TrimStart('.').ToLowerInvariant() }";
+            var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
 
             var tempKey = albumConfiguration.Routes.BuildTempPicturePath(
                 uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
@@ -84,7 +84,7 @@ namespace Musify.Application.Albums
                 await database.SaveChangesAsync(cancellationToken);
                 await transaction.CommitAsync(cancellationToken);
 
-                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (AlbumPicture, temp key: {Key} )", intent.Id, request.UserId, tempKey);
+                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (AlbumPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
 
                 return new AlbumPictureUploadResponse(
                     intent.Id,

backend/Core/Musify.Application/Albums/Responses/AlbumApplicationResponse.cs

@@ -1,23 +1,15 @@
 using System.Text.Json.Serialization;
 using Musify.Domain.Entities;
+using Musify.Application.Serialization;
 
 namespace Musify.Application.Albums.Responses
 {
-    // [JsonPolymorphic]/[JsonDerivedType] are required here, not optional: without them
-    // System.Text.Json serializes strictly by the declared CLR type at each call site
-    // (AlbumApplicationResponse, both as a bare return type and nested inside
-    // AlbumSearchItemResponse.Album), so an ExternalAlbumApplicationResponse instance would
-    // silently lose ExternalId/ThumbnailUrl on the wire. This also gives every response a
-    // "source" discriminator field for free, matching AlbumSearchItemResponse.Source.
-    [JsonPolymorphic(TypeDiscriminatorPropertyName = "source")]
-    [JsonDerivedType(typeof(AlbumApplicationResponse), typeDiscriminator: "Local")]
-    [JsonDerivedType(typeof(ExternalAlbumApplicationResponse), typeDiscriminator: "YouTube")]
     public record AlbumApplicationResponse(
         Guid Id,
         string Title,
         string? Description,
         int? ReleaseYear,
-        long OwnerUserId,
+        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
         int TrackCount,
         string? SmallImageKeyName,
         string? MediumImageKeyName,
@@ -29,7 +21,7 @@ namespace Musify.Application.Albums.Responses
         public const int CoverTrackCount = 4;
 
         public static AlbumApplicationResponse FromEntity(
-            UserAlbum album,
+            Album album,
             int trackCount,
             IReadOnlyList<Guid>? coverTrackIds = null)
         {
@@ -47,18 +39,5 @@ namespace Musify.Application.Albums.Responses
                 album.UpdatedAt,
                 coverTrackIds ?? []);
         }
-
-        public static AlbumApplicationResponse FromEntity(
-            Album album,
-            int trackCount,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return album switch
-            {
-                ExternalAlbum externalAlbum => ExternalAlbumApplicationResponse.FromEntity(externalAlbum, trackCount, coverTrackIds),
-                UserAlbum userAlbum => FromEntity(userAlbum, trackCount, coverTrackIds),
-                _ => throw new NotSupportedException($"Unsupported album entity type '{album.GetType().Name}'.")
-            };
-        }
     }
 }

backend/Core/Musify.Application/Albums/Responses/AlbumSearchItemResponse.cs

@@ -1,22 +1,7 @@
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-
 namespace Musify.Application.Albums.Responses
 {
-    /// <summary>One item of a combined local/external album listing. Exactly one of
-    /// <see cref="Album"/> or <see cref="YouTubeAlbum"/> is populated: <see cref="Album"/> for
-    /// anything already in the catalog (locally created albums and external albums materialized
-    /// earlier), <see cref="YouTubeAlbum"/> for a live external search hit that hasn't been
-    /// materialized yet, so it has no album id.</summary>
-    public record AlbumSearchItemResponse(
-        TrackSource Source,
-        AlbumApplicationResponse? Album,
-        YouTubeAlbumResult? YouTubeAlbum)
+    public record AlbumSearchItemResponse(AlbumApplicationResponse Album)
     {
-        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) =>
-            new(album is ExternalAlbumApplicationResponse ? TrackSource.YouTube : TrackSource.Local, album, null);
-
-        public static AlbumSearchItemResponse FromYouTubeAlbum(YouTubeAlbumResult album) =>
-            new(TrackSource.YouTube, null, album);
+        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) => new(album);
     }
 }

backend/Core/Musify.Application/Albums/Responses/AlbumsSearchResponse.cs

@@ -1,11 +1,6 @@
 namespace Musify.Application.Albums.Responses
 {
-    /// <summary>Result of a combined albums listing/search: a page of local catalog albums
-    /// (user-created and previously materialized external albums), plus, when a search term was
-    /// given, live external hits appended after them. Pagination metadata (<see cref="PageNumber"/>,
-    /// <see cref="PageSize"/>, <see cref="PageCount"/>, <see cref="TotalItemCount"/>) describes only
-    /// the local page — the external source has no stable total, so its continuation is tracked
-    /// separately via <see cref="NextYoutubeContinuationToken"/>.</summary>
+
     public record AlbumsSearchResponse(
         IReadOnlyList<AlbumSearchItemResponse> Items,
         int PageNumber,
@@ -13,26 +8,5 @@ namespace Musify.Application.Albums.Responses
         int PageCount,
         int TotalItemCount,
         bool HasPreviousPage,
-        bool HasNextLocalPage,
-        string? NextYoutubeContinuationToken,
-        bool YoutubeUnavailable,
-        bool HasNextPage)
-    {
-        // HasNextPage is a real field (not a computed property) so it shows up as a required member
-        // of the generated OpenAPI schema, same as every other field here — a get-only property added
-        // outside the primary constructor gets reflected as optional instead, which is never true here.
-        public static AlbumsSearchResponse Create(
-            IReadOnlyList<AlbumSearchItemResponse> items,
-            int pageNumber,
-            int pageSize,
-            int pageCount,
-            int totalItemCount,
-            bool hasPreviousPage,
-            bool hasNextLocalPage,
-            string? nextYoutubeContinuationToken,
-            bool youtubeUnavailable) =>
-            new(items, pageNumber, pageSize, pageCount, totalItemCount, hasPreviousPage, hasNextLocalPage,
-                nextYoutubeContinuationToken, youtubeUnavailable,
-                HasNextPage: hasNextLocalPage || !string.IsNullOrEmpty(nextYoutubeContinuationToken));
-    }
+        bool HasNextPage);
 }

backend/Core/Musify.Application/Albums/Responses/ExternalAlbumApplicationResponse.cs

@@ -1,47 +0,0 @@
-using Musify.Domain.Entities;
-
-namespace Musify.Application.Albums.Responses
-{
-    public record ExternalAlbumApplicationResponse(
-        Guid Id,
-        string Title,
-        string? Description,
-        int? ReleaseYear,
-        long OwnerUserId,
-        int TrackCount,
-        string? SmallImageKeyName,
-        string? MediumImageKeyName,
-        string? LargeImageKeyName,
-        DateTime CreatedAt,
-        DateTime UpdatedAt,
-        IReadOnlyList<Guid> CoverTrackIds,
-        string ExternalId,
-        string? ThumbnailUrl)
-        : AlbumApplicationResponse(
-            Id, Title, Description, ReleaseYear, OwnerUserId, TrackCount,
-            SmallImageKeyName, MediumImageKeyName, LargeImageKeyName,
-            CreatedAt, UpdatedAt, CoverTrackIds)
-    {
-        public static ExternalAlbumApplicationResponse FromEntity(
-            ExternalAlbum album,
-            int trackCount,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return new ExternalAlbumApplicationResponse(
-                album.Id,
-                album.Title,
-                album.Description,
-                album.ReleaseYear,
-                0,
-                trackCount,
-                album.Pictures?.SmallName,
-                album.Pictures?.MediumName,
-                album.Pictures?.LargeName,
-                album.CreatedAt,
-                album.UpdatedAt,
-                coverTrackIds ?? [],
-                album.ExternalId,
-                album.ThumbnailUrl);
-        }
-    }
-}

backend/Core/Musify.Application/Albums/UpdateAlbum.cs

@@ -34,9 +34,9 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
+            if (album == null)
             {
                 logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                 return Error.NotFound();
@@ -77,8 +77,6 @@ namespace Musify.Application.Albums
                 finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
             }
 
-            database.UserAlbums.Update(album);
-
             if (pictureIntent != null && finalPictureKey != null)
             {
                 var publishResult = await PublishUpdateAlbumPictureSourceEventAsync(

backend/Core/Musify.Application/ApplicationDependencyInjection.cs

@@ -12,7 +12,6 @@ public static class ApplicationDependencyInjection
         services.AddMediator();
         services.AddScoped<UploadIntentValidator>();
         services.AddScoped<TrackStreamIssuer>();
-        services.AddScoped<YouTubeTrackProvisioner>();
 
         services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration, ApplicationStorageConfiguration.SectionName);
         services.AddValidatedOptions<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName);

backend/Core/Musify.Application/Configuration/GetPlaybackPublicConfig.cs

@@ -3,8 +3,7 @@ using Musify.Application.Configuration.Responses;
 
 namespace Musify.Application.Configuration
 {
-    /// <summary>Reads the parts of <see cref="PlaybackConfiguration"/> that are safe to expose to an
-    /// unauthenticated client, so it can decide whether to gate the app behind sign-in at all.</summary>
+
     public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
 
     public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)

backend/Core/Musify.Application/Configuration/MixConfiguration.cs

@@ -6,16 +6,7 @@ namespace Musify.Application.Configuration
     {
         public const string SectionName = "Mix";
 
-        [Range(1, 20)]
-        public int ArtistMixCount { get; set; } = 3;
-
         [Range(4, 100)]
         public int ItemsPerMix { get; set; } = 12;
-
-        [Range(1, 10)]
-        public int SeedArtistCount { get; set; } = 3;
-
-        [Range(1, 100)]
-        public int YouTubeResultsPerSeed { get; set; } = 12;
     }
 }

backend/Core/Musify.Application/Configuration/PlayListConfiguration.cs

@@ -12,10 +12,6 @@ namespace Musify.Application.Configuration
 
         [Required]
         public PlayListPicturesSizes PicturesSizes { get; set; } = new PlayListPicturesSizes();
-
-        public bool SeedPresetPictures { get; set; } = true;
-
-        public bool OverwritePresetPictures { get; set; } = false;
     }
 
     public class PlayListRoutes
@@ -38,18 +34,6 @@ namespace Musify.Application.Configuration
         [Required]
         public string LargePicturesFolder { get; set; } = "LargePictures";
 
-        [Required]
-        public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
-
-        [Required]
-        public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
-
-        [Required]
-        public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
-
-        [Required]
-        public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
-
         public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
 
         public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
@@ -58,12 +42,6 @@ namespace Musify.Application.Configuration
 
         public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
 
-        public string PresetSmallPicturePath => StorageKey.Combine(ParentFolders, SmallPicturesFolder, PresetSmallPicture);
-
-        public string PresetMediumPicturePath => StorageKey.Combine(ParentFolders, MediumPicturesFolder, PresetMediumPicture);
-
-        public string PresetLargePicturePath => StorageKey.Combine(ParentFolders, LargePicturesFolder, PresetLargePicture);
-
         public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
 
         public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);

backend/Core/Musify.Application/Configuration/PlaybackConfiguration.cs

@@ -2,28 +2,16 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    /// <summary>Controls whether listeners without a session can stream music at all, and if so,
-    /// how much of a track they get to hear before being cut off (a Spotify-style preview).</summary>
+
     public sealed class PlaybackConfiguration
     {
         public const string SectionName = "Playback";
 
-        /// <summary>When false (the default), every stream endpoint requires a signed-in user, exactly
-        /// like before this setting existed. When true, an anonymous request is issued a stream ticket
-        /// too, capped by <see cref="AnonymousFragmentSeconds"/> if that is greater than zero.</summary>
         public bool AllowAnonymousListening { get; set; }
 
-        /// <summary>How many seconds of a track an anonymous listener may hear, enforced by the
-        /// Streaming Gateway clamping the byte range it will serve for that ticket. Zero (the default)
-        /// means no cap: anonymous listeners hear the full track, same as a signed-in user. Ignored
-        /// when <see cref="AllowAnonymousListening"/> is false.</summary>
         [Range(0, 3600)]
         public int AnonymousFragmentSeconds { get; set; }
 
-        /// <summary>Bytes per second of the transcoded audio, used to turn <see cref="AnonymousFragmentSeconds"/>
-        /// into a byte cap for the stream ticket. Defaults to the app's own transcoder output (128 kbps
-        /// AAC, <c>AudioTranscoder:Ffmpeg:AudioBitrate</c>) — update this alongside that setting if it
-        /// ever changes, since the two aren't wired together.</summary>
         [Range(1, int.MaxValue)]
         public int EstimatedAudioBytesPerSecond { get; set; } = 16_000;
     }

backend/Core/Musify.Application/Configuration/Responses/PlaybackPublicConfigResponse.cs

@@ -1,7 +1,5 @@
 namespace Musify.Application.Configuration.Responses
 {
-    /// <param name="AllowAnonymousListening">Whether listeners without a session can stream music at all.</param>
-    /// <param name="AnonymousFragmentSeconds">How many seconds of a track an anonymous listener may hear.
-    /// Zero means no cap. Meaningless when <paramref name="AllowAnonymousListening"/> is false.</param>
+
     public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
 }

backend/Core/Musify.Application/Contracts/IDatabase.cs

@@ -11,22 +11,10 @@ namespace Musify.Application.Contracts
 
         DbSet<Album> Albums { get; }
 
-        DbSet<UserAlbum> UserAlbums { get; }
-
-        DbSet<ExternalAlbum> ExternalAlbums { get; }
-
         DbSet<AlbumHasTrack> AlbumHasTracks { get; }
 
         DbSet<Track> Tracks { get; }
 
-        DbSet<LocalTrack> LocalTracks { get; }
-
-        DbSet<ExternalTrack> ExternalTracks { get; }
-
-        DbSet<Artist> Artists { get; }
-
-        DbSet<TrackArtist> TrackArtists { get; }
-
         DbSet<UserHasTrack> UserHasTracks { get; }
 
         DbSet<PlayListHasTrack> PlayListHasTracks { get; }
@@ -41,6 +29,12 @@ namespace Musify.Application.Contracts
 
         DbSet<ListeningHistory> ListeningHistories { get; }
 
+        DbSet<TrackLike> TrackLikes { get; }
+
+        DbSet<TrackTag> TrackTags { get; }
+
+        DbSet<UserFollow> UserFollows { get; }
+
         Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
 
         Task<int> SaveChangesAsync(CancellationToken cancellationToken);

backend/Core/Musify.Application/Contracts/IStreamTicketService.cs

@@ -2,11 +2,7 @@ namespace Musify.Application.Contracts
 {
     public interface IStreamTicketService
     {
-        /// <param name="userId">Null for an anonymous listener — the ticket is issued without a
-        /// <c>sub</c> claim.</param>
-        /// <param name="keyPrefix">The storage key (prefix) the ticket authorizes reading from.</param>
-        /// <param name="maxBytes">When set, the Streaming Gateway clamps the byte range it will serve
-        /// for this ticket to <c>[0, maxBytes)</c> — used for the anonymous preview fragment.</param>
+
         StreamTicket IssueTicket(long? userId, string keyPrefix, long? maxBytes = null);
     }
 

backend/Core/Musify.Application/Contracts/IYouTubeDownloaderService.cs

@@ -1,9 +0,0 @@
-namespace Musify.Application.Contracts
-{
-    public record YouTubeDownloadResult(int ExitCode, string StandardError);
-
-    public interface IYouTubeDownloaderService
-    {
-        Task<YouTubeDownloadResult> DownloadAudioAsync(string videoId, string destinationFilePath, CancellationToken cancellationToken);
-    }
-}

backend/Core/Musify.Application/Contracts/IYouTubeMusicService.cs

@@ -1,64 +0,0 @@
-using ErrorOr;
-
-namespace Musify.Application.Contracts
-{
-    public record YouTubeArtistRef(string? Id, string Name);
-
-    public record YouTubeSongResult(
-        string VideoId,
-        string Title,
-        string Artist,
-        string Album,
-        int DurationSeconds,
-        string ThumbnailUrl,
-        bool IsExplicit,
-        IReadOnlyList<YouTubeArtistRef> Artists);
-
-    public record YouTubeSearchResult(
-        IReadOnlyList<YouTubeSongResult> Items,
-        string ContinuationToken);
-
-    public record YouTubeAlbumResult(
-        string AlbumId,
-        string Title,
-        string Artist,
-        string ThumbnailUrl,
-        int? ReleaseYear,
-        bool IsSingle,
-        bool IsEp,
-        IReadOnlyList<YouTubeArtistRef> Artists);
-
-    public record YouTubeAlbumSearchResult(
-        IReadOnlyList<YouTubeAlbumResult> Items,
-        string ContinuationToken);
-
-    public record YouTubeAlbumTrack(
-        string VideoId,
-        string Title,
-        int DurationSeconds,
-        int TrackNumber,
-        bool IsExplicit);
-
-    public record YouTubeAlbumDetail(
-        YouTubeAlbumResult Album,
-        string Description,
-        int TotalDurationSeconds,
-        IReadOnlyList<YouTubeAlbumTrack> Tracks);
-
-    public record YouTubeStreamInfo(string Url, int ExpiresInSeconds);
-
-    public interface IYouTubeMusicService
-    {
-        Task<ErrorOr<YouTubeSearchResult>> SearchSongsAsync(string query, string continuationToken, CancellationToken cancellationToken);
-
-        Task<ErrorOr<YouTubeAlbumSearchResult>> SearchAlbumsAsync(string query, string continuationToken, CancellationToken cancellationToken);
-
-        Task<ErrorOr<YouTubeAlbumDetail>> GetAlbumAsync(string albumId, CancellationToken cancellationToken);
-
-        Task<ErrorOr<YouTubeStreamInfo>> GetAudioStreamAsync(string videoId, CancellationToken cancellationToken);
-
-        Task<ErrorOr<YouTubeSongResult>> GetSongAsync(string videoId, CancellationToken cancellationToken);
-
-        string ResolveArtworkUrl(string thumbnailUrl);
-    }
-}

backend/Core/Musify.Application/Events/DownloadYouTubeTrackEvent.cs

@@ -1,14 +0,0 @@
-using Musify.Application.Shared;
-
-namespace Musify.Application.Events
-{
-    public record DownloadYouTubeTrackEvent(
-        Guid TrackId,
-        string VideoId,
-        string ThumbnailUrl,
-        string Bucket,
-        string AudioProcessedFolderKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
-}

backend/Core/Musify.Application/Likes/GetLikedTracks.cs

@@ -0,0 +1,43 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
+using X.PagedList;
+using X.PagedList.EF;
+
+namespace Musify.Application.Likes
+{
+    public record GetLikedTracksQuery(
+        long UserId,
+        int PageNumber,
+        int PageSize)
+        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
+
+    public class GetLikedTracksQueryHandler(IDatabase database)
+        : IQueryHandler<GetLikedTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
+    {
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetLikedTracksQuery request, CancellationToken cancellationToken)
+        {
+            var likesQuery = database.TrackLikes
+                .AsNoTracking()
+                .Include(like => like.Track.Owner)
+                .Include(like => like.Track.Tags)
+                .Where(like => like.UserId == request.UserId);
+
+            var totalCount = await likesQuery.CountAsync(cancellationToken);
+
+            var pagedEntities = await likesQuery
+                .OrderByDescending(like => like.CreatedAt)
+                .Select(like => new { like.Track, ListensCount = like.Track.ListeningHistories.Count })
+                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
+                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
+                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+
+            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+        }
+    }
+}

backend/Core/Musify.Application/Likes/ToggleTrackLike.cs

@@ -0,0 +1,56 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Likes
+{
+    public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
+        : ICommand<ErrorOr<bool>>;
+
+    public class ToggleTrackLikeCommandHandler(
+        IDatabase database,
+        ILogger<ToggleTrackLikeCommandHandler> logger)
+        : ICommandHandler<ToggleTrackLikeCommand, ErrorOr<bool>>
+    {
+        public async ValueTask<ErrorOr<bool>> Handle(ToggleTrackLikeCommand request, CancellationToken cancellationToken)
+        {
+            var trackExists = await database.Tracks
+                .AsNoTracking()
+                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
+            if (!trackExists)
+            {
+                logger.LogInformation("Track {TrackId} not found", request.TrackId);
+                return Error.NotFound(description: $"Track {request.TrackId} not found");
+            }
+
+            var existingLike = await database.TrackLikes
+                .SingleOrDefaultAsync(like => like.UserId == request.UserId && like.TrackId == request.TrackId, cancellationToken);
+
+            bool nowLiked;
+            if (existingLike != null)
+            {
+                database.TrackLikes.Remove(existingLike);
+                nowLiked = false;
+            }
+            else
+            {
+                await database.TrackLikes.AddAsync(new TrackLike
+                {
+                    UserId = request.UserId,
+                    TrackId = request.TrackId
+                }, cancellationToken);
+                nowLiked = true;
+            }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {UserId} {Action} track {TrackId}",
+                request.UserId, nowLiked ? "liked" : "unliked", request.TrackId);
+
+            return nowLiked;
+        }
+    }
+}

backend/Core/Musify.Application/Mixes/GenerateMixesForUser.cs

@@ -4,7 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
-using Musify.Application.Tracks.Responses;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
@@ -15,26 +14,28 @@ namespace Musify.Application.Mixes
 
     public class GenerateMixesForUserCommandHandler(
         IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
         MixConfiguration mixConfiguration,
         ILogger<GenerateMixesForUserCommandHandler> logger)
         : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
     {
-        private sealed record SeedArtist(Guid Id, string Name);
-
-        private sealed record LocalCandidate(Guid TrackId, string Title, string? Artist, double DurationSeconds);
-
-        private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<MixItem> Items);
-
-        private const int TitleLength = 300;
-        private const int ArtistLength = 300;
-        private const int ThumbnailUrlLength = 512;
-        private const int MixTitleLength = 100;
+        private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);
 
         public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
         {
             var userId = request.UserId;
 
+            var libraryTrackIds = await database.UserHasTracks
+                .AsNoTracking()
+                .Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(userTrack => userTrack.TrackId)
+                .ToListAsync(cancellationToken);
+
+            if (libraryTrackIds.Count == 0)
+            {
+                logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
+                return new Success();
+            }
+
             var historyTrackIds = await database.ListeningHistories
                 .AsNoTracking()
                 .Where(history => history.UserId == userId)
@@ -42,33 +43,29 @@ namespace Musify.Application.Mixes
                 .Distinct()
                 .ToListAsync(cancellationToken);
 
-            if (historyTrackIds.Count == 0)
+            var historySet = new HashSet<Guid>(historyTrackIds);
+            var unheardTrackIds = libraryTrackIds.Where(id => !historySet.Contains(id)).ToList();
+
+            var drafts = new List<MixDraft>();
+
+            var discovery = Take(Shuffle(unheardTrackIds));
+            if (discovery.Count > 0)
             {
-                logger.LogInformation("User {UserId} has no listening history yet, skipping mix generation", userId);
-                return new Success();
+                drafts.Add(new MixDraft(
+                    "Descubrimiento",
+                    "Canciones de tu biblioteca que todavía no has escuchado.",
+                    discovery));
             }
 
-            var seedArtists = await GetSeedArtistsAsync(historyTrackIds, cancellationToken);
-
-            if (seedArtists.Count == 0)
+            var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
+            if (daily.Count > 0)
             {
-                logger.LogInformation("User {UserId} has no artists to seed mixes from, skipping mix generation", userId);
-                return new Success();
+                drafts.Add(new MixDraft(
+                    "Tu mezcla diaria",
+                    "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
+                    daily));
             }
 
-            var knownVideoIds = await database.ExternalTracks
-                .AsNoTracking()
-                .Where(track => track.Source == TrackSource.YouTube && historyTrackIds.Contains(track.Id))
-                .Select(track => track.ExternalId)
-                .ToListAsync(cancellationToken);
-
-            var excludedVideoIds = new HashSet<string>(knownVideoIds, StringComparer.OrdinalIgnoreCase);
-
-            var youTubeByArtist = await SearchYouTubeAsync(seedArtists, excludedVideoIds, cancellationToken);
-            var localByArtist = await GetLocalCandidatesAsync(seedArtists, historyTrackIds, cancellationToken);
-
-            var drafts = BuildDrafts(seedArtists, localByArtist, youTubeByArtist);
-
             if (drafts.Count == 0)
             {
                 logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
@@ -91,197 +88,21 @@ namespace Musify.Application.Mixes
             return new Success();
         }
 
-        private async Task<List<SeedArtist>> GetSeedArtistsAsync(
-            IReadOnlyList<Guid> historyTrackIds,
-            CancellationToken cancellationToken)
+        private List<Guid> Take(IEnumerable<Guid> trackIds) =>
+            [.. trackIds.Take(mixConfiguration.ItemsPerMix)];
+
+        private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
+            [.. trackIds.OrderBy(_ => Guid.NewGuid())];
+
+        private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
         {
-            var ranked = await database.TrackArtists
-                .AsNoTracking()
-                .Where(trackArtist => historyTrackIds.Contains(trackArtist.TrackId))
-                .GroupBy(trackArtist => trackArtist.ArtistId)
-                .Select(group => new { ArtistId = group.Key, Listens = group.Count() } )
-                .OrderByDescending(entry => entry.Listens)
-                .Take(mixConfiguration.SeedArtistCount)
-                .ToListAsync(cancellationToken);
-
-            var artistIds = ranked.Select(entry => entry.ArtistId).ToList();
-
-            var names = await database.Artists
-                .AsNoTracking()
-                .Where(artist => artistIds.Contains(artist.Id))
-                .ToDictionaryAsync(artist => artist.Id, artist => artist.Name, cancellationToken);
-
-            return [.. ranked
-                .Where(entry => names.ContainsKey(entry.ArtistId))
-                .Select(entry => new SeedArtist(entry.ArtistId, names[entry.ArtistId])) ];
-        }
-
-        private async Task<Dictionary<Guid, List<MixItem>> > SearchYouTubeAsync(
-            IReadOnlyList<SeedArtist> seedArtists,
-            HashSet<string> excludedVideoIds,
-            CancellationToken cancellationToken)
-        {
-            var byArtist = new Dictionary<Guid, List<MixItem>>();
-
-            foreach (var seed in seedArtists)
-            {
-                var searchResult = await youTubeMusicService.SearchSongsAsync(seed.Name, string.Empty, cancellationToken);
-                if (searchResult.IsError)
-                {
-                    logger.LogWarning("YouTube Music search failed for seed artist {Artist}: {Error}",
-                        seed.Name, searchResult.FirstError.Description);
-                    byArtist[seed.Id] = [];
-                    continue;
-                }
-
-                var songs = new List<MixItem>();
-                foreach (var song in searchResult.Value.Items.Take(mixConfiguration.YouTubeResultsPerSeed))
-                {
-                    if (!excludedVideoIds.Add(song.VideoId))
-                        continue;
-
-                    songs.Add(new MixItem
-                    {
-                        MixId = Guid.Empty,
-                        Source = MixItemSource.YouTube,
-                        VideoId = song.VideoId,
-                        Title = Truncate(song.Title, TitleLength),
-                        Artist = Truncate(song.Artist, ArtistLength),
-                        ThumbnailUrl = Truncate(youTubeMusicService.ResolveArtworkUrl(song.ThumbnailUrl), ThumbnailUrlLength),
-                        DurationSeconds = song.DurationSeconds,
-                        IsExplicit = song.IsExplicit
-                    } );
-                }
-
-                byArtist[seed.Id] = songs;
-            }
-
-            return byArtist;
-        }
-
-        private async Task<Dictionary<Guid, List<MixItem>> > GetLocalCandidatesAsync(
-            IReadOnlyList<SeedArtist> seedArtists,
-            IReadOnlyList<Guid> historyTrackIds,
-            CancellationToken cancellationToken)
-        {
-            var artistIds = seedArtists.Select(seed => seed.Id).ToList();
-
-            var links = await database.TrackArtists
-                .AsNoTracking()
-                .Where(trackArtist => artistIds.Contains(trackArtist.ArtistId) && !historyTrackIds.Contains(trackArtist.TrackId))
-                .Select(trackArtist => new { trackArtist.ArtistId, trackArtist.TrackId } )
-                .ToListAsync(cancellationToken);
-
-            var trackIds = links.Select(link => link.TrackId).Distinct().ToList();
-
-            var candidates = await LoadCandidatesAsync(trackIds, cancellationToken);
-
-            var byArtist = new Dictionary<Guid, List<MixItem>>();
-            foreach (var seed in seedArtists)
-            {
-                byArtist[seed.Id] = [.. links
-                    .Where(link => link.ArtistId == seed.Id)
-                    .Select(link => candidates.GetValueOrDefault(link.TrackId))
-                    .Where(candidate => candidate is not null)
-                    .Select(candidate => ToMixItem(candidate!))];
-            }
-
-            return byArtist;
-        }
-
-        private async Task<Dictionary<Guid, LocalCandidate>> LoadCandidatesAsync(
-            IReadOnlyList<Guid> trackIds,
-            CancellationToken cancellationToken)
-        {
-            if (trackIds.Count == 0)
-                return [];
-
-            var tracks = await database.Tracks
-                .AsNoTracking()
-                .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
-                .Include(track => ((ExternalTrack)track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(track => ((LocalTrack)track).Owner)
-                .ToListAsync(cancellationToken);
-
-            return tracks
-                .Select(track => TrackApplicationResponse.FromEntity(track, 0))
-                .ToDictionary(
-                    response => response.Id,
-                    response => new LocalCandidate(response.Id, response.Title, response.Artist, response.Duration));
-        }
-
-        private static MixItem ToMixItem(LocalCandidate candidate) => new()
-        {
-            MixId = Guid.Empty,
-            Source = MixItemSource.Musify,
-            TrackId = candidate.TrackId,
-            Title = candidate.Title,
-            Artist = candidate.Artist,
-            DurationSeconds = candidate.DurationSeconds
-        };
-
-        private List<MixDraft> BuildDrafts(
-            IReadOnlyList<SeedArtist> seedArtists,
-            IReadOnlyDictionary<Guid, List<MixItem>> localByArtist,
-            IReadOnlyDictionary<Guid, List<MixItem>> youTubeByArtist)
-        {
-            var drafts = new List<MixDraft>();
-
-            var everyYouTube = seedArtists.SelectMany(seed => youTubeByArtist[seed.Id]).ToList();
-            var everyLocal = seedArtists.SelectMany(seed => localByArtist[seed.Id]).ToList();
-
-            var discovery = Take(Shuffle(everyYouTube));
-            if (discovery.Count > 0)
-            {
-                drafts.Add(new MixDraft(
-                    "Descubrimiento",
-                    "Canciones nuevas que todavía no has escuchado.",
-                    discovery));
-            }
-
-            var daily = Take(Interleave(Shuffle(everyLocal), Shuffle(everyYouTube)));
-            if (daily.Count > 0)
-            {
-                drafts.Add(new MixDraft(
-                    "Tu mezcla diaria",
-                    "Lo que más escuchas, con alguna sorpresa nueva.",
-                    daily));
-            }
-
-            foreach (var seed in seedArtists.Take(mixConfiguration.ArtistMixCount))
-            {
-                var items = Take(Interleave(Shuffle(localByArtist[seed.Id]), Shuffle(youTubeByArtist[seed.Id])));
-                if (items.Count == 0)
-                    continue;
-
-                drafts.Add(new MixDraft(
-                    Truncate(seed.Name, MixTitleLength),
-                    $"Canciones de {seed.Name} y de artistas parecidos.",
-                    items));
-            }
-
-            return drafts;
-        }
-
-        private List<MixItem> Take(IEnumerable<MixItem> items) =>
-            [.. items.Take(mixConfiguration.ItemsPerMix)];
-
-        private static string Truncate(string value, int maxLength) =>
-            value.Length <= maxLength ? value : value[..maxLength];
-
-        private static List<MixItem> Shuffle(IEnumerable<MixItem> items) =>
-            [.. items.OrderBy(_ => Guid.NewGuid())];
-
-        private static List<MixItem> Interleave(IReadOnlyList<MixItem> first, IReadOnlyList<MixItem> second)
-        {
-            var merged = new List<MixItem>(first.Count + second.Count);
+            var merged = new List<Guid>(first.Count + second.Count);
             for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
             {
                 if (index < first.Count)
-                    merged.Add(first[index] );
+                    merged.Add(first[index]);
                 if (index < second.Count)
-                    merged.Add(second[index] );
+                    merged.Add(second[index]);
             }
 
             return merged;
@@ -317,21 +138,13 @@ namespace Musify.Application.Mixes
 
                 await database.Mixes.AddAsync(mix, cancellationToken);
 
-                for (var itemPosition = 0; itemPosition < draft.Items.Count; itemPosition++)
+                for (var itemPosition = 0; itemPosition < draft.TrackIds.Count; itemPosition++)
                 {
-                    var item = draft.Items[itemPosition];
                     await database.MixItems.AddAsync(new MixItem
                     {
                         MixId = mix.Id,
                         Position = itemPosition,
-                        Source = item.Source,
-                        TrackId = item.TrackId,
-                        VideoId = item.VideoId,
-                        Title = item.Title,
-                        Artist = item.Artist,
-                        ThumbnailUrl = item.ThumbnailUrl,
-                        DurationSeconds = item.DurationSeconds,
-                        IsExplicit = item.IsExplicit
+                        TrackId = draft.TrackIds[itemPosition]
                     }, cancellationToken);
                 }
             }

backend/Core/Musify.Application/Mixes/GetMixById.cs

@@ -19,12 +19,13 @@ namespace Musify.Application.Mixes
                 .Include(mix => mix.Items)
                 .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
 
-            if (mix is null)
+            if (mix == null)
                 return Error.NotFound(description: $"Mix {request.MixId} was not found");
 
-            var items = mix.Items.OrderBy(item => item.Position).ToList();
+            var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
+            var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
 
-            return MixApplicationResponse.FromEntity(mix, items.Count, items);
+            return new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, items.Count, items);
         }
     }
 }

backend/Core/Musify.Application/Mixes/GetMixesByUserId.cs

@@ -14,24 +14,24 @@ namespace Musify.Application.Mixes
     {
         public async ValueTask<ErrorOr<IReadOnlyList<MixApplicationResponse>>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
         {
-            var entries = await database.Mixes
+            var mixes = await database.Mixes
                 .AsNoTracking()
                 .Where(mix => mix.UserId == request.UserId)
+                .Include(mix => mix.Items)
                 .OrderBy(mix => mix.Position)
-                .Select(mix => new
-                {
-                    Mix = mix,
-                    ItemCount = mix.Items.Count,
-                    CoverItems = mix.Items
-                        .OrderBy(item => item.Position)
-                        .Take(MixApplicationResponse.CoverItemCount)
-                        .ToList()
-                })
                 .ToListAsync(cancellationToken);
 
-            return entries
-                .Select(entry => MixApplicationResponse.FromEntity(entry.Mix, entry.ItemCount, entry.CoverItems))
-                .ToList();
+            var responses = new List<MixApplicationResponse>(mixes.Count);
+            foreach (var mix in mixes)
+            {
+                var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
+                var coverItems = await MixItemMapper.ToResponsesAsync(
+                    database, orderedItems.Take(MixApplicationResponse.CoverItemCount).ToList(), cancellationToken);
+
+                responses.Add(new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, orderedItems.Count, coverItems));
+            }
+
+            return responses;
         }
     }
 }

backend/Core/Musify.Application/Mixes/MixItemMapper.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Mixes.Responses;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Mixes
+{
+
+    internal static class MixItemMapper
+    {
+        public static async Task<List<MixItemApplicationResponse>> ToResponsesAsync(
+            IDatabase database,
+            IReadOnlyList<MixItem> orderedItems,
+            CancellationToken cancellationToken)
+        {
+            var trackIds = orderedItems.Select(item => item.TrackId).Distinct().ToList();
+
+            var tracksById = await database.Tracks
+                .AsNoTracking()
+                .Include(track => track.Owner)
+                .Where(track => trackIds.Contains(track.Id))
+                .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count })
+                .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
+
+            return orderedItems
+                .Where(item => tracksById.ContainsKey(item.TrackId))
+                .Select(item =>
+                {
+                    var entry = tracksById[item.TrackId];
+                    return new MixItemApplicationResponse(
+                        item.TrackId,
+                        entry.Track.Title,
+                        entry.Track.Owner.Name,
+                        entry.Track.DurationSeconds,
+                        entry.ListensCount);
+                })
+                .ToList();
+        }
+    }
+}

backend/Core/Musify.Application/Mixes/Responses/MixApplicationResponse.cs

@@ -1,5 +1,3 @@
-using Musify.Domain.Entities;
-
 namespace Musify.Application.Mixes.Responses
 {
     public record MixApplicationResponse(
@@ -10,16 +8,5 @@ namespace Musify.Application.Mixes.Responses
         IReadOnlyList<MixItemApplicationResponse> Items)
     {
         public const int CoverItemCount = 4;
-
-        public static MixApplicationResponse FromEntity(
-            Mix mix,
-            int itemCount,
-            IReadOnlyList<MixItem> items) =>
-            new(
-                mix.Id,
-                mix.Title,
-                mix.Subtitle,
-                itemCount,
-                [.. items.Select(MixItemApplicationResponse.FromEntity)]);
     }
 }

backend/Core/Musify.Application/Mixes/Responses/MixItemApplicationResponse.cs

@@ -1,27 +1,9 @@
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
 namespace Musify.Application.Mixes.Responses
 {
     public record MixItemApplicationResponse(
-        MixItemSource Source,
-        Guid? TrackId,
-        string? VideoId,
+        Guid TrackId,
         string Title,
         string? Artist,
-        string? ThumbnailUrl,
         double DurationSeconds,
-        bool IsExplicit)
-    {
-        public static MixItemApplicationResponse FromEntity(MixItem item) =>
-            new(
-                item.Source,
-                item.TrackId,
-                item.VideoId,
-                item.Title ?? string.Empty,
-                item.Artist,
-                item.ThumbnailUrl,
-                item.DurationSeconds,
-                item.IsExplicit);
-    }
+        int ListensCount);
 }

backend/Core/Musify.Application/PlayLists/AddTrackToPlayList.cs

@@ -19,7 +19,7 @@ namespace Musify.Application.PlayLists
         {
             var playList = await database.PlayLists
                 .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
+            if (playList == null)
             {
                 logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
                 return Error.NotFound();

backend/Core/Musify.Application/PlayLists/AddYouTubeTrackToPlayList.cs

@@ -1,149 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Application.Services;
-using Musify.Application.Shared;
-using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.PlayLists
-{
-    public record AddYouTubeTrackToPlayListCommand(
-        long UserId,
-        Guid PlayListId,
-        string VideoId)
-        : ICommand<ErrorOr<TrackApplicationResponse>>;
-
-    public class AddYouTubeTrackToPlayListCommandHandler(
-        IDatabase database,
-        IEventBus eventBus,
-        IYouTubeMusicService youTubeMusicService,
-        YouTubeTrackProvisioner provisioner,
-        ApplicationStorageConfiguration storageConfiguration,
-        TrackConfiguration trackConfiguration,
-        ILogger<AddYouTubeTrackToPlayListCommandHandler> logger)
-        : ICommandHandler<AddYouTubeTrackToPlayListCommand, ErrorOr<TrackApplicationResponse>>
-    {
-        public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(AddYouTubeTrackToPlayListCommand request, CancellationToken cancellationToken)
-        {
-            var playList = await database.PlayLists.AsNoTracking()
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
-
-            var provisionResult = await provisioner.GetOrCreateAsync(request.VideoId, cancellationToken);
-            if (provisionResult.IsError)
-                return provisionResult.Errors;
-
-            var track = provisionResult.Value.Track;
-
-            var failed = track.Audio.IsFailed;
-            var neverQueued = !track.Audio.DownloadRequested && !track.Audio.IsProcessed;
-            if (failed || neverQueued)
-            {
-                if (failed)
-                {
-                    track.Audio.TranscodeStatus = ProcessingStatus.Pending;
-                    track.Pictures.ProcessingStatus = ProcessingStatus.Pending;
-                    track.LifeCycleStatus = LifeCycleStatus.Active;
-                    track.Audio.RetryCount += 1;
-                    track.Audio.LastRetryAt = DateTime.UtcNow;
-                }
-                track.Audio.DownloadRequested = true;
-
-                var thumbnailUrl = await ResolveThumbnailUrlAsync(request.VideoId, provisionResult.Value.Song, cancellationToken);
-                if (thumbnailUrl.IsError)
-                    return thumbnailUrl.Errors;
-
-                await PublishDownloadEventAsync(track.Id, request.VideoId, thumbnailUrl.Value, cancellationToken);
-                await database.SaveChangesAsync(cancellationToken);
-                logger.LogInformation("Queued YouTube track {VideoId} for download", request.VideoId);
-            }
-
-            var alreadyAdded = await database.PlayListHasTracks.AsNoTracking()
-                .AnyAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == track.Id, cancellationToken);
-            if (alreadyAdded)
-            {
-                logger.LogInformation("Track {TrackId} already in playlist {PlayListId}", track.Id, request.PlayListId);
-                return Error.Conflict(description: "Track is already in the playlist.");
-            }
-
-            var playListTracksQuery = database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId);
-
-            var hasTracks = await playListTracksQuery.AnyAsync(cancellationToken);
-            var nextPosition = hasTracks
-                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
-                : 0;
-
-            await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
-            {
-                PlayListId = request.PlayListId,
-                TrackId = track.Id,
-                Position = nextPosition
-            }, cancellationToken);
-
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Added YouTube track {VideoId} ({TrackId}) to playlist {PlayListId} at position {Position}",
-                request.VideoId, track.Id, request.PlayListId, nextPosition);
-
-            var listensCount = await database.ListeningHistories.AsNoTracking()
-                .CountAsync(lh => lh.TrackId == track.Id, cancellationToken);
-
-            return TrackApplicationResponse.FromEntity(track, listensCount);
-        }
-
-        private async Task<ErrorOr<string>> ResolveThumbnailUrlAsync(string videoId, YouTubeSongResult? song, CancellationToken cancellationToken)
-        {
-            if (!string.IsNullOrEmpty(song?.ThumbnailUrl))
-                return youTubeMusicService.ResolveArtworkUrl(song.ThumbnailUrl);
-
-            var songResult = await youTubeMusicService.GetSongAsync(videoId, cancellationToken);
-            if (songResult.IsError)
-                return songResult.Errors;
-
-            return youTubeMusicService.ResolveArtworkUrl(songResult.Value.ThumbnailUrl);
-        }
-
-        private async Task PublishDownloadEventAsync(Guid trackId, string videoId, string thumbnailUrl, CancellationToken cancellationToken)
-        {
-            var audioProcessedFolderKey = trackConfiguration.Routes.BuildProcessedAudioPath(Guid.NewGuid().ToString());
-
-            await eventBus.PublishAsync(
-                new DownloadYouTubeTrackEvent(
-                    trackId,
-                    videoId,
-                    thumbnailUrl,
-                    storageConfiguration.Bucket,
-                    audioProcessedFolderKey,
-                    new ImageSize(
-                        trackConfiguration.Routes.SmallPicturesPath,
-                        trackConfiguration.PicturesSizes.SmallPictureWidth,
-                        trackConfiguration.PicturesSizes.SmallPictureHeight),
-                    new ImageSize(
-                        trackConfiguration.Routes.MediumPicturesPath,
-                        trackConfiguration.PicturesSizes.MediumPictureWidth,
-                        trackConfiguration.PicturesSizes.MediumPictureHeight),
-                    new ImageSize(
-                        trackConfiguration.Routes.LargePicturesPath,
-                        trackConfiguration.PicturesSizes.LargePictureWidth,
-                        trackConfiguration.PicturesSizes.LargePictureHeight)),
-                cancellationToken);
-        }
-    }
-}

backend/Core/Musify.Application/PlayLists/CreatePlayList.cs

@@ -17,7 +17,8 @@ namespace Musify.Application.PlayLists
         long UserId,
         string Name,
         string? Description,
-        Guid? PictureIntentId)
+        Guid? PictureIntentId,
+        PlaylistVisibility Visibility = PlaylistVisibility.Private)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class CreatePlayListCommandHandler(
@@ -30,7 +31,7 @@ namespace Musify.Application.PlayLists
         UploadIntentConfiguration uploadIntentConfiguration)
         : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
-        private sealed record ResolvedPlayListPictures(PlayListPictures Pictures, UploadIntent? Intent);
+        private sealed record ResolvedPlayListPictures(PlayListPictures? Pictures, UploadIntent? Intent);
 
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
         {
@@ -54,14 +55,15 @@ namespace Musify.Application.PlayLists
                 UserId = request.UserId,
                 Name = request.Name,
                 NormalizedName = request.Name.Trim().ToUpperInvariant(),
-                Description = string.IsNullOrWhiteSpace(request.Description)? null: request.Description.Trim(),
-                Pictures = resolvedPictures.Pictures
+                Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
+                Pictures = resolvedPictures.Pictures,
+                Visibility = request.Visibility
             };
             await database.PlayLists.AddAsync(playList, cancellationToken);
 
             if (resolvedPictures.Intent != null)
             {
-                var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures.OriginalName);
+                var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures!.OriginalName);
                 var publishResult = await PublishCreatePlayListEventAsync(playList.Id, resolvedPictures.Intent, finalPictureKey, cancellationToken);
                 if (publishResult.IsError)
                     return publishResult.Errors;
@@ -86,13 +88,7 @@ namespace Musify.Application.PlayLists
         {
             if (!request.PictureIntentId.HasValue)
             {
-                return new ResolvedPlayListPictures(new PlayListPictures
-                {
-                    OriginalName = playListConfiguration.Routes.PresetOriginalPicture,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
-                }, null);
+                return new ResolvedPlayListPictures(null, null);
             }
 
             var validation = await uploadIntentValidator.ValidateAndLoadAsync(
@@ -104,13 +100,13 @@ namespace Musify.Application.PlayLists
             return new ResolvedPlayListPictures(new PlayListPictures
             {
                 OriginalName = validation.Value.ObjectName,
-                SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                LargeName = playListConfiguration.Routes.PresetLargePicture
+                SmallName = validation.Value.ObjectName,
+                MediumName = validation.Value.ObjectName,
+                LargeName = validation.Value.ObjectName
             }, validation.Value);
         }
 
-        async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
+        private async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
             Guid playListId,
             UploadIntent pictureIntent,
             string finalPictureKey,

backend/Core/Musify.Application/PlayLists/DeletePlayList.cs

@@ -20,7 +20,7 @@ namespace Musify.Application.PlayLists
         public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
         {
             var playList = await database.PlayLists.SingleOrDefaultAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
+            if (playList == null)
             {
                 logger.LogDebug("Playlist {PlayListId} not found", request.PlayListId);
                 return Error.NotFound();

backend/Core/Musify.Application/PlayLists/GetPlayListById.cs

@@ -3,10 +3,11 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.PlayLists.Responses;
 using Mediator;
 using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists
 {
-    public record GetPlayListByIdQuery(Guid Id)
+    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
         : IQuery<ErrorOr<PlayListApplicationResponse>>;
 
     public class GetPlayListByIdQueryHandler(IDatabase database)
@@ -28,7 +29,11 @@ namespace Musify.Application.PlayLists
                 })
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (entry is null)
+            if (entry == null)
+                return Error.NotFound();
+
+            if (entry.PlayList.Visibility == PlaylistVisibility.Private
+                && entry.PlayList.UserId != request.RequestingUserId)
                 return Error.NotFound();
 
             return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds);

backend/Core/Musify.Application/PlayLists/GetPlayListCover.cs

@@ -25,7 +25,7 @@ namespace Musify.Application.PlayLists
                 .Select(p => p.Pictures)
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (pictures is null)
+            if (pictures == null)
                 return Error.NotFound();
 
             var routes = playListConfiguration.Routes;

backend/Core/Musify.Application/PlayLists/GetPlayListTracks.cs

@@ -4,7 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 using X.PagedList;
 using X.PagedList.EF;
 
@@ -17,9 +16,9 @@ namespace Musify.Application.PlayLists
         : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
     public class GetPlayListTracksQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>> >
+        : IQueryHandler<GetPlayListTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse> >> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
         {
             var playListExists = await database.PlayLists
                 .AsNoTracking()
@@ -29,9 +28,8 @@ namespace Musify.Application.PlayLists
 
             var tracksQuery = database.PlayListHasTracks
                 .AsNoTracking()
-                .Include(plt => ((ExternalTrack)plt.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(plt => ((LocalTrack)plt.Track).Owner)
+                .Include(plt => plt.Track.Owner)
+                .Include(plt => plt.Track.Tags)
                 .Where(plt => plt.PlayListId == request.PlayListId);
 
             var totalCount = await tracksQuery.CountAsync(cancellationToken);

backend/Core/Musify.Application/PlayLists/GetPlayLists.cs

@@ -10,12 +10,12 @@ using Musify.Application.Contracts;
 namespace Musify.Application.PlayLists
 {
     public record GetPlayListsQuery(int PageNumber, int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>> >;
+        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
 
     public class GetPlayListsQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse> >>
+        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse> >> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
+        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
         {
             var totalCount = await database.PlayLists.CountAsync(cancellationToken);
 

backend/Core/Musify.Application/PlayLists/GetPlayListsByUserId.cs

@@ -14,18 +14,24 @@ namespace Musify.Application.PlayLists
         long UserId,
         string? Name,
         int PageNumber,
-        int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>> >;
+        int PageSize,
+        bool OnlyPublic = false)
+        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
 
     public class GetPlayListsByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse> > >
+        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse> >> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
+        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
         {
             var playListsQuery = database.PlayLists
                 .AsNoTracking()
                 .Where(p => p.UserId == request.UserId);
 
+            if (request.OnlyPublic)
+            {
+                playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
+            }
+
             if (!string.IsNullOrEmpty(request.Name))
             {
                 var normalizedName = request.Name.Trim().ToUpperInvariant();
@@ -45,7 +51,7 @@ namespace Musify.Application.PlayLists
                         .Take(PlayListApplicationResponse.CoverTrackCount)
                         .Select(plt => plt.TrackId)
                         .ToList()
-                } )
+                })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(

backend/Core/Musify.Application/PlayLists/RemoveTrackFromPlayList.cs

@@ -18,7 +18,7 @@ namespace Musify.Application.PlayLists
         {
             var playList = await database.PlayLists
                 .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
+            if (playList == null)
             {
                 logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
                 return Error.NotFound();
@@ -32,7 +32,7 @@ namespace Musify.Application.PlayLists
 
             var link = await database.PlayListHasTracks
                 .SingleOrDefaultAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-            if (link is null)
+            if (link == null)
             {
                 logger.LogInformation("Track {TrackId} not in playlist {PlayListId}", request.TrackId, request.PlayListId);
                 return Error.NotFound(description: "Track is not in the playlist.");

backend/Core/Musify.Application/PlayLists/RequestPlayListPictureUpload.cs

@@ -42,7 +42,7 @@ namespace Musify.Application.PlayLists
             var effectiveSizeBytes = request.ExpectedSizeBytes
                 ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
 
-            var objectName = $"{Guid.NewGuid() }.{request.FileType.TrimStart('.').ToLowerInvariant() }";
+            var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
 
             var tempKey = playListConfiguration.Routes.BuildTempPicturePath(
                 uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
@@ -84,7 +84,7 @@ namespace Musify.Application.PlayLists
                 await database.SaveChangesAsync(cancellationToken);
                 await transaction.CommitAsync(cancellationToken);
 
-                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (PlayListPicture, temp key: {Key} )", intent.Id, request.UserId, tempKey);
+                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (PlayListPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
 
                 return new PlayListPictureUploadResponse(
                     intent.Id,

backend/Core/Musify.Application/PlayLists/Responses/PlayListApplicationResponse.cs

@@ -1,4 +1,5 @@
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists.Responses
 {
@@ -9,6 +10,7 @@ namespace Musify.Application.PlayLists.Responses
         string? SmallImageKeyName,
         string? MediumImageKeyName,
         string? LargeImageKeyName,
+        PlaylistVisibility Visibility,
         DateTime CreatedAt,
         DateTime UpdatedAt,
         IReadOnlyList<Guid> CoverTrackIds)
@@ -26,6 +28,7 @@ namespace Musify.Application.PlayLists.Responses
                 playList.Pictures?.SmallName,
                 playList.Pictures?.MediumName,
                 playList.Pictures?.LargeName,
+                playList.Visibility,
                 playList.CreatedAt,
                 playList.UpdatedAt,
                 coverTrackIds ?? []);

backend/Core/Musify.Application/PlayLists/UpdatePlayList.cs

@@ -18,7 +18,8 @@ namespace Musify.Application.PlayLists
         Guid PlayListId,
         string? NewName,
         string? NewDescription,
-        Guid? NewPictureIntentId)
+        Guid? NewPictureIntentId,
+        PlaylistVisibility? NewVisibility = null)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class UpdatePlayListCommandHandler(
@@ -34,7 +35,7 @@ namespace Musify.Application.PlayLists
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
         {
             var playListEntity = await database.PlayLists.SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playListEntity is null)
+            if (playListEntity == null)
             {
                 logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
                 return Error.NotFound();
@@ -57,6 +58,11 @@ namespace Musify.Application.PlayLists
                 playListEntity.Description = request.NewDescription;
             }
 
+            if (request.NewVisibility.HasValue)
+            {
+                playListEntity.Visibility = request.NewVisibility.Value;
+            }
+
             UploadIntent? pictureIntent = null;
             string? finalPictureKey = null;
 
@@ -72,16 +78,14 @@ namespace Musify.Application.PlayLists
                 playListEntity.Pictures = new PlayListPictures
                 {
                     OriginalName = pictureIntent.ObjectName,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
+                    SmallName = pictureIntent.ObjectName,
+                    MediumName = pictureIntent.ObjectName,
+                    LargeName = pictureIntent.ObjectName
                 };
                 finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
             }
 
-            database.PlayLists.Update(playListEntity);
-
-            if (pictureIntent != null&& finalPictureKey != null)
+            if (pictureIntent != null && finalPictureKey != null)
             {
                 var publishResult = await PublishUpdatePlayListPictureSourceEventAsync(
                     playListEntity.Id, pictureIntent, finalPictureKey, cancellationToken);
@@ -111,7 +115,7 @@ namespace Musify.Application.PlayLists
             return PlayListApplicationResponse.FromEntity(playListEntity, coverTrackIds);
         }
 
-        async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
+        private async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
             Guid playListId,
             UploadIntent pictureIntent,
             string finalPictureKey,

backend/Core/Musify.Application/Serialization/LongAsStringConverter.cs

@@ -0,0 +1,37 @@
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Musify.Application.Serialization;
+
+public sealed class LongAsStringConverter : JsonConverter<long>
+{
+    public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+        reader.TokenType == JsonTokenType.String
+            ? long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
+            : reader.GetInt64();
+
+    public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options) =>
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+}
+
+public sealed class NullableLongAsStringConverter : JsonConverter<long?>
+{
+    public override long? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+            return null;
+
+        return reader.TokenType == JsonTokenType.String
+            ? string.IsNullOrEmpty(reader.GetString()) ? null : long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
+            : reader.GetInt64();
+    }
+
+    public override void Write(Utf8JsonWriter writer, long? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        else
+            writer.WriteNullValue();
+    }
+}

backend/Core/Musify.Application/Services/TrackStreamIssuer.cs

@@ -30,9 +30,7 @@ public sealed class TrackStreamIssuer(
             folderPath,
             streamGatewayConfiguration.AudioFileName);
 
-        // Anonymous listeners have no User row to satisfy ListeningHistory's foreign key against, and
-        // their plays aren't "history" anyone can look back on anyway, so there's nothing to record.
-        if (userId is not null)
+        if (userId != null)
         {
             var newListeningHistory = new ListeningHistory
             {
@@ -48,7 +46,7 @@ public sealed class TrackStreamIssuer(
 
     private long? AnonymousFragmentBytes(long? userId)
     {
-        if (userId is not null || playbackConfiguration.AnonymousFragmentSeconds <= 0)
+        if (userId != null || playbackConfiguration.AnonymousFragmentSeconds <= 0)
             return null;
 
         return (long)playbackConfiguration.AnonymousFragmentSeconds * playbackConfiguration.EstimatedAudioBytesPerSecond;

backend/Core/Musify.Application/Services/UploadIntentValidator.cs

@@ -42,7 +42,7 @@ public sealed class UploadIntentValidator(
         var intent = await database.UploadIntents
             .FirstOrDefaultAsync(i => i.Id == intentId, cancellationToken);
 
-        if (intent is null || intent.UserId != userId)
+        if (intent == null || intent.UserId != userId)
             return Error.NotFound(description: "Upload intent not found or not accessible.");
 
         if (intent.IsConsumed)
@@ -52,7 +52,7 @@ public sealed class UploadIntentValidator(
             return Error.Validation(description: "Upload intent has expired.");
 
         var metadata = await storageService.HeadObjectAsync(intent.Bucket, intent.Key, cancellationToken);
-        if (metadata is null)
+        if (metadata == null)
             return Error.NotFound(description: "Uploaded object not found in storage. Upload the file first.");
 
         if (metadata.ContentLength > config.MaxUploadBytes)

backend/Core/Musify.Application/Services/YouTubeTrackProvisioner.cs

@@ -1,265 +0,0 @@
-using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Services;
-
-public sealed record YouTubeTrackProvision(ExternalTrack Track, YouTubeSongResult? Song);
-
-public sealed class YouTubeTrackProvisioner(
-    IDatabase database,
-    IYouTubeMusicService youTubeMusicService,
-    TrackConfiguration trackConfiguration,
-    ILogger<YouTubeTrackProvisioner> logger)
-{
-    public Task<ExternalTrack?> FindAsync(string videoId, CancellationToken cancellationToken) =>
-        database.ExternalTracks
-            .Include(track => track.TrackArtists)
-            .ThenInclude(trackArtist => trackArtist.Artist)
-            .SingleOrDefaultAsync(t => t.Source == TrackSource.YouTube && t.ExternalId == videoId, cancellationToken);
-
-    public async Task<ErrorOr<YouTubeTrackProvision>> GetOrCreateAsync(string videoId, CancellationToken cancellationToken)
-    {
-        var existing = await FindAsync(videoId, cancellationToken);
-        if (existing is not null)
-            return new YouTubeTrackProvision(existing, Song: null);
-
-        var songResult = await youTubeMusicService.GetSongAsync(videoId, cancellationToken);
-        if (songResult.IsError)
-            return songResult.Errors;
-
-        var song = songResult.Value;
-
-        var artistRefs = song.Artists
-            .GroupBy(artistRef => artistRef.Id ?? artistRef.Name.ToUpperInvariant())
-            .Select(group => group.First())
-            .ToList();
-
-        var artists = new List<Artist>();
-        foreach (var artistRef in artistRefs)
-            artists.Add(await GetOrCreateArtistAsync(artistRef, cancellationToken));
-
-        var title = Truncate(song.Title, 200);
-        var track = new ExternalTrack
-        {
-            Title = title,
-            NormalizedTitle = title.ToUpperInvariant(),
-            Source = TrackSource.YouTube,
-            ExternalId = videoId,
-            DurationSeconds = song.DurationSeconds,
-            Pictures = new TrackPictures
-            {
-                SmallName = trackConfiguration.Routes.PresetSmallPicture,
-                MediumName = trackConfiguration.Routes.PresetMediumPicture,
-                LargeName = trackConfiguration.Routes.PresetLargePicture,
-                ProcessingStatus = ProcessingStatus.Pending
-            },
-            Audio = new TrackAudio
-            {
-                DownloadRequested = false,
-                TranscodeStatus = ProcessingStatus.Pending
-            }
-        };
-
-        await database.ExternalTracks.AddAsync(track, cancellationToken);
-
-        for (var position = 0; position < artists.Count; position++)
-        {
-            await database.TrackArtists.AddAsync(new TrackArtist
-            {
-                TrackId = track.Id,
-                ArtistId = artists[position].Id,
-                Position = position
-            }, cancellationToken);
-        }
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-            logger.LogInformation("Created YouTube track {VideoId} ({TrackId})", videoId, track.Id);
-            return new YouTubeTrackProvision(track, Song: song);
-        }
-        catch (DbUpdateException)
-        {
-            database.ExternalTracks.Remove(track);
-            var refetched = await FindAsync(videoId, cancellationToken);
-            if (refetched is null)
-            {
-                logger.LogWarning("YouTube track {VideoId} creation raced but could not be refetched", videoId);
-                return Error.Conflict(description: "The track was just created by another request. Retry the operation.");
-            }
-            return new YouTubeTrackProvision(refetched, Song: null);
-        }
-    }
-
-    public async Task MaterializeAlbumAsync(string albumExternalId, YouTubeAlbumDetail detail, CancellationToken cancellationToken)
-    {
-        var validTracks = detail.Tracks
-            .Where(track => !string.IsNullOrEmpty(track.VideoId))
-            .ToList();
-        if (validTracks.Count == 0)
-            return;
-
-        var album = await GetOrCreateExternalAlbumAsync(albumExternalId, detail.Album.Title, detail.Album.ThumbnailUrl, cancellationToken);
-
-        var videoIds = validTracks.Select(track => track.VideoId).ToList();
-
-        var tracksByVideoId = await database.ExternalTracks
-            .Where(track => track.Source == TrackSource.YouTube && videoIds.Contains(track.ExternalId))
-            .ToDictionaryAsync(track => track.ExternalId, cancellationToken);
-
-        var linkedTrackIds = (await database.AlbumHasTracks
-            .Where(albumTrack => albumTrack.AlbumId == album.Id)
-            .Select(albumTrack => albumTrack.TrackId)
-            .ToListAsync(cancellationToken))
-            .ToHashSet();
-
-        if (tracksByVideoId.Count == validTracks.Count && linkedTrackIds.Count >= validTracks.Count)
-            return;
-
-        var artistRefs = detail.Album.Artists
-            .GroupBy(artistRef => artistRef.Id ?? artistRef.Name.ToUpperInvariant())
-            .Select(group => group.First())
-            .ToList();
-
-        var albumArtists = new List<Artist>();
-        foreach (var artistRef in artistRefs)
-            albumArtists.Add(await GetOrCreateArtistAsync(artistRef, cancellationToken));
-
-        foreach (var albumTrack in validTracks)
-        {
-            if (!tracksByVideoId.TryGetValue(albumTrack.VideoId, out var track))
-            {
-                track = BuildStubTrack(albumTrack);
-                await database.ExternalTracks.AddAsync(track, cancellationToken);
-
-                for (var position = 0; position < albumArtists.Count; position++)
-                {
-                    await database.TrackArtists.AddAsync(new TrackArtist
-                    {
-                        TrackId = track.Id,
-                        ArtistId = albumArtists[position].Id,
-                        Position = position
-                    }, cancellationToken);
-                }
-
-                tracksByVideoId[albumTrack.VideoId] = track;
-            }
-
-            if (linkedTrackIds.Contains(track.Id))
-                continue;
-
-            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
-            {
-                AlbumId = album.Id,
-                TrackId = track.Id,
-                TrackNumber = albumTrack.TrackNumber
-            }, cancellationToken);
-            linkedTrackIds.Add(track.Id);
-        }
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-            logger.LogInformation("Materialized YouTube album {AlbumId} ({TrackCount} tracks)", albumExternalId, validTracks.Count);
-        }
-        catch (DbUpdateException exception)
-        {
-            logger.LogWarning(exception, "Race while materializing YouTube album {AlbumId}", albumExternalId);
-        }
-    }
-
-    private ExternalTrack BuildStubTrack(YouTubeAlbumTrack albumTrack)
-    {
-        var title = Truncate(albumTrack.Title, 200);
-        return new ExternalTrack
-        {
-            Title = title,
-            NormalizedTitle = title.ToUpperInvariant(),
-            Source = TrackSource.YouTube,
-            ExternalId = albumTrack.VideoId,
-            DurationSeconds = albumTrack.DurationSeconds,
-            Pictures = new TrackPictures
-            {
-                SmallName = trackConfiguration.Routes.PresetSmallPicture,
-                MediumName = trackConfiguration.Routes.PresetMediumPicture,
-                LargeName = trackConfiguration.Routes.PresetLargePicture,
-                ProcessingStatus = ProcessingStatus.Pending
-            },
-            Audio = new TrackAudio
-            {
-                DownloadRequested = false,
-                TranscodeStatus = ProcessingStatus.Pending
-            }
-        };
-    }
-
-    private async Task<Artist> GetOrCreateArtistAsync(YouTubeArtistRef reference, CancellationToken cancellationToken)
-    {
-        var name = Truncate(reference.Name, 200);
-        var normalized = name.ToUpperInvariant();
-        var externalId = reference.Id ?? $"name:{normalized}";
-
-        var existing = await database.Artists.SingleOrDefaultAsync(a => a.ExternalId == externalId, cancellationToken);
-        if (existing is not null)
-            return existing;
-
-        var artist = new Artist
-        {
-            Name = name,
-            NormalizedName = normalized,
-            ExternalId = externalId
-        };
-
-        await database.Artists.AddAsync(artist, cancellationToken);
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-            return artist;
-        }
-        catch (DbUpdateException)
-        {
-            database.Artists.Remove(artist);
-            return await database.Artists.SingleAsync(a => a.ExternalId == externalId, cancellationToken);
-        }
-    }
-
-    private async Task<ExternalAlbum> GetOrCreateExternalAlbumAsync(string externalId, string name, string? thumbnailUrl, CancellationToken cancellationToken)
-    {
-        var existing = await database.ExternalAlbums
-            .SingleOrDefaultAsync(album => album.Source == TrackSource.YouTube && album.ExternalId == externalId, cancellationToken);
-        if (existing is not null)
-            return existing;
-
-        var title = Truncate(name, 200);
-        var album = new ExternalAlbum
-        {
-            Title = title,
-            NormalizedTitle = title.ToUpperInvariant(),
-            Source = TrackSource.YouTube,
-            ExternalId = externalId,
-            ThumbnailUrl = string.IsNullOrEmpty(thumbnailUrl) ? null : Truncate(thumbnailUrl, 512)
-        };
-
-        await database.ExternalAlbums.AddAsync(album, cancellationToken);
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-            return album;
-        }
-        catch (DbUpdateException)
-        {
-            database.ExternalAlbums.Remove(album);
-            return await database.ExternalAlbums.SingleAsync(a => a.Source == TrackSource.YouTube && a.ExternalId == externalId, cancellationToken);
-        }
-    }
-
-    private static string Truncate(string value, int maxLength) =>
-        value.Length <= maxLength ? value : value[..maxLength];
-}

backend/Core/Musify.Application/Tracks/CreateTrack.cs

@@ -17,7 +17,8 @@ namespace Musify.Application.Tracks
         long UserId,
         string Title,
         Guid PictureIntentId,
-        Guid AudioIntentId)
+        Guid AudioIntentId,
+        IReadOnlyCollection<Genre> Tags)
         : ICommand<ErrorOr<TrackApplicationResponse>>;
 
     public class CreateTrackCommandHandler(
@@ -34,12 +35,29 @@ namespace Musify.Application.Tracks
         {
             var user = await database.Users
                 .SingleOrDefaultAsync(u => u.Id == request.UserId, cancellationToken);
-            if (user is null)
+            if (user == null)
             {
                 logger.LogWarning("User {UserId} not found", request.UserId);
                 return Error.NotFound(description: $"User {request.UserId} not found");
             }
 
+            var distinctTags = request.Tags.Distinct().ToList();
+            if (distinctTags.Count == 0)
+            {
+                logger.LogWarning("Track {Title} was submitted without any tags", request.Title);
+                return Error.Validation(description: "At least one tag is required.");
+            }
+
+            var tagConflicts = GenreCompatibility.FindConflicts(distinctTags);
+            if (tagConflicts.Count > 0)
+            {
+                var conflict = tagConflicts.First();
+                logger.LogWarning(
+                    "Track {Title} was submitted with incompatible tags {First} and {Second}",
+                    request.Title, conflict.First, conflict.Second);
+                return Error.Validation(description: $"Tags '{conflict.First}' and '{conflict.Second}' are not compatible.");
+            }
+
             var pictureValidation = await uploadIntentValidator.ValidateAndLoadAsync(
                 uploadIntentConfiguration,
                 request.PictureIntentId, request.UserId, cancellationToken);
@@ -59,7 +77,7 @@ namespace Musify.Application.Tracks
             var finalAudioKey = trackConfiguration.Routes.BuildOriginalAudioPath(request.UserId, audioIntent.ObjectName);
             var audioProcessedFolderKey = trackConfiguration.Routes.BuildProcessedAudioPath(Guid.NewGuid().ToString());
 
-            var trackEntity = new LocalTrack
+            var trackEntity = new Track
             {
                 Title = request.Title,
                 NormalizedTitle = request.Title.ToUpperInvariant(),
@@ -80,7 +98,11 @@ namespace Musify.Application.Tracks
                 }
             };
 
-            await database.LocalTracks.AddAsync(trackEntity, cancellationToken);
+            trackEntity.Tags = distinctTags
+                .Select(tag => new TrackTag { TrackId = trackEntity.Id, Tag = tag })
+                .ToList();
+
+            await database.Tracks.AddAsync(trackEntity, cancellationToken);
 
             await database.UserHasTracks.AddAsync(new UserHasTrack
             {

backend/Core/Musify.Application/Tracks/DeleteTrack.cs

@@ -23,13 +23,13 @@ namespace Musify.Application.Tracks
         public async ValueTask<ErrorOr<Success>> Handle(DeleteTrackCommand request, CancellationToken cancellationToken)
         {
             var track = await database.Tracks.SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (track is null)
+            if (track == null)
             {
                 logger.LogInformation("Track {TrackId} not found", request.TrackId);
                 return Error.NotFound();
             }
 
-            if (track is not LocalTrack localTrack || localTrack.OwnerUserId != request.UserId)
+            if (track.OwnerUserId != request.UserId)
             {
                 logger.LogWarning("User {UserId} unauthorized to delete track {TrackId}", request.UserId, request.TrackId);
                 return Error.Unauthorized();

backend/Core/Musify.Application/Tracks/GetLastTrackListenedByUserId.cs

@@ -0,0 +1,30 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Tracks.Responses;
+
+namespace Musify.Application.Tracks
+{
+    public record GetLastTrackListenedByUserIdQuery(long UserId) : IQuery<ErrorOr<TrackApplicationResponse>>;
+
+    public class GetLastTrackListenedByUserIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetLastTrackListenedByUserIdQuery, ErrorOr<TrackApplicationResponse>>
+    {
+        public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetLastTrackListenedByUserIdQuery query, CancellationToken cancellationToken)
+        {
+            var track = await database.ListeningHistories
+                .AsNoTracking()
+                .Include(t => t.Track.Owner)
+                .Include(t => t.Track.Tags)
+                .Where(t => t.UserId == query.UserId)
+                .OrderByDescending(t => t.ListenedAt)
+                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count))
+                .FirstOrDefaultAsync(cancellationToken);
+
+            return track == null
+                ? Error.NotFound("Track.NotFound", "No track found for the given user ID.")
+                : track;
+        }
+    }
+}

backend/Core/Musify.Application/Tracks/GetListeningHistory.cs

@@ -2,7 +2,6 @@
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 
 namespace Musify.Application.Tracks
 {
@@ -17,6 +16,7 @@ namespace Musify.Application.Tracks
         public async ValueTask<IEnumerable<TrackApplicationResponse>> Handle(GetListeningHistoryQuery query, CancellationToken cancellationToken)
         {
             var recentTrackIds = await database.ListeningHistories
+                .AsNoTracking()
                 .Where(l => l.UserId == query.UserId)
                 .GroupBy(l => l.TrackId)
                 .OrderByDescending(g => g.Max(l => l.ListenedAt))
@@ -25,15 +25,15 @@ namespace Musify.Application.Tracks
                 .ToListAsync(cancellationToken);
 
             var tracksById = await database.Tracks
-                .Include(t => ((ExternalTrack)t).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(t => ((LocalTrack)t).Owner)
+                .AsNoTracking()
+                .Include(t => t.Owner)
+                .Include(t => t.Tags)
                 .Where(t => recentTrackIds.Contains(t.Id))
-                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count } )
+                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count })
                 .ToDictionaryAsync(t => t.Id, cancellationToken);
 
             return recentTrackIds
-                .Select(id => tracksById[id] )
+                .Select(id => tracksById[id])
                 .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.ListensCount));
         }
     }

backend/Core/Musify.Application/Tracks/GetTrackById.cs

@@ -3,7 +3,6 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 
 namespace Musify.Application.Tracks
 {
@@ -11,19 +10,18 @@ namespace Musify.Application.Tracks
         : IQuery<ErrorOr<TrackApplicationResponse>>;
 
     public class GetTrackByIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetTrackByIdQuery, ErrorOr<TrackApplicationResponse> >
+        : IQueryHandler<GetTrackByIdQuery, ErrorOr<TrackApplicationResponse>>
     {
         public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetTrackByIdQuery request, CancellationToken cancellationToken)
         {
             var entity = await database.Tracks.AsNoTracking()
-                .Include(t => ((ExternalTrack)t).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(t => ((LocalTrack)t).Owner)
+                .Include(t => t.Owner)
+                .Include(t => t.Tags)
                 .Where(t => t.Id == request.TrackId)
                 .Select(t => new { Track = t, ListensCount = t.ListeningHistories.Count })
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (entity is null)
+            if (entity == null)
                 return Error.NotFound();
 
             return TrackApplicationResponse.FromEntity(entity.Track, entity.ListensCount);

backend/Core/Musify.Application/Tracks/GetTrackCover.cs

@@ -48,6 +48,6 @@ namespace Musify.Application.Tracks
         }
 
         private static string? BuildKey(Func<string, string> builder, string? name)
-            => string.IsNullOrEmpty(name)? null: builder(name);
+            => string.IsNullOrEmpty(name) ? null : builder(name);
     }
 }

backend/Core/Musify.Application/Tracks/GetTrackStream.cs

@@ -9,8 +9,7 @@ using Musify.Application.Tracks.Responses;
 
 namespace Musify.Application.Tracks
 {
-    /// <param name="UserId">Null for an anonymous request — allowed only when
-    /// <see cref="PlaybackConfiguration.AllowAnonymousListening"/> is enabled.</param>
+
     public record GetTrackStreamQuery(Guid TrackId, long? UserId)
         : IQuery<ErrorOr<TrackStreamResponse>>;
 
@@ -23,7 +22,7 @@ namespace Musify.Application.Tracks
     {
         public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(GetTrackStreamQuery request, CancellationToken cancellationToken)
         {
-            if (request.UserId is null && !playbackConfiguration.AllowAnonymousListening)
+            if (request.UserId == null && !playbackConfiguration.AllowAnonymousListening)
                 return Error.Unauthorized(description: "Sign in to stream music, or ask an administrator to enable anonymous listening.");
 
             var track = await database.Tracks.AsNoTracking()

backend/Core/Musify.Application/Tracks/GetTracks.cs

@@ -1,37 +1,25 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
-    public record GetTracksQuery(string? Name, int PageNumber, int PageSize, string? YoutubeContinuationToken = null)
+    public record GetTracksQuery(string? Name, int PageNumber, int PageSize)
         : IQuery<ErrorOr<TracksSearchResponse>>;
 
-    public class GetTracksQueryHandler(
-        IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
-        ILogger<GetTracksQueryHandler> logger)
+    public class GetTracksQueryHandler(IDatabase database)
         : IQueryHandler<GetTracksQuery, ErrorOr<TracksSearchResponse>>
     {
-        // Mirrors the web client's search-box debounce threshold: a query shorter than this is too
-        // likely to still be mid-keystroke to justify a live call to the YouTube Music API for every
-        // client that hits this endpoint.
-        private const int MinNameLengthForYouTubeSearch = 2;
-
         public async ValueTask<ErrorOr<TracksSearchResponse>> Handle(GetTracksQuery request, CancellationToken cancellationToken)
         {
             var tracksQuery = database.UserHasTracks
                 .AsNoTracking()
-                .Include(ut => ((ExternalTrack)ut.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(ut => ((LocalTrack)ut.Track).Owner)
+                .Include(ut => ut.Track.Owner)
+                .Include(ut => ut.Track.Tags)
                 .AsQueryable();
 
             if (!string.IsNullOrEmpty(request.Name))
@@ -48,61 +36,18 @@ namespace Musify.Application.Tracks
                 .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            var localItems = pagedEntities
+            var items = pagedEntities
                 .Select(x => TrackSearchItemResponse.FromTrack(TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)))
                 .ToList();
 
-            var knownVideoIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            foreach (var entry in pagedEntities)
-            {
-                if (entry.Track is ExternalTrack { Source: TrackSource.YouTube } external)
-                    knownVideoIds.Add(external.ExternalId);
-            }
-
-            var youtubeItems = new List<TrackSearchItemResponse>();
-            string? nextContinuationToken = null;
-            var youtubeUnavailable = false;
-
-            if (request.Name?.Trim().Length >= MinNameLengthForYouTubeSearch)
-                (youtubeItems, nextContinuationToken, youtubeUnavailable) =
-                    await SearchYouTubeAsync(request.Name, request.YoutubeContinuationToken, knownVideoIds, cancellationToken);
-
-            return TracksSearchResponse.Create(
-                [.. localItems, .. youtubeItems],
+            return new TracksSearchResponse(
+                items,
                 pagedEntities.PageNumber,
                 pagedEntities.PageSize,
                 pagedEntities.PageCount,
                 pagedEntities.TotalItemCount,
                 pagedEntities.HasPreviousPage,
-                pagedEntities.HasNextPage,
-                nextContinuationToken,
-                youtubeUnavailable);
-        }
-
-        private async Task<(List<TrackSearchItemResponse> Items, string? NextContinuationToken, bool Unavailable)> SearchYouTubeAsync(
-            string name,
-            string? continuationToken,
-            HashSet<string> knownVideoIds,
-            CancellationToken cancellationToken)
-        {
-            var searchResult = await youTubeMusicService.SearchSongsAsync(name, continuationToken ?? string.Empty, cancellationToken);
-            if (searchResult.IsError)
-            {
-                logger.LogInformation(
-                    "YouTube search unavailable while combining track results: {Error}", searchResult.FirstError.Description);
-                return ([], null, true);
-            }
-
-            var items = searchResult.Value.Items
-                .Where(song => knownVideoIds.Add(song.VideoId))
-                .Select(TrackSearchItemResponse.FromYouTubeSong)
-                .ToList();
-
-            var nextToken = string.IsNullOrEmpty(searchResult.Value.ContinuationToken)
-                ? null
-                : searchResult.Value.ContinuationToken;
-
-            return (items, nextToken, false);
+                pagedEntities.HasNextPage);
         }
     }
 }

backend/Core/Musify.Application/Tracks/GetTracksByUserId.cs

@@ -6,7 +6,6 @@ using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 using Musify.Application.Contracts;
-using Musify.Domain.Entities;
 
 namespace Musify.Application.Tracks
 {
@@ -15,21 +14,20 @@ namespace Musify.Application.Tracks
         string? Name,
         int PageNumber,
         int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse> > >;
+        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
     public class GetTracksByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetTracksByUserIdQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>> >
+        : IQueryHandler<GetTracksByUserIdQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse> >> Handle(GetTracksByUserIdQuery request, CancellationToken cancellationToken)
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetTracksByUserIdQuery request, CancellationToken cancellationToken)
         {
             var pageNumber = request.PageNumber < 1 ? 1 : request.PageNumber;
             var pageSize = request.PageSize < 1 ? 10 : request.PageSize;
 
             var tracksQuery = database.UserHasTracks
                 .AsNoTracking()
-                .Include(ut => ((ExternalTrack)ut.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(ut => ((LocalTrack)ut.Track).Owner)
+                .Include(ut => ut.Track.Owner)
+                .Include(ut => ut.Track.Tags)
                 .Where(p => p.UserId == request.UserId);
 
             if (!string.IsNullOrEmpty(request.Name))

backend/Core/Musify.Application/Tracks/Responses/ExternalTrackApplicationResponse.cs

@@ -1,30 +0,0 @@
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Tracks.Responses
-{
-    public record ExternalTrackApplicationResponse(
-        Guid Id,
-        string Title,
-        string? Artist,
-        ProcessingStatus AudioStatus,
-        double Duration,
-        int ListensCount,
-        DateTime CreatedAt,
-        DateTime UpdatedAt,
-        string ExternalId)
-        : TrackApplicationResponse(Id, Title, Artist, AudioStatus, Duration, ListensCount, CreatedAt, UpdatedAt)
-    {
-        public static ExternalTrackApplicationResponse FromEntity(ExternalTrack track, int listensCount) =>
-            new(
-                track.Id,
-                track.Title,
-                FormatArtist(track),
-                track.Audio.TranscodeStatus,
-                track.DurationSeconds,
-                listensCount,
-                track.CreatedAt,
-                track.UpdatedAt,
-                track.ExternalId);
-    }
-}

backend/Core/Musify.Application/Tracks/Responses/LocalTrackApplicationResponse.cs

@@ -1,30 +0,0 @@
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Tracks.Responses
-{
-    public record LocalTrackApplicationResponse(
-        Guid Id,
-        string Title,
-        string? Artist,
-        ProcessingStatus AudioStatus,
-        double Duration,
-        int ListensCount,
-        DateTime CreatedAt,
-        DateTime UpdatedAt,
-        long OwnerUserId)
-        : TrackApplicationResponse(Id, Title, Artist, AudioStatus, Duration, ListensCount, CreatedAt, UpdatedAt)
-    {
-        public static LocalTrackApplicationResponse FromEntity(LocalTrack track, int listensCount) =>
-            new(
-                track.Id,
-                track.Title,
-                FormatArtist(track),
-                track.Audio.TranscodeStatus,
-                track.DurationSeconds,
-                listensCount,
-                track.CreatedAt,
-                track.UpdatedAt,
-                track.OwnerUserId);
-    }
-}

backend/Core/Musify.Application/Tracks/Responses/TrackApplicationResponse.cs

@@ -1,24 +1,11 @@
-using System.Text.Json.Serialization;
+using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using System.Text.Json.Serialization;
 
 namespace Musify.Application.Tracks.Responses
 {
-    // See AlbumApplicationResponse for why [JsonPolymorphic]/[JsonDerivedType] are required
-    // (not optional) whenever a base type carries subtype-only data across the wire. Track is a
-    // cleaner case than Album: both OwnerUserId (local-only) and ExternalId (external-only) are
-    // genuinely exclusive to one side, so the base has no "meaningless sentinel" field at all —
-    // every real value is one of the two derived types, hence base is abstract.
-    //
-    // No explicit Source property here (unlike the domain entities): STJ's polymorphism support
-    // already injects a "source" discriminator property with the same "Local"/"YouTube" values a
-    // hand-written TrackSource field would have, and a real property with that exact name would
-    // collide with it ("contains property 'source' that conflicts with an existing metadata
-    // property name"). Use the discriminator (or a type check) instead of a Source field.
-    [JsonPolymorphic(TypeDiscriminatorPropertyName = "source")]
-    [JsonDerivedType(typeof(LocalTrackApplicationResponse), typeDiscriminator: "Local")]
-    [JsonDerivedType(typeof(ExternalTrackApplicationResponse), typeDiscriminator: "YouTube")]
-    public abstract record TrackApplicationResponse(
+    public record TrackApplicationResponse(
         Guid Id,
         string Title,
         string? Artist,
@@ -26,24 +13,21 @@ namespace Musify.Application.Tracks.Responses
         double Duration,
         int ListensCount,
         DateTime CreatedAt,
-        DateTime UpdatedAt)
+        DateTime UpdatedAt,
+        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+        IReadOnlyCollection<Genre> Tags)
     {
         public static TrackApplicationResponse FromEntity(Track track, int listensCount) =>
-            track switch
-            {
-                LocalTrack local => LocalTrackApplicationResponse.FromEntity(local, listensCount),
-                ExternalTrack external => ExternalTrackApplicationResponse.FromEntity(external, listensCount),
-                _ => throw new NotSupportedException($"Unsupported track entity type '{track.GetType().Name}'.")
-            };
-
-        protected static string? FormatArtist(Track track) => track switch
-        {
-            LocalTrack local => local.Owner.Name,
-            ExternalTrack { TrackArtists.Count: > 0 } external =>
-                string.Join(", ", external.TrackArtists
-                    .OrderBy(trackArtist => trackArtist.Position)
-                    .Select(trackArtist => trackArtist.Artist.Name)),
-            _ => null
-        };
+            new(
+                track.Id,
+                track.Title,
+                track.Owner.Name,
+                track.Audio.TranscodeStatus,
+                track.DurationSeconds,
+                listensCount,
+                track.CreatedAt,
+                track.UpdatedAt,
+                track.OwnerUserId,
+                track.Tags.Select(tag => tag.Tag).ToList());
     }
 }

backend/Core/Musify.Application/Tracks/Responses/TrackSearchItemResponse.cs

@@ -1,22 +1,7 @@
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-
 namespace Musify.Application.Tracks.Responses
 {
-    /// <summary>One item of a combined local/YouTube track listing. Exactly one of
-    /// <see cref="Track"/> or <see cref="YouTubeSong"/> is populated: <see cref="Track"/> for
-    /// anything already in the catalog (local uploads and YouTube tracks provisioned earlier),
-    /// <see cref="YouTubeSong"/> for a live YouTube Music search hit that has not been
-    /// provisioned yet, so it has no track id.</summary>
-    public record TrackSearchItemResponse(
-        TrackSource Source,
-        TrackApplicationResponse? Track,
-        YouTubeSongResult? YouTubeSong)
+    public record TrackSearchItemResponse(TrackApplicationResponse Track)
     {
-        public static TrackSearchItemResponse FromTrack(TrackApplicationResponse track) =>
-            new(track is ExternalTrackApplicationResponse ? TrackSource.YouTube : TrackSource.Local, track, null);
-
-        public static TrackSearchItemResponse FromYouTubeSong(YouTubeSongResult song) =>
-            new(TrackSource.YouTube, null, song);
+        public static TrackSearchItemResponse FromTrack(TrackApplicationResponse track) => new(track);
     }
 }

backend/Core/Musify.Application/Tracks/Responses/TracksSearchResponse.cs

@@ -1,11 +1,6 @@
 namespace Musify.Application.Tracks.Responses
 {
-    /// <summary>Result of a combined tracks listing/search: a page of local catalog tracks
-    /// (uploads and previously provisioned YouTube tracks), plus, when a search term was given,
-    /// live YouTube Music hits appended after them. Pagination metadata (<see cref="PageNumber"/>,
-    /// <see cref="PageSize"/>, <see cref="PageCount"/>, <see cref="TotalItemCount"/>) describes only
-    /// the local page — YouTube has no stable total, so its continuation is tracked separately via
-    /// <see cref="NextYoutubeContinuationToken"/>.</summary>
+
     public record TracksSearchResponse(
         IReadOnlyList<TrackSearchItemResponse> Items,
         int PageNumber,
@@ -13,26 +8,5 @@ namespace Musify.Application.Tracks.Responses
         int PageCount,
         int TotalItemCount,
         bool HasPreviousPage,
-        bool HasNextLocalPage,
-        string? NextYoutubeContinuationToken,
-        bool YoutubeUnavailable,
-        bool HasNextPage)
-    {
-        // HasNextPage is a real field (not a computed property) so it shows up as a required member
-        // of the generated OpenAPI schema, same as every other field here — a get-only property added
-        // outside the primary constructor gets reflected as optional instead, which is never true here.
-        public static TracksSearchResponse Create(
-            IReadOnlyList<TrackSearchItemResponse> items,
-            int pageNumber,
-            int pageSize,
-            int pageCount,
-            int totalItemCount,
-            bool hasPreviousPage,
-            bool hasNextLocalPage,
-            string? nextYoutubeContinuationToken,
-            bool youtubeUnavailable) =>
-            new(items, pageNumber, pageSize, pageCount, totalItemCount, hasPreviousPage, hasNextLocalPage,
-                nextYoutubeContinuationToken, youtubeUnavailable,
-                HasNextPage: hasNextLocalPage || !string.IsNullOrEmpty(nextYoutubeContinuationToken));
-    }
+        bool HasNextPage);
 }

backend/Core/Musify.Application/Users/CreateUser.cs

@@ -28,7 +28,7 @@ namespace Musify.Application.Users
     }
 
     public class CreateUserCommandHandler(IDatabase database, ILogger<CreateUserCommandHandler> logger)
-        : ICommandHandler<CreateUserCommand, ErrorOr<UserApplicationResponse> >
+        : ICommandHandler<CreateUserCommand, ErrorOr<UserApplicationResponse>>
     {
         public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(CreateUserCommand request, CancellationToken cancellationToken)
         {

backend/Core/Musify.Application/Users/FollowUser.cs

@@ -0,0 +1,50 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Users
+{
+    public record FollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
+
+    public class FollowUserCommandHandler(
+        IDatabase database,
+        ILogger<FollowUserCommandHandler> logger)
+        : ICommandHandler<FollowUserCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(FollowUserCommand request, CancellationToken cancellationToken)
+        {
+            if (request.FollowerId == request.FollowedId)
+                return Error.Validation(description: "A user cannot follow themselves.");
+
+            var followedExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(u => u.Id == request.FollowedId, cancellationToken);
+            if (!followedExists)
+            {
+                logger.LogInformation("User {FollowedId} not found", request.FollowedId);
+                return Error.NotFound(description: $"User {request.FollowedId} not found");
+            }
+
+            var alreadyFollowing = await database.UserFollows
+                .AsNoTracking()
+                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
+            if (alreadyFollowing)
+                return new Success();
+
+            await database.UserFollows.AddAsync(new UserFollow
+            {
+                FollowerId = request.FollowerId,
+                FollowedId = request.FollowedId
+            }, cancellationToken);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {FollowerId} followed user {FollowedId}", request.FollowerId, request.FollowedId);
+
+            return new Success();
+        }
+    }
+}

backend/Core/Musify.Application/Users/GetListeningStats.cs

@@ -0,0 +1,50 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Users
+{
+    public record GetListeningStatsQuery(long UserId) : IQuery<ListeningStatsResponse>;
+
+    public record ListeningStatsResponse(int TracksThisWeek, int SecondsThisWeek, int StreakDays);
+
+    public class GetListeningStatsQueryHandler(IDatabase database)
+        : IQueryHandler<GetListeningStatsQuery, ListeningStatsResponse>
+    {
+        public async ValueTask<ListeningStatsResponse> Handle(GetListeningStatsQuery request, CancellationToken cancellationToken)
+        {
+            var weekAgo = DateTime.UtcNow.AddDays(-7);
+
+            var thisWeekHistory = database.ListeningHistories
+                .AsNoTracking()
+                .Where(l => l.UserId == request.UserId && l.ListenedAt >= weekAgo);
+
+            var tracksThisWeek = await thisWeekHistory
+                .Select(l => l.TrackId)
+                .Distinct()
+                .CountAsync(cancellationToken);
+
+            var secondsThisWeek = await thisWeekHistory
+                .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => t.DurationSeconds)
+                .SumAsync(cancellationToken);
+
+            var listenedDates = await database.ListeningHistories
+                .AsNoTracking()
+                .Where(l => l.UserId == request.UserId)
+                .Select(l => l.ListenedAt.Date)
+                .Distinct()
+                .ToListAsync(cancellationToken);
+
+            var listenedDateSet = listenedDates.ToHashSet();
+            var streakDays = 0;
+            var day = DateTime.UtcNow.Date;
+            while (listenedDateSet.Contains(day))
+            {
+                streakDays++;
+                day = day.AddDays(-1);
+            }
+
+            return new ListeningStatsResponse(tracksThisWeek, (int)Math.Round(secondsThisWeek), streakDays);
+        }
+    }
+}

backend/Core/Musify.Application/Users/GetUserById.cs

@@ -7,10 +7,10 @@ using Musify.Application.Users.Responses;
 namespace Musify.Application.Users
 {
     public record GetUserByIdQuery(long Id)
-        : IQuery<ErrorOr<UserApplicationResponse> >;
+        : IQuery<ErrorOr<UserApplicationResponse>>;
 
     public class GetUserByIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetUserByIdQuery, ErrorOr<UserApplicationResponse> >
+        : IQueryHandler<GetUserByIdQuery, ErrorOr<UserApplicationResponse>>
     {
         public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
         {
@@ -20,7 +20,7 @@ namespace Musify.Application.Users
                 .Select(u => UserApplicationResponse.FromEntity(u))
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (user is null)
+            if (user == null)
                 return Error.NotFound();
 
             return user;

backend/Core/Musify.Application/Users/GetUserProfile.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Serialization;
+
+namespace Musify.Application.Users
+{
+    public record GetUserProfileQuery(long UserId) : IQuery<ErrorOr<UserProfileResponse>>;
+
+    public record UserProfileResponse(
+        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+        string Name,
+        string? FirstName,
+        string? SecondName,
+        string? ProfilePictureUrl,
+        DateTime CreatedAt,
+        int FollowersCount,
+        int FollowingCount);
+
+    public class GetUserProfileQueryHandler(IDatabase database)
+        : IQueryHandler<GetUserProfileQuery, ErrorOr<UserProfileResponse>>
+    {
+        public async ValueTask<ErrorOr<UserProfileResponse>> Handle(GetUserProfileQuery request, CancellationToken cancellationToken)
+        {
+            var user = await database.Users
+                .AsNoTracking()
+                .Where(u => u.Id == request.UserId)
+                .Select(u => new
+                {
+                    u.Id,
+                    u.Name,
+                    u.FirstName,
+                    u.SecondName,
+                    u.ProfilePictureUrl,
+                    u.CreatedAt
+                })
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if (user == null)
+                return Error.NotFound();
+
+            var followersCount = await database.UserFollows
+                .AsNoTracking()
+                .CountAsync(f => f.FollowedId == request.UserId, cancellationToken);
+
+            var followingCount = await database.UserFollows
+                .AsNoTracking()
+                .CountAsync(f => f.FollowerId == request.UserId, cancellationToken);
+
+            return new UserProfileResponse(
+                user.Id,
+                user.Name,
+                user.FirstName,
+                user.SecondName,
+                user.ProfilePictureUrl,
+                user.CreatedAt,
+                followersCount,
+                followingCount);
+        }
+    }
+}

backend/Core/Musify.Application/Users/GetUsers.cs

@@ -9,29 +9,29 @@ using Musify.Application.Contracts;
 namespace Musify.Application.Users
 {
     public record GetUsersQuery(int PageNumber, int PageSize, string? UsernameSearch)
-        : IQuery<ErrorOr<PaginatedResponse<UserApplicationResponse> >>;
+        : IQuery<ErrorOr<PaginatedResponse<UserApplicationResponse>>>;
 
     public class GetUsersQueryHandler(IDatabase database)
-        : IQueryHandler<GetUsersQuery, ErrorOr<PaginatedResponse<UserApplicationResponse> > >
+        : IQueryHandler<GetUsersQuery, ErrorOr<PaginatedResponse<UserApplicationResponse>>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<UserApplicationResponse> >> Handle(GetUsersQuery request, CancellationToken cancellationToken)
+        public async ValueTask<ErrorOr<PaginatedResponse<UserApplicationResponse>>> Handle(GetUsersQuery request, CancellationToken cancellationToken)
         {
-            var user = database.Users
+            var usersQuery = database.Users
                 .AsNoTracking()
                 .AsQueryable();
 
             if (!string.IsNullOrEmpty(request.UsernameSearch))
             {
                 var normalizedUsername = request.UsernameSearch.Trim().ToUpperInvariant();
-                user = user.Where(u => u.NormalizedName.Contains(normalizedUsername));
+                usersQuery = usersQuery.Where(u => u.NormalizedName.Contains(normalizedUsername));
             }
 
-            var totalCount = await user.CountAsync(cancellationToken);
-            var pagedUser = await user
+            var totalCount = await usersQuery.CountAsync(cancellationToken);
+            var pagedUsers = await usersQuery
                 .Select(u => UserApplicationResponse.FromEntity(u))
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            return PaginatedResponse<UserApplicationResponse>.FromPagedList(pagedUser);
+            return PaginatedResponse<UserApplicationResponse>.FromPagedList(pagedUsers);
         }
     }
 }

backend/Core/Musify.Application/Users/IsFollowingUser.cs

@@ -0,0 +1,17 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Users
+{
+    public record IsFollowingUserQuery(long FollowerId, long FollowedId) : IQuery<bool>;
+
+    public class IsFollowingUserQueryHandler(IDatabase database)
+        : IQueryHandler<IsFollowingUserQuery, bool>
+    {
+        public ValueTask<bool> Handle(IsFollowingUserQuery request, CancellationToken cancellationToken) =>
+            new(database.UserFollows
+                .AsNoTracking()
+                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken));
+    }
+}

backend/Core/Musify.Application/Users/Responses/UserApplicationResponse.cs

@@ -1,9 +1,11 @@
-using Musify.Domain.Entities;
+using System.Text.Json.Serialization;
+using Musify.Application.Serialization;
+using Musify.Domain.Entities;
 
 namespace Musify.Application.Users.Responses
 {
     public record UserApplicationResponse(
-        long Id,
+        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
         string Name,
         string? FirstName,
         string? SecondName,

backend/Core/Musify.Application/Users/SyncUser.cs

@@ -23,7 +23,7 @@ namespace Musify.Application.Users
             var user = await database.Users
                 .SingleOrDefaultAsync(u => u.Id == request.Id, cancellationToken);
 
-            if (user is null)
+            if (user == null)
             {
                 await database.Users.AddAsync(new User
                 {

backend/Core/Musify.Application/Users/UnfollowUser.cs

@@ -0,0 +1,32 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Users
+{
+    public record UnfollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
+
+    public class UnfollowUserCommandHandler(
+        IDatabase database,
+        ILogger<UnfollowUserCommandHandler> logger)
+        : ICommandHandler<UnfollowUserCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(UnfollowUserCommand request, CancellationToken cancellationToken)
+        {
+            var follow = await database.UserFollows
+                .SingleOrDefaultAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
+
+            if (follow == null)
+                return new Success();
+
+            database.UserFollows.Remove(follow);
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {FollowerId} unfollowed user {FollowedId}", request.FollowerId, request.FollowedId);
+
+            return new Success();
+        }
+    }
+}

backend/Core/Musify.Application/YouTube/GetYouTubeAlbum.cs

@@ -1,36 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Application.Services;
-
-namespace Musify.Application.YouTube
-{
-    public record GetYouTubeAlbumQuery(string AlbumId)
-        : IQuery<ErrorOr<YouTubeAlbumDetail>>;
-
-    public class GetYouTubeAlbumQueryHandler(
-        IYouTubeMusicService youTubeMusicService,
-        YouTubeTrackProvisioner provisioner,
-        ILogger<GetYouTubeAlbumQueryHandler> logger)
-        : IQueryHandler<GetYouTubeAlbumQuery, ErrorOr<YouTubeAlbumDetail>>
-    {
-        public async ValueTask<ErrorOr<YouTubeAlbumDetail>> Handle(GetYouTubeAlbumQuery request, CancellationToken cancellationToken)
-        {
-            var result = await youTubeMusicService.GetAlbumAsync(request.AlbumId, cancellationToken);
-            if (result.IsError)
-                return result;
-
-            try
-            {
-                await provisioner.MaterializeAlbumAsync(request.AlbumId, result.Value, cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogWarning(exception, "Failed to materialize YouTube album {AlbumId}", request.AlbumId);
-            }
-
-            return result;
-        }
-    }
-}

backend/Core/Musify.Application/YouTube/ResolveYouTubeTrackStream.cs

@@ -1,85 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Services;
-using Musify.Application.YouTube.Responses;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.YouTube
-{
-    public record ResolveYouTubeTrackStreamCommand(string VideoId, long? UserId)
-        : ICommand<ErrorOr<YouTubeStreamResponse>>;
-
-    public class ResolveYouTubeTrackStreamCommandHandler(
-        IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
-        YouTubeTrackProvisioner provisioner,
-        TrackStreamIssuer streamIssuer,
-        PlaybackConfiguration playbackConfiguration,
-        ILogger<ResolveYouTubeTrackStreamCommandHandler> logger)
-        : ICommandHandler<ResolveYouTubeTrackStreamCommand, ErrorOr<YouTubeStreamResponse>>
-    {
-        public async ValueTask<ErrorOr<YouTubeStreamResponse>> Handle(ResolveYouTubeTrackStreamCommand request, CancellationToken cancellationToken)
-        {
-            var isAnonymous = !request.UserId.HasValue;
-            if (isAnonymous && !playbackConfiguration.AllowAnonymousListening)
-                return Error.Unauthorized(description: "Sign in to stream music, or ask an administrator to enable anonymous listening.");
-
-            var track = await provisioner.FindAsync(request.VideoId, cancellationToken);
-
-            if (track != null && track.Audio.IsProcessed)
-            {
-                var serverStream = await streamIssuer.IssueAsync(track.Id, track.Audio.FolderName, request.UserId, cancellationToken);
-                return new YouTubeStreamResponse(
-                    track.Id,
-                    YouTubeStreamMode.Server,
-                    serverStream.ManifestUrl,
-                    serverStream.Ticket,
-                    serverStream.ExpiresInSeconds);
-            }
-
-            if (isAnonymous && playbackConfiguration.AnonymousFragmentSeconds > 0)
-                return Error.Conflict(description: "This track isn't available for anonymous preview yet. Try again in a moment.");
-
-            var streamInfo = await youTubeMusicService.GetAudioStreamAsync(request.VideoId, cancellationToken);
-            if (streamInfo.IsError)
-                return streamInfo.Errors;
-
-            if (track == null)
-            {
-                var provisionResult = await provisioner.GetOrCreateAsync(request.VideoId, cancellationToken);
-                if (!provisionResult.IsError)
-                    track = provisionResult.Value.Track;
-                else
-                    logger.LogWarning("Could not provision YouTube track {VideoId}: {Error}", request.VideoId, provisionResult.FirstError.Description);
-            }
-
-            if (track != null&& request.UserId != null)
-            {
-                await database.ListeningHistories.AddAsync(new ListeningHistory
-                {
-                    UserId = request.UserId.Value,
-                    TrackId = track.Id,
-                }, cancellationToken);
-
-                try
-                {
-                    await database.SaveChangesAsync(cancellationToken);
-                }
-                catch (DbUpdateException exception)
-                {
-                    logger.LogWarning(exception, "Failed to record listening history for YouTube video {VideoId}", request.VideoId);
-                }
-            }
-
-            return new YouTubeStreamResponse(
-                track?.Id,
-                YouTubeStreamMode.YouTube,
-                streamInfo.Value.Url, null,
-                streamInfo.Value.ExpiresInSeconds);
-        }
-    }
-}

backend/Core/Musify.Application/YouTube/Responses/YouTubeStreamResponse.cs

@@ -1,15 +0,0 @@
-namespace Musify.Application.YouTube.Responses
-{
-    public enum YouTubeStreamMode
-    {
-        Server = 0,
-        YouTube = 1
-    }
-
-    public record YouTubeStreamResponse(
-        Guid? TrackId,
-        YouTubeStreamMode Mode,
-        string StreamUrl,
-        string? Ticket,
-        int ExpiresInSeconds);
-}

backend/Core/Musify.Domain/Entities/Album.cs

@@ -1,11 +1,12 @@
 using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.Abstractions;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
-    public abstract class Album : IAuditable
+    public class Album : IAuditable
     {
         [Key]
         public Guid Id { get; set; } = Guid.NewGuid();
@@ -25,6 +26,12 @@ namespace Musify.Domain.Entities
 
         public AlbumPictures? Pictures { get; set; }
 
+        [Required]
+        public required long OwnerUserId { get; set; }
+
+        [ForeignKey(nameof(OwnerUserId))]
+        public User Owner { get; set; }
+
         [Required]
         public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;
 

backend/Core/Musify.Domain/Entities/Artist.cs

@@ -1,32 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Musify.Domain.Abstractions;
-
-namespace Musify.Domain.Entities
-{
-#pragma warning disable CS8618
-    public class Artist : IAuditable
-    {
-        [Key]
-        public Guid Id { get; set; } = Guid.NewGuid();
-
-        [Required]
-        [MaxLength(200)]
-        public required string Name { get; set; }
-
-        [Required]
-        [MaxLength(200)]
-        public required string NormalizedName { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string ExternalId { get; set; }
-
-        [Required]
-        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-
-        [Required]
-        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
-
-        public ICollection<TrackArtist> TrackArtists { get; set; } = new List<TrackArtist>();
-    }
-}

backend/Core/Musify.Domain/Entities/ExternalAlbum.cs

@@ -1,18 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Domain.Entities
-{
-    public class ExternalAlbum : Album
-    {
-        [Required]
-        public required TrackSource Source { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string ExternalId { get; set; }
-
-        [MaxLength(512)]
-        public string? ThumbnailUrl { get; set; }
-    }
-}

backend/Core/Musify.Domain/Entities/ExternalTrack.cs

@@ -1,17 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Domain.Entities
-{
-    public class ExternalTrack : Track
-    {
-        [Required]
-        public required TrackSource Source { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string ExternalId { get; set; }
-
-        public ICollection<TrackArtist> TrackArtists { get; set; } = new List<TrackArtist>();
-    }
-}

backend/Core/Musify.Domain/Entities/LocalTrack.cs

@@ -1,14 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Musify.Domain.Entities
-{
-    public class LocalTrack : Track
-    {
-        [Required]
-        public required long OwnerUserId { get; set; }
-
-        [ForeignKey(nameof(OwnerUserId)) ]
-        public required User Owner { get; set; }
-    }
-}

backend/Core/Musify.Domain/Entities/MixItem.cs

@@ -1,8 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-using Musify.Domain.ValueObjects;
-
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
@@ -19,32 +17,12 @@ namespace Musify.Domain.Entities
         public int Position { get; set; } = 0;
 
         [Required]
-        public required MixItemSource Source { get; set; }
-
-        public Guid? TrackId { get; set; }
-
-        [MaxLength(64)]
-        public string? VideoId { get; set; }
-
-        [MaxLength(300)]
-        public string? Title { get; set; }
-
-        [MaxLength(300)]
-        public string? Artist { get; set; }
-
-        [MaxLength(512)]
-        public string? ThumbnailUrl { get; set; }
-
-        [Required]
-        public double DurationSeconds { get; set; }
-
-        [Required]
-        public bool IsExplicit { get; set; }
+        public required Guid TrackId { get; set; }
 
         [ForeignKey(nameof(MixId))]
         public Mix Mix { get; set; }
 
         [ForeignKey(nameof(TrackId))]
-        public Track? Track { get; set; }
+        public Track Track { get; set; }
     }
 }

backend/Core/Musify.Domain/Entities/PlayList.cs

@@ -27,12 +27,14 @@ namespace Musify.Domain.Entities
         [MaxLength(256)]
         public string? Description { get; set; }
 
-        [Required]
-        public required PlayListPictures Pictures { get; set; }
+        public PlayListPictures? Pictures { get; set; }
 
         [Required]
         public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;
 
+        [Required]
+        public PlaylistVisibility Visibility { get; set; } = PlaylistVisibility.Private;
+
         [Required]
         public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
 

backend/Core/Musify.Domain/Entities/Track.cs

@@ -1,11 +1,12 @@
 using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.Abstractions;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
-    public abstract class Track : IAuditable
+    public class Track : IAuditable
     {
         [Key]
         public Guid Id { get; set; } = Guid.NewGuid();
@@ -21,6 +22,12 @@ namespace Musify.Domain.Entities
         [Required]
         public double DurationSeconds { get; set; }
 
+        [Required]
+        public required long OwnerUserId { get; set; }
+
+        [ForeignKey(nameof(OwnerUserId))]
+        public required User Owner { get; set; }
+
         [Required]
         public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;
 
@@ -41,5 +48,7 @@ namespace Musify.Domain.Entities
         public ICollection<AlbumHasTrack> AlbumTracks { get; set; } = new List<AlbumHasTrack>();
 
         public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();
+
+        public ICollection<TrackTag> Tags { get; set; } = new List<TrackTag>();
     }
 }

backend/Core/Musify.Domain/Entities/TrackArtist.cs

@@ -1,25 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Musify.Domain.Entities
-{
-#pragma warning disable CS8618
-    [Table("TrackArtist")]
-    public class TrackArtist
-    {
-        [Required]
-        public required Guid TrackId { get; set; }
-
-        [Required]
-        public required Guid ArtistId { get; set; }
-
-        [Required]
-        public int Position { get; set; } = 0;
-
-        [ForeignKey(nameof(TrackId)) ]
-        public ExternalTrack Track { get; set; }
-
-        [ForeignKey(nameof(ArtistId)) ]
-        public Artist Artist { get; set; }
-    }
-}

backend/Core/Musify.Domain/Entities/TrackLike.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    [Table("TrackLikes")]
+    public class TrackLike
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required long UserId { get; set; }
+
+        [Required]
+        public required Guid TrackId { get; set; }
+
+        [Required]
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        [ForeignKey(nameof(UserId))]
+        public User User { get; set; }
+
+        [ForeignKey(nameof(TrackId))]
+        public Track Track { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/TrackTag.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    public class TrackTag
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required Guid TrackId { get; set; }
+
+        [Required]
+        public required Genre Tag { get; set; }
+
+        [ForeignKey(nameof(TrackId))]
+        public Track Track { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/UserAlbum.cs

@@ -1,15 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Musify.Domain.Entities
-{
-#pragma warning disable CS8618
-    public class UserAlbum : Album
-    {
-        [Required]
-        public required long OwnerUserId { get; set; }
-
-        [ForeignKey(nameof(OwnerUserId)) ]
-        public User Owner { get; set; }
-    }
-}

backend/Core/Musify.Domain/Entities/UserFollow.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    [Table("UserFollows")]
+    public class UserFollow
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required long FollowerId { get; set; }
+
+        [Required]
+        public required long FollowedId { get; set; }
+
+        [Required]
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        [ForeignKey(nameof(FollowerId))]
+        public User Follower { get; set; }
+
+        [ForeignKey(nameof(FollowedId))]
+        public User Followed { get; set; }
+    }
+}

backend/Core/Musify.Domain/ValueObjects/Genre.cs

@@ -0,0 +1,32 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum Genre
+    {
+        Pop = 0,
+        Rock = 1,
+        HipHop = 2,
+        RnB = 3,
+        Jazz = 4,
+        Blues = 5,
+        Classical = 6,
+        Electronic = 7,
+        House = 8,
+        Techno = 9,
+        Trance = 10,
+        Dubstep = 11,
+        DrumAndBass = 12,
+        Metal = 13,
+        Punk = 14,
+        Reggae = 15,
+        Reggaeton = 16,
+        Country = 17,
+        Folk = 18,
+        Indie = 19,
+        KPop = 20,
+        Latin = 21,
+        Soul = 22,
+        Funk = 23,
+        Ambient = 24,
+        Lofi = 25
+    }
+}

backend/Core/Musify.Domain/ValueObjects/GenreCompatibility.cs

@@ -0,0 +1,48 @@
+namespace Musify.Domain.ValueObjects
+{
+
+    public static class GenreCompatibility
+    {
+        private static readonly HashSet<(Genre, Genre)> IncompatiblePairs = BuildIncompatiblePairs();
+
+        private static HashSet<(Genre, Genre)> BuildIncompatiblePairs()
+        {
+            var pairs = new HashSet<(Genre, Genre)>();
+
+            void Add(Genre a, Genre b)
+            {
+                pairs.Add((a, b));
+                pairs.Add((b, a));
+            }
+
+            var intense = new[] { Genre.Metal, Genre.Punk, Genre.Dubstep, Genre.DrumAndBass };
+            var mellow = new[] { Genre.Classical, Genre.Ambient, Genre.Lofi };
+
+            foreach (var intenseGenre in intense)
+                foreach (var mellowGenre in mellow)
+                    Add(intenseGenre, mellowGenre);
+
+            return pairs;
+        }
+
+        public static bool AreCompatible(Genre a, Genre b) =>
+            a == b || !IncompatiblePairs.Contains((a, b));
+
+        public static IReadOnlyCollection<(Genre First, Genre Second)> FindConflicts(IEnumerable<Genre> tags)
+        {
+            var distinctTags = tags.Distinct().ToList();
+            var conflicts = new List<(Genre, Genre)>();
+
+            for (var i = 0; i < distinctTags.Count; i++)
+            {
+                for (var j = i + 1; j < distinctTags.Count; j++)
+                {
+                    if (!AreCompatible(distinctTags[i], distinctTags[j]))
+                        conflicts.Add((distinctTags[i], distinctTags[j]));
+                }
+            }
+
+            return conflicts;
+        }
+    }
+}

backend/Core/Musify.Domain/ValueObjects/MixItemSource.cs

@@ -1,8 +0,0 @@
-namespace Musify.Domain.ValueObjects
-{
-    public enum MixItemSource
-    {
-        Musify = 0,
-        YouTube = 1
-    }
-}

backend/Core/Musify.Domain/ValueObjects/PlaylistVisibility.cs

@@ -0,0 +1,8 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum PlaylistVisibility
+    {
+        Private = 0,
+        Public = 1
+    }
+}

backend/Core/Musify.Domain/ValueObjects/TrackSource.cs

@@ -1,8 +0,0 @@
-namespace Musify.Domain.ValueObjects
-{
-    public enum TrackSource
-    {
-        Local = 0,
-        YouTube = 1
-    }
-}