Restore the invitations tab, render library tracks on first paint and re-measure the tab indicator

Owners invite existing users to coauthor a track; invitees accept or reject,
and either side can remove a coauthor. Only accepted coauthors appear in track
responses and in the coauthor's public track list. The owner also receives the
full invitation list with statuses on the user tracks response.

.claude/launch.json

@@ -14,6 +14,12 @@
 			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.Api"],
 			"port": 5111
 		},
+		{
+			"name": "musify-worker",
+			"runtimeExecutable": "dotnet",
+			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.Worker"],
+			"port": 5112
+		},
 		{
 			"name": "musify-streaming-gateway",
 			"runtimeExecutable": "dotnet",

backend/.editorconfig

@@ -18,7 +18,7 @@ generated_code = true
 [*.cs]
 indent_size = 4
 
-csharp_style_namespace_declarations = file_scoped:warning
+csharp_style_namespace_declarations = block_scoped:warning
 csharp_using_directive_placement = outside_namespace:warning
 dotnet_sort_system_directives_first = true
 dotnet_separate_import_directive_groups = false
@@ -33,33 +33,47 @@ csharp_style_prefer_primary_constructors = true:suggestion
 csharp_style_expression_bodied_methods = when_on_single_line:suggestion
 dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion
 
+# Naming. Roslyn applies the first matching rule in file order, so the specific rules come first.
+# Private fields are _camelCase whatever their modifiers (static, readonly, const).
 dotnet_naming_rule.private_fields.symbols = private_fields
-dotnet_naming_rule.private_fields.style = camel_case
+dotnet_naming_rule.private_fields.style = underscore_camel_case
 dotnet_naming_rule.private_fields.severity = warning
 dotnet_naming_symbols.private_fields.applicable_kinds = field
 dotnet_naming_symbols.private_fields.applicable_accessibilities = private
-dotnet_naming_symbols.private_fields.required_modifiers =
+dotnet_naming_style.underscore_camel_case.capitalization = camel_case
-dotnet_naming_style.camel_case.capitalization = camel_case
+dotnet_naming_style.underscore_camel_case.required_prefix = _
 
-dotnet_naming_rule.private_constants.symbols = private_constants
+# Non-private fields (constants, static readonly, etc.) are PascalCase.
-dotnet_naming_rule.private_constants.style = pascal_case
+dotnet_naming_rule.other_fields.symbols = other_fields
-dotnet_naming_rule.private_constants.severity = warning
+dotnet_naming_rule.other_fields.style = pascal_case
-dotnet_naming_symbols.private_constants.applicable_kinds = field
+dotnet_naming_rule.other_fields.severity = warning
-dotnet_naming_symbols.private_constants.required_modifiers = const
+dotnet_naming_symbols.other_fields.applicable_kinds = field
+dotnet_naming_symbols.other_fields.applicable_accessibilities = public, internal, protected, protected_internal, private_protected
 dotnet_naming_style.pascal_case.capitalization = pascal_case
 
-# Analyzer rules that would need behaviour or API changes; downgraded in P0, revisit in P15.
+dotnet_naming_rule.interfaces.symbols = interfaces
+dotnet_naming_rule.interfaces.style = interface_style
+dotnet_naming_rule.interfaces.severity = warning
+dotnet_naming_symbols.interfaces.applicable_kinds = interface
+dotnet_naming_style.interface_style.capitalization = pascal_case
+dotnet_naming_style.interface_style.required_prefix = I
+
+dotnet_naming_rule.types_and_members.symbols = types_and_members
+dotnet_naming_rule.types_and_members.style = pascal_case
+dotnet_naming_rule.types_and_members.severity = warning
+dotnet_naming_symbols.types_and_members.applicable_kinds = class, struct, enum, delegate, property, method, event
+dotnet_naming_symbols.types_and_members.applicable_accessibilities = *
+
+# CA1848/CA1873 would turn every log call into a [LoggerMessage] source-generated method; CA1716 flags the
+# EF-style IDatabase.Set<T>() and the Musify.Application.Shared namespace, whose names are deliberate.
 dotnet_diagnostic.CA1848.severity = suggestion
 dotnet_diagnostic.CA1873.severity = suggestion
-dotnet_diagnostic.CA1305.severity = suggestion
-dotnet_diagnostic.CA1707.severity = suggestion
-dotnet_diagnostic.CA1859.severity = suggestion
 dotnet_diagnostic.CA1716.severity = suggestion
-dotnet_diagnostic.CA1000.severity = suggestion
+# The routing slip builders are stateless services resolved from DI; they stay instance members.
-dotnet_diagnostic.CA1725.severity = suggestion
-dotnet_diagnostic.CA1816.severity = suggestion
 dotnet_diagnostic.CA1822.severity = suggestion
-dotnet_diagnostic.CA1852.severity = suggestion
+
-dotnet_diagnostic.CA1068.severity = suggestion
+# Test names follow Method_Scenario_Expected.
-dotnet_diagnostic.CA1711.severity = suggestion
+[Tests/**.cs]
-dotnet_diagnostic.CA1861.severity = suggestion
+dotnet_diagnostic.CA1707.severity = none
+# xUnit collection fixtures are conventionally named ...Collection.
+dotnet_diagnostic.CA1711.severity = none

backend/CLAUDE.md

@@ -0,0 +1,58 @@
+# Musify: backend
+
+.NET 10 solution (`Musify.slnx`): `Core/` (Domain, Application, Infrastructure), `Hosts/` (Api, Worker, StreamingGateway) and `Tests/`. Architecture and flows are in `../docs/`.
+
+## Commands
+
+Run from `backend/`.
+
+```sh
+dotnet build Musify.slnx            # warnings are errors, including unused usings (IDE0005)
+dotnet test Musify.slnx             # Infrastructure and Api tests need Docker (Testcontainers)
+dotnet format Musify.slnx --verify-no-changes
+```
+
+- Read the totals of `dotnet test` (`total:`, `succeeded:`) before trusting it; don't chain it with `&&` into a commit.
+- EF migrations: `dotnet ef migrations add <Name> --project Core/Musify.Infrastructure --startup-project Core/Musify.Infrastructure` (set `Database__ConnectionString` to any value). A model change needs a migration; the entity model lives in `ModelConfiguration.Apply`, which the in-memory test database reuses.
+- An HTTP contract change (routes, DTOs, responses) needs the web-player schema regenerated (`web-player/src/lib/api/schema.d.ts`, from `/openapi/v1.json`) and `npm run check` clean.
+- A MassTransit message change (events, routing slip arguments, process kinds) means the queues must be drained before deploying; note it in the commit.
+
+## Style
+
+- Block-scoped namespaces (`namespace X { }`; file-scoped `namespace X;` is not allowed), usings outside the namespace and sorted (`.editorconfig` enforces it).
+- Private fields are `_camelCase` whatever their modifiers (including `static readonly` and `const`); non-private constants and static fields, types, methods and properties are PascalCase; interfaces start with `I`; explicit accessibility. Enforced by `.editorconfig` (IDE1006).
+- `ArgumentNullException.ThrowIfNull(x)` without `nameof`.
+- Use `PlayList` (not `Playlist`) in code; configuration POCOs end in `Configuration`; injected services are named after their type (`storageService`).
+- User-facing strings are in English (the web-player owns translation).
+- Trim stored names; normalized columns go through `TextNormalizer.Normalize`.
+- Format ids and numbers with `CultureInfo.InvariantCulture`; put `CancellationToken` last.
+
+## Application layer
+
+- One file per use case, `<Feature>/<UseCase>.cs`, holding the record and its handler; responses go in `Responses/`.
+- Errors come from `AppErrors` (`NotFound`, `Forbidden` = 403 for "not the owner", `Conflict`). `Error.Unauthorized` (401) only means "not signed in". The success value is `Result.Success`; the API maps it to 204.
+- Handlers that cannot fail return plain types. Lists are paginated through `PageRequest` / `ToPaginatedAsync`, ordered with an `Id` tiebreak, and public reads return only `LifeCycleStatus.Active` rows.
+- Owned-entity operations go through `FindOwnedAsync` (non-active entities are not found).
+- No try/catch around `SaveChangesAsync` or `PublishAsync` in handlers: the outbox makes publish + save atomic. Infrastructure either handles an error or lets it propagate; never log and rethrow.
+- List query records keep `int PageNumber, int PageSize`; the API binds them through `PageQuery` and validates them with `PageQueryValidator`.
+
+## API layer
+
+- Routes: `{id:guid}` for the resource, `{trackId:guid}` for sub-resources, `{id:long}` / `{userId:long}` for user ids.
+- Every endpoint returns `IResult` (`Results.Ok` when the handler cannot fail, `ToHttpResult()` otherwise).
+- Validation limits live in `Validators/Limits.cs`; the database column length wins when a limit disagrees with the web-player. Upload allow-lists are in `Validators/Uploads.cs`.
+- `.WithSummary(...)` is sentence case without a trailing period.
+
+## Infrastructure and hosts
+
+- MassTransit routing slips are built from `RoutingSlips.Create` / `AddStep` / `TrackFaults`; activities for the three owner types share generic bases (`MarkLifeCycleActivity<T>`, `DeleteEntityActivity<T>`, `UpdatePicturesActivity<T>`).
+- Recurring work is Hangfire (`RecurringJobsRegistrar`); intervals are in seconds and rounded up to whole minutes.
+- The Worker calls `AddApplication` and validates its service container on build, so any handler dependency must be registered there. Shared config sections in its `appsettings.json` mirror the API's.
+- The StreamingGateway references neither Application nor Infrastructure and keeps its own options.
+
+## Tests
+
+- xUnit v3; pass `TestContext.Current.CancellationToken` to methods that take a token (analyzer xUnit1051).
+- Test names are `Method_Scenario_Expected`.
+- Application tests use the in-memory SQLite `TestDatabase`; Infrastructure and Api tests use Testcontainers (Postgres, SeaweedFS). MassTransit sagas and consumers are tested on the MassTransit test harness.
+- `Infrastructure` exposes its internals to `Musify.Infrastructure.Tests`.

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

@@ -7,17 +7,16 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-/// <summary>Appends your own tracks to an album in the given order, skipping the ones it already has.</summary>
+    public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
-public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
         : ICommand<ErrorOr<Success>>;
 
-public class AddTracksToAlbumCommandHandler(
+    public class AddTracksToAlbumCommandHandler(
         IDatabase database,
         ILogger<AddTracksToAlbumCommandHandler> logger)
         : ICommandHandler<AddTracksToAlbumCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
         {
             var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
@@ -50,7 +49,6 @@ public class AddTracksToAlbumCommandHandler(
             if (toAdd.Count == 0)
                 return Result.Success;
 
-        // Album track numbers are user-visible, so they start at 1.
             var nextTrackNumber = (await database.AlbumHasTracks
                 .Where(link => link.AlbumId == request.AlbumId)
                 .MaxAsync(link => (int?)link.TrackNumber, cancellationToken) ?? 0) + 1;
@@ -74,4 +72,5 @@ public class AddTracksToAlbumCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -12,24 +12,26 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record CreateAlbumCommand(
+    public record CreateAlbumCommand(
         long UserId,
         string Title,
         string? Description,
         int? ReleaseYear,
-    Guid PictureIntentId)
+        Guid PictureIntentId,
+        AlbumType Type = AlbumType.Album,
+        IReadOnlyList<Guid>? TrackIds = null)
         : ICommand<ErrorOr<AlbumApplicationResponse>>;
 
-public class CreateAlbumCommandHandler(
+    public class CreateAlbumCommandHandler(
         IEventBus eventBus,
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreateAlbumCommandHandler> logger,
         AlbumConfiguration albumConfiguration)
         : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
         {
             var userExists = await database.Users
@@ -38,6 +40,21 @@ public class CreateAlbumCommandHandler(
             if (!userExists)
                 return AppErrors.NotFound("User", request.UserId);
 
+            var trackIds = (request.TrackIds ?? []).Distinct().ToList();
+            var tracks = await database.Tracks
+                .AsNoTracking()
+                .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => new { track.Id, track.OwnerUserId, track.IsPublished })
+                .ToListAsync(cancellationToken);
+
+            var missing = trackIds.FirstOrDefault(id => tracks.All(track => track.Id != id));
+            if (missing != Guid.Empty)
+                return AppErrors.NotFound("Track", missing);
+
+            var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
+            if (foreign != null)
+                return AppErrors.Forbidden("Track", foreign.Id);
+
             var prepared = await PictureSourceChange.PrepareAsync(
                 uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
             if (prepared.IsError)
@@ -53,11 +70,19 @@ public class CreateAlbumCommandHandler(
                 NormalizedTitle = TextNormalizer.Normalize(title),
                 Description = request.Description,
                 ReleaseYear = request.ReleaseYear,
+                Type = request.Type,
                 Pictures = picture.Pictures
             };
 
             await database.Albums.AddAsync(album, cancellationToken);
 
+            for (var index = 0; index < trackIds.Count; index++)
+            {
+                await database.AlbumHasTracks.AddAsync(
+                    new AlbumHasTrack { AlbumId = album.Id, TrackId = trackIds[index], TrackNumber = index + 1 },
+                    cancellationToken);
+            }
+
             await eventBus.PublishAsync(
                 new CreateAlbumResourcesEvent(
                     album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
@@ -65,8 +90,15 @@ public class CreateAlbumCommandHandler(
 
             await database.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
+            logger.LogInformation("Created album {AlbumId} for user {UserId} with {Count} tracks", album.Id, request.UserId, trackIds.Count);
 
-        return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
+            var published = tracks.Where(track => track.IsPublished).Select(track => track.Id).ToHashSet();
+            var visibleTrackIds = trackIds.Where(published.Contains).ToList();
+
+            return AlbumApplicationResponse.FromEntity(
+                album,
+                visibleTrackIds.Count,
+                [.. visibleTrackIds.Take(AlbumProjections.CoverTrackCount)]);
+        }
     }
 }

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

@@ -6,17 +6,17 @@ using Musify.Application.Events;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record DeleteAlbumCommand(long UserId, Guid AlbumId)
+    public record DeleteAlbumCommand(long UserId, Guid AlbumId)
         : ICommand<ErrorOr<Success>>;
 
-public class DeleteAlbumCommandHandler(
+    public class DeleteAlbumCommandHandler(
         IDatabase database,
         IEventBus eventBus,
         ILogger<DeleteAlbumCommandHandler> logger)
         : ICommandHandler<DeleteAlbumCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
         {
             var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
@@ -33,4 +33,5 @@ public class DeleteAlbumCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -5,14 +5,14 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record GetAlbumByIdQuery(Guid Id)
+    public record GetAlbumByIdQuery(Guid Id)
         : IQuery<ErrorOr<AlbumApplicationResponse>>;
 
-public class GetAlbumByIdQueryHandler(IDatabase database)
+    public class GetAlbumByIdQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
         {
             var album = await database.Albums
@@ -26,4 +26,5 @@ public class GetAlbumByIdQueryHandler(IDatabase database)
                 ? AppErrors.NotFound("Album", request.Id)
                 : album;
         }
+    }
 }

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

@@ -0,0 +1,35 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Albums.Responses;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Albums
+{
+    public record GetAlbumTrackIdsQuery(long UserId, Guid AlbumId)
+        : IQuery<ErrorOr<AlbumTrackIdsResponse>>;
+
+    public class GetAlbumTrackIdsQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumTrackIdsQuery, ErrorOr<AlbumTrackIdsResponse>>
+    {
+        public async ValueTask<ErrorOr<AlbumTrackIdsResponse>> Handle(GetAlbumTrackIdsQuery request, CancellationToken cancellationToken)
+        {
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
+
+            var trackIds = await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId
+                    && albumTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .ThenBy(albumTrack => albumTrack.Id)
+                .Select(albumTrack => albumTrack.TrackId)
+                .ToListAsync(cancellationToken);
+
+            return new AlbumTrackIdsResponse(trackIds);
+        }
+    }
+}

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

@@ -6,17 +6,17 @@ using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record GetAlbumTracksQuery(
+    public record GetAlbumTracksQuery(
         Guid AlbumId,
         int PageNumber,
         int PageSize)
         : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
-public class GetAlbumTracksQueryHandler(IDatabase database)
+    public class GetAlbumTracksQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
-{
+    {
         public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
         {
             var albumExists = await database.Albums
@@ -28,11 +28,12 @@ public class GetAlbumTracksQueryHandler(IDatabase database)
 
             return await database.AlbumHasTracks
                 .AsNoTracking()
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active && albumTrack.Track.IsPublished)
                 .OrderBy(albumTrack => albumTrack.TrackNumber)
                 .ThenBy(albumTrack => albumTrack.Id)
                 .Select(albumTrack => albumTrack.Track)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -4,14 +4,14 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
+    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
         : IQuery<PaginatedResponse<AlbumApplicationResponse>>;
 
-public class GetAlbumsQueryHandler(IDatabase database)
+    public class GetAlbumsQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumsQuery, PaginatedResponse<AlbumApplicationResponse>>
-{
+    {
         public async ValueTask<PaginatedResponse<AlbumApplicationResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
         {
             var albumsQuery = database.Albums
@@ -30,4 +30,5 @@ public class GetAlbumsQueryHandler(IDatabase database)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -5,14 +5,14 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
+    public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
         : IQuery<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>;
 
-public class GetAlbumsByUserIdQueryHandler(IDatabase database)
+    public class GetAlbumsByUserIdQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumsByUserIdQuery, ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>
-{
+    {
         public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
         {
             var userExists = await database.Users
@@ -30,4 +30,5 @@ public class GetAlbumsByUserIdQueryHandler(IDatabase database)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -3,14 +3,14 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
+    public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
         : IQuery<IReadOnlyList<AlbumApplicationResponse>>;
 
-public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
+    public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
         : IQueryHandler<GetRecentlyListenedAlbumsQuery, IReadOnlyList<AlbumApplicationResponse>>
-{
+    {
         public async ValueTask<IReadOnlyList<AlbumApplicationResponse>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
         {
             var listens = database.ListeningHistories
@@ -20,6 +20,7 @@ public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
             var ranked = await database.AlbumHasTracks
                 .AsNoTracking()
                 .Where(albumTrack => albumTrack.Album.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
+                .Where(albumTrack => albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active && albumTrack.Track.IsPublished)
                 .Join(
                     listens,
                     albumTrack => albumTrack.TrackId,
@@ -48,4 +49,5 @@ public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
                 .Select(entry => albumsById[entry.AlbumId])
                 .ToList();
         }
+    }
 }

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

@@ -5,16 +5,16 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record RemoveTrackFromAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
+    public record RemoveTrackFromAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
         : ICommand<ErrorOr<Success>>;
 
-public class RemoveTrackFromAlbumCommandHandler(
+    public class RemoveTrackFromAlbumCommandHandler(
         IDatabase database,
         ILogger<RemoveTrackFromAlbumCommandHandler> logger)
         : ICommandHandler<RemoveTrackFromAlbumCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
         {
             var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
@@ -42,4 +42,5 @@ public class RemoveTrackFromAlbumCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -5,20 +5,21 @@ using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record RequestAlbumPictureUploadCommand(
+    public record RequestAlbumPictureUploadCommand(
         long UserId,
         string FileType,
         string ContentType,
         long? ExpectedSizeBytes = null)
         : ICommand<ErrorOr<PictureUploadResponse>>;
 
-public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
+    public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
         : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<PictureUploadResponse>>
-{
+    {
         public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken) =>
             await issuer.IssuePictureAsync(
                 request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration,
                 request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
+    }
 }

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

@@ -1,8 +1,9 @@
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums.Responses;
+namespace Musify.Application.Albums.Responses
-
+{
-public record AlbumApplicationResponse(
+    public record AlbumApplicationResponse(
         Guid Id,
         string Title,
         string? Description,
@@ -14,8 +15,9 @@ public record AlbumApplicationResponse(
         string? LargeImageKeyName,
         DateTime CreatedAt,
         DateTime UpdatedAt,
-    IReadOnlyList<Guid> CoverTrackIds)
+        IReadOnlyList<Guid> CoverTrackIds,
-{
+        AlbumType Type)
+    {
         public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
 
         public static AlbumApplicationResponse FromEntity(
@@ -35,6 +37,8 @@ public record AlbumApplicationResponse(
                 album.Pictures?.LargeName,
                 album.CreatedAt,
                 album.UpdatedAt,
-            coverTrackIds ?? []);
+                coverTrackIds ?? [],
+                album.Type);
+        }
     }
 }

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

@@ -1,10 +1,10 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums.Responses;
+namespace Musify.Application.Albums.Responses
-
-public static class AlbumProjections
 {
+    public static class AlbumProjections
+    {
         public const int CoverTrackCount = 4;
 
         public static IQueryable<Album> Active(this IQueryable<Album> query) =>
@@ -17,15 +17,18 @@ public static class AlbumProjections
                 album.Description,
                 album.ReleaseYear,
                 album.OwnerUserId,
-            album.AlbumTracks.Count,
+                album.AlbumTracks.Count(albumTrack => albumTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && albumTrack.Track.IsPublished),
                 album.Pictures!.SmallName,
                 album.Pictures!.MediumName,
                 album.Pictures!.LargeName,
                 album.CreatedAt,
                 album.UpdatedAt,
                 album.AlbumTracks
+                    .Where(albumTrack => albumTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && albumTrack.Track.IsPublished)
                     .OrderBy(albumTrack => albumTrack.TrackNumber)
                     .Take(CoverTrackCount)
                     .Select(albumTrack => albumTrack.TrackId)
-                .ToList()));
+                    .ToList(),
+                album.Type));
+    }
 }

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

@@ -0,0 +1,4 @@
+namespace Musify.Application.Albums.Responses
+{
+    public record AlbumTrackIdsResponse(IReadOnlyList<Guid> TrackIds);
+}

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

@@ -3,33 +3,26 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Albums.Responses;
-using Musify.Application.Configuration;
 using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Application.Pictures;
-using Musify.Application.Services;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
+{
-public record UpdateAlbumCommand(
+    public record UpdateAlbumCommand(
         long UserId,
         Guid AlbumId,
         string Title,
         string? Description,
         int? ReleaseYear,
-    Guid? NewPictureIntentId)
+        AlbumType? Type = null)
         : ICommand<ErrorOr<AlbumApplicationResponse>>;
 
-public class UpdateAlbumCommandHandler(
+    public class UpdateAlbumCommandHandler(
-    IEventBus eventBus,
         IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
+        ILogger<UpdateAlbumCommandHandler> logger)
-    ILogger<UpdateAlbumCommandHandler> logger,
-    AlbumConfiguration albumConfiguration)
         : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
         {
             var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
@@ -41,24 +34,9 @@ public class UpdateAlbumCommandHandler(
 
             album.Title = title;
             album.NormalizedTitle = TextNormalizer.Normalize(title);
-        album.Description = request.Description;
+            album.Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim();
             album.ReleaseYear = request.ReleaseYear;
-
+            album.Type = request.Type ?? album.Type;
-        if (request.NewPictureIntentId is { } intentId)
-        {
-            var prepared = await PictureSourceChange.PrepareAsync(
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
-            if (prepared.IsError)
-                return prepared.Errors;
-
-            var picture = prepared.Value;
-            album.Pictures = picture.Pictures;
-
-            await eventBus.PublishAsync(
-                new UpdateAlbumPictureSourceEvent(
-                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
-                cancellationToken);
-        }
 
             await database.SaveChangesAsync(cancellationToken);
 
@@ -70,4 +48,5 @@ public class UpdateAlbumCommandHandler(
                 .SelectResponse()
                 .SingleAsync(cancellationToken);
         }
+    }
 }

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

@@ -0,0 +1,59 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Albums.Responses;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Application.Pictures;
+using Musify.Application.Services;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Albums
+{
+    public record UpdateAlbumPictureCommand(long UserId, Guid AlbumId, Guid PictureIntentId)
+        : ICommand<ErrorOr<AlbumApplicationResponse>>;
+
+    public class UpdateAlbumPictureCommandHandler(
+        IEventBus eventBus,
+        IDatabase database,
+        UploadIntentValidator uploadIntentValidator,
+        ILogger<UpdateAlbumPictureCommandHandler> logger,
+        AlbumConfiguration albumConfiguration)
+        : ICommandHandler<UpdateAlbumPictureCommand, ErrorOr<AlbumApplicationResponse>>
+    {
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumPictureCommand request, CancellationToken cancellationToken)
+        {
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
+
+            var album = found.Value;
+
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
+
+            var picture = prepared.Value;
+            album.Pictures = picture.Pictures;
+
+            await eventBus.PublishAsync(
+                new UpdateAlbumPictureSourceEvent(
+                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                cancellationToken);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated picture of album {AlbumId}", album.Id);
+
+            return await database.Albums
+                .AsNoTracking()
+                .Where(a => a.Id == album.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
+        }
+    }
+}

backend/Core/Musify.Application/ApplicationDependencyInjection.cs

@@ -3,10 +3,10 @@ using Microsoft.Extensions.DependencyInjection;
 using Musify.Application.Configuration;
 using Musify.Application.Services;
 
-namespace Musify.Application;
+namespace Musify.Application
-
-public static class ApplicationDependencyInjection
 {
+    public static class ApplicationDependencyInjection
+    {
         public static IServiceCollection AddApplication(this IServiceCollection services, IConfiguration configuration)
         {
             services.AddMediator();
@@ -25,4 +25,5 @@ public static class ApplicationDependencyInjection
 
             return services;
         }
+    }
 }

backend/Core/Musify.Application/Coauthors/GetCoauthorInvitations.cs

@@ -0,0 +1,35 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Coauthors.Responses;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Coauthors
+{
+    public record GetCoauthorInvitationsQuery(long UserId, int PageNumber, int PageSize)
+        : IQuery<PaginatedResponse<CoauthorInvitationResponse>>;
+
+    public class GetCoauthorInvitationsQueryHandler(IDatabase database)
+        : IQueryHandler<GetCoauthorInvitationsQuery, PaginatedResponse<CoauthorInvitationResponse>>
+    {
+        public async ValueTask<PaginatedResponse<CoauthorInvitationResponse>> Handle(GetCoauthorInvitationsQuery request, CancellationToken cancellationToken)
+        {
+            return await database.TrackCoauthors
+                .AsNoTracking()
+                .Where(coauthor => coauthor.UserId == request.UserId
+                    && coauthor.Status == CoauthorStatus.Pending
+                    && coauthor.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .OrderByDescending(coauthor => coauthor.InvitedAt)
+                .ThenBy(coauthor => coauthor.Id)
+                .Select(coauthor => new CoauthorInvitationResponse(
+                    coauthor.Id,
+                    coauthor.TrackId,
+                    coauthor.Track.Title,
+                    coauthor.Track.Owner.Name,
+                    coauthor.Track.OwnerUserId,
+                    coauthor.InvitedAt))
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+        }
+    }
+}

backend/Core/Musify.Application/Coauthors/InviteCoauthors.cs

@@ -0,0 +1,84 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Coauthors
+{
+    public record InviteCoauthorsCommand(long OwnerId, Guid TrackId, IReadOnlyList<long> UserIds)
+        : ICommand<ErrorOr<IReadOnlyList<TrackCoauthorInviteReference>>>;
+
+    public class InviteCoauthorsCommandHandler(
+        IDatabase database,
+        ILogger<InviteCoauthorsCommandHandler> logger)
+        : ICommandHandler<InviteCoauthorsCommand, ErrorOr<IReadOnlyList<TrackCoauthorInviteReference>>>
+    {
+        public async ValueTask<ErrorOr<IReadOnlyList<TrackCoauthorInviteReference>>> Handle(InviteCoauthorsCommand request, CancellationToken cancellationToken)
+        {
+            var found = await database.Tracks.FindOwnedAsync(request.TrackId, request.OwnerId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
+
+            var userIds = request.UserIds.Distinct().ToList();
+            if (userIds.Contains(request.OwnerId))
+                return Error.Validation("Coauthor.Self", "You cannot invite yourself as a coauthor.");
+
+            var existingUserIds = await database.Users
+                .AsNoTracking()
+                .Where(user => userIds.Contains(user.Id))
+                .Select(user => user.Id)
+                .ToListAsync(cancellationToken);
+
+            var missing = userIds.Where(id => !existingUserIds.Contains(id)).Select(id => (long?)id).FirstOrDefault();
+            if (missing != null)
+                return AppErrors.NotFound("User", missing.Value);
+
+            var existing = await database.TrackCoauthors
+                .Where(coauthor => coauthor.TrackId == request.TrackId && userIds.Contains(coauthor.UserId))
+                .ToListAsync(cancellationToken);
+
+            var alreadyInvited = existing.FirstOrDefault(coauthor => coauthor.Status != CoauthorStatus.Rejected);
+            if (alreadyInvited != null)
+                return AppErrors.Conflict("Coauthor.AlreadyInvited", $"User {alreadyInvited.UserId} was already invited to this track.");
+
+            var now = DateTime.UtcNow;
+            foreach (var rejected in existing)
+            {
+                rejected.Status = CoauthorStatus.Pending;
+                rejected.InvitedAt = now;
+                rejected.RespondedAt = null;
+            }
+
+            var reinvitedIds = existing.Select(coauthor => coauthor.UserId).ToHashSet();
+            foreach (var userId in userIds.Where(id => !reinvitedIds.Contains(id)))
+            {
+                await database.TrackCoauthors.AddAsync(new TrackCoauthor
+                {
+                    TrackId = request.TrackId,
+                    UserId = userId,
+                    InvitedAt = now
+                }, cancellationToken);
+            }
+
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("Coauthor.AlreadyInvited", "A user was already invited to this track."), cancellationToken);
+            if (saved.IsError)
+                return saved.Errors;
+
+            logger.LogInformation("Owner {OwnerId} invited {Count} coauthors to track {TrackId}", request.OwnerId, userIds.Count, request.TrackId);
+
+            return await database.TrackCoauthors
+                .AsNoTracking()
+                .Where(coauthor => coauthor.TrackId == request.TrackId)
+                .OrderBy(coauthor => coauthor.InvitedAt)
+                .ThenBy(coauthor => coauthor.UserId)
+                .Select(coauthor => new TrackCoauthorInviteReference(coauthor.UserId, coauthor.User.Name, coauthor.Status))
+                .ToListAsync(cancellationToken);
+        }
+    }
+}

backend/Core/Musify.Application/Coauthors/RemoveCoauthor.cs

@@ -0,0 +1,47 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Coauthors
+{
+    public record RemoveCoauthorCommand(long UserId, Guid TrackId, long CoauthorUserId)
+        : ICommand<ErrorOr<Success>>;
+
+    public class RemoveCoauthorCommandHandler(
+        IDatabase database,
+        ILogger<RemoveCoauthorCommandHandler> logger)
+        : ICommandHandler<RemoveCoauthorCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(RemoveCoauthorCommand request, CancellationToken cancellationToken)
+        {
+            var ownerUserId = await database.Tracks
+                .AsNoTracking()
+                .Where(track => track.Id == request.TrackId && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => (long?)track.OwnerUserId)
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if (ownerUserId == null)
+                return AppErrors.NotFound("Track", request.TrackId);
+
+            if (ownerUserId != request.UserId && request.CoauthorUserId != request.UserId)
+                return AppErrors.Forbidden("Track", request.TrackId);
+
+            var coauthor = await database.TrackCoauthors
+                .SingleOrDefaultAsync(c => c.TrackId == request.TrackId && c.UserId == request.CoauthorUserId, cancellationToken);
+            if (coauthor == null)
+                return AppErrors.NotFound("Coauthor", request.CoauthorUserId);
+
+            database.TrackCoauthors.Remove(coauthor);
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {UserId} removed coauthor {CoauthorUserId} from track {TrackId}",
+                request.UserId, request.CoauthorUserId, request.TrackId);
+
+            return Result.Success;
+        }
+    }
+}

backend/Core/Musify.Application/Coauthors/RespondToCoauthorInvitation.cs

@@ -0,0 +1,44 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Coauthors
+{
+    public record RespondToCoauthorInvitationCommand(long UserId, Guid InvitationId, bool Accept)
+        : ICommand<ErrorOr<Success>>;
+
+    public class RespondToCoauthorInvitationCommandHandler(
+        IDatabase database,
+        ILogger<RespondToCoauthorInvitationCommandHandler> logger)
+        : ICommandHandler<RespondToCoauthorInvitationCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(RespondToCoauthorInvitationCommand request, CancellationToken cancellationToken)
+        {
+            var invitation = await database.TrackCoauthors
+                .Include(coauthor => coauthor.Track)
+                .SingleOrDefaultAsync(coauthor => coauthor.Id == request.InvitationId, cancellationToken);
+
+            if (invitation == null || invitation.Track.LifeCycleStatus != LifeCycleStatus.Active)
+                return AppErrors.NotFound("CoauthorInvitation", request.InvitationId);
+
+            if (invitation.UserId != request.UserId)
+                return AppErrors.Forbidden("CoauthorInvitation", request.InvitationId);
+
+            if (invitation.Status != CoauthorStatus.Pending)
+                return AppErrors.Conflict("CoauthorInvitation.NotPending", "The invitation was already answered.");
+
+            invitation.Status = request.Accept ? CoauthorStatus.Accepted : CoauthorStatus.Rejected;
+            invitation.RespondedAt = DateTime.UtcNow;
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {UserId} {Action} coauthor invitation {InvitationId}",
+                request.UserId, request.Accept ? "accepted" : "rejected", request.InvitationId);
+
+            return Result.Success;
+        }
+    }
+}

backend/Core/Musify.Application/Coauthors/Responses/CoauthorInvitationResponse.cs

@@ -0,0 +1,10 @@
+namespace Musify.Application.Coauthors.Responses
+{
+    public record CoauthorInvitationResponse(
+        Guid Id,
+        Guid TrackId,
+        string TrackTitle,
+        string? Artist,
+        long OwnerUserId,
+        DateTime InvitedAt);
+}

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

@@ -1,9 +1,9 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class AlbumConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
+    public class AlbumConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
+    {
         public static string SectionName => "Album";
 
         [Required]
@@ -11,4 +11,5 @@ public class AlbumConfiguration : IConfigurationOptions, IPictureOwnerConfigurat
 
         [Required]
         public PictureSizes PicturesSizes { get; set; } = new();
+    }
 }

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

@@ -1,12 +1,13 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class ApplicationStorageConfiguration : IConfigurationOptions
 {
+    public class ApplicationStorageConfiguration : IConfigurationOptions
+    {
         public static string SectionName => "ApplicationStorage";
 
         [Required]
         [StringLength(128, MinimumLength = 1)]
         public required string Bucket { get; set; }
+    }
 }

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

@@ -2,10 +2,10 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public static class ConfigurationDependencyInjection
 {
+    public static class ConfigurationDependencyInjection
+    {
         public static IServiceCollection AddValidatedOptions<T>(this IServiceCollection services, IConfiguration configuration)
             where T : class, IConfigurationOptions =>
             services.AddValidatedOptions<T>(configuration, T.SectionName);
@@ -26,4 +26,5 @@ public static class ConfigurationDependencyInjection
 
             return services;
         }
+    }
 }

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

@@ -1,16 +1,17 @@
 using Mediator;
 using Musify.Application.Configuration.Responses;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-
-public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
-
-public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)
-    : IQueryHandler<GetPlaybackPublicConfigQuery, PlaybackPublicConfigResponse>
 {
+
+    public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
+
+    public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)
+        : IQueryHandler<GetPlaybackPublicConfigQuery, PlaybackPublicConfigResponse>
+    {
         public ValueTask<PlaybackPublicConfigResponse> Handle(GetPlaybackPublicConfigQuery query, CancellationToken cancellationToken) =>
             ValueTask.FromResult(new PlaybackPublicConfigResponse(
                 playbackConfiguration.AllowAnonymousListening,
                 playbackConfiguration.AnonymousFragmentSeconds));
+    }
 }

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public interface IConfigurationOptions
 {
+    public interface IConfigurationOptions
+    {
         public static abstract string SectionName { get; }
+    }
 }

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

@@ -1,11 +1,12 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class MixConfiguration : IConfigurationOptions
 {
+    public class MixConfiguration : IConfigurationOptions
+    {
         public static string SectionName => "Mix";
 
         [Range(4, 100)]
         public int ItemsPerMix { get; set; } = 12;
+    }
 }

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

@@ -1,17 +1,18 @@
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public enum PictureSize
 {
+    public enum PictureSize
+    {
         Small,
         Medium,
         Large
-}
+    }
 
-public class PictureRoutes
+    public class PictureRoutes
-{
+    {
         [Required]
         public string UploadsFolder { get; set; } = "uploads";
 
@@ -41,14 +42,14 @@ public class PictureRoutes
         public string BuildPicturePath(PictureSize size, string pictureName) => StorageKey.Combine(FolderPath(size), pictureName);
 
         public string BuildOriginalPicturePath(long userId, string pictureName) =>
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalPicturesFolder, pictureName);
+            StorageKey.Combine(UploadsFolder, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, OriginalPicturesFolder, pictureName);
 
         public string BuildTempPath(string tempRootPrefix, long userId, string objectName) =>
-        StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
+            StorageKey.Combine(tempRootPrefix, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, objectName);
-}
+    }
 
-public class PictureSizes
+    public class PictureSizes
-{
+    {
         [Range(1, 1024)]
         public int SmallWidth { get; set; } = 128;
 
@@ -71,20 +72,20 @@ public class PictureSizes
             new ImageSize(routes.FolderPath(PictureSize.Small), SmallWidth, SmallHeight),
             new ImageSize(routes.FolderPath(PictureSize.Medium), MediumWidth, MediumHeight),
             new ImageSize(routes.FolderPath(PictureSize.Large), LargeWidth, LargeHeight));
-}
+    }
 
-public interface IPictureOwnerConfiguration
+    public interface IPictureOwnerConfiguration
-{
+    {
         public PictureRoutes Routes { get; }
 
         public PictureSizes PicturesSizes { get; }
-}
+    }
 
-public static class PictureSizeParser
+    public static class PictureSizeParser
-{
+    {
-    /// <summary>Parses the <c>size</c> query value; anything unknown means <see cref="PictureSize.Medium"/>.</summary>
         public static PictureSize Parse(string? value) =>
             Enum.TryParse<PictureSize>(value, ignoreCase: true, out var size) && Enum.IsDefined(size)
                 ? size
                 : PictureSize.Medium;
+    }
 }

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

@@ -1,9 +1,9 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class PlayListConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
+    public class PlayListConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
+    {
         public static string SectionName => "PlayList";
 
         [Required]
@@ -11,4 +11,5 @@ public class PlayListConfiguration : IConfigurationOptions, IPictureOwnerConfigu
 
         [Required]
         public PictureSizes PicturesSizes { get; set; } = new();
+    }
 }

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

@@ -1,10 +1,10 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-
-public sealed class PlaybackConfiguration : IConfigurationOptions
 {
+
+    public sealed class PlaybackConfiguration : IConfigurationOptions
+    {
         public static string SectionName => "Playback";
 
         public bool AllowAnonymousListening { get; set; }
@@ -14,4 +14,5 @@ public sealed class PlaybackConfiguration : IConfigurationOptions
 
         [Range(1, int.MaxValue)]
         public int EstimatedAudioBytesPerSecond { get; set; } = 16_000;
+    }
 }

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

@@ -1,4 +1,5 @@
-namespace Musify.Application.Configuration.Responses;
+namespace Musify.Application.Configuration.Responses
+{
 
-
+    public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
-public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
+}

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

@@ -1,9 +1,9 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class StreamGatewayConfiguration : IConfigurationOptions
 {
+    public class StreamGatewayConfiguration : IConfigurationOptions
+    {
         public static string SectionName => "StreamGateway";
 
         [Url]
@@ -12,4 +12,5 @@ public class StreamGatewayConfiguration : IConfigurationOptions
 
         [Required]
         public string AudioFileName { get; set; } = "audio.m4a";
+    }
 }

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

@@ -1,10 +1,11 @@
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class TrackConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
+    public class TrackConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
+    {
         public static string SectionName => "Track";
 
         [Required]
@@ -14,10 +15,10 @@ public class TrackConfiguration : IConfigurationOptions, IPictureOwnerConfigurat
         public PictureSizes PicturesSizes { get; set; } = new();
 
         PictureRoutes IPictureOwnerConfiguration.Routes => Routes;
-}
+    }
 
-public class TrackRoutes : PictureRoutes
+    public class TrackRoutes : PictureRoutes
-{
+    {
         public TrackRoutes()
         {
             ParentFolder = "Tracks";
@@ -48,8 +49,9 @@ public class TrackRoutes : PictureRoutes
         public string PresetLargePicturePath => StorageKey.Combine(ParentFolder, PresetLargePicture);
 
         public string BuildOriginalAudioPath(long userId, string audioName) =>
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalAudiosFolder, audioName);
+            StorageKey.Combine(UploadsFolder, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, OriginalAudiosFolder, audioName);
 
         public string BuildProcessedAudioPath(string folderName) =>
             StorageKey.Combine(ParentFolder, ProcessedAudiosFolder, folderName);
+    }
 }

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

@@ -1,19 +1,19 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class UploadIntentConfiguration : IConfigurationOptions
 {
+    public class UploadIntentConfiguration : IConfigurationOptions
+    {
         public static string SectionName => "UploadIntent";
 
         [Range(10, 3600)]
         public int UploadUrlExpiresInSeconds { get; set; } = 120;
 
         [Range(1, 100)]
-    public int MaxActiveUploadIntentsPerUser { get; set; } = 5;
+        public int MaxActiveUploadIntentsPerUser { get; set; } = 50;
 
         [Range(1, long.MaxValue)]
-    public long MaxActiveUploadBytesPerUser { get; set; } = 200L * 1024 * 1024;
+        public long MaxActiveUploadBytesPerUser { get; set; } = 1024L * 1024 * 1024;
 
         [Range(1, long.MaxValue)]
         public long MaxUploadBytes { get; set; } = 100L * 1024 * 1024;
@@ -38,4 +38,5 @@ public class UploadIntentConfiguration : IConfigurationOptions
 
         [Range(60, 86400)]
         public int TempCleanupJobIntervalSeconds { get; set; } = 3600;
+    }
 }

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record AudioTranscodeResult(int StatusCode, TimeSpan Duration);
+    public record AudioTranscodeResult(int StatusCode, TimeSpan Duration);
+}

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IAudioTranscoderService
 {
+    public interface IAudioTranscoderService
+    {
         public Task<AudioTranscodeResult> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken);
+    }
 }

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

@@ -2,10 +2,10 @@ using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IDatabase
 {
+    public interface IDatabase
+    {
         public DbSet<User> Users { get; }
 
         public DbSet<PlayList> PlayLists { get; }
@@ -32,9 +32,14 @@ public interface IDatabase
 
         public DbSet<UserFollow> UserFollows { get; }
 
+        public DbSet<TrackCoauthor> TrackCoauthors { get; }
+
         public Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
 
+        public DbSet<TEntity> Set<TEntity>() where TEntity : class;
+
         public Task<int> SaveChangesAsync(CancellationToken cancellationToken);
 
         public Task<ErrorOr<Success>> TrySaveChangesAsync(Error onUniqueViolation, CancellationToken cancellationToken);
+    }
 }

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IDatabaseTransaction : IAsyncDisposable
 {
+    public interface IDatabaseTransaction : IAsyncDisposable
+    {
         public Task CommitAsync(CancellationToken cancellationToken = default);
+    }
 }

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IEventBus
 {
+    public interface IEventBus
+    {
         public Task PublishAsync<T>(T message, CancellationToken cancellationToken) where T : class;
+    }
 }

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IPictureService
 {
+    public interface IPictureService
+    {
         public Task<Stream> ResizePictureAsWebpAsync(Stream pictureStream, int width, int height, CancellationToken cancellationToken);
+    }
 }

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

@@ -1,8 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IStorageService
 {
-    /// <summary>Opens an object for reading, or returns null when it does not exist.</summary>
+    public interface IStorageService
+    {
         public Task<Stream?> GetFileAsync(string bucket, string key, CancellationToken cancellationToken);
 
         public Task<ObjectMetaData?> HeadObjectAsync(string bucket, string key, CancellationToken cancellationToken);
@@ -21,4 +20,5 @@ public interface IStorageService
             CancellationToken cancellationToken);
 
         public IAsyncEnumerable<StorageObject> ListObjectsAsync(string bucket, string prefix, CancellationToken cancellationToken);
+    }
 }

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

@@ -1,8 +1,9 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IStreamTicketService
 {
+    public interface IStreamTicketService
+    {
         public StreamTicket IssueTicket(long? userId, string keyPrefix, long? maxBytes = null);
-}
+    }
 
-public record StreamTicket(string Token, int ExpiresInSeconds);
+    public record StreamTicket(string Token, int ExpiresInSeconds);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record ObjectMetaData(string ContentType, long ContentLength);
+    public record ObjectMetaData(string ContentType, long ContentLength);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record StorageObject(string Key, DateTime LastModifiedUtc);
+    public record StorageObject(string Key, DateTime LastModifiedUtc);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumPictureProcessed(Guid AlbumId);
+    public record AlbumPictureProcessed(Guid AlbumId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumPictureProcessingFailed(Guid AlbumId);
+    public record AlbumPictureProcessingFailed(Guid AlbumId);
+}

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumProcessingFailed(
+    public record AlbumProcessingFailed(
         Guid AlbumId,
         string? Bucket,
         string? PictureKey);
+}

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

@@ -1,11 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreateAlbumResourcesEvent(
+    public record CreateAlbumResourcesEvent(
         Guid AlbumId,
         Guid PictureIntentId,
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
         ImageSizes Sizes);
+}

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

@@ -1,11 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreatePlayListResourcesEvent(
+    public record CreatePlayListResourcesEvent(
         Guid PlayListId,
         Guid PictureIntentId,
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
         ImageSizes Sizes);
+}

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

@@ -1,15 +1,16 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreateTrackResourcesEvent(
+    public record CreateTrackResourcesEvent(
         Guid TrackId,
-    Guid PictureIntentId,
+        Guid? PictureIntentId,
         Guid AudioIntentId,
         string Bucket,
-    string PictureSourceKey,
+        string? PictureSourceKey,
-    string PictureDestinationKey,
+        string? PictureDestinationKey,
         string AudioSourceKey,
         string AudioDestinationKey,
         string AudioProcessedFolderKey,
         ImageSizes Sizes);
+}

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

@@ -1,5 +1,6 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record DeleteAlbumEvent(
+    public record DeleteAlbumEvent(
         Guid AlbumId,
         long UserId);
+}

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

@@ -1,5 +1,6 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record DeletePlayListEvent(
+    public record DeletePlayListEvent(
         Guid PlayListId,
         long UserId);
+}

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

@@ -1,5 +1,6 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record DeleteTrackEvent(
+    public record DeleteTrackEvent(
         Guid TrackId,
         long UserId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListPictureProcessed(Guid PlayListId);
+    public record PlayListPictureProcessed(Guid PlayListId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListPictureProcessingFailed(Guid PlayListId);
+    public record PlayListPictureProcessingFailed(Guid PlayListId);
+}

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

@@ -1,6 +1,7 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListProcessingFailed(
+    public record PlayListProcessingFailed(
         Guid PlayListId,
         string? Bucket,
         string? PictureKey);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackAudioProcessed(Guid TrackId);
+    public record TrackAudioProcessed(Guid TrackId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackAudioProcessingFailed(Guid TrackId);
+    public record TrackAudioProcessingFailed(Guid TrackId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackPictureProcessed(Guid TrackId);
+    public record TrackPictureProcessed(Guid TrackId);
+}

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

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackPictureProcessingFailed(Guid TrackId);
+    public record TrackPictureProcessingFailed(Guid TrackId);
+}

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

@@ -1,7 +1,8 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackProcessingFailed(
+    public record TrackProcessingFailed(
         Guid TrackId,
         string? Bucket,
         string? PictureKey,
         string? AudioKey);
+}

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

@@ -1,9 +1,10 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateAlbumPictureEvent(
+    public record UpdateAlbumPictureEvent(
         Guid AlbumId,
         string Bucket,
         string SourceKey,
         ImageSizes Sizes);
+}

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

@@ -1,11 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateAlbumPictureSourceEvent(
+    public record UpdateAlbumPictureSourceEvent(
         Guid AlbumId,
         Guid PictureIntentId,
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
         ImageSizes Sizes);
+}

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

@@ -1,9 +1,10 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdatePlayListPictureEvent(
+    public record UpdatePlayListPictureEvent(
         Guid PlayListId,
         string Bucket,
         string SourceKey,
         ImageSizes Sizes);
+}

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

@@ -1,11 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdatePlayListPictureSourceEvent(
+    public record UpdatePlayListPictureSourceEvent(
         Guid PlayListId,
         Guid PictureIntentId,
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
         ImageSizes Sizes);
+}

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

@@ -1,8 +1,9 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateTrackAudioEvent(
+    public record UpdateTrackAudioEvent(
         Guid TrackId,
         string SourceBucket,
         string SourceKey,
         string DestinationBucket,
         string DestinationFolderKey);
+}

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

@@ -1,9 +1,10 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateTrackPictureEvent(
+    public record UpdateTrackPictureEvent(
         Guid TrackId,
         string Bucket,
         string SourceKey,
         ImageSizes Sizes);
+}

backend/Core/Musify.Application/Genres/GetAvailableGenres.cs

@@ -1,17 +1,17 @@
 using Mediator;
-using Musify.Domain.ValueObjects;
 using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Genres;
+namespace Musify.Application.Genres
-
-public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
-
-public class GetAvailableGenresQueryHandler
-    : IQueryHandler<GetAvailableGenresQuery, IReadOnlyList<AvailableGenreResponse>>
 {
+    public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
+
+    public class GetAvailableGenresQueryHandler
+        : IQueryHandler<GetAvailableGenresQuery, IReadOnlyList<AvailableGenreResponse>>
+    {
         public ValueTask<IReadOnlyList<AvailableGenreResponse>> Handle(GetAvailableGenresQuery request, CancellationToken cancellationToken)
         {
-        var all = Enum.GetValues<Genre>();
+            var all = Enum.GetValues<Genre>().Where(genre => genre != Genre.None).ToArray();
 
             IReadOnlyList<AvailableGenreResponse> result = all
                 .Select(genre => new AvailableGenreResponse(
@@ -21,4 +21,5 @@ public class GetAvailableGenresQueryHandler
 
             return ValueTask.FromResult(result);
         }
+    }
 }

backend/Core/Musify.Application/Genres/GetGenres.cs

@@ -1,21 +1,21 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
 using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Genres;
+namespace Musify.Application.Genres
-
-public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
-
-public class GetGenresQueryHandler(IDatabase database)
-    : IQueryHandler<GetGenresQuery, IReadOnlyList<GenreResponse>>
 {
+    public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
+
+    public class GetGenresQueryHandler(IDatabase database)
+        : IQueryHandler<GetGenresQuery, IReadOnlyList<GenreResponse>>
+    {
         public async ValueTask<IReadOnlyList<GenreResponse>> Handle(GetGenresQuery request, CancellationToken cancellationToken)
         {
             var rows = await database.TrackTags
                 .AsNoTracking()
-            .Where(tag => tag.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(tag => tag.Track.LifeCycleStatus == LifeCycleStatus.Active && tag.Track.IsPublished)
                 .GroupBy(tag => tag.Tag)
                 .Select(group => new { Genre = group.Key, TrackCount = group.Select(tag => tag.TrackId).Distinct().Count() })
                 .ToListAsync(cancellationToken);
@@ -26,4 +26,5 @@ public class GetGenresQueryHandler(IDatabase database)
                 .Select(row => new GenreResponse(row.Genre, row.TrackCount))
                 .ToList();
         }
+    }
 }

backend/Core/Musify.Application/Genres/Responses/AvailableGenreResponse.cs

@@ -1,5 +1,6 @@
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Genres.Responses;
+namespace Musify.Application.Genres.Responses
-
+{
-public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);
+    public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);
+}

backend/Core/Musify.Application/Genres/Responses/GenreResponse.cs

@@ -1,5 +1,6 @@
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Genres.Responses;
+namespace Musify.Application.Genres.Responses
-
+{
-public record GenreResponse(Genre Genre, int TrackCount);
+    public record GenreResponse(Genre Genre, int TrackCount);
+}

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

@@ -5,26 +5,27 @@ using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Likes;
+namespace Musify.Application.Likes
-
+{
-public record GetLikedTracksQuery(
+    public record GetLikedTracksQuery(
         long UserId,
         int PageNumber,
         int PageSize)
         : IQuery<PaginatedResponse<TrackApplicationResponse>>;
 
-public class GetLikedTracksQueryHandler(IDatabase database)
+    public class GetLikedTracksQueryHandler(IDatabase database)
         : IQueryHandler<GetLikedTracksQuery, PaginatedResponse<TrackApplicationResponse>>
-{
+    {
         public async ValueTask<PaginatedResponse<TrackApplicationResponse>> Handle(GetLikedTracksQuery request, CancellationToken cancellationToken)
         {
             return await database.TrackLikes
                 .AsNoTracking()
-            .Where(like => like.UserId == request.UserId && like.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(like => like.UserId == request.UserId && like.Track.LifeCycleStatus == LifeCycleStatus.Active && like.Track.IsPublished)
                 .OrderByDescending(like => like.CreatedAt)
                 .ThenBy(like => like.Id)
                 .Select(like => like.Track)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -7,21 +7,21 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Likes;
+namespace Musify.Application.Likes
-
+{
-public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
+    public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
         : ICommand<ErrorOr<bool>>;
 
-public class ToggleTrackLikeCommandHandler(
+    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 && t.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
+                .AnyAsync(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active && t.IsPublished, cancellationToken);
             if (!trackExists)
                 return AppErrors.NotFound("Track", request.TrackId);
 
@@ -44,7 +44,6 @@ public class ToggleTrackLikeCommandHandler(
                 nowLiked = true;
             }
 
-        // A concurrent double click can hit the unique index; the outcome is already in place, so treat it as a no-op.
             var saved = await database.TrySaveChangesAsync(
                 AppErrors.Conflict("TrackLike.Duplicate", "Track is already liked."), cancellationToken);
             if (saved.IsError)
@@ -55,4 +54,5 @@ public class ToggleTrackLikeCommandHandler(
 
             return nowLiked;
         }
+    }
 }

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

@@ -6,17 +6,17 @@ using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
+{
-public record GenerateMixesForUserCommand(long UserId)
+    public record GenerateMixesForUserCommand(long UserId)
         : ICommand;
 
-public class GenerateMixesForUserCommandHandler(
+    public class GenerateMixesForUserCommandHandler(
         IDatabase database,
         MixConfiguration mixConfiguration,
         ILogger<GenerateMixesForUserCommandHandler> logger)
         : ICommandHandler<GenerateMixesForUserCommand>
-{
+    {
         private sealed record MixDraft(MixKind Kind, IReadOnlyList<Guid> TrackIds);
 
         public async ValueTask<Unit> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
@@ -25,7 +25,7 @@ public class GenerateMixesForUserCommandHandler(
 
             var libraryTrackIds = await database.Tracks
                 .AsNoTracking()
-            .Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active && track.IsPublished)
                 .Select(track => track.Id)
                 .ToListAsync(cancellationToken);
 
@@ -79,7 +79,7 @@ public class GenerateMixesForUserCommandHandler(
         private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
             [.. trackIds.OrderBy(_ => Guid.NewGuid())];
 
-    private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
+        private static List<Guid> Interleave(List<Guid> first, List<Guid> second)
         {
             var merged = new List<Guid>(first.Count + second.Count);
             for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
@@ -127,4 +127,5 @@ public class GenerateMixesForUserCommandHandler(
                 }
             }
         }
+    }
 }

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

@@ -5,14 +5,14 @@ using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
+{
-public record GetMixByIdQuery(long UserId, Guid MixId)
+    public record GetMixByIdQuery(long UserId, Guid MixId)
         : IQuery<ErrorOr<MixApplicationResponse>>;
 
-public class GetMixByIdQueryHandler(IDatabase database)
+    public class GetMixByIdQueryHandler(IDatabase database)
         : IQueryHandler<GetMixByIdQuery, ErrorOr<MixApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<MixApplicationResponse>> Handle(GetMixByIdQuery request, CancellationToken cancellationToken)
         {
             var mix = await database.Mixes
@@ -28,4 +28,5 @@ public class GetMixByIdQueryHandler(IDatabase database)
 
             return new MixApplicationResponse(mix.Id, mix.Kind, items.Count, items);
         }
+    }
 }

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

@@ -3,14 +3,14 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
+{
-public record GetMixesByUserIdQuery(long UserId)
+    public record GetMixesByUserIdQuery(long UserId)
         : IQuery<IReadOnlyList<MixApplicationResponse>>;
 
-public class GetMixesByUserIdQueryHandler(IDatabase database)
+    public class GetMixesByUserIdQueryHandler(IDatabase database)
         : IQueryHandler<GetMixesByUserIdQuery, IReadOnlyList<MixApplicationResponse>>
-{
+    {
         public async ValueTask<IReadOnlyList<MixApplicationResponse>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
         {
             var mixes = await database.Mixes
@@ -25,7 +25,13 @@ public class GetMixesByUserIdQueryHandler(IDatabase database)
                 mix => mix.Id,
                 mix => mix.Items.OrderBy(item => item.Position).ToList());
 
-        var coverItems = orderedItemsByMix.Values
+            var visibleTrackIds = await MixItemMapper.VisibleTrackIdsAsync(
+                database, orderedItemsByMix.Values.SelectMany(items => items), cancellationToken);
+            var visibleItemsByMix = orderedItemsByMix.ToDictionary(
+                entry => entry.Key,
+                entry => entry.Value.Where(item => visibleTrackIds.Contains(item.TrackId)).ToList());
+
+            var coverItems = visibleItemsByMix.Values
                 .SelectMany(items => items.Take(MixApplicationResponse.CoverItemCount))
                 .ToList();
             var coverResponses = (await MixItemMapper.ToResponsesAsync(database, coverItems, cancellationToken))
@@ -35,7 +41,7 @@ public class GetMixesByUserIdQueryHandler(IDatabase database)
             var responses = new List<MixApplicationResponse>(mixes.Count);
             foreach (var mix in mixes)
             {
-            var orderedItems = orderedItemsByMix[mix.Id];
+                var orderedItems = visibleItemsByMix[mix.Id];
                 var covers = orderedItems
                     .Take(MixApplicationResponse.CoverItemCount)
                     .Where(item => coverResponses.ContainsKey(item.TrackId))
@@ -47,4 +53,5 @@ public class GetMixesByUserIdQueryHandler(IDatabase database)
 
             return responses;
         }
+    }
 }

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

@@ -4,11 +4,27 @@ using Musify.Application.Mixes.Responses;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
-
-internal static class MixItemMapper
 {
+
+    internal static class MixItemMapper
+    {
+        public static async Task<HashSet<Guid>> VisibleTrackIdsAsync(
+            IDatabase database,
+            IEnumerable<MixItem> items,
+            CancellationToken cancellationToken)
+        {
+            var trackIds = items.Select(item => item.TrackId).Distinct().ToList();
+
+            var visible = await database.Tracks
+                .AsNoTracking()
+                .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active && track.IsPublished)
+                .Select(track => track.Id)
+                .ToListAsync(cancellationToken);
+
+            return [.. visible];
+        }
+
         public static async Task<List<MixItemApplicationResponse>> ToResponsesAsync(
             IDatabase database,
             IReadOnlyList<MixItem> orderedItems,
@@ -19,7 +35,7 @@ internal static class MixItemMapper
             var tracksById = await database.Tracks
                 .AsNoTracking()
                 .Include(track => track.Owner)
-            .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active && track.IsPublished)
                 .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
 
@@ -37,4 +53,5 @@ internal static class MixItemMapper
                 })
                 .ToList();
         }
+    }
 }

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

@@ -1,12 +1,13 @@
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Mixes.Responses;
+namespace Musify.Application.Mixes.Responses
-
+{
-public record MixApplicationResponse(
+    public record MixApplicationResponse(
         Guid Id,
         MixKind Kind,
         int ItemCount,
         IReadOnlyList<MixItemApplicationResponse> Items)
-{
+    {
         public const int CoverItemCount = 4;
+    }
 }

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

@@ -1,8 +1,9 @@
-namespace Musify.Application.Mixes.Responses;
+namespace Musify.Application.Mixes.Responses
-
+{
-public record MixItemApplicationResponse(
+    public record MixItemApplicationResponse(
         Guid TrackId,
         string Title,
         string? Artist,
         double DurationSeconds,
         int ListensCount);
+}

backend/Core/Musify.Application/Pictures/GetCover.cs

@@ -7,38 +7,35 @@ using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Pictures;
+namespace Musify.Application.Pictures
-
-public enum CoverOwner
 {
+    public enum CoverOwner
+    {
         Track,
         Album,
         PlayList
-}
+    }
 
-public record GetCoverQuery(CoverOwner Owner, Guid Id, PictureSize Size = PictureSize.Medium)
+    public record GetCoverQuery(CoverOwner Owner, Guid Id, PictureSize Size = PictureSize.Medium)
         : IQuery<ErrorOr<CoverLocation>>;
 
-public record CoverLocation(string Bucket, string Key, string ContentType);
+    public record CoverLocation(string Bucket, string Key, string ContentType);
 
-public class GetCoverQueryHandler(
+    public class GetCoverQueryHandler(
         IDatabase database,
         ApplicationStorageConfiguration storageConfiguration,
         TrackConfiguration trackConfiguration,
         AlbumConfiguration albumConfiguration,
         PlayListConfiguration playListConfiguration)
         : IQueryHandler<GetCoverQuery, ErrorOr<CoverLocation>>
-{
+    {
         private sealed record CoverSource(long OwnerUserId, string? Original, string? Small, string? Medium, string? Large);
 
         public async ValueTask<ErrorOr<CoverLocation>> Handle(GetCoverQuery request, CancellationToken cancellationToken)
         {
             var (source, routes) = request.Owner switch
             {
-            CoverOwner.Track => (await database.Tracks.AsNoTracking()
+                CoverOwner.Track => await FindTrackSourceAsync(request.Id, cancellationToken),
-                .Where(t => t.Id == request.Id && t.LifeCycleStatus == LifeCycleStatus.Active)
-                .Select(t => new CoverSource(t.OwnerUserId, t.Pictures.OriginalName, t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName))
-                .SingleOrDefaultAsync(cancellationToken), trackConfiguration.Routes),
                 CoverOwner.Album => (await database.Albums.AsNoTracking()
                     .Where(a => a.Id == request.Id && a.LifeCycleStatus == LifeCycleStatus.Active && a.Pictures != null)
                     .Select(a => new CoverSource(a.OwnerUserId, a.Pictures!.OriginalName, a.Pictures.SmallName, a.Pictures.MediumName, a.Pictures.LargeName))
@@ -60,7 +57,6 @@ public class GetCoverQueryHandler(
                 _ => source.Medium
             };
 
-        // The resized files only exist once processing has finished; until then serve the original.
             var (name, key) = !string.IsNullOrEmpty(resizedName)
                 ? (resizedName, routes.BuildPicturePath(request.Size, resizedName))
                 : !string.IsNullOrEmpty(source.Original)
@@ -72,4 +68,34 @@ public class GetCoverQueryHandler(
 
             return new CoverLocation(storageConfiguration.Bucket, key, MimeUtility.GetMimeMapping(name));
         }
+
+        private async Task<(CoverSource? Source, PictureRoutes Routes)> FindTrackSourceAsync(Guid trackId, CancellationToken cancellationToken)
+        {
+            var track = await database.Tracks.AsNoTracking()
+                .Where(t => t.Id == trackId && t.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(t => new
+                {
+                    Own = new CoverSource(t.OwnerUserId, t.Pictures.OriginalName, t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName),
+                    Album = t.AlbumTracks
+                        .Where(albumTrack => albumTrack.Album.LifeCycleStatus == LifeCycleStatus.Active && albumTrack.Album.Pictures != null)
+                        .OrderBy(albumTrack => albumTrack.AddedAt)
+                        .ThenBy(albumTrack => albumTrack.AlbumId)
+                        .Select(albumTrack => new CoverSource(
+                            albumTrack.Album.OwnerUserId,
+                            albumTrack.Album.Pictures!.OriginalName,
+                            albumTrack.Album.Pictures.SmallName,
+                            albumTrack.Album.Pictures.MediumName,
+                            albumTrack.Album.Pictures.LargeName))
+                        .FirstOrDefault()
+                })
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if (track == null)
+                return (null, trackConfiguration.Routes);
+
+            return string.IsNullOrEmpty(track.Own.Original) && track.Album != null
+                ? (track.Album, albumConfiguration.Routes)
+                : (track.Own, trackConfiguration.Routes);
+        }
+    }
 }

backend/Core/Musify.Application/Pictures/PictureSourceChange.cs

@@ -5,13 +5,12 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Pictures;
+namespace Musify.Application.Pictures
-
-/// <summary>What an album or playlist needs to switch to a freshly uploaded picture.</summary>
-public sealed record PreparedPicture(UploadIntent Intent, EntityPictures Pictures, string FinalKey, ImageSizes Sizes);
-
-public static class PictureSourceChange
 {
+    public sealed record PreparedPicture(UploadIntent Intent, EntityPictures Pictures, string FinalKey, ImageSizes Sizes);
+
+    public static class PictureSourceChange
+    {
         public static async Task<ErrorOr<PreparedPicture>> PrepareAsync(
             UploadIntentValidator uploadIntentValidator,
             Guid intentId,
@@ -32,4 +31,5 @@ public static class PictureSourceChange
                 owner.Routes.BuildOriginalPicturePath(userId, intent.ObjectName),
                 owner.PicturesSizes.ToImageSizes(owner.Routes));
         }
+    }
 }

backend/Core/Musify.Application/Pictures/Responses/PictureUploadResponse.cs

@@ -1,6 +1,6 @@
-namespace Musify.Application.Pictures.Responses;
+namespace Musify.Application.Pictures.Responses
-
+{
-public record PictureUploadResponse(
+    public record PictureUploadResponse(
         Guid IntentId,
         string Bucket,
         string Key,
@@ -8,3 +8,4 @@ public record PictureUploadResponse(
         string ContentType,
         int ExpiresInSeconds,
         string UploadUrl);
+}

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

@@ -0,0 +1,81 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Albums.Responses;
+using Musify.Application.Contracts;
+using Musify.Application.PlayLists.Responses;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.PlayLists
+{
+    public record AddAlbumToPlayListCommand(long UserId, Guid PlayListId, Guid AlbumId)
+        : ICommand<ErrorOr<AddAlbumToPlayListResponse>>;
+
+    public class AddAlbumToPlayListCommandHandler(
+        IDatabase database,
+        ILogger<AddAlbumToPlayListCommandHandler> logger)
+        : ICommandHandler<AddAlbumToPlayListCommand, ErrorOr<AddAlbumToPlayListResponse>>
+    {
+        public async ValueTask<ErrorOr<AddAlbumToPlayListResponse>> Handle(AddAlbumToPlayListCommand request, CancellationToken cancellationToken)
+        {
+            var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (playList.IsError)
+                return playList.Errors;
+
+            var albumExists = await database.Albums
+                .AsNoTracking()
+                .Active()
+                .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
+            if (!albumExists)
+                return AppErrors.NotFound("Album", request.AlbumId);
+
+            var albumTrackIds = await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && albumTrack.Track.IsPublished)
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .Select(albumTrack => albumTrack.TrackId)
+                .ToListAsync(cancellationToken);
+
+            var playListTracksQuery = database.PlayListHasTracks
+                .Where(link => link.PlayListId == request.PlayListId);
+
+            var existingTrackIds = (await playListTracksQuery
+                .Select(link => link.TrackId)
+                .ToListAsync(cancellationToken)).ToHashSet();
+
+            var newTrackIds = albumTrackIds
+                .Where(trackId => !existingTrackIds.Contains(trackId))
+                .ToList();
+
+            if (newTrackIds.Count == 0)
+                return new AddAlbumToPlayListResponse(0);
+
+            var nextPosition = existingTrackIds.Count > 0
+               ? await playListTracksQuery.MaxAsync(link => link.Position, cancellationToken) + 1
+                : 0;
+
+            foreach (var trackId in newTrackIds)
+            {
+                await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
+                {
+                    PlayListId = request.PlayListId,
+                    TrackId = trackId,
+                    Position = nextPosition++
+                }, cancellationToken);
+            }
+
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("PlayList.ConcurrentChange", "The playlist changed while adding tracks. Try again."), cancellationToken);
+            if (saved.IsError)
+                return saved.Errors;
+
+            logger.LogInformation("Added {Count} tracks from album {AlbumId} to playlist {PlayListId}",
+                newTrackIds.Count, request.AlbumId, request.PlayListId);
+
+            return new AddAlbumToPlayListResponse(newTrackIds.Count);
+        }
+    }
+}

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

@@ -7,17 +7,16 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-/// <summary>Appends tracks to a playlist in the given order, skipping the ones it already has.</summary>
+    public record AddTracksToPlayListCommand(long UserId, Guid PlayListId, IReadOnlyList<Guid> TrackIds)
-public record AddTracksToPlayListCommand(long UserId, Guid PlayListId, IReadOnlyList<Guid> TrackIds)
         : ICommand<ErrorOr<Success>>;
 
-public class AddTracksToPlayListCommandHandler(
+    public class AddTracksToPlayListCommandHandler(
         IDatabase database,
         ILogger<AddTracksToPlayListCommandHandler> logger)
         : ICommandHandler<AddTracksToPlayListCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(AddTracksToPlayListCommand request, CancellationToken cancellationToken)
         {
             var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
@@ -28,7 +27,7 @@ public class AddTracksToPlayListCommandHandler(
 
             var existingIds = await database.Tracks
                 .AsNoTracking()
-            .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active && track.IsPublished)
                 .Select(track => track.Id)
                 .ToListAsync(cancellationToken);
 
@@ -46,10 +45,12 @@ public class AddTracksToPlayListCommandHandler(
             if (toAdd.Count == 0)
                 return Result.Success;
 
-        // Playlist positions are internal indexes, so they start at 0.
+            var playListTracksQuery = database.PlayListHasTracks
-        var nextPosition = (await database.PlayListHasTracks
+                .Where(link => link.PlayListId == request.PlayListId);
-            .Where(link => link.PlayListId == request.PlayListId)
+
-            .MaxAsync(link => (int?)link.Position, cancellationToken) ?? -1) + 1;
+            var nextPosition = await playListTracksQuery.AnyAsync(cancellationToken)
+               ? await playListTracksQuery.MaxAsync(link => link.Position, cancellationToken) + 1
+                : 0;
 
             foreach (var trackId in toAdd)
             {
@@ -70,4 +71,5 @@ public class AddTracksToPlayListCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -12,9 +12,9 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record CreatePlayListCommand(
+    public record CreatePlayListCommand(
         long UserId,
         string Name,
         string? Description,
@@ -22,14 +22,14 @@ public record CreatePlayListCommand(
         PlayListVisibility Visibility = PlayListVisibility.Private)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
-public class CreatePlayListCommandHandler(
+    public class CreatePlayListCommandHandler(
         IEventBus eventBus,
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreatePlayListCommandHandler> logger,
         PlayListConfiguration playListConfiguration)
         : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
         {
             var userExists = await database.Users
@@ -39,10 +39,10 @@ public class CreatePlayListCommandHandler(
                 return AppErrors.NotFound("User", request.UserId);
 
             PreparedPicture? picture = null;
-        if (request.PictureIntentId is { } intentId)
+            if (request.PictureIntentId.HasValue)
             {
                 var prepared = await PictureSourceChange.PrepareAsync(
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                    uploadIntentValidator, request.PictureIntentId.Value, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
                 if (prepared.IsError)
                     return prepared.Errors;
 
@@ -75,4 +75,5 @@ public class CreatePlayListCommandHandler(
 
             return PlayListApplicationResponse.FromEntity(playList);
         }
+    }
 }

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

@@ -6,17 +6,17 @@ using Musify.Application.Events;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record DeletePlayListCommand(long UserId, Guid PlayListId)
+    public record DeletePlayListCommand(long UserId, Guid PlayListId)
         : ICommand<ErrorOr<Success>>;
 
-public class DeletePlayListCommandHandler(
+    public class DeletePlayListCommandHandler(
         IDatabase database,
         IEventBus eventBus,
         ILogger<DeletePlayListCommandHandler> logger)
         : ICommandHandler<DeletePlayListCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
         {
             var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
@@ -33,4 +33,5 @@ public class DeletePlayListCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -5,14 +5,14 @@ using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
+    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
         : IQuery<ErrorOr<PlayListApplicationResponse>>;
 
-public class GetPlayListByIdQueryHandler(IDatabase database)
+    public class GetPlayListByIdQueryHandler(IDatabase database)
         : IQueryHandler<GetPlayListByIdQuery, ErrorOr<PlayListApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
         {
             var playList = await database.PlayLists
@@ -27,4 +27,5 @@ public class GetPlayListByIdQueryHandler(IDatabase database)
                 ? AppErrors.NotFound("PlayList", request.Id)
                 : playList;
         }
+    }
 }

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

@@ -7,18 +7,18 @@ using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record GetPlayListTracksQuery(
+    public record GetPlayListTracksQuery(
         Guid PlayListId,
         int PageNumber,
         int PageSize,
         long? ViewerId = null)
         : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
-public class GetPlayListTracksQueryHandler(IDatabase database)
+    public class GetPlayListTracksQueryHandler(IDatabase database)
         : IQueryHandler<GetPlayListTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
-{
+    {
         public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
         {
             var playListVisible = await database.PlayLists
@@ -31,11 +31,12 @@ public class GetPlayListTracksQueryHandler(IDatabase database)
 
             return await database.PlayListHasTracks
                 .AsNoTracking()
-            .Where(playListTrack => playListTrack.PlayListId == request.PlayListId && playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(playListTrack => playListTrack.PlayListId == request.PlayListId && playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && playListTrack.Track.IsPublished)
                 .OrderBy(playListTrack => playListTrack.Position)
                 .ThenBy(playListTrack => playListTrack.Id)
                 .Select(playListTrack => playListTrack.Track)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -4,9 +4,9 @@ using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record GetPlayListsByUserIdQuery(
+    public record GetPlayListsByUserIdQuery(
         long UserId,
         string? Name,
         int PageNumber,
@@ -14,9 +14,9 @@ public record GetPlayListsByUserIdQuery(
         long? ViewerId = null)
         : IQuery<PaginatedResponse<PlayListApplicationResponse>>;
 
-public class GetPlayListsByUserIdQueryHandler(IDatabase database)
+    public class GetPlayListsByUserIdQueryHandler(IDatabase database)
         : IQueryHandler<GetPlayListsByUserIdQuery, PaginatedResponse<PlayListApplicationResponse>>
-{
+    {
         public async ValueTask<PaginatedResponse<PlayListApplicationResponse>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
         {
             var playListsQuery = database.PlayLists
@@ -37,4 +37,5 @@ public class GetPlayListsByUserIdQueryHandler(IDatabase database)
                 .SelectResponse()
                 .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
+    }
 }

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

@@ -5,16 +5,16 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record RemoveTrackFromPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
+    public record RemoveTrackFromPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
         : ICommand<ErrorOr<Success>>;
 
-public class RemoveTrackFromPlayListCommandHandler(
+    public class RemoveTrackFromPlayListCommandHandler(
         IDatabase database,
         ILogger<RemoveTrackFromPlayListCommandHandler> logger)
         : ICommandHandler<RemoveTrackFromPlayListCommand, ErrorOr<Success>>
-{
+    {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromPlayListCommand request, CancellationToken cancellationToken)
         {
             var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
@@ -42,4 +42,5 @@ public class RemoveTrackFromPlayListCommandHandler(
 
             return Result.Success;
         }
+    }
 }

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

@@ -5,20 +5,21 @@ using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record RequestPlayListPictureUploadCommand(
+    public record RequestPlayListPictureUploadCommand(
         long UserId,
         string FileType,
         string ContentType,
         long? ExpectedSizeBytes = null)
         : ICommand<ErrorOr<PictureUploadResponse>>;
 
-public class RequestPlayListPictureUploadCommandHandler(UploadIntentIssuer issuer, PlayListConfiguration playListConfiguration)
+    public class RequestPlayListPictureUploadCommandHandler(UploadIntentIssuer issuer, PlayListConfiguration playListConfiguration)
         : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PictureUploadResponse>>
-{
+    {
         public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken) =>
             await issuer.IssuePictureAsync(
                 request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration,
                 request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
+    }
 }

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

@@ -0,0 +1,4 @@
+namespace Musify.Application.PlayLists.Responses
+{
+    public record AddAlbumToPlayListResponse(int AddedCount);
+}

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

@@ -2,9 +2,9 @@ using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
 
-namespace Musify.Application.PlayLists.Responses;
+namespace Musify.Application.PlayLists.Responses
-
+{
-public record PlayListApplicationResponse(
+    public record PlayListApplicationResponse(
         Guid Id,
         string Name,
         string? Description,
@@ -18,7 +18,7 @@ public record PlayListApplicationResponse(
         long OwnerUserId,
         int TrackCount,
         double DurationSeconds)
-{
+    {
         public const int CoverTrackCount = PlayListProjections.CoverTrackCount;
 
         public static PlayListApplicationResponse FromEntity(
@@ -42,4 +42,5 @@ public record PlayListApplicationResponse(
                 trackCount,
                 durationSeconds);
         }
+    }
 }

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

@@ -1,10 +1,10 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists.Responses;
+namespace Musify.Application.PlayLists.Responses
-
-public static class PlayListProjections
 {
+    public static class PlayListProjections
+    {
         public const int CoverTrackCount = 4;
 
         public static IQueryable<PlayList> Active(this IQueryable<PlayList> query) =>
@@ -25,13 +25,15 @@ public static class PlayListProjections
                 playList.CreatedAt,
                 playList.UpdatedAt,
                 playList.PlayListTracks
+                    .Where(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && playListTrack.Track.IsPublished)
                     .OrderBy(playListTrack => playListTrack.Position)
                     .Take(CoverTrackCount)
                     .Select(playListTrack => playListTrack.TrackId)
                     .ToList(),
                 playList.OwnerUserId,
-            playList.PlayListTracks.Count(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active),
+                playList.PlayListTracks.Count(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && playListTrack.Track.IsPublished),
                 playList.PlayListTracks
-                .Where(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                    .Where(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active && playListTrack.Track.IsPublished)
                     .Sum(playListTrack => playListTrack.Track.DurationSeconds)));
+    }
 }

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

@@ -2,34 +2,26 @@ 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.Pictures;
 using Musify.Application.PlayLists.Responses;
-using Musify.Application.Services;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
+{
-public record UpdatePlayListCommand(
+    public record UpdatePlayListCommand(
         long UserId,
         Guid PlayListId,
-    string? NewName,
+        string NewName,
         string? NewDescription,
-    Guid? NewPictureIntentId,
+        PlayListVisibility NewVisibility)
-    PlayListVisibility? NewVisibility = null)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
-public class UpdatePlayListCommandHandler(
+    public class UpdatePlayListCommandHandler(
-    IEventBus eventBus,
         IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
+        ILogger<UpdatePlayListCommandHandler> logger)
-    ILogger<UpdatePlayListCommandHandler> logger,
-    PlayListConfiguration playListConfiguration)
         : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
-{
+    {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
         {
             var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
@@ -38,34 +30,10 @@ public class UpdatePlayListCommandHandler(
 
             var playList = found.Value;
 
-        if (!string.IsNullOrWhiteSpace(request.NewName))
-        {
             playList.Name = request.NewName.Trim();
             playList.NormalizedName = TextNormalizer.Normalize(request.NewName);
-        }
-
-        // null means "unchanged"; a blank description clears it.
-        if (request.NewDescription != null)
             playList.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
-
+            playList.Visibility = request.NewVisibility;
-        if (request.NewVisibility is { } visibility)
-            playList.Visibility = visibility;
-
-        if (request.NewPictureIntentId is { } intentId)
-        {
-            var prepared = await PictureSourceChange.PrepareAsync(
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
-            if (prepared.IsError)
-                return prepared.Errors;
-
-            var picture = prepared.Value;
-            playList.Pictures = picture.Pictures;
-
-            await eventBus.PublishAsync(
-                new UpdatePlayListPictureSourceEvent(
-                    playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
-                cancellationToken);
-        }
 
             await database.SaveChangesAsync(cancellationToken);
 
@@ -77,4 +45,5 @@ public class UpdatePlayListCommandHandler(
                 .SelectResponse()
                 .SingleAsync(cancellationToken);
         }
+    }
 }

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

@@ -0,0 +1,59 @@
+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.Pictures;
+using Musify.Application.PlayLists.Responses;
+using Musify.Application.Services;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.PlayLists
+{
+    public record UpdatePlayListPictureCommand(long UserId, Guid PlayListId, Guid PictureIntentId)
+        : ICommand<ErrorOr<PlayListApplicationResponse>>;
+
+    public class UpdatePlayListPictureCommandHandler(
+        IEventBus eventBus,
+        IDatabase database,
+        UploadIntentValidator uploadIntentValidator,
+        ILogger<UpdatePlayListPictureCommandHandler> logger,
+        PlayListConfiguration playListConfiguration)
+        : ICommandHandler<UpdatePlayListPictureCommand, ErrorOr<PlayListApplicationResponse>>
+    {
+        public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListPictureCommand request, CancellationToken cancellationToken)
+        {
+            var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
+
+            var playList = found.Value;
+
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
+
+            var picture = prepared.Value;
+            playList.Pictures = picture.Pictures;
+
+            await eventBus.PublishAsync(
+                new UpdatePlayListPictureSourceEvent(
+                    playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                cancellationToken);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated picture of playlist {PlayListId}", playList.Id);
+
+            return await database.PlayLists
+                .AsNoTracking()
+                .Where(p => p.Id == playList.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
+        }
+    }
+}