Add track publication, album types, optional track pictures and batch upload URLs

Tracks
- Track.IsPublished (migration marks existing tracks as published). New
  tracks are created unpublished.
- PUT /tracks/{id}/published and PUT /tracks/published change the flag;
  publishing requires completed audio processing (the batch endpoint
  reports skipped tracks).
- An unpublished track is only visible to its owner. A WherePublished /
  VisibleTo filter is applied to search, genres, listening history, last
  listened, likes, mixes, album and playlist contents and counts, recently
  listened albums, public user tracks, track details and stream tickets.
- isPublished is part of the track responses, GET /tracks/users/{userId}
  accepts a published filter and status-counts reports published and
  unpublished totals.
- CreateTrackRequest.pictureIntentId is optional: without it the track
  uses the album cover or the preset picture and no picture processing
  runs. CreateTrackResourcesEvent carries nullable picture fields, so
  queues must be drained before deploying.
- POST /tracks/upload-urls accepts an audios list and one optional picture
  shared by all of them, and returns an intent per file. The upload intent
  limits are raised so a batch fits.

Albums
- AlbumType (Album, EP, Single) on create, update and responses.
- CreateAlbumRequest.trackIds creates the album and links the tracks in a
  single save.

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

@@ -19,7 +19,9 @@ namespace Musify.Application.Albums
         string Title,
         string? Description,
         int? ReleaseYear,
-        Guid PictureIntentId)
+        Guid PictureIntentId,
+        AlbumType Type = AlbumType.Album,
+        IReadOnlyList<Guid>? TrackIds = null)
         : ICommand<ErrorOr<AlbumApplicationResponse>>;
 
     public class CreateAlbumCommandHandler(
@@ -38,6 +40,21 @@ namespace Musify.Application.Albums
             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 @@ namespace Musify.Application.Albums
                 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,9 +90,15 @@ namespace Musify.Application.Albums
 
             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)]);
         }
     }
 }