Update naming conventions in .editorconfig and docs.editorc

Use invariant culture when formatting ids, put cancellation tokens last in endpoint handlers, remove the
CS8618 pragmas and keep only the analyzer overrides that still apply.

.claude/launch.json

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

.gitea/workflows/ci-cd.yml

@@ -0,0 +1,127 @@
+name: CI/CD
+
+on:
+  push:
+    branches: ['**']
+  pull_request:
+    branches: ['**']
+
+concurrency:
+  group: production-deploy
+  cancel-in-progress: false
+
+jobs:
+  backend-tests:
+    name: BackEnd
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    defaults:
+      run:
+        working-directory: backend
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore
+        run: dotnet restore Musify.slnx
+
+      - name: Build
+        run: dotnet build Musify.slnx --no-restore -c Release
+
+      - name: Test
+        run: dotnet test Musify.slnx --no-build -c Release
+
+  web-player-checks:
+    name: WebPlayer
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    defaults:
+      run:
+        working-directory: web-player
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: web-player/package-lock.json
+
+      - run: npm ci
+
+      - name: Type-check
+        run: npm run check
+
+      - name: Lint
+        run: npm run lint
+
+  # Runs on the production host itself, through the existing self-hosted
+  # Gitea Actions runner (act_runner), which also carries a "production"
+  # label registered in native (non-docker) mode so its steps see the host's
+  # real Docker daemon directly (Docker socket + a bind-mounted deploy
+  # directory — see deploy/README.md for how that runner is set up).
+  #
+  # DEPLOY_PATH is the persistent clone already on that host (the one whose
+  # deploy/.env.prod is filled in and matches SharedServices/.env.prod) —
+  # deploy reuses it instead of a fresh checkout, since .env.prod is
+  # untracked and only lives there.
+  deploy:
+    name: Deploy
+    needs: [backend-tests, web-player-checks]
+    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
+    runs-on: [production]
+    timeout-minutes: 20
+    env:
+      DEPLOY_PATH: /home/ubuntu/deploys/musify
+      COMPOSE: docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compose.prod.yml
+    steps:
+      - name: Pull latest master
+        run: |
+          set -euo pipefail
+          git config --global --add safe.directory "$DEPLOY_PATH"
+          cd "$DEPLOY_PATH"
+          git fetch origin master
+          git reset --hard origin/master
+
+      - name: Generate stream-ticket keys
+        run: |
+          set -euo pipefail
+          cd "$DEPLOY_PATH"
+          $COMPOSE run --rm --no-deps keys-init
+
+      # The migrations are baked into the migrator image, so it is rebuilt on
+      # every deploy (plain `up` would reuse the stale image and re-apply the
+      # old migrations). `run --rm` starts wait-for-postgres, blocks until the
+      # migration finishes and propagates its exit code, so a failed migration
+      # aborts the deploy before the new API is started against an old schema.
+      - name: Migrate database
+        run: |
+          set -euo pipefail
+          cd "$DEPLOY_PATH"
+          $COMPOSE build migrate
+          $COMPOSE run --rm migrate
+
+      # Both jobs verify themselves through the public auth./s3. URLs, served
+      # by the shared edge nginx (Infrastructure's edge/), and are idempotent.
+      - name: Create OIDC app and S3 bucket
+        run: |
+          set -euo pipefail
+          cd "$DEPLOY_PATH"
+          $COMPOSE up -d seaweedfs-init zitadel-init
+          for job in musify-seaweedfs-init musify-zitadel-init; do
+            code=$(docker wait "$job")
+            if [ "$code" != "0" ]; then
+              docker logs "$job"
+              echo "$job exited with $code"
+              exit 1
+            fi
+          done
+
+      - name: Build and start apps
+        run: |
+          set -euo pipefail
+          cd "$DEPLOY_PATH"
+          $COMPOSE --profile apps up -d --build api worker gateway web-player

.gitignore

@@ -7,6 +7,9 @@ obj/
 *.userosscache
 .vs/
 artifacts/
+TestResults/
+*.trx
+*.coverage
 
 # Rider / VS
 .idea/
@@ -25,5 +28,4 @@ Thumbs.db
 # Deploy secrets and runtime state
 deploy/keys/
 deploy/secrets/
-deploy/nginx/certs/
 deploy/zitadel/.output/

README.md

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

backend/.editorconfig

@@ -0,0 +1,79 @@
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+
+[*.{csproj,props,targets,slnx,xml}]
+indent_size = 2
+
+[*.json]
+indent_size = 4
+
+[**/Migrations/**.cs]
+generated_code = true
+
+[*.cs]
+indent_size = 4
+
+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
+dotnet_diagnostic.IDE0005.severity = warning
+
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+csharp_prefer_braces = when_multiline:warning
+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 = 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_style.underscore_camel_case.capitalization = camel_case
+dotnet_naming_style.underscore_camel_case.required_prefix = _
+
+# Non-private fields (constants, static readonly, etc.) are PascalCase.
+dotnet_naming_rule.other_fields.symbols = other_fields
+dotnet_naming_rule.other_fields.style = pascal_case
+dotnet_naming_rule.other_fields.severity = warning
+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
+
+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.CA1716.severity = suggestion
+# The routing slip builders are stateless services resolved from DI; they stay instance members.
+dotnet_diagnostic.CA1822.severity = suggestion
+
+# Test names follow Method_Scenario_Expected.
+[Tests/**.cs]
+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/AddTrackToAlbum.cs

@@ -1,85 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.Albums
-{
-    public record AddTrackToAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
-        : ICommand<ErrorOr<Success>>;
-
-    public class AddTrackToAlbumCommandHandler(
-        IDatabase database,
-        ILogger<AddTrackToAlbumCommandHandler> logger)
-        : ICommandHandler<AddTrackToAlbumCommand, ErrorOr<Success>>
-    {
-        public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
-        {
-            var album = await database.UserAlbums
-                .AsNoTracking()
-                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
-            {
-                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound();
-            }
-
-            if (album.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
-                return Error.Unauthorized();
-            }
-
-            var trackExists = await database.Tracks
-                .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (!trackExists)
-            {
-                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                return Error.NotFound(description: $"Track {request.TrackId} not found");
-            }
-
-            var localTrack = await database.LocalTracks
-                .AsNoTracking()
-                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (localTrack is not null && localTrack.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} does not own track {TrackId}", request.UserId, request.TrackId);
-                return Error.Unauthorized();
-            }
-
-            var alreadyAdded = await database.AlbumHasTracks
-                .AsNoTracking()
-                .AnyAsync(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.TrackId == request.TrackId, cancellationToken);
-            if (alreadyAdded)
-            {
-                logger.LogInformation("Track {TrackId} already in album {AlbumId}", request.TrackId, request.AlbumId);
-                return Error.Conflict(description: "Track is already in the album.");
-            }
-
-            var albumTracksQuery = database.AlbumHasTracks
-                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
-
-            var hasTracks = await albumTracksQuery.AnyAsync(cancellationToken);
-            var nextTrackNumber = hasTracks
-                ? await albumTracksQuery.MaxAsync(albumTrack => albumTrack.TrackNumber, cancellationToken) + 1
-                : 1;
-
-            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
-            {
-                AlbumId = request.AlbumId,
-                TrackId = request.TrackId,
-                TrackNumber = nextTrackNumber
-            }, cancellationToken);
-
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Added track {TrackId} to album {AlbumId} as number {TrackNumber}",
-                request.TrackId, request.AlbumId, nextTrackNumber);
-
-            return new Success();
-        }
-    }
-}

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

@@ -0,0 +1,78 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+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)
+        : ICommand<ErrorOr<Success>>;
+
+    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);
+            if (album.IsError)
+                return album.Errors;
+
+            var requestedIds = request.TrackIds.Distinct().ToList();
+
+            var tracks = await database.Tracks
+                .AsNoTracking()
+                .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => new { track.Id, track.OwnerUserId })
+                .ToListAsync(cancellationToken);
+
+            var missing = requestedIds.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 alreadyInAlbum = await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(link => link.AlbumId == request.AlbumId && requestedIds.Contains(link.TrackId))
+                .Select(link => link.TrackId)
+                .ToListAsync(cancellationToken);
+
+            var toAdd = requestedIds.Where(id => !alreadyInAlbum.Contains(id)).ToList();
+            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;
+
+            foreach (var trackId in toAdd)
+            {
+                await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
+                {
+                    AlbumId = request.AlbumId,
+                    TrackId = trackId,
+                    TrackNumber = nextTrackNumber++
+                }, cancellationToken);
+            }
+
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("Album.ConcurrentChange", "The album changed while adding tracks. Try again."), cancellationToken);
+            if (saved.IsError)
+                return saved;
+
+            logger.LogInformation("Added {Count} tracks to album {AlbumId}", toAdd.Count, request.AlbumId);
+
+            return Result.Success;
+        }
+    }
+}

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

@@ -2,14 +2,15 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Shared;
-using Musify.Application.Events;
 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.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.Albums
 {
@@ -26,9 +27,7 @@ namespace Musify.Application.Albums
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreateAlbumCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        AlbumConfiguration albumConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        AlbumConfiguration albumConfiguration)
         : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
@@ -37,92 +36,38 @@ namespace Musify.Application.Albums
                 .AsNoTracking()
                 .AnyAsync(user => user.Id == request.UserId, cancellationToken);
             if (!userExists)
-            {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
-            }
+                return AppErrors.NotFound("User", request.UserId);
 
-            var pictureIntent = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration, request.PictureIntentId, request.UserId, cancellationToken);
-            if (pictureIntent.IsError)
-                return pictureIntent.Errors;
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
 
-            var intent = pictureIntent.Value;
+            var picture = prepared.Value;
             var title = request.Title.Trim();
 
-            var album = new UserAlbum
+            var album = new Album
             {
                 OwnerUserId = request.UserId,
                 Title = title,
-                NormalizedTitle = title.ToUpperInvariant(),
+                NormalizedTitle = TextNormalizer.Normalize(title),
                 Description = request.Description,
                 ReleaseYear = request.ReleaseYear,
-                Pictures = new AlbumPictures
-                {
-                    OriginalName = intent.ObjectName,
-                    SmallName = intent.ObjectName,
-                    MediumName = intent.ObjectName,
-                    LargeName = intent.ObjectName
-                }
+                Pictures = picture.Pictures
             };
 
-            await database.UserAlbums.AddAsync(album, cancellationToken);
+            await database.Albums.AddAsync(album, cancellationToken);
 
-            var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
-            var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);
-            if (publishResult.IsError)
-                return publishResult.Errors;
+            await eventBus.PublishAsync(
+                new CreateAlbumResourcesEvent(
+                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                cancellationToken);
 
-            try
-            {
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to save album for user {UserId}", request.UserId);
-                return Error.Failure(description: $"Failed to create album for user {request.UserId}");
-            }
 
             logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
 
             return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
         }
-
-        private async Task<ErrorOr<Success>> PublishCreateAlbumEventAsync(
-            Guid albumId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
-                await eventBus.PublishAsync(
-                    new CreateAlbumResourcesEvent(
-                        albumId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            albumConfiguration.Routes.SmallPicturesPath,
-                            albumConfiguration.PicturesSizes.SmallPictureWidth,
-                            albumConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            albumConfiguration.Routes.MediumPicturesPath,
-                            albumConfiguration.PicturesSizes.MediumPictureWidth,
-                            albumConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            albumConfiguration.Routes.LargePicturesPath,
-                            albumConfiguration.PicturesSizes.LargePictureWidth,
-                            albumConfiguration.PicturesSizes.LargePictureHeight)),
-                    cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish create album event for album {AlbumId}", albumId);
-                return Error.Failure(description: $"Failed to publish create album event for album {albumId}");
-            }
-        }
     }
 }

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

@@ -1,8 +1,10 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Albums
 {
@@ -11,40 +13,25 @@ namespace Musify.Application.Albums
 
     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 album = await database.UserAlbums
-                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
-            {
-                logger.LogDebug("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound();
-            }
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
-            if (album.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
-                return Error.Unauthorized();
-            }
+            var album = found.Value;
+            album.LifeCycleStatus = LifeCycleStatus.Removing;
 
-            database.UserAlbums.Remove(album);
-
-            try
-            {
+            await eventBus.PublishAsync(new DeleteAlbumEvent(album.Id, request.UserId), cancellationToken);
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to delete album {AlbumId}", request.AlbumId);
-                return Error.Failure(description: $"Failed to delete album {request.AlbumId}");
-            }
 
-            logger.LogInformation("Deleted album {AlbumId} for user {UserId}", request.AlbumId, request.UserId);
+            logger.LogInformation("Marked album {AlbumId} as removing", request.AlbumId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Albums
 {
@@ -14,25 +15,16 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
+                .Active()
                 .Where(a => a.Id == request.Id)
-                .Select(a => new
-                {
-                    Album = a,
-                    TrackCount = a.AlbumTracks.Count,
-                    CoverTrackIds = a.AlbumTracks
-                        .OrderBy(albumTrack => albumTrack.TrackNumber)
-                        .Take(AlbumApplicationResponse.CoverTrackCount)
-                        .Select(albumTrack => albumTrack.TrackId)
-                        .ToList()
-                })
+                .SelectResponse()
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (album is null)
-                return Error.NotFound();
-
-            return AlbumApplicationResponse.FromEntity(album.Album, album.TrackCount, album.CoverTrackIds);
+            return album == null
+                ? AppErrors.NotFound("Album", request.Id)
+                : album;
         }
     }
 }

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

@@ -1,49 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using MimeMapping;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.Albums
-{
-    public record GetAlbumCoverQuery(Guid AlbumId, string Size)
-        : IQuery<ErrorOr<AlbumCoverLocation>>;
-
-    public record AlbumCoverLocation(string Bucket, string Key, string ContentType);
-
-    public class GetAlbumCoverQueryHandler(
-        IDatabase database,
-        ApplicationStorageConfiguration storageConfiguration,
-        AlbumConfiguration albumConfiguration)
-        : IQueryHandler<GetAlbumCoverQuery, ErrorOr<AlbumCoverLocation>>
-    {
-        public async ValueTask<ErrorOr<AlbumCoverLocation>> Handle(GetAlbumCoverQuery request, CancellationToken cancellationToken)
-        {
-            var pictures = await database.Albums.AsNoTracking()
-                .Where(a => a.Id == request.AlbumId)
-                .Select(a => a.Pictures)
-                .SingleOrDefaultAsync(cancellationToken);
-
-            if (pictures is null)
-                return Error.NotFound();
-
-            var routes = albumConfiguration.Routes;
-            var (name, key) = request.Size.ToLowerInvariant() switch
-            {
-                "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
-                "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
-                _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
-            };
-
-            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
-                return Error.NotFound();
-
-            var contentType = MimeUtility.GetMimeMapping(name);
-            return new AlbumCoverLocation(storageConfiguration.Bucket, key, contentType);
-        }
-
-        private static string? BuildKey(Func<string, string> builder, string? name)
-            => string.IsNullOrEmpty(name) ? null : builder(name);
-    }
-}

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

@@ -1,12 +1,10 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
+using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
@@ -23,29 +21,19 @@ namespace Musify.Application.Albums
         {
             var albumExists = await database.Albums
                 .AsNoTracking()
+                .Active()
                 .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
             if (!albumExists)
-                return Error.NotFound();
+                return AppErrors.NotFound("Album", request.AlbumId);
 
-            var tracksQuery = database.AlbumHasTracks
+            return await database.AlbumHasTracks
                 .AsNoTracking()
-                .Include(albumTrack => ((ExternalTrack)albumTrack.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(albumTrack => ((LocalTrack)albumTrack.Track).Owner)
-                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
-
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
                 .OrderBy(albumTrack => albumTrack.TrackNumber)
-                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
-                pagedEntities.Select(entry => TrackApplicationResponse.FromEntity(entry.Track, entry.ListensCount)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+                .ThenBy(albumTrack => albumTrack.Id)
+                .Select(albumTrack => albumTrack.Track)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

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

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

@@ -4,8 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
@@ -21,33 +19,16 @@ namespace Musify.Application.Albums
                 .AsNoTracking()
                 .AnyAsync(user => user.Id == request.UserId, cancellationToken);
             if (!userExists)
-                return Error.NotFound(description: $"User {request.UserId} not found");
+                return AppErrors.NotFound("User", request.UserId);
 
-            var albumsQuery = database.UserAlbums
+            return await database.Albums
                 .AsNoTracking()
-                .Where(album => album.OwnerUserId == request.UserId);
-
-            var totalCount = await albumsQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await albumsQuery
+                .Active()
+                .Where(album => album.OwnerUserId == request.UserId)
                 .OrderByDescending(album => album.CreatedAt)
-                .Select(album => new
-                {
-                    Album = album,
-                    TrackCount = album.AlbumTracks.Count,
-                    CoverTrackIds = album.AlbumTracks
-                        .OrderBy(albumTrack => albumTrack.TrackNumber)
-                        .Take(AlbumApplicationResponse.CoverTrackCount)
-                        .Select(albumTrack => albumTrack.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedAlbums = new StaticPagedList<AlbumApplicationResponse>(
-                pagedEntities.Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<AlbumApplicationResponse>.FromPagedList(pagedAlbums);
+                .ThenBy(album => album.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -1,4 +1,3 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
@@ -7,54 +6,46 @@ using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
     public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
-        : IQuery<ErrorOr<IReadOnlyList<AlbumApplicationResponse> >>;
+        : IQuery<IReadOnlyList<AlbumApplicationResponse>>;
 
     public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
-        : IQueryHandler<GetRecentlyListenedAlbumsQuery, ErrorOr<IReadOnlyList<AlbumApplicationResponse>>>
+        : IQueryHandler<GetRecentlyListenedAlbumsQuery, IReadOnlyList<AlbumApplicationResponse>>
     {
-        public async ValueTask<ErrorOr<IReadOnlyList<AlbumApplicationResponse>>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
+        public async ValueTask<IReadOnlyList<AlbumApplicationResponse>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
         {
-            var listenedTrackIds = database.ListeningHistories
+            var listens = database.ListeningHistories
                 .AsNoTracking()
-                .Where(history => history.UserId == request.UserId);
+                .Where(history => history.UserId == request.UserId && history.IsCounted);
 
             var ranked = await database.AlbumHasTracks
                 .AsNoTracking()
+                .Where(albumTrack => albumTrack.Album.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
                 .Join(
-                    listenedTrackIds,
+                    listens,
                     albumTrack => albumTrack.TrackId,
                     history => history.TrackId,
                     (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt })
                 .GroupBy(entry => entry.AlbumId)
                 .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) })
                 .OrderByDescending(entry => entry.LastListenedAt)
+                .ThenBy(entry => entry.AlbumId)
                 .Take(request.Limit)
                 .ToListAsync(cancellationToken);
 
             if (ranked.Count == 0)
-                return new List<AlbumApplicationResponse>();
+                return [];
 
             var albumIds = ranked.Select(entry => entry.AlbumId).ToList();
 
-            var albums = await database.Albums
+            var albumsById = await database.Albums
                 .AsNoTracking()
                 .Where(album => albumIds.Contains(album.Id))
-                .Select(album => new
-                {
-                    Album = album,
-                    TrackCount = album.AlbumTracks.Count,
-                    CoverTrackIds = album.AlbumTracks
-                        .OrderBy(albumTrack => albumTrack.TrackNumber)
-                        .Take(AlbumApplicationResponse.CoverTrackCount)
-                        .Select(albumTrack => albumTrack.TrackId)
-                        .ToList()
-                } )
-                .ToDictionaryAsync(entry => entry.Album.Id, cancellationToken);
+                .SelectResponse()
+                .ToDictionaryAsync(album => album.Id, cancellationToken);
 
             return ranked
-                .Where(entry => albums.ContainsKey(entry.AlbumId))
-                .Select(entry => albums[entry.AlbumId])
-                .Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds))
+                .Where(entry => albumsById.ContainsKey(entry.AlbumId))
+                .Select(entry => albumsById[entry.AlbumId])
                 .ToList();
         }
     }

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Albums
 {
@@ -16,20 +17,9 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
-                .AsNoTracking()
-                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
-            {
-                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound();
-            }
-
-            if (album.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
-                return Error.Unauthorized();
-            }
+            var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (album.IsError)
+                return album.Errors;
 
             var albumTracks = await database.AlbumHasTracks
                 .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
@@ -37,11 +27,8 @@ namespace Musify.Application.Albums
                 .ToListAsync(cancellationToken);
 
             var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
-            if (link is null)
-            {
-                logger.LogInformation("Track {TrackId} not in album {AlbumId}", request.TrackId, request.AlbumId);
-                return Error.NotFound(description: "Track is not in the album.");
-            }
+            if (link == null)
+                return Error.NotFound("Album.TrackNotFound", "Track is not in the album.");
 
             database.AlbumHasTracks.Remove(link);
 
@@ -53,7 +40,7 @@ namespace Musify.Application.Albums
 
             logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

@@ -1,13 +1,9 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Albums.Responses;
+using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.Albums
 {
@@ -16,90 +12,14 @@ namespace Musify.Application.Albums
         string FileType,
         string ContentType,
         long? ExpectedSizeBytes = null)
-        : ICommand<ErrorOr<AlbumPictureUploadResponse>>;
+        : ICommand<ErrorOr<PictureUploadResponse>>;
 
-    public class RequestAlbumPictureUploadCommandHandler(
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        IStorageService storageService,
-        ILogger<RequestAlbumPictureUploadCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        AlbumConfiguration albumConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<AlbumPictureUploadResponse>>
+    public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
+        : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<PictureUploadResponse>>
     {
-        public async ValueTask<ErrorOr<AlbumPictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken)
-        {
-            var userExists = await database.Users
-                .AsNoTracking()
-                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-            if (!userExists)
-            {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
-            }
-
-            var effectiveSizeBytes = request.ExpectedSizeBytes
-                ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
-
-            var objectName = $"{Guid.NewGuid() }.{request.FileType.TrimStart('.').ToLowerInvariant() }";
-
-            var tempKey = albumConfiguration.Routes.BuildTempPicturePath(
-                uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
-
-            try
-            {
-                var uploadUrl = await storageService.GetUploadUrlAsync(
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    request.ContentType,
-                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                    cancellationToken);
-
-                await using var transaction = await database.BeginTransactionAsync(
-                    System.Data.IsolationLevel.Serializable, cancellationToken);
-
-                var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
-                    uploadIntentConfiguration,
-                    request.UserId, effectiveSizeBytes, 1, cancellationToken);
-                if (quotaCheck.IsError)
-                {
-                    logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
-                    return quotaCheck.Errors;
-                }
-
-                var intent = new UploadIntent
-                {
-                    UserId = request.UserId,
-                    Bucket = storageConfiguration.Bucket,
-                    Key = tempKey,
-                    ObjectName = objectName,
-                    ContentType = request.ContentType,
-                    ExpectedSizeBytes = effectiveSizeBytes,
-                    Purpose = UploadIntentPurpose.AlbumPicture,
-                    ExpiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                };
-
-                await database.UploadIntents.AddAsync(intent, cancellationToken);
-                await database.SaveChangesAsync(cancellationToken);
-                await transaction.CommitAsync(cancellationToken);
-
-                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (AlbumPicture, temp key: {Key} )", intent.Id, request.UserId, tempKey);
-
-                return new AlbumPictureUploadResponse(
-                    intent.Id,
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    objectName,
-                    request.ContentType,
-                    uploadIntentConfiguration.UploadUrlExpiresInSeconds,
-                    uploadUrl);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to generate album picture upload URL for user {UserId}", request.UserId);
-                return Error.Failure(description: "Failed to generate upload URL");
-            }
-        }
+        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,17 +1,7 @@
-using System.Text.Json.Serialization;
 using Musify.Domain.Entities;
 
 namespace Musify.Application.Albums.Responses
 {
-    // [JsonPolymorphic]/[JsonDerivedType] are required here, not optional: without them
-    // System.Text.Json serializes strictly by the declared CLR type at each call site
-    // (AlbumApplicationResponse, both as a bare return type and nested inside
-    // AlbumSearchItemResponse.Album), so an ExternalAlbumApplicationResponse instance would
-    // silently lose ExternalId/ThumbnailUrl on the wire. This also gives every response a
-    // "source" discriminator field for free, matching AlbumSearchItemResponse.Source.
-    [JsonPolymorphic(TypeDiscriminatorPropertyName = "source")]
-    [JsonDerivedType(typeof(AlbumApplicationResponse), typeDiscriminator: "Local")]
-    [JsonDerivedType(typeof(ExternalAlbumApplicationResponse), typeDiscriminator: "YouTube")]
     public record AlbumApplicationResponse(
         Guid Id,
         string Title,
@@ -26,10 +16,10 @@ namespace Musify.Application.Albums.Responses
         DateTime UpdatedAt,
         IReadOnlyList<Guid> CoverTrackIds)
     {
-        public const int CoverTrackCount = 4;
+        public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
 
         public static AlbumApplicationResponse FromEntity(
-            UserAlbum album,
+            Album album,
             int trackCount,
             IReadOnlyList<Guid>? coverTrackIds = null)
         {
@@ -47,18 +37,5 @@ namespace Musify.Application.Albums.Responses
                 album.UpdatedAt,
                 coverTrackIds ?? []);
         }
-
-        public static AlbumApplicationResponse FromEntity(
-            Album album,
-            int trackCount,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return album switch
-            {
-                ExternalAlbum externalAlbum => ExternalAlbumApplicationResponse.FromEntity(externalAlbum, trackCount, coverTrackIds),
-                UserAlbum userAlbum => FromEntity(userAlbum, trackCount, coverTrackIds),
-                _ => throw new NotSupportedException($"Unsupported album entity type '{album.GetType().Name}'.")
-            };
-        }
     }
 }

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

@@ -0,0 +1,32 @@
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Albums.Responses
+{
+    public static class AlbumProjections
+    {
+        public const int CoverTrackCount = 4;
+
+        public static IQueryable<Album> Active(this IQueryable<Album> query) =>
+            query.Where(album => album.LifeCycleStatus == LifeCycleStatus.Active);
+
+        public static IQueryable<AlbumApplicationResponse> SelectResponse(this IQueryable<Album> query) =>
+            query.Select(album => new AlbumApplicationResponse(
+                album.Id,
+                album.Title,
+                album.Description,
+                album.ReleaseYear,
+                album.OwnerUserId,
+                album.AlbumTracks.Count,
+                album.Pictures!.SmallName,
+                album.Pictures!.MediumName,
+                album.Pictures!.LargeName,
+                album.CreatedAt,
+                album.UpdatedAt,
+                album.AlbumTracks
+                    .OrderBy(albumTrack => albumTrack.TrackNumber)
+                    .Take(CoverTrackCount)
+                    .Select(albumTrack => albumTrack.TrackId)
+                    .ToList()));
+    }
+}

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

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

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

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

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

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

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

@@ -2,14 +2,14 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Shared;
-using Musify.Application.Events;
 using Musify.Application.Albums.Responses;
-using Musify.Application.Services;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
+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
 {
@@ -27,126 +27,48 @@ namespace Musify.Application.Albums
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<UpdateAlbumCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        AlbumConfiguration albumConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        AlbumConfiguration albumConfiguration)
         : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
-                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album is null)
-            {
-                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound();
-            }
-
-            if (album.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
-                return Error.Unauthorized();
-            }
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
+            var album = found.Value;
             var title = request.Title.Trim();
 
             album.Title = title;
-            album.NormalizedTitle = title.ToUpperInvariant();
+            album.NormalizedTitle = TextNormalizer.Normalize(title);
             album.Description = request.Description;
             album.ReleaseYear = request.ReleaseYear;
 
-            UploadIntent? pictureIntent = null;
-            string? finalPictureKey = null;
-
-            if (request.NewPictureIntentId.HasValue)
+            if (request.NewPictureIntentId is { } intentId)
             {
-                var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                    uploadIntentConfiguration,
-                    request.NewPictureIntentId.Value, request.UserId, cancellationToken);
-                if (validation.IsError)
-                    return validation.Errors;
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
 
-                pictureIntent = validation.Value;
-                album.Pictures = new AlbumPictures
-                {
-                    OriginalName = pictureIntent.ObjectName,
-                    SmallName = pictureIntent.ObjectName,
-                    MediumName = pictureIntent.ObjectName,
-                    LargeName = pictureIntent.ObjectName
-                };
-                finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
-            }
+                var picture = prepared.Value;
+                album.Pictures = picture.Pictures;
 
-            database.UserAlbums.Update(album);
-
-            if (pictureIntent != null && finalPictureKey != null)
-            {
-                var publishResult = await PublishUpdateAlbumPictureSourceEventAsync(
-                    album.Id, pictureIntent, finalPictureKey, cancellationToken);
-                if (publishResult.IsError)
-                    return publishResult.Errors;
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to update album {AlbumId}", request.AlbumId);
-                return Error.Failure(description: $"Failed to update album {request.AlbumId}");
-            }
-
-            var albumTracks = database.AlbumHasTracks
-                .AsNoTracking()
-                .Where(albumTrack => albumTrack.AlbumId == album.Id);
-
-            var trackCount = await albumTracks.CountAsync(cancellationToken);
-            var coverTrackIds = await albumTracks
-                .OrderBy(albumTrack => albumTrack.TrackNumber)
-                .Take(AlbumApplicationResponse.CoverTrackCount)
-                .Select(albumTrack => albumTrack.TrackId)
-                .ToListAsync(cancellationToken);
-
-            logger.LogInformation("Updated album {AlbumId}", album.Id);
-            return AlbumApplicationResponse.FromEntity(album, trackCount, coverTrackIds);
-        }
-
-        private async Task<ErrorOr<Success>> PublishUpdateAlbumPictureSourceEventAsync(
-            Guid albumId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
                 await eventBus.PublishAsync(
                     new UpdateAlbumPictureSourceEvent(
-                        albumId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            albumConfiguration.Routes.SmallPicturesPath,
-                            albumConfiguration.PicturesSizes.SmallPictureWidth,
-                            albumConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            albumConfiguration.Routes.MediumPicturesPath,
-                            albumConfiguration.PicturesSizes.MediumPictureWidth,
-                            albumConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            albumConfiguration.Routes.LargePicturesPath,
-                            albumConfiguration.PicturesSizes.LargePictureWidth,
-                            albumConfiguration.PicturesSizes.LargePictureHeight)),
+                        album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                     cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish update album picture source event for album {AlbumId}", albumId);
-                return Error.Failure(description: $"Failed to publish update album picture source event for album {albumId}");
             }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated album {AlbumId}", album.Id);
+
+            return await database.Albums
+                .AsNoTracking()
+                .Where(a => a.Id == album.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
         }
     }
 }

backend/Core/Musify.Application/Application.csproj

@@ -19,8 +19,6 @@
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
     <PackageReference Include="Microsoft.Extensions.Options.DataAnnotations" />
     <PackageReference Include="MimeMapping" />
-    <PackageReference Include="X.PagedList" />
-    <PackageReference Include="X.PagedList.EF" />
   </ItemGroup>
 
   <ItemGroup>

backend/Core/Musify.Application/ApplicationDependencyInjection.cs

@@ -3,26 +3,27 @@ using Microsoft.Extensions.DependencyInjection;
 using Musify.Application.Configuration;
 using Musify.Application.Services;
 
-namespace Musify.Application;
-
+namespace Musify.Application
+{
     public static class ApplicationDependencyInjection
     {
         public static IServiceCollection AddApplication(this IServiceCollection services, IConfiguration configuration)
         {
             services.AddMediator();
             services.AddScoped<UploadIntentValidator>();
+            services.AddScoped<UploadIntentIssuer>();
             services.AddScoped<TrackStreamIssuer>();
-        services.AddScoped<YouTubeTrackProvisioner>();
 
-        services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration, ApplicationStorageConfiguration.SectionName);
-        services.AddValidatedOptions<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName);
-        services.AddValidatedOptions<AlbumConfiguration>(configuration, AlbumConfiguration.SectionName);
-        services.AddValidatedOptions<TrackConfiguration>(configuration, TrackConfiguration.SectionName);
-        services.AddValidatedOptions<MixConfiguration>(configuration, MixConfiguration.SectionName);
-        services.AddValidatedOptions<StreamGatewayConfiguration>(configuration, StreamGatewayConfiguration.SectionName);
-        services.AddValidatedOptions<UploadIntentConfiguration>(configuration, UploadIntentConfiguration.SectionName);
-        services.AddValidatedOptions<PlaybackConfiguration>(configuration, PlaybackConfiguration.SectionName);
+            services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration);
+            services.AddValidatedOptions<PlayListConfiguration>(configuration);
+            services.AddValidatedOptions<AlbumConfiguration>(configuration);
+            services.AddValidatedOptions<TrackConfiguration>(configuration);
+            services.AddValidatedOptions<MixConfiguration>(configuration);
+            services.AddValidatedOptions<StreamGatewayConfiguration>(configuration);
+            services.AddValidatedOptions<UploadIntentConfiguration>(configuration);
+            services.AddValidatedOptions<PlaybackConfiguration>(configuration);
 
             return services;
         }
     }
+}

backend/Core/Musify.Application/AssemblyInfo.cs

@@ -1,4 +1,4 @@
-using Mediator;
+using Mediator;
 using Microsoft.Extensions.DependencyInjection;
 
 [assembly: MediatorOptions(ServiceLifetime = ServiceLifetime.Scoped)]

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

@@ -1,79 +1,15 @@
 using System.ComponentModel.DataAnnotations;
-using Musify.Application.Shared;
 
 namespace Musify.Application.Configuration
 {
-    public class AlbumConfiguration
+    public class AlbumConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
     {
-        public const string SectionName = "Album";
+        public static string SectionName => "Album";
 
         [Required]
-        public AlbumRoutes Routes { get; set; } = new AlbumRoutes();
+        public PictureRoutes Routes { get; set; } = new() { ParentFolder = "Albums" };
 
         [Required]
-        public AlbumPicturesSizes PicturesSizes { get; set; } = new AlbumPicturesSizes();
-    }
-
-    public class AlbumRoutes
-    {
-        [Required]
-        public string UploadsFolder { get; set; } = "uploads";
-
-        [Required]
-        public string ParentFolders { get; set; } = "Albums";
-
-        [Required]
-        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
-
-        [Required]
-        public string SmallPicturesFolder { get; set; } = "SmallPictures";
-
-        [Required]
-        public string MediumPicturesFolder { get; set; } = "MediumPictures";
-
-        [Required]
-        public string LargePicturesFolder { get; set; } = "LargePictures";
-
-        public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
-
-        public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
-
-        public string LargePicturesPath => StorageKey.Combine(ParentFolders, LargePicturesFolder);
-
-        public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
-
-        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
-
-        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);
-
-        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, SmallPicturesFolder, pictureName);
-
-        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, MediumPicturesFolder, pictureName);
-
-        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(ParentFolders, LargePicturesFolder, pictureName);
-
-        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
-            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolders, objectName);
-    }
-
-    public class AlbumPicturesSizes
-    {
-        [Range(1, 1024)]
-        public int SmallPictureWidth { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int SmallPictureHeight { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int MediumPictureWidth { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int MediumPictureHeight { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int LargePictureWidth { get; set; } = 512;
-
-        [Range(1, 1024)]
-        public int LargePictureHeight { get; set; } = 512;
+        public PictureSizes PicturesSizes { get; set; } = new();
     }
 }

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

@@ -2,9 +2,9 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    public class ApplicationStorageConfiguration
+    public class ApplicationStorageConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "ApplicationStorage";
+        public static string SectionName => "ApplicationStorage";
 
         [Required]
         [StringLength(128, MinimumLength = 1)]

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

@@ -2,10 +2,14 @@ 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 IServiceCollection AddValidatedOptions<T>(this IServiceCollection services, IConfiguration configuration)
+            where T : class, IConfigurationOptions =>
+            services.AddValidatedOptions<T>(configuration, T.SectionName);
+
         public static IServiceCollection AddValidatedOptions<T>(
             this IServiceCollection services,
             IConfiguration configuration,
@@ -23,3 +27,4 @@ public static class ConfigurationDependencyInjection
             return services;
         }
     }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,92 @@
+using System.ComponentModel.DataAnnotations;
+using System.Globalization;
+using Musify.Application.Shared;
+
+namespace Musify.Application.Configuration
+{
+    public enum PictureSize
+    {
+        Small,
+        Medium,
+        Large
+    }
+
+    public class PictureRoutes
+    {
+        [Required]
+        public string UploadsFolder { get; set; } = "uploads";
+
+        [Required]
+        public string ParentFolder { get; set; } = string.Empty;
+
+        [Required]
+        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
+
+        [Required]
+        public string SmallPicturesFolder { get; set; } = "SmallPictures";
+
+        [Required]
+        public string MediumPicturesFolder { get; set; } = "MediumPictures";
+
+        [Required]
+        public string LargePicturesFolder { get; set; } = "LargePictures";
+
+        public string FolderPath(PictureSize size) => StorageKey.Combine(ParentFolder, size switch
+        {
+            PictureSize.Small => SmallPicturesFolder,
+            PictureSize.Medium => MediumPicturesFolder,
+            PictureSize.Large => LargePicturesFolder,
+            _ => throw new ArgumentOutOfRangeException(nameof(size), size, null)
+        });
+
+        public string BuildPicturePath(PictureSize size, string pictureName) => StorageKey.Combine(FolderPath(size), pictureName);
+
+        public string BuildOriginalPicturePath(long userId, string 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(CultureInfo.InvariantCulture), ParentFolder, objectName);
+    }
+
+    public class PictureSizes
+    {
+        [Range(1, 1024)]
+        public int SmallWidth { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int SmallHeight { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int MediumWidth { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int MediumHeight { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int LargeWidth { get; set; } = 512;
+
+        [Range(1, 1024)]
+        public int LargeHeight { get; set; } = 512;
+
+        public ImageSizes ToImageSizes(PictureRoutes routes) => new(
+            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 PictureRoutes Routes { get; }
+
+        public PictureSizes PicturesSizes { get; }
+    }
+
+    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,101 +1,15 @@
 using System.ComponentModel.DataAnnotations;
-using Musify.Application.Shared;
 
 namespace Musify.Application.Configuration
 {
-    public class PlayListConfiguration
+    public class PlayListConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
     {
-        public const string SectionName = "PlayList";
+        public static string SectionName => "PlayList";
 
         [Required]
-        public PlayListRoutes Routes { get; set; } = new PlayListRoutes();
+        public PictureRoutes Routes { get; set; } = new() { ParentFolder = "PlayLists" };
 
         [Required]
-        public PlayListPicturesSizes PicturesSizes { get; set; } = new PlayListPicturesSizes();
-
-        public bool SeedPresetPictures { get; set; } = true;
-
-        public bool OverwritePresetPictures { get; set; } = false;
-    }
-
-    public class PlayListRoutes
-    {
-        [Required]
-        public string UploadsFolder { get; set; } = "uploads";
-
-        [Required]
-        public string ParentFolders { get; set; } = "PlayLists";
-
-        [Required]
-        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
-
-        [Required]
-        public string SmallPicturesFolder { get; set; } = "SmallPictures";
-
-        [Required]
-        public string MediumPicturesFolder { get; set; } = "MediumPictures";
-
-        [Required]
-        public string LargePicturesFolder { get; set; } = "LargePictures";
-
-        [Required]
-        public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
-
-        [Required]
-        public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
-
-        [Required]
-        public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
-
-        [Required]
-        public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
-
-        public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
-
-        public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
-
-        public string LargePicturesPath => StorageKey.Combine(ParentFolders, LargePicturesFolder);
-
-        public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
-
-        public string PresetSmallPicturePath => StorageKey.Combine(ParentFolders, SmallPicturesFolder, PresetSmallPicture);
-
-        public string PresetMediumPicturePath => StorageKey.Combine(ParentFolders, MediumPicturesFolder, PresetMediumPicture);
-
-        public string PresetLargePicturePath => StorageKey.Combine(ParentFolders, LargePicturesFolder, PresetLargePicture);
-
-        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
-
-        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);
-
-        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, SmallPicturesFolder, pictureName);
-
-        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, MediumPicturesFolder, pictureName);
-
-        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(ParentFolders, LargePicturesFolder, pictureName);
-
-        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
-            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolders, objectName);
-    }
-
-    public class PlayListPicturesSizes
-    {
-        [Range(1, 1024)]
-        public int SmallPictureWidth { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int SmallPictureHeight { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int MediumPictureWidth { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int MediumPictureHeight { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int LargePictureWidth { get; set; } = 512;
-
-        [Range(1, 1024)]
-        public int LargePictureHeight { get; set; } = 512;
+        public PictureSizes PicturesSizes { get; set; } = new();
     }
 }

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

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

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

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

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

@@ -2,9 +2,9 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    public class StreamGatewayConfiguration
+    public class StreamGatewayConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "StreamGateway";
+        public static string SectionName => "StreamGateway";
 
         [Url]
         [Required]

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

@@ -1,38 +1,28 @@
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using Musify.Application.Shared;
 
 namespace Musify.Application.Configuration
 {
-    public class TrackConfiguration
+    public class TrackConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
     {
-        public const string SectionName = "Track";
+        public static string SectionName => "Track";
 
         [Required]
-        public TrackRoutes Routes { get; set; } = new TrackRoutes();
+        public TrackRoutes Routes { get; set; } = new();
 
         [Required]
-        public TrackPicturesSizes PicturesSizes { get; set; } = new TrackPicturesSizes();
+        public PictureSizes PicturesSizes { get; set; } = new();
+
+        PictureRoutes IPictureOwnerConfiguration.Routes => Routes;
     }
 
-    public class TrackRoutes
+    public class TrackRoutes : PictureRoutes
     {
-        [Required]
-        public string UploadsFolder { get; set; } = "uploads";
-
-        [Required]
-        public string ParentFolder { get; set; } = "Tracks";
-
-        [Required]
-        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
-
-        [Required]
-        public string SmallPicturesFolder { get; set; } = "SmallPictures";
-
-        [Required]
-        public string MediumPicturesFolder { get; set; } = "MediumPictures";
-
-        [Required]
-        public string LargePicturesFolder { get; set; } = "LargePictures";
+        public TrackRoutes()
+        {
+            ParentFolder = "Tracks";
+        }
 
         [Required]
         public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
@@ -50,13 +40,7 @@ namespace Musify.Application.Configuration
         public string OriginalAudiosFolder { get; set; } = "OriginalAudios";
 
         [Required]
-        public string ProcessedAudioFolder { get; set; } = "ProcessedAudios";
-
-        public string SmallPicturesPath => StorageKey.Combine(ParentFolder, SmallPicturesFolder);
-
-        public string MediumPicturesPath => StorageKey.Combine(ParentFolder, MediumPicturesFolder);
-
-        public string LargePicturesPath => StorageKey.Combine(ParentFolder, LargePicturesFolder);
+        public string ProcessedAudiosFolder { get; set; } = "ProcessedAudios";
 
         public string PresetSmallPicturePath => StorageKey.Combine(ParentFolder, PresetSmallPicture);
 
@@ -64,53 +48,10 @@ namespace Musify.Application.Configuration
 
         public string PresetLargePicturePath => StorageKey.Combine(ParentFolder, PresetLargePicture);
 
-        public string OriginalPicturesPath => StorageKey.Combine(ParentFolder, OriginalPicturesFolder);
+        public string BuildOriginalAudioPath(long userId, string audioName) =>
+            StorageKey.Combine(UploadsFolder, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, OriginalAudiosFolder, audioName);
 
-        public string OriginalAudiosPath => StorageKey.Combine(ParentFolder, OriginalAudiosFolder);
-
-        public string ProcessedAudiosPath => StorageKey.Combine(ParentFolder, ProcessedAudioFolder);
-
-        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(OriginalPicturesPath, pictureName);
-
-        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), OriginalPicturesPath, pictureName);
-
-        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(SmallPicturesPath, pictureName);
-
-        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(MediumPicturesPath, pictureName);
-
-        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(LargePicturesPath, pictureName);
-
-        public string BuildOriginalAudioPath(string audioName) => StorageKey.Combine(OriginalAudiosPath, audioName);
-
-        public string BuildOriginalAudioPath(long userId, string audioName) => StorageKey.Combine(UploadsFolder, userId.ToString(), OriginalAudiosPath, audioName);
-
-        public string BuildProcessedAudioPath(string audioName) => StorageKey.Combine(ProcessedAudiosPath, audioName);
-
-        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
-            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
-
-        public string BuildTempAudioPath(string tempRootPrefix, long userId, string objectName) =>
-            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
-    }
-
-    public class TrackPicturesSizes
-    {
-        [Range(1, 1024)]
-        public int SmallPictureWidth { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int SmallPictureHeight { get; set; } = 128;
-
-        [Range(1, 1024)]
-        public int MediumPictureWidth { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int MediumPictureHeight { get; set; } = 256;
-
-        [Range(1, 1024)]
-        public int LargePictureWidth { get; set; } = 512;
-
-        [Range(1, 1024)]
-        public int LargePictureHeight { get; set; } = 512;
+        public string BuildProcessedAudioPath(string folderName) =>
+            StorageKey.Combine(ParentFolder, ProcessedAudiosFolder, folderName);
     }
 }

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

@@ -2,9 +2,9 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    public class UploadIntentConfiguration
+    public class UploadIntentConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "UploadIntent";
+        public static string SectionName => "UploadIntent";
 
         [Range(10, 3600)]
         public int UploadUrlExpiresInSeconds { get; set; } = 120;
@@ -31,12 +31,12 @@ namespace Musify.Application.Configuration
         public int ExpiredIntentsRetentionDays { get; set; } = 7;
 
         [Required, MinLength(1)]
-        public string TemporalRootPrefix { get; set; } = "temporal";
+        public string TempRootPrefix { get; set; } = "temp";
 
         [Range(1, 30)]
-        public int TemporalUploadsRetentionDays { get; set; } = 3;
+        public int TempUploadsRetentionDays { get; set; } = 3;
 
         [Range(60, 86400)]
-        public int TemporalCleanUpJobIntervalSeconds { get; set; } = 3600;
+        public int TempCleanupJobIntervalSeconds { get; set; } = 3600;
     }
 }

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

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

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

@@ -1,3 +1,4 @@
+using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Domain.Entities;
 
@@ -5,44 +6,38 @@ namespace Musify.Application.Contracts
 {
     public interface IDatabase
     {
-        DbSet<User> Users { get; }
+        public DbSet<User> Users { get; }
 
-        DbSet<PlayList> PlayLists { get; }
+        public DbSet<PlayList> PlayLists { get; }
 
-        DbSet<Album> Albums { get; }
+        public DbSet<Album> Albums { get; }
 
-        DbSet<UserAlbum> UserAlbums { get; }
+        public DbSet<AlbumHasTrack> AlbumHasTracks { get; }
 
-        DbSet<ExternalAlbum> ExternalAlbums { get; }
+        public DbSet<Track> Tracks { get; }
 
-        DbSet<AlbumHasTrack> AlbumHasTracks { get; }
+        public DbSet<PlayListHasTrack> PlayListHasTracks { get; }
 
-        DbSet<Track> Tracks { get; }
+        public DbSet<Mix> Mixes { get; }
 
-        DbSet<LocalTrack> LocalTracks { get; }
+        public DbSet<MixItem> MixItems { get; }
 
-        DbSet<ExternalTrack> ExternalTracks { get; }
+        public DbSet<UploadIntent> UploadIntents { get; }
 
-        DbSet<Artist> Artists { get; }
+        public DbSet<ListeningHistory> ListeningHistories { get; }
 
-        DbSet<TrackArtist> TrackArtists { get; }
+        public DbSet<TrackLike> TrackLikes { get; }
 
-        DbSet<UserHasTrack> UserHasTracks { get; }
+        public DbSet<TrackTag> TrackTags { get; }
 
-        DbSet<PlayListHasTrack> PlayListHasTracks { get; }
+        public DbSet<UserFollow> UserFollows { get; }
 
-        DbSet<Mix> Mixes { get; }
+        public Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
 
-        DbSet<MixItem> MixItems { get; }
+        public DbSet<TEntity> Set<TEntity>() where TEntity : class;
 
-        DbSet<Upload> Uploads { get; }
+        public Task<int> SaveChangesAsync(CancellationToken cancellationToken);
 
-        DbSet<UploadIntent> UploadIntents { get; }
-
-        DbSet<ListeningHistory> ListeningHistories { get; }
-
-        Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
-
-        Task<int> SaveChangesAsync(CancellationToken cancellationToken);
+        public Task<ErrorOr<Success>> TrySaveChangesAsync(Error onUniqueViolation, CancellationToken cancellationToken);
     }
 }

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

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

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

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

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

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

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

@@ -2,27 +2,24 @@ namespace Musify.Application.Contracts
 {
     public interface IStorageService
     {
-        Task<Stream> GetFileAsync(string bucket, string key, CancellationToken cancellationToken);
+        /// <summary>Opens an object for reading, or returns null when it does not exist.</summary>
+        public Task<Stream?> GetFileAsync(string bucket, string key, CancellationToken cancellationToken);
 
-        Task<ObjectMetaData?> HeadObjectAsync(string bucket, string key, CancellationToken cancellationToken);
+        public Task<ObjectMetaData?> HeadObjectAsync(string bucket, string key, CancellationToken cancellationToken);
 
-        Task<string> GetUrlAsync(string bucket, string key, TimeSpan ExpirationTime, CancellationToken cancellationToken);
+        public Task<string> GetUploadUrlAsync(string bucket, string key, string contentType, TimeSpan expirationTime, bool preventOverwrite = true, CancellationToken cancellationToken = default);
 
-        Task<string> GetUploadUrlAsync(string bucket, string key, string contentType, TimeSpan expirationTime, CancellationToken cancellationToken, bool preventOverwrite = true);
+        public Task UploadFileAsync(string filePath, string bucket, string key, CancellationToken cancellationToken);
 
-        Task UploadFileAsync(string filePath, string bucket, string key, CancellationToken cancellationToken);
+        public Task UploadFileAsync(Stream sourceStream, string contentType, string bucket, string key, CancellationToken cancellationToken);
 
-        Task UploadFileAsync(Stream sourceStream, string contentType, string bucket, string key, CancellationToken cancellationToken);
+        public Task<IReadOnlyList<string>> TransferFilesAsync(string sourceDirectory, string bucket, string route, CancellationToken cancellationToken);
 
-        Task<IReadOnlyList<string>> TransferFilesAsync(string sourceDirectory, string bucket, string route, CancellationToken cancellationToken);
+        public Task RemoveFileAsync(string bucket, string key, CancellationToken cancellationToken);
 
-        Task RemoveFileAsync(string bucket, string key, CancellationToken cancellationToken);
-
-        Task CopyFileAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey,
+        public Task CopyFileAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey,
             CancellationToken cancellationToken);
 
-        Task RemoveFolderAsync(string bucket, string folderKey, CancellationToken cancellationToken);
-        
-        IAsyncEnumerable<StorageObject> ListObjectsAsync(string bucket, string prefix, CancellationToken cancellationToken);
+        public IAsyncEnumerable<StorageObject> ListObjectsAsync(string bucket, string prefix, CancellationToken cancellationToken);
     }
 }

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

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

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

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

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

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

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -12,7 +12,5 @@ namespace Musify.Application.Events
         string AudioSourceKey,
         string AudioDestinationKey,
         string AudioProcessedFolderKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

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

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

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

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

@@ -6,7 +6,5 @@ namespace Musify.Application.Events
         Guid AlbumId,
         string Bucket,
         string SourceKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

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

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -1,4 +1,4 @@
-namespace Musify.Application.Events
+namespace Musify.Application.Events
 {
     public record UpdateTrackAudioEvent(
         Guid TrackId,

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

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

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

@@ -0,0 +1,25 @@
+using Mediator;
+using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Genres
+{
+    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>();
+
+            IReadOnlyList<AvailableGenreResponse> result = all
+                .Select(genre => new AvailableGenreResponse(
+                    genre,
+                    all.Where(other => !GenreCompatibility.AreCompatible(genre, other)).ToList()))
+                .ToList();
+
+            return ValueTask.FromResult(result);
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Genres
+{
+    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)
+                .GroupBy(tag => tag.Tag)
+                .Select(group => new { Genre = group.Key, TrackCount = group.Select(tag => tag.TrackId).Distinct().Count() })
+                .ToListAsync(cancellationToken);
+
+            return rows
+                .OrderByDescending(row => row.TrackCount)
+                .ThenBy(row => row.Genre)
+                .Select(row => new GenreResponse(row.Genre, row.TrackCount))
+                .ToList();
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,31 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Likes
+{
+    public record GetLikedTracksQuery(
+        long UserId,
+        int PageNumber,
+        int PageSize)
+        : IQuery<PaginatedResponse<TrackApplicationResponse>>;
+
+    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)
+                .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

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

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

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

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Mixes
 {
@@ -19,12 +20,13 @@ namespace Musify.Application.Mixes
                 .Include(mix => mix.Items)
                 .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
 
-            if (mix is null)
-                return Error.NotFound(description: $"Mix {request.MixId} was not found");
+            if (mix == null)
+                return AppErrors.NotFound("Mix", request.MixId);
 
-            var items = mix.Items.OrderBy(item => item.Position).ToList();
+            var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
+            var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
 
-            return MixApplicationResponse.FromEntity(mix, items.Count, items);
+            return new MixApplicationResponse(mix.Id, mix.Kind, items.Count, items);
         }
     }
 }

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

@@ -1,4 +1,3 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
@@ -7,31 +6,46 @@ using Musify.Application.Mixes.Responses;
 namespace Musify.Application.Mixes
 {
     public record GetMixesByUserIdQuery(long UserId)
-        : IQuery<ErrorOr<IReadOnlyList<MixApplicationResponse>>>;
+        : IQuery<IReadOnlyList<MixApplicationResponse>>;
 
     public class GetMixesByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetMixesByUserIdQuery, ErrorOr<IReadOnlyList<MixApplicationResponse>>>
+        : IQueryHandler<GetMixesByUserIdQuery, IReadOnlyList<MixApplicationResponse>>
     {
-        public async ValueTask<ErrorOr<IReadOnlyList<MixApplicationResponse>>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
+        public async ValueTask<IReadOnlyList<MixApplicationResponse>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
         {
-            var entries = await database.Mixes
+            var mixes = await database.Mixes
                 .AsNoTracking()
                 .Where(mix => mix.UserId == request.UserId)
+                .Include(mix => mix.Items)
                 .OrderBy(mix => mix.Position)
-                .Select(mix => new
-                {
-                    Mix = mix,
-                    ItemCount = mix.Items.Count,
-                    CoverItems = mix.Items
-                        .OrderBy(item => item.Position)
-                        .Take(MixApplicationResponse.CoverItemCount)
-                        .ToList()
-                })
+                .ThenBy(mix => mix.Id)
                 .ToListAsync(cancellationToken);
 
-            return entries
-                .Select(entry => MixApplicationResponse.FromEntity(entry.Mix, entry.ItemCount, entry.CoverItems))
+            var orderedItemsByMix = mixes.ToDictionary(
+                mix => mix.Id,
+                mix => mix.Items.OrderBy(item => item.Position).ToList());
+
+            var coverItems = orderedItemsByMix.Values
+                .SelectMany(items => items.Take(MixApplicationResponse.CoverItemCount))
                 .ToList();
+            var coverResponses = (await MixItemMapper.ToResponsesAsync(database, coverItems, cancellationToken))
+                .GroupBy(response => response.TrackId)
+                .ToDictionary(group => group.Key, group => group.First());
+
+            var responses = new List<MixApplicationResponse>(mixes.Count);
+            foreach (var mix in mixes)
+            {
+                var orderedItems = orderedItemsByMix[mix.Id];
+                var covers = orderedItems
+                    .Take(MixApplicationResponse.CoverItemCount)
+                    .Where(item => coverResponses.ContainsKey(item.TrackId))
+                    .Select(item => coverResponses[item.TrackId])
+                    .ToList();
+
+                responses.Add(new MixApplicationResponse(mix.Id, mix.Kind, orderedItems.Count, covers));
+            }
+
+            return responses;
         }
     }
 }

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

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

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

@@ -1,25 +1,13 @@
-using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Mixes.Responses
 {
     public record MixApplicationResponse(
         Guid Id,
-        string Title,
-        string? Subtitle,
+        MixKind Kind,
         int ItemCount,
         IReadOnlyList<MixItemApplicationResponse> Items)
     {
         public const int CoverItemCount = 4;
-
-        public static MixApplicationResponse FromEntity(
-            Mix mix,
-            int itemCount,
-            IReadOnlyList<MixItem> items) =>
-            new(
-                mix.Id,
-                mix.Title,
-                mix.Subtitle,
-                itemCount,
-                [.. items.Select(MixItemApplicationResponse.FromEntity)]);
     }
 }

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

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

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

@@ -0,0 +1,76 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using MimeMapping;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Pictures
+{
+    public enum CoverOwner
+    {
+        Track,
+        Album,
+        PlayList
+    }
+
+    public record GetCoverQuery(CoverOwner Owner, Guid Id, PictureSize Size = PictureSize.Medium)
+        : IQuery<ErrorOr<CoverLocation>>;
+
+    public record CoverLocation(string Bucket, string Key, string ContentType);
+
+    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()
+                    .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))
+                    .SingleOrDefaultAsync(cancellationToken), albumConfiguration.Routes),
+                _ => (await database.PlayLists.AsNoTracking()
+                    .Where(p => p.Id == request.Id && p.LifeCycleStatus == LifeCycleStatus.Active && p.Pictures != null)
+                    .Select(p => new CoverSource(p.OwnerUserId, p.Pictures!.OriginalName, p.Pictures.SmallName, p.Pictures.MediumName, p.Pictures.LargeName))
+                    .SingleOrDefaultAsync(cancellationToken), playListConfiguration.Routes)
+            };
+
+            var entity = request.Owner.ToString();
+            if (source == null)
+                return AppErrors.NotFound($"{entity}Cover", request.Id);
+
+            var resizedName = request.Size switch
+            {
+                PictureSize.Small => source.Small,
+                PictureSize.Large => source.Large,
+                _ => 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)
+                    ? (source.Original, routes.BuildOriginalPicturePath(source.OwnerUserId, source.Original))
+                    : (null, null);
+
+            if (name == null || key == null)
+                return AppErrors.NotFound($"{entity}Cover", request.Id);
+
+            return new CoverLocation(storageConfiguration.Bucket, key, MimeUtility.GetMimeMapping(name));
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+using ErrorOr;
+using Musify.Application.Configuration;
+using Musify.Application.Services;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+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 static async Task<ErrorOr<PreparedPicture>> PrepareAsync(
+            UploadIntentValidator uploadIntentValidator,
+            Guid intentId,
+            long userId,
+            UploadIntentPurpose purpose,
+            IPictureOwnerConfiguration owner,
+            CancellationToken cancellationToken)
+        {
+            var validation = await uploadIntentValidator.ValidateAndLoadAsync(intentId, userId, purpose, cancellationToken);
+            if (validation.IsError)
+                return validation.Errors;
+
+            var intent = validation.Value;
+
+            return new PreparedPicture(
+                intent,
+                EntityPictures.Pending(intent.ObjectName),
+                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.Albums.Responses
+namespace Musify.Application.Pictures.Responses
 {
-    public record AlbumPictureUploadResponse(
+    public record PictureUploadResponse(
         Guid IntentId,
         string Bucket,
         string Key,

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

@@ -1,75 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.PlayLists
-{
-    public record AddTrackToPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
-        : ICommand<ErrorOr<Success>>;
-
-    public class AddTrackToPlayListCommandHandler(
-        IDatabase database,
-        ILogger<AddTrackToPlayListCommandHandler> logger)
-        : ICommandHandler<AddTrackToPlayListCommand, ErrorOr<Success>>
-    {
-        public async ValueTask<ErrorOr<Success>> Handle(AddTrackToPlayListCommand request, CancellationToken cancellationToken)
-        {
-            var playList = await database.PlayLists
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
-
-            var trackExists = await database.Tracks
-                .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (!trackExists)
-            {
-                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                return Error.NotFound(description: $"Track {request.TrackId} not found");
-            }
-
-            var alreadyAdded = await database.PlayListHasTracks
-                .AsNoTracking()
-                .AnyAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-            if (alreadyAdded)
-            {
-                logger.LogInformation("Track {TrackId} already in playlist {PlayListId}", request.TrackId, request.PlayListId);
-                return Error.Conflict(description: "Track is already in the playlist.");
-            }
-
-            var playListTracksQuery = database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId);
-
-            var hasTracks = await playListTracksQuery.AnyAsync(cancellationToken);
-            var nextPosition = hasTracks
-                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
-                : 0;
-
-            await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
-            {
-                PlayListId = request.PlayListId,
-                TrackId = request.TrackId,
-                Position = nextPosition
-            }, cancellationToken);
-
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Added track {TrackId} to playlist {PlayListId} at position {Position}",
-                request.TrackId, request.PlayListId, nextPosition);
-
-            return new Success();
-        }
-    }
-}

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

@@ -0,0 +1,74 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+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)
+        : ICommand<ErrorOr<Success>>;
+
+    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);
+            if (playList.IsError)
+                return playList.Errors;
+
+            var requestedIds = request.TrackIds.Distinct().ToList();
+
+            var existingIds = await database.Tracks
+                .AsNoTracking()
+                .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => track.Id)
+                .ToListAsync(cancellationToken);
+
+            var missing = requestedIds.FirstOrDefault(id => !existingIds.Contains(id));
+            if (missing != Guid.Empty)
+                return AppErrors.NotFound("Track", missing);
+
+            var alreadyInPlayList = await database.PlayListHasTracks
+                .AsNoTracking()
+                .Where(link => link.PlayListId == request.PlayListId && requestedIds.Contains(link.TrackId))
+                .Select(link => link.TrackId)
+                .ToListAsync(cancellationToken);
+
+            var toAdd = requestedIds.Where(id => !alreadyInPlayList.Contains(id)).ToList();
+            if (toAdd.Count == 0)
+                return Result.Success;
+
+            // Playlist positions are internal indexes, so they start at 0.
+            var nextPosition = (await database.PlayListHasTracks
+                .Where(link => link.PlayListId == request.PlayListId)
+                .MaxAsync(link => (int?)link.Position, cancellationToken) ?? -1) + 1;
+
+            foreach (var trackId in toAdd)
+            {
+                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;
+
+            logger.LogInformation("Added {Count} tracks to playlist {PlayListId}", toAdd.Count, request.PlayListId);
+
+            return Result.Success;
+        }
+    }
+}

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

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

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

@@ -3,13 +3,14 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Shared;
+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.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -17,7 +18,8 @@ namespace Musify.Application.PlayLists
         long UserId,
         string Name,
         string? Description,
-        Guid? PictureIntentId)
+        Guid? PictureIntentId,
+        PlayListVisibility Visibility = PlayListVisibility.Private)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class CreatePlayListCommandHandler(
@@ -25,126 +27,53 @@ namespace Musify.Application.PlayLists
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        PlayListConfiguration playListConfiguration)
         : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
-        private sealed record ResolvedPlayListPictures(PlayListPictures Pictures, UploadIntent? Intent);
-
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
         {
             var userExists = await database.Users
                 .AsNoTracking()
                 .AnyAsync(u => u.Id == request.UserId, cancellationToken);
             if (!userExists)
+                return AppErrors.NotFound("User", request.UserId);
+
+            PreparedPicture? picture = null;
+            if (request.PictureIntentId is { } intentId)
             {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
+
+                picture = prepared.Value;
             }
 
-            var picturesResult = await ResolvePicturesAsync(request, cancellationToken);
-            if (picturesResult.IsError)
-                return picturesResult.Errors;
-
-            var resolvedPictures = picturesResult.Value;
-
+            var name = request.Name.Trim();
             var playList = new PlayList
             {
-                UserId = request.UserId,
-                Name = request.Name,
-                NormalizedName = request.Name.Trim().ToUpperInvariant(),
+                OwnerUserId = request.UserId,
+                Name = name,
+                NormalizedName = TextNormalizer.Normalize(name),
                 Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
-                Pictures = resolvedPictures.Pictures
+                Pictures = picture?.Pictures,
+                Visibility = request.Visibility
             };
             await database.PlayLists.AddAsync(playList, cancellationToken);
 
-            if (resolvedPictures.Intent != null)
-            {
-                var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures.OriginalName);
-                var publishResult = await PublishCreatePlayListEventAsync(playList.Id, resolvedPictures.Intent, finalPictureKey, cancellationToken);
-                if (publishResult.IsError)
-                    return publishResult.Errors;
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to save playlist for user {UserId}", request.UserId);
-                return Error.Failure(description: $"Failed to create playlist for user {request.UserId}");
-            }
-
-            logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
-            return PlayListApplicationResponse.FromEntity(playList);
-        }
-
-        private async ValueTask<ErrorOr<ResolvedPlayListPictures>> ResolvePicturesAsync(
-            CreatePlayListCommand request, CancellationToken cancellationToken)
-        {
-            if (!request.PictureIntentId.HasValue)
-            {
-                return new ResolvedPlayListPictures(new PlayListPictures
-                {
-                    OriginalName = playListConfiguration.Routes.PresetOriginalPicture,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
-                }, null);
-            }
-
-            var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration, request.PictureIntentId.Value, request.UserId, cancellationToken);
-
-            if (validation.IsError)
-                return validation.Errors;
-
-            return new ResolvedPlayListPictures(new PlayListPictures 
-            { 
-                OriginalName = validation.Value.ObjectName,
-                SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                LargeName = playListConfiguration.Routes.PresetLargePicture
-            }, validation.Value);
-        }
-
-        async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
+            if (picture != null)
             {
                 await eventBus.PublishAsync(
                     new CreatePlayListResourcesEvent(
-                        playListId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            playListConfiguration.Routes.SmallPicturesPath,
-                            playListConfiguration.PicturesSizes.SmallPictureWidth,
-                            playListConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.MediumPicturesPath,
-                            playListConfiguration.PicturesSizes.MediumPictureWidth,
-                            playListConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.LargePicturesPath,
-                            playListConfiguration.PicturesSizes.LargePictureWidth,
-                            playListConfiguration.PicturesSizes.LargePictureHeight)),
+                        playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                     cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish create playlist event for playlist {PlayListId}", playListId);
-                return Error.Failure(description: $"Failed to publish create playlist event for playlist {playListId}");
             }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
+
+            return PlayListApplicationResponse.FromEntity(playList);
         }
     }
 }

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

@@ -1,9 +1,9 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists
@@ -19,44 +19,19 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
         {
-            var playList = await database.PlayLists.SingleOrDefaultAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
-            {
-                logger.LogDebug("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("Playlist {PlayListId} does not belong to user {UserId}", request.PlayListId, request.UserId);
-                return Error.Unauthorized();
-            }
+            var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
+            var playList = found.Value;
             playList.LifeCycleStatus = LifeCycleStatus.Removing;
 
-            try
-            {
-                await eventBus.PublishAsync(
-                    new DeletePlayListEvent(playList.Id, request.UserId),
-                    cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish delete playlist event for playlist {PlayListId}", request.PlayListId);
-                return Error.Failure(description: $"Failed to delete playlist {request.PlayListId}");
-            }
-
-            try
-            {
+            await eventBus.PublishAsync(new DeletePlayListEvent(playList.Id, request.UserId), cancellationToken);
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to mark playlist {PlayListId} as removing", request.PlayListId);
-                return Error.Failure(description: $"Failed to delete playlist {request.PlayListId}");
-            }
 
-            return new Success();
+            logger.LogInformation("Marked playlist {PlayListId} as removing", request.PlayListId);
+
+            return Result.Success;
         }
     }
 }

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

@@ -1,12 +1,13 @@
 using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.PlayLists.Responses;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.PlayLists.Responses;
+using Musify.Application.Shared;
 
 namespace Musify.Application.PlayLists
 {
-    public record GetPlayListByIdQuery(Guid Id)
+    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
         : IQuery<ErrorOr<PlayListApplicationResponse>>;
 
     public class GetPlayListByIdQueryHandler(IDatabase database)
@@ -14,24 +15,17 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
         {
-            var entry = await database.PlayLists
+            var playList = await database.PlayLists
                 .AsNoTracking()
+                .Active()
+                .VisibleTo(request.RequestingUserId)
                 .Where(p => p.Id == request.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
+                .SelectResponse()
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (entry is null)
-                return Error.NotFound();
-
-            return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds);
+            return playList == null
+                ? AppErrors.NotFound("PlayList", request.Id)
+                : playList;
         }
     }
 }

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

@@ -1,49 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using MimeMapping;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.PlayLists
-{
-    public record GetPlayListCoverQuery(Guid PlayListId, string Size)
-        : IQuery<ErrorOr<PlayListCoverLocation>>;
-
-    public record PlayListCoverLocation(string Bucket, string Key, string ContentType);
-
-    public class GetPlayListCoverQueryHandler(
-        IDatabase database,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration)
-        : IQueryHandler<GetPlayListCoverQuery, ErrorOr<PlayListCoverLocation>>
-    {
-        public async ValueTask<ErrorOr<PlayListCoverLocation>> Handle(GetPlayListCoverQuery request, CancellationToken cancellationToken)
-        {
-            var pictures = await database.PlayLists.AsNoTracking()
-                .Where(p => p.Id == request.PlayListId)
-                .Select(p => p.Pictures)
-                .SingleOrDefaultAsync(cancellationToken);
-
-            if (pictures is null)
-                return Error.NotFound();
-
-            var routes = playListConfiguration.Routes;
-            var (name, key) = request.Size.ToLowerInvariant() switch
-            {
-                "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
-                "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
-                _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
-            };
-
-            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
-                return Error.NotFound();
-
-            var contentType = MimeUtility.GetMimeMapping(name);
-            return new PlayListCoverLocation(storageConfiguration.Bucket, key, contentType);
-        }
-
-        private static string? BuildKey(Func<string, string> builder, string? name)
-            => string.IsNullOrEmpty(name) ? null : builder(name);
-    }
-}

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

@@ -2,18 +2,18 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
-using X.PagedList;
-using X.PagedList.EF;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists
 {
     public record GetPlayListTracksQuery(
         Guid PlayListId,
         int PageNumber,
-        int PageSize)
+        int PageSize,
+        long? ViewerId = null)
         : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
     public class GetPlayListTracksQueryHandler(IDatabase database)
@@ -21,31 +21,22 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
         {
-            var playListExists = await database.PlayLists
+            var playListVisible = await database.PlayLists
                 .AsNoTracking()
-                .AnyAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (!playListExists)
-                return Error.NotFound();
+                .Active()
+                .VisibleTo(request.ViewerId)
+                .AnyAsync(playList => playList.Id == request.PlayListId, cancellationToken);
+            if (!playListVisible)
+                return AppErrors.NotFound("PlayList", request.PlayListId);
 
-            var tracksQuery = database.PlayListHasTracks
+            return await database.PlayListHasTracks
                 .AsNoTracking()
-                .Include(plt => ((ExternalTrack)plt.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(plt => ((LocalTrack)plt.Track).Owner)
-                .Where(plt => plt.PlayListId == request.PlayListId);
-
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
-                .OrderBy(plt => plt.Position)
-                .Select(plt => new { plt.Track, ListensCount = plt.Track.ListeningHistories.Count })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
-                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+                .Where(playListTrack => playListTrack.PlayListId == request.PlayListId && playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .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/GetPlayLists.cs

@@ -1,43 +0,0 @@
-using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.Shared;
-using Musify.Application.PlayLists.Responses;
-using X.PagedList;
-using X.PagedList.EF;
-using Mediator;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.PlayLists
-{
-    public record GetPlayListsQuery(int PageNumber, int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>> >;
-
-    public class GetPlayListsQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse> >>
-    {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse> >> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
-        {
-            var totalCount = await database.PlayLists.CountAsync(cancellationToken);
-
-            var pagedEntities = await database.PlayLists
-                .AsNoTracking()
-                .OrderBy(p => p.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
-                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
-        }
-    }
-}

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

@@ -1,12 +1,8 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.PlayLists
 {
@@ -14,45 +10,32 @@ namespace Musify.Application.PlayLists
         long UserId,
         string? Name,
         int PageNumber,
-        int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>> >;
+        int PageSize,
+        long? ViewerId = null)
+        : IQuery<PaginatedResponse<PlayListApplicationResponse>>;
 
     public class GetPlayListsByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse> > >
+        : IQueryHandler<GetPlayListsByUserIdQuery, PaginatedResponse<PlayListApplicationResponse>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse> >> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
+        public async ValueTask<PaginatedResponse<PlayListApplicationResponse>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
         {
             var playListsQuery = database.PlayLists
                 .AsNoTracking()
-                .Where(p => p.UserId == request.UserId);
+                .Active()
+                .VisibleTo(request.ViewerId)
+                .Where(playList => playList.OwnerUserId == request.UserId);
 
-            if (!string.IsNullOrEmpty(request.Name))
+            if (!string.IsNullOrWhiteSpace(request.Name))
             {
-                var normalizedName = request.Name.Trim().ToUpperInvariant();
-                playListsQuery = playListsQuery.Where(p => p.NormalizedName.Contains(normalizedName));
+                var normalizedName = TextNormalizer.Normalize(request.Name);
+                playListsQuery = playListsQuery.Where(playList => playList.NormalizedName.Contains(normalizedName));
             }
 
-            var totalCount = await playListsQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await playListsQuery
-                .OrderBy(p => p.CreatedAt)
-                .Where(p => p.LifeCycleStatus == LifeCycleStatus.Active)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                } )
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
-                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
+            return await playListsQuery
+                .OrderBy(playList => playList.CreatedAt)
+                .ThenBy(playList => playList.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.PlayLists
 {
@@ -16,34 +17,30 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromPlayListCommand request, CancellationToken cancellationToken)
         {
-            var playList = await database.PlayLists
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList is null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
+            var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (playList.IsError)
+                return playList.Errors;
 
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
+            var playListTracks = await database.PlayListHasTracks
+                .Where(plt => plt.PlayListId == request.PlayListId)
+                .OrderBy(plt => plt.Position)
+                .ToListAsync(cancellationToken);
 
-            var link = await database.PlayListHasTracks
-                .SingleOrDefaultAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-            if (link is null)
-            {
-                logger.LogInformation("Track {TrackId} not in playlist {PlayListId}", request.TrackId, request.PlayListId);
-                return Error.NotFound(description: "Track is not in the playlist.");
-            }
+            var link = playListTracks.SingleOrDefault(plt => plt.TrackId == request.TrackId);
+            if (link == null)
+                return Error.NotFound("PlayList.TrackNotFound", "Track is not in the playlist.");
 
             database.PlayListHasTracks.Remove(link);
+
+            var position = 0;
+            foreach (var remaining in playListTracks.Where(plt => plt.Id != link.Id))
+                remaining.Position = position++;
+
             await database.SaveChangesAsync(cancellationToken);
 
             logger.LogInformation("Removed track {TrackId} from playlist {PlayListId}", request.TrackId, request.PlayListId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

@@ -1,13 +1,9 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.PlayLists.Responses;
+using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -16,90 +12,14 @@ namespace Musify.Application.PlayLists
         string FileType,
         string ContentType,
         long? ExpectedSizeBytes = null)
-        : ICommand<ErrorOr<PlayListPictureUploadResponse>>;
+        : ICommand<ErrorOr<PictureUploadResponse>>;
 
-    public class RequestPlayListPictureUploadCommandHandler(
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        IStorageService storageService,
-        ILogger<RequestPlayListPictureUploadCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PlayListPictureUploadResponse>>
+    public class RequestPlayListPictureUploadCommandHandler(UploadIntentIssuer issuer, PlayListConfiguration playListConfiguration)
+        : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PictureUploadResponse>>
     {
-        public async ValueTask<ErrorOr<PlayListPictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken)
-        {
-            var userExists = await database.Users
-                .AsNoTracking()
-                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-            if (!userExists)
-            {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
-            }
-
-            var effectiveSizeBytes = request.ExpectedSizeBytes
-                ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
-
-            var objectName = $"{Guid.NewGuid() }.{request.FileType.TrimStart('.').ToLowerInvariant() }";
-
-            var tempKey = playListConfiguration.Routes.BuildTempPicturePath(
-                uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
-
-            try
-            {
-                var uploadUrl = await storageService.GetUploadUrlAsync(
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    request.ContentType,
-                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                    cancellationToken);
-
-                await using var transaction = await database.BeginTransactionAsync(
-                    System.Data.IsolationLevel.Serializable, cancellationToken);
-
-                var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
-                    uploadIntentConfiguration,
-                    request.UserId, effectiveSizeBytes, 1, cancellationToken);
-                if (quotaCheck.IsError)
-                {
-                    logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
-                    return quotaCheck.Errors;
-                }
-
-                var intent = new UploadIntent
-                {
-                    UserId = request.UserId,
-                    Bucket = storageConfiguration.Bucket,
-                    Key = tempKey,
-                    ObjectName = objectName,
-                    ContentType = request.ContentType,
-                    ExpectedSizeBytes = effectiveSizeBytes,
-                    Purpose = UploadIntentPurpose.PlayListPicture,
-                    ExpiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                };
-
-                await database.UploadIntents.AddAsync(intent, cancellationToken);
-                await database.SaveChangesAsync(cancellationToken);
-                await transaction.CommitAsync(cancellationToken);
-
-                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (PlayListPicture, temp key: {Key} )", intent.Id, request.UserId, tempKey);
-
-                return new PlayListPictureUploadResponse(
-                    intent.Id,
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    objectName,
-                    request.ContentType,
-                    uploadIntentConfiguration.UploadUrlExpiresInSeconds,
-                    uploadUrl);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to generate playlist picture upload URL for user {UserId}", request.UserId);
-                return Error.Failure(description: "Failed to generate upload URL");
-            }
-        }
+        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/PlayListApplicationResponse.cs

@@ -1,4 +1,6 @@
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
 
 namespace Musify.Application.PlayLists.Responses
 {
@@ -9,15 +11,21 @@ namespace Musify.Application.PlayLists.Responses
         string? SmallImageKeyName,
         string? MediumImageKeyName,
         string? LargeImageKeyName,
+        PlayListVisibility Visibility,
         DateTime CreatedAt,
         DateTime UpdatedAt,
-        IReadOnlyList<Guid> CoverTrackIds)
+        IReadOnlyList<Guid> CoverTrackIds,
+        long OwnerUserId,
+        int TrackCount,
+        double DurationSeconds)
     {
-        public const int CoverTrackCount = 4;
+        public const int CoverTrackCount = PlayListProjections.CoverTrackCount;
 
         public static PlayListApplicationResponse FromEntity(
             PlayList playList,
-            IReadOnlyList<Guid>? coverTrackIds = null)
+            IReadOnlyList<Guid>? coverTrackIds = null,
+            int trackCount = 0,
+            double durationSeconds = 0)
         {
             return new PlayListApplicationResponse(
                 playList.Id,
@@ -26,9 +34,13 @@ namespace Musify.Application.PlayLists.Responses
                 playList.Pictures?.SmallName,
                 playList.Pictures?.MediumName,
                 playList.Pictures?.LargeName,
+                playList.Visibility,
                 playList.CreatedAt,
                 playList.UpdatedAt,
-                coverTrackIds ?? []);
+                coverTrackIds ?? [],
+                playList.OwnerUserId,
+                trackCount,
+                durationSeconds);
         }
     }
 }

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

@@ -1,11 +0,0 @@
-namespace Musify.Application.PlayLists.Responses
-{
-    public record PlayListPictureUploadResponse(
-        Guid IntentId,
-        string Bucket,
-        string Key,
-        string PictureName,
-        string ContentType,
-        int ExpiresInSeconds,
-        string UploadUrl);
-}

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

@@ -0,0 +1,38 @@
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.PlayLists.Responses
+{
+    public static class PlayListProjections
+    {
+        public const int CoverTrackCount = 4;
+
+        public static IQueryable<PlayList> Active(this IQueryable<PlayList> query) =>
+            query.Where(playList => playList.LifeCycleStatus == LifeCycleStatus.Active);
+
+        public static IQueryable<PlayList> VisibleTo(this IQueryable<PlayList> query, long? viewerId) =>
+            query.Where(playList => playList.Visibility == PlayListVisibility.Public || playList.OwnerUserId == viewerId);
+
+        public static IQueryable<PlayListApplicationResponse> SelectResponse(this IQueryable<PlayList> query) =>
+            query.Select(playList => new PlayListApplicationResponse(
+                playList.Id,
+                playList.Name,
+                playList.Description,
+                playList.Pictures!.SmallName,
+                playList.Pictures!.MediumName,
+                playList.Pictures!.LargeName,
+                playList.Visibility,
+                playList.CreatedAt,
+                playList.UpdatedAt,
+                playList.PlayListTracks
+                    .OrderBy(playListTrack => playListTrack.Position)
+                    .Take(CoverTrackCount)
+                    .Select(playListTrack => playListTrack.TrackId)
+                    .ToList(),
+                playList.OwnerUserId,
+                playList.PlayListTracks.Count(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active),
+                playList.PlayListTracks
+                    .Where(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                    .Sum(playListTrack => playListTrack.Track.DurationSeconds)));
+    }
+}

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

@@ -3,13 +3,13 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Shared;
+using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
+using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -18,7 +18,8 @@ namespace Musify.Application.PlayLists
         Guid PlayListId,
         string? NewName,
         string? NewDescription,
-        Guid? NewPictureIntentId)
+        Guid? NewPictureIntentId,
+        PlayListVisibility? NewVisibility = null)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class UpdatePlayListCommandHandler(
@@ -26,126 +27,55 @@ namespace Musify.Application.PlayLists
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<UpdatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        PlayListConfiguration playListConfiguration)
         : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
         {
-            var playListEntity = await database.PlayLists.SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playListEntity is null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
+            var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
-            if (playListEntity.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
+            var playList = found.Value;
 
             if (!string.IsNullOrWhiteSpace(request.NewName))
             {
-                playListEntity.Name = request.NewName;
-                playListEntity.NormalizedName = request.NewName.Trim().ToUpperInvariant();
+                playList.Name = request.NewName.Trim();
+                playList.NormalizedName = TextNormalizer.Normalize(request.NewName);
             }
 
-            if (!string.IsNullOrWhiteSpace(request.NewDescription))
+            // null means "unchanged"; a blank description clears it.
+            if (request.NewDescription != null)
+                playList.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
+
+            if (request.NewVisibility is { } visibility)
+                playList.Visibility = visibility;
+
+            if (request.NewPictureIntentId is { } intentId)
             {
-                playListEntity.Description = request.NewDescription;
-            }
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
 
-            UploadIntent? pictureIntent = null;
-            string? finalPictureKey = null;
+                var picture = prepared.Value;
+                playList.Pictures = picture.Pictures;
 
-            if (request.NewPictureIntentId.HasValue)
-            {
-                var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                    uploadIntentConfiguration,
-                    request.NewPictureIntentId.Value, request.UserId, cancellationToken);
-                if (validation.IsError)
-                    return validation.Errors;
-
-                pictureIntent = validation.Value;
-                playListEntity.Pictures = new PlayListPictures 
-                { 
-                    OriginalName = pictureIntent.ObjectName,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
-                };
-                finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
-            }
-
-            database.PlayLists.Update(playListEntity);
-
-            if (pictureIntent != null&& finalPictureKey != null)
-            {
-                var publishResult = await PublishUpdatePlayListPictureSourceEventAsync(
-                    playListEntity.Id, pictureIntent, finalPictureKey, cancellationToken);
-                if (publishResult.IsError)
-                    return publishResult.Errors;
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to update playlist {PlayListId}", playListEntity.Id);
-                return Error.Failure(description: $"Failed to update playlist {playListEntity.Id}");
-            }
-
-            var coverTrackIds = await database.PlayListHasTracks
-                .AsNoTracking()
-                .Where(plt => plt.PlayListId == playListEntity.Id)
-                .OrderBy(plt => plt.Position)
-                .Take(PlayListApplicationResponse.CoverTrackCount)
-                .Select(plt => plt.TrackId)
-                .ToListAsync(cancellationToken);
-
-            logger.LogInformation("Updated playlist {PlayListId}", playListEntity.Id);
-            return PlayListApplicationResponse.FromEntity(playListEntity, coverTrackIds);
-        }
-
-        async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
                 await eventBus.PublishAsync(
                     new UpdatePlayListPictureSourceEvent(
-                        playListId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            playListConfiguration.Routes.SmallPicturesPath,
-                            playListConfiguration.PicturesSizes.SmallPictureWidth,
-                            playListConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.MediumPicturesPath,
-                            playListConfiguration.PicturesSizes.MediumPictureWidth,
-                            playListConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.LargePicturesPath,
-                            playListConfiguration.PicturesSizes.LargePictureWidth,
-                            playListConfiguration.PicturesSizes.LargePictureHeight)),
+                        playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                     cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish update playlist picture source event for playlist {PlayListId}", playListId);
-                return Error.Failure(description: $"Failed to publish update playlist picture source event for playlist {playListId}");
             }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated playlist {PlayListId}", playList.Id);
+
+            return await database.PlayLists
+                .AsNoTracking()
+                .Where(p => p.Id == playList.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
         }
     }
 }

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

@@ -1,28 +1,20 @@
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.Services;
 
+namespace Musify.Application.Services
+{
+    /// <summary>Builds the stream URL and signed ticket for a processed track. It never touches the database.</summary>
     public sealed class TrackStreamIssuer(
-    IDatabase database,
         IStreamTicketService ticketService,
         TrackConfiguration trackConfiguration,
         StreamGatewayConfiguration streamGatewayConfiguration,
         PlaybackConfiguration playbackConfiguration)
     {
-    public async Task<TrackStreamResponse> IssueAsync(
-        Guid trackId,
-        string audioFolderName,
-        long? userId,
-        CancellationToken cancellationToken)
+        public TrackStreamResponse Issue(string audioFolderName, long? userId, Guid? listenId)
         {
             var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
-        var keyPrefix = $"{folderPath}/";
-
-        var maxBytes = AnonymousFragmentBytes(userId);
-        var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
+            var ticket = ticketService.IssueTicket(userId, $"{folderPath}/", AnonymousFragmentBytes(userId));
 
             var manifestUrl = string.Join('/',
                 streamGatewayConfiguration.PublicBaseUrl.TrimEnd('/'),
@@ -30,27 +22,15 @@ public sealed class TrackStreamIssuer(
                 folderPath,
                 streamGatewayConfiguration.AudioFileName);
 
-        // Anonymous listeners have no User row to satisfy ListeningHistory's foreign key against, and
-        // their plays aren't "history" anyone can look back on anyway, so there's nothing to record.
-        if (userId is not null)
-        {
-            var newListeningHistory = new ListeningHistory
-            {
-                UserId = userId.Value,
-                TrackId = trackId,
-            };
-            await database.ListeningHistories.AddAsync(newListeningHistory, cancellationToken);
-            await database.SaveChangesAsync(cancellationToken);
-        }
-
-        return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds);
+            return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds, listenId);
         }
 
         private long? AnonymousFragmentBytes(long? userId)
         {
-        if (userId is not null || playbackConfiguration.AnonymousFragmentSeconds <= 0)
+            if (userId != null || playbackConfiguration.AnonymousFragmentSeconds <= 0)
                 return null;
 
             return (long)playbackConfiguration.AnonymousFragmentSeconds * playbackConfiguration.EstimatedAudioBytesPerSecond;
         }
     }
+}

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

@@ -0,0 +1,134 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Pictures.Responses;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Services
+{
+    public sealed record UploadRequest(
+        UploadIntentPurpose Purpose,
+        PictureRoutes Routes,
+        string FileType,
+        string ContentType,
+        long? ExpectedSizeBytes);
+
+    public sealed record IssuedUpload(
+        Guid IntentId,
+        string Key,
+        string ObjectName,
+        string ContentType,
+        string UploadUrl);
+
+    /// <summary>Issues pre-signed upload URLs and the upload intents that track them, checking the user quota first.</summary>
+    public sealed class UploadIntentIssuer(
+        IDatabase database,
+        IStorageService storageService,
+        UploadIntentValidator uploadIntentValidator,
+        ApplicationStorageConfiguration storageConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration,
+        ILogger<UploadIntentIssuer> logger)
+    {
+        public async Task<ErrorOr<IReadOnlyList<IssuedUpload>>> IssueAsync(
+            long userId,
+            IReadOnlyList<UploadRequest> requests,
+            CancellationToken cancellationToken)
+        {
+            var userExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(user => user.Id == userId, cancellationToken);
+            if (!userExists)
+                return AppErrors.NotFound("User", userId);
+
+            var planned = requests
+                .Select(request =>
+                {
+                    var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
+                    var key = request.Routes.BuildTempPath(uploadIntentConfiguration.TempRootPrefix, userId, objectName);
+                    var size = request.ExpectedSizeBytes ?? DefaultSize(request.Purpose);
+                    return (Request: request, ObjectName: objectName, Key: key, Size: size);
+                })
+                .ToList();
+
+            await using var transaction = await database.BeginTransactionAsync(
+                System.Data.IsolationLevel.Serializable, cancellationToken);
+
+            var quota = await uploadIntentValidator.CheckQuotaAsync(
+                userId, planned.Sum(item => item.Size), planned.Count, cancellationToken);
+            if (quota.IsError)
+                return quota.Errors;
+
+            var expiresIn = TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds);
+            var expiresAt = DateTime.UtcNow + expiresIn;
+            var issued = new List<IssuedUpload>(planned.Count);
+
+            foreach (var item in planned)
+            {
+                var uploadUrl = await storageService.GetUploadUrlAsync(
+                    storageConfiguration.Bucket, item.Key, item.Request.ContentType, expiresIn, cancellationToken: cancellationToken);
+
+                var intent = new UploadIntent
+                {
+                    UserId = userId,
+                    Bucket = storageConfiguration.Bucket,
+                    Key = item.Key,
+                    ObjectName = item.ObjectName,
+                    ContentType = item.Request.ContentType,
+                    ExpectedSizeBytes = item.Size,
+                    Purpose = item.Request.Purpose,
+                    ExpiresAt = expiresAt,
+                };
+
+                await database.UploadIntents.AddAsync(intent, cancellationToken);
+                issued.Add(new IssuedUpload(intent.Id, item.Key, item.ObjectName, item.Request.ContentType, uploadUrl));
+            }
+
+            await database.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+
+            logger.LogInformation("Issued {Count} upload intents for user {UserId} ({Purposes})",
+                issued.Count, userId, string.Join('/', planned.Select(item => item.Request.Purpose)));
+
+            return issued;
+        }
+
+        public async Task<ErrorOr<IssuedUpload>> IssueOneAsync(long userId, UploadRequest request, CancellationToken cancellationToken)
+        {
+            var issued = await IssueAsync(userId, [request], cancellationToken);
+            return issued.IsError ? issued.Errors : issued.Value[0];
+        }
+
+        public async Task<ErrorOr<PictureUploadResponse>> IssuePictureAsync(
+            long userId,
+            UploadIntentPurpose purpose,
+            IPictureOwnerConfiguration owner,
+            string fileType,
+            string contentType,
+            long? expectedSizeBytes,
+            CancellationToken cancellationToken)
+        {
+            var issued = await IssueOneAsync(
+                userId, new UploadRequest(purpose, owner.Routes, fileType, contentType, expectedSizeBytes), cancellationToken);
+            if (issued.IsError)
+                return issued.Errors;
+
+            return new PictureUploadResponse(
+                issued.Value.IntentId,
+                storageConfiguration.Bucket,
+                issued.Value.Key,
+                issued.Value.ObjectName,
+                issued.Value.ContentType,
+                uploadIntentConfiguration.UploadUrlExpiresInSeconds,
+                issued.Value.UploadUrl);
+        }
+
+        private long DefaultSize(UploadIntentPurpose purpose) =>
+            purpose == UploadIntentPurpose.TrackAudio
+                ? uploadIntentConfiguration.DefaultExpectedAudioSizeBytes
+                : uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
+    }
+}

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

@@ -1,59 +1,73 @@
 using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.Services;
 
+namespace Musify.Application.Services
+{
     public sealed class UploadIntentValidator(
         IDatabase database,
-    IStorageService storageService)
+        IStorageService storageService,
+        UploadIntentConfiguration config)
     {
         public async Task<ErrorOr<Success>> CheckQuotaAsync(
-        UploadIntentConfiguration config,
             long userId,
             long requiredBytes,
             int requiredIntentCount,
             CancellationToken cancellationToken)
         {
-        var activeIntents = await database.UploadIntents
-            .AsNoTracking()
-            .Where(i => i.UserId == userId && i.Status == UploadIntentStatus.Issued)
-            .ToListAsync(cancellationToken);
+            var now = DateTime.UtcNow;
+            var pictureDefault = config.DefaultExpectedPictureSizeBytes;
+            var audioDefault = config.DefaultExpectedAudioSizeBytes;
 
-        if (activeIntents.Count + requiredIntentCount > config.MaxActiveUploadIntentsPerUser)
+            var active = await database.UploadIntents
+                .AsNoTracking()
+                .Where(intent => intent.UserId == userId && intent.Status == UploadIntentStatus.Issued && intent.ExpiresAt > now)
+                .GroupBy(_ => 1)
+                .Select(group => new
+                {
+                    Count = group.Count(),
+                    Bytes = group.Sum(intent => intent.ExpectedSizeBytes
+                        ?? (intent.Purpose == UploadIntentPurpose.TrackAudio ? audioDefault : pictureDefault))
+                })
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if ((active?.Count ?? 0) + requiredIntentCount > config.MaxActiveUploadIntentsPerUser)
                 return Error.Validation(description: "Upload intent limit exceeded. Wait for existing uploads to complete or expire.");
 
-        var activeBytes = activeIntents.Sum(i => i.ExpectedSizeBytes ?? config.DefaultExpectedPictureSizeBytes);
-        if (activeBytes + requiredBytes > config.MaxActiveUploadBytesPerUser)
+            if ((active?.Bytes ?? 0) + requiredBytes > config.MaxActiveUploadBytesPerUser)
                 return Error.Validation(description: "Upload byte quota exceeded. Wait for existing uploads to complete or expire.");
 
-        return new Success();
+            return Result.Success;
         }
 
         public async Task<ErrorOr<UploadIntent>> ValidateAndLoadAsync(
-        UploadIntentConfiguration config,
             Guid intentId,
             long userId,
+            UploadIntentPurpose purpose,
             CancellationToken cancellationToken)
         {
             var intent = await database.UploadIntents
                 .FirstOrDefaultAsync(i => i.Id == intentId, cancellationToken);
 
-        if (intent is null || intent.UserId != userId)
-            return Error.NotFound(description: "Upload intent not found or not accessible.");
+            if (intent == null || intent.UserId != userId)
+                return AppErrors.NotFound("UploadIntent", intentId);
+
+            if (intent.Purpose != purpose)
+                return Error.Validation(description: "Upload intent was issued for a different purpose.");
 
             if (intent.IsConsumed)
-            return Error.Conflict(description: "Upload intent has already been consumed.");
+                return AppErrors.Conflict("UploadIntent.Consumed", "Upload intent has already been consumed.");
 
-        if (intent.IsExpired)
+            if (intent.IsExpiredAt(DateTime.UtcNow))
                 return Error.Validation(description: "Upload intent has expired.");
 
             var metadata = await storageService.HeadObjectAsync(intent.Bucket, intent.Key, cancellationToken);
-        if (metadata is null)
-            return Error.NotFound(description: "Uploaded object not found in storage. Upload the file first.");
+            if (metadata == null)
+                return Error.NotFound("UploadIntent.ObjectMissing", "Uploaded object not found in storage. Upload the file first.");
 
             if (metadata.ContentLength > config.MaxUploadBytes)
                 return Error.Validation(description: $"Uploaded file exceeds the maximum allowed size of {config.MaxUploadBytes} bytes.");
@@ -61,3 +75,4 @@ public sealed class UploadIntentValidator(
             return intent;
         }
     }
+}

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

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

backend/Core/Musify.Application/Shared/AppErrors.cs

@@ -0,0 +1,16 @@
+using ErrorOr;
+
+namespace Musify.Application.Shared
+{
+    public static class AppErrors
+    {
+        public static Error NotFound(string entity, object id) =>
+            Error.NotFound($"{entity}.NotFound", $"{entity} {id} was not found.");
+
+        public static Error Forbidden(string entity, object id) =>
+            Error.Forbidden($"{entity}.Forbidden", $"You do not have permission to modify {entity} {id}.");
+
+        public static Error Conflict(string code, string description) =>
+            Error.Conflict(code, description);
+    }
+}

backend/Core/Musify.Application/Shared/ImageSize.cs

@@ -1,7 +1,12 @@
-namespace Musify.Application.Shared
+namespace Musify.Application.Shared
 {
     public record ImageSize(
         string SavePath,
         int Width,
         int Height);
+
+    public record ImageSizes(
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
 }

backend/Core/Musify.Application/Shared/OwnershipExtensions.cs

@@ -0,0 +1,29 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Domain.Abstractions;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Shared
+{
+    public static class OwnershipExtensions
+    {
+        /// <summary>
+        /// Loads an active, tracked entity owned by <paramref name="userId"/>: NotFound when it is missing
+        /// or not active, Forbidden when someone else owns it.
+        /// </summary>
+        public static async Task<ErrorOr<T>> FindOwnedAsync<T>(
+            this DbSet<T> set, Guid id, long userId, CancellationToken cancellationToken)
+            where T : class, IOwnedEntity, IHasLifeCycle
+        {
+            var entity = await set.SingleOrDefaultAsync(
+                e => e.Id == id && e.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
+
+            if (entity == null)
+                return AppErrors.NotFound(typeof(T).Name, id);
+
+            return entity.OwnerUserId == userId
+                ? entity
+                : AppErrors.Forbidden(typeof(T).Name, id);
+        }
+    }
+}

backend/Core/Musify.Application/Shared/PaginatedResponse.cs

@@ -1,26 +0,0 @@
-using X.PagedList;
-
-namespace Musify.Application.Shared
-{
-    public record PaginatedResponse<T>(
-        IReadOnlyCollection<T> Items,
-        int PageNumber,
-        int PageSize,
-        int PageCount,
-        int TotalItemCount,
-        bool HasNextPage,
-        bool HasPreviousPage)
-    {
-        public static PaginatedResponse<T> FromPagedList(IPagedList<T> pagedList)
-        {
-            return new PaginatedResponse<T>(
-                pagedList.ToArray(),
-                pagedList.PageNumber,
-                pagedList.PageSize,
-                pagedList.PageCount,
-                pagedList.TotalItemCount,
-                pagedList.HasNextPage,
-                pagedList.HasPreviousPage);
-        }
-    }
-}

backend/Core/Musify.Application/Shared/Pagination.cs

@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Musify.Application.Shared
+{
+    public record PageRequest(int PageNumber = 1, int PageSize = 20)
+    {
+        public const int MaxPageSize = 100;
+    }
+
+    public record PaginatedResponse<T>(
+        IReadOnlyList<T> Items,
+        int PageNumber,
+        int PageSize,
+        int PageCount,
+        int TotalItemCount,
+        bool HasNextPage,
+        bool HasPreviousPage);
+
+    public static class PaginationExtensions
+    {
+        /// <summary>Counts and pages the same (already filtered, ordered and projected) query.</summary>
+        public static async Task<PaginatedResponse<T>> ToPaginatedAsync<T>(
+            this IQueryable<T> query, PageRequest page, CancellationToken cancellationToken)
+        {
+            var pageNumber = Math.Max(page.PageNumber, 1);
+            var pageSize = Math.Clamp(page.PageSize, 1, PageRequest.MaxPageSize);
+
+            var totalCount = await query.CountAsync(cancellationToken);
+            var items = await query
+                .Skip((pageNumber - 1) * pageSize)
+                .Take(pageSize)
+                .ToListAsync(cancellationToken);
+
+            var pageCount = (int)Math.Ceiling(totalCount / (double)pageSize);
+
+            return new PaginatedResponse<T>(
+                items,
+                pageNumber,
+                pageSize,
+                pageCount,
+                totalCount,
+                HasNextPage: pageNumber < pageCount,
+                HasPreviousPage: pageNumber > 1 && pageCount > 0);
+        }
+    }
+}