Merge branch 'master' into dynamic-genres

Reviewed-on: #19

.gitea/workflows/ci-cd.yml

@@ -0,0 +1,115 @@
+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: Migrate database, generate keys
+        run: |
+          set -euo pipefail
+          cd "$DEPLOY_PATH"
+          $COMPOSE up -d wait-for-postgres keys-init 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

@@ -28,5 +28,4 @@ Thumbs.db
 # Deploy secrets and runtime state
 deploy/keys/
 deploy/secrets/
-deploy/nginx/certs/
 deploy/zitadel/.output/

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

@@ -36,7 +36,7 @@ namespace Musify.Application.Albums
 
             var pagedEntities = await tracksQuery
                 .OrderBy(albumTrack => albumTrack.TrackNumber)
-                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count })
+                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var pagedTracks = new StaticPagedList<TrackApplicationResponse>(

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

@@ -16,7 +16,7 @@ namespace Musify.Application.Albums
         {
             var listenedTrackIds = database.ListeningHistories
                 .AsNoTracking()
-                .Where(history => history.UserId == request.UserId);
+                .Where(history => history.UserId == request.UserId && history.IsCounted);
 
             var ranked = await database.AlbumHasTracks
                 .AsNoTracking()

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

@@ -0,0 +1,26 @@
+using Mediator;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Genres
+{
+    public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
+
+    public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);
+
+    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,31 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Genres
+{
+    public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
+
+    public record GenreResponse(Genre Genre, int TrackCount);
+
+    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 => database.UserHasTracks.Any(userTrack => userTrack.TrackId == tag.TrackId))
+                .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/Likes/GetLikedTracks.cs

@@ -30,7 +30,7 @@ namespace Musify.Application.Likes
 
             var pagedEntities = await likesQuery
                 .OrderByDescending(like => like.CreatedAt)
-                .Select(like => new { like.Track, ListensCount = like.Track.ListeningHistories.Count })
+                .Select(like => new { like.Track, ListensCount = like.Track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var pagedTracks = new StaticPagedList<TrackApplicationResponse>(

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

@@ -38,7 +38,7 @@ namespace Musify.Application.Mixes
 
             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);

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

@@ -19,7 +19,7 @@ namespace Musify.Application.Mixes
                 .AsNoTracking()
                 .Include(track => track.Owner)
                 .Where(track => trackIds.Contains(track.Id))
-                .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count })
+                .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
 
             return orderedItems

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

@@ -36,7 +36,7 @@ namespace Musify.Application.PlayLists
 
             var pagedEntities = await tracksQuery
                 .OrderBy(plt => plt.Position)
-                .Select(plt => new { plt.Track, ListensCount = plt.Track.ListeningHistories.Count })
+                .Select(plt => new { plt.Track, ListensCount = plt.Track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var pagedTracks = new StaticPagedList<TrackApplicationResponse>(

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

@@ -30,6 +30,7 @@ public sealed class TrackStreamIssuer(
             folderPath,
             streamGatewayConfiguration.AudioFileName);
 
+        Guid? listenId = null;
         if (userId != null)
         {
             var newListeningHistory = new ListeningHistory
@@ -39,9 +40,10 @@ public sealed class TrackStreamIssuer(
             };
             await database.ListeningHistories.AddAsync(newListeningHistory, cancellationToken);
             await database.SaveChangesAsync(cancellationToken);
+            listenId = newListeningHistory.Id;
         }
 
-        return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds);
+        return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds, listenId);
     }
 
     private long? AnonymousFragmentBytes(long? userId)

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

@@ -0,0 +1,33 @@
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Tracks
+{
+    public record DeleteStaleUncountedListensCommand : ICommand<int>;
+
+    public class DeleteStaleUncountedListensCommandHandler(
+        IDatabase database,
+        ILogger<DeleteStaleUncountedListensCommandHandler> logger)
+        : ICommandHandler<DeleteStaleUncountedListensCommand, int>
+    {
+        public async ValueTask<int> Handle(DeleteStaleUncountedListensCommand request, CancellationToken cancellationToken)
+        {
+            var cutoff = DateTime.UtcNow.AddDays(-ListeningRules.UncountedRetentionDays);
+
+            var stale = await database.ListeningHistories
+                .Where(l => !l.IsCounted && l.ListenedAt < cutoff)
+                .ToListAsync(cancellationToken);
+
+            if (stale.Count == 0)
+                return 0;
+
+            database.ListeningHistories.RemoveRange(stale);
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Deleted {Count} uncounted listens older than {Days} days", stale.Count, ListeningRules.UncountedRetentionDays);
+            return stale.Count;
+        }
+    }
+}

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

@@ -19,7 +19,7 @@ namespace Musify.Application.Tracks
                 .Include(t => t.Track.Tags)
                 .Where(t => t.UserId == query.UserId)
                 .OrderByDescending(t => t.ListenedAt)
-                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count))
+                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count(l => l.IsCounted)))
                 .FirstOrDefaultAsync(cancellationToken);
 
             return track == null

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

@@ -17,7 +17,7 @@ namespace Musify.Application.Tracks
         {
             var recentTrackIds = await database.ListeningHistories
                 .AsNoTracking()
-                .Where(l => l.UserId == query.UserId)
+                .Where(l => l.UserId == query.UserId && l.IsCounted)
                 .GroupBy(l => l.TrackId)
                 .OrderByDescending(g => g.Max(l => l.ListenedAt))
                 .Select(g => g.Key)
@@ -29,7 +29,7 @@ namespace Musify.Application.Tracks
                 .Include(t => t.Owner)
                 .Include(t => t.Tags)
                 .Where(t => recentTrackIds.Contains(t.Id))
-                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count })
+                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count(l => l.IsCounted) })
                 .ToDictionaryAsync(t => t.Id, cancellationToken);
 
             return recentTrackIds

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

@@ -18,7 +18,7 @@ namespace Musify.Application.Tracks
                 .Include(t => t.Owner)
                 .Include(t => t.Tags)
                 .Where(t => t.Id == request.TrackId)
-                .Select(t => new { Track = t, ListensCount = t.ListeningHistories.Count })
+                .Select(t => new { Track = t, ListensCount = t.ListeningHistories.Count(l => l.IsCounted) })
                 .SingleOrDefaultAsync(cancellationToken);
 
             if (entity == null)

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

@@ -5,10 +5,11 @@ using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
-    public record GetTracksQuery(string? Name, int PageNumber, int PageSize)
+    public record GetTracksQuery(string? Name, int PageNumber, int PageSize, Genre? Genre = null)
         : IQuery<ErrorOr<TracksSearchResponse>>;
 
     public class GetTracksQueryHandler(IDatabase database)
@@ -28,12 +29,15 @@ namespace Musify.Application.Tracks
                 tracksQuery = tracksQuery.Where(t => t.Track.NormalizedTitle.Contains(normalizedName));
             }
 
+            if (request.Genre is { } genre)
+                tracksQuery = tracksQuery.Where(t => t.Track.Tags.Any(tag => tag.Tag == genre));
+
             var totalCount = await tracksQuery.CountAsync(cancellationToken);
 
             var pagedEntities = await tracksQuery
                 .OrderByDescending(t => t.Track.CreatedAt)
                 .ThenBy(t => t.Id)
-                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count })
+                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var items = pagedEntities

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

@@ -40,7 +40,7 @@ namespace Musify.Application.Tracks
 
             var pagedEntities = await tracksQuery
                 .OrderBy(t => t.Track.CreatedAt)
-                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count })
+                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToPagedListAsync(pageNumber, pageSize, totalCount, cancellationToken);
 
             var pagedTracks = new StaticPagedList<TrackApplicationResponse>(

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

@@ -0,0 +1,14 @@
+namespace Musify.Application.Tracks
+{
+    public static class ListeningRules
+    {
+        public const double CountedThresholdSeconds = 30;
+        public const double CountedThresholdFraction = 0.5;
+        public const double DurationToleranceSeconds = 2;
+        public const double ClockToleranceSeconds = 5;
+        public const int UncountedRetentionDays = 8;
+
+        public static double CountedThreshold(double durationSeconds) =>
+            Math.Min(CountedThresholdSeconds, durationSeconds * CountedThresholdFraction);
+    }
+}

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

@@ -0,0 +1,44 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Tracks
+{
+    public record RecordListeningProgressCommand(
+        long UserId,
+        Guid ListenId,
+        double PlayedSeconds)
+        : ICommand<ErrorOr<Success>>;
+
+    public class RecordListeningProgressCommandHandler(IDatabase database)
+        : ICommandHandler<RecordListeningProgressCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(RecordListeningProgressCommand request, CancellationToken cancellationToken)
+        {
+            if (!double.IsFinite(request.PlayedSeconds) || request.PlayedSeconds < 0)
+                return Error.Validation(description: "playedSeconds must be a non-negative number.");
+
+            var listen = await database.ListeningHistories
+                .Include(l => l.Track)
+                .SingleOrDefaultAsync(l => l.Id == request.ListenId && l.UserId == request.UserId, cancellationToken);
+
+            if (listen == null)
+                return Error.NotFound();
+
+            var now = DateTime.UtcNow;
+            var durationCap = listen.Track.DurationSeconds + ListeningRules.DurationToleranceSeconds;
+            var clockCap = (now - listen.ListenedAt).TotalSeconds + ListeningRules.ClockToleranceSeconds;
+            var accepted = Math.Min(request.PlayedSeconds, Math.Min(durationCap, clockCap));
+
+            listen.PlayedSeconds = Math.Max(listen.PlayedSeconds ?? 0, accepted);
+            listen.LastProgressAt = now;
+            listen.IsCounted = listen.IsCounted
+                || listen.PlayedSeconds >= ListeningRules.CountedThreshold(listen.Track.DurationSeconds);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            return Result.Success;
+        }
+    }
+}

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

@@ -3,5 +3,6 @@ namespace Musify.Application.Tracks.Responses
     public record TrackStreamResponse(
         string ManifestUrl,
         string Ticket,
-        int ExpiresInSeconds);
+        int ExpiresInSeconds,
+        Guid? ListenId = null);
 }

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

@@ -20,17 +20,18 @@ namespace Musify.Application.Users
                 .Where(l => l.UserId == request.UserId && l.ListenedAt >= weekAgo);
 
             var tracksThisWeek = await thisWeekHistory
+                .Where(l => l.IsCounted)
                 .Select(l => l.TrackId)
                 .Distinct()
                 .CountAsync(cancellationToken);
 
             var secondsThisWeek = await thisWeekHistory
-                .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => t.DurationSeconds)
+                .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => l.PlayedSeconds ?? (l.IsCounted ? t.DurationSeconds : 0))
                 .SumAsync(cancellationToken);
 
             var listenedDates = await database.ListeningHistories
                 .AsNoTracking()
-                .Where(l => l.UserId == request.UserId)
+                .Where(l => l.UserId == request.UserId && l.IsCounted)
                 .Select(l => l.ListenedAt.Date)
                 .Distinct()
                 .ToListAsync(cancellationToken);

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

@@ -19,6 +19,12 @@ namespace Musify.Domain.Entities
         [Required]
         public DateTime ListenedAt { get; set; } = DateTime.UtcNow;
 
+        public double? PlayedSeconds { get; set; }
+
+        public DateTime? LastProgressAt { get; set; }
+
+        public bool IsCounted { get; set; }
+
         [ForeignKey(nameof(UserId) )]
         public User User { get; set; }
 

backend/Core/Musify.Infrastructure/Jobs/DailyMixGenerationJob.cs

@@ -15,6 +15,7 @@ namespace Musify.Infrastructure.Jobs
         {
             var userIds = await database.ListeningHistories
                 .AsNoTracking()
+                .Where(history => history.IsCounted)
                 .Select(history => history.UserId)
                 .Distinct()
                 .ToListAsync(cancellationToken);

backend/Core/Musify.Infrastructure/Jobs/ListeningHistoryCleanupJob.cs

@@ -0,0 +1,13 @@
+using Mediator;
+using Musify.Application.Tracks;
+
+namespace Musify.Infrastructure.Jobs
+{
+    public class ListeningHistoryCleanupJob(IMediator mediator)
+    {
+        public async Task RunAsync(CancellationToken cancellationToken)
+        {
+            await mediator.Send(new DeleteStaleUncountedListensCommand(), cancellationToken);
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/AuditableEntityInterceptor.cs

@@ -37,7 +37,7 @@ namespace Musify.Infrastructure.Persistence
                 }
                 else if (entry.State == EntityState.Modified)
                 {
-                    entry.Entity.UpdatedAt = now;
+                    entry.Property(nameof(IAuditable.UpdatedAt)).CurrentValue = now;
                 }
             }
         }

backend/Core/Musify.Infrastructure/Persistence/Database.cs

@@ -13,9 +13,13 @@ namespace Musify.Infrastructure.Persistence
     public class Database(DatabaseConfiguration configuration)
         : DbContext, AppIDatabase
     {
+        private static readonly AuditableEntityInterceptor AuditInterceptor = new();
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
-            optionsBuilder.UseNpgsql(configuration.ConnectionString, o => o.MapEnum<Genre>("genre"));
+            optionsBuilder
+                .UseNpgsql(configuration.ConnectionString, o => o.MapEnum<Genre>("genre"))
+                .AddInterceptors(AuditInterceptor);
         }
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)

backend/Core/Musify.Infrastructure/Persistence/DatabaseDependencyInjection.cs

@@ -18,10 +18,7 @@ namespace Musify.Infrastructure.Persistence
             serviceDescriptors.AddSingleton(serviceProvider =>
                 serviceProvider.GetRequiredService<IOptions<DatabaseConfiguration>>().Value);
 
-            serviceDescriptors.AddSingleton<AuditableEntityInterceptor>();
-
-            serviceDescriptors.AddDbContext<Database>((serviceProvider, options) =>
-                options.AddInterceptors(serviceProvider.GetRequiredService<AuditableEntityInterceptor>()));
+            serviceDescriptors.AddDbContext<Database>();
 
             serviceDescriptors.AddScoped<IDatabase>(serviceProvider => serviceProvider.GetRequiredService<Database>());
 

backend/Core/Musify.Infrastructure/Persistence/Migrations/20260923172640_TrackPlayedSeconds.cs

@@ -0,0 +1,52 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class TrackPlayedSeconds : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsCounted",
+                table: "ListeningHistory",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastProgressAt",
+                table: "ListeningHistory",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<double>(
+                name: "PlayedSeconds",
+                table: "ListeningHistory",
+                type: "double precision",
+                nullable: true);
+
+            migrationBuilder.Sql("UPDATE \"ListeningHistory\" SET \"IsCounted\" = TRUE;");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsCounted",
+                table: "ListeningHistory");
+
+            migrationBuilder.DropColumn(
+                name: "LastProgressAt",
+                table: "ListeningHistory");
+
+            migrationBuilder.DropColumn(
+                name: "PlayedSeconds",
+                table: "ListeningHistory");
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/Migrations/DatabaseModelSnapshot.cs

@@ -1,4 +1,4 @@
-
+// <auto-generated />
 using System;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -68,7 +68,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("Delivered");
 
-                    b.ToTable("InboxState", (string)null);
+                    b.ToTable("InboxState");
                 });
 
             modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
@@ -159,7 +159,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber")
                         .IsUnique();
 
-                    b.ToTable("OutboxMessage", (string)null);
+                    b.ToTable("OutboxMessage");
                 });
 
             modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b =>
@@ -189,7 +189,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("Created");
 
-                    b.ToTable("OutboxState", (string)null);
+                    b.ToTable("OutboxState");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.Album", b =>
@@ -231,7 +231,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("OwnerUserId");
 
-                    b.ToTable("Albums", (string)null);
+                    b.ToTable("Albums");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.AlbumHasTrack", b =>
@@ -259,7 +259,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.HasIndex("AlbumId", "TrackId")
                         .IsUnique();
 
-                    b.ToTable("AlbumHasTrack", (string)null);
+                    b.ToTable("AlbumHasTrack");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.ListeningHistory", b =>
@@ -268,9 +268,18 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uuid");
 
+                    b.Property<bool>("IsCounted")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastProgressAt")
+                        .HasColumnType("timestamp with time zone");
+
                     b.Property<DateTime>("ListenedAt")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<double?>("PlayedSeconds")
+                        .HasColumnType("double precision");
+
                     b.Property<Guid>("TrackId")
                         .HasColumnType("uuid");
 
@@ -283,7 +292,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("ListeningHistory", (string)null);
+                    b.ToTable("ListeningHistory");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.Mix", b =>
@@ -317,7 +326,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("UserId", "Position");
 
-                    b.ToTable("Mixes", (string)null);
+                    b.ToTable("Mixes");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.MixItem", b =>
@@ -341,7 +350,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("MixId", "Position");
 
-                    b.ToTable("MixItems", (string)null);
+                    b.ToTable("MixItems");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
@@ -385,7 +394,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("PlayLists", (string)null);
+                    b.ToTable("PlayLists");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.PlayListHasTrack", b =>
@@ -412,7 +421,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("TrackId");
 
-                    b.ToTable("PlayListHasTrack", (string)null);
+                    b.ToTable("PlayListHasTrack");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
@@ -450,7 +459,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("OwnerUserId");
 
-                    b.ToTable("Tracks", (string)null);
+                    b.ToTable("Tracks");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.TrackLike", b =>
@@ -475,7 +484,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.HasIndex("UserId", "TrackId")
                         .IsUnique();
 
-                    b.ToTable("TrackLikes", (string)null);
+                    b.ToTable("TrackLikes");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.TrackTag", b =>
@@ -495,7 +504,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.HasIndex("TrackId", "Tag")
                         .IsUnique();
 
-                    b.ToTable("TrackTags", (string)null);
+                    b.ToTable("TrackTags");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.Upload", b =>
@@ -524,7 +533,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Upload", (string)null);
+                    b.ToTable("Upload");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.UploadIntent", b =>
@@ -575,7 +584,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("UploadIntents", (string)null);
+                    b.ToTable("UploadIntents");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.User", b =>
@@ -613,7 +622,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("User", (string)null);
+                    b.ToTable("User");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.UserFollow", b =>
@@ -638,7 +647,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.HasIndex("FollowerId", "FollowedId")
                         .IsUnique();
 
-                    b.ToTable("UserFollows", (string)null);
+                    b.ToTable("UserFollows");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
@@ -659,7 +668,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("UserHasTrack", (string)null);
+                    b.ToTable("UserHasTrack");
                 });
 
             modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.AlbumProcessingState", b =>
@@ -686,7 +695,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasKey("CorrelationId");
 
-                    b.ToTable("AlbumProcessingState", (string)null);
+                    b.ToTable("AlbumProcessingState");
                 });
 
             modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.PlayListProcessingState", b =>
@@ -713,7 +722,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasKey("CorrelationId");
 
-                    b.ToTable("PlayListProcessingState", (string)null);
+                    b.ToTable("PlayListProcessingState");
                 });
 
             modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.TrackProcessingState", b =>
@@ -749,7 +758,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                     b.HasKey("CorrelationId");
 
-                    b.ToTable("TrackProcessingState", (string)null);
+                    b.ToTable("TrackProcessingState");
                 });
 
             modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
@@ -803,7 +812,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                             b1.HasKey("AlbumId");
 
-                            b1.ToTable("Albums", (string)null);
+                            b1.ToTable("Albums");
 
                             b1.WithOwner()
                                 .HasForeignKey("AlbumId");
@@ -896,32 +905,28 @@ namespace Musify.Infrastructure.Persistence.Migrations
                                 .HasColumnType("uuid");
 
                             b1.Property<string>("LargeName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("LargePictureName");
 
                             b1.Property<string>("MediumName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("MediumPictureName");
 
                             b1.Property<string>("OriginalName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("OriginalPictureName");
 
                             b1.Property<string>("SmallName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("SmallPictureName");
 
                             b1.HasKey("PlayListId");
 
-                            b1.ToTable("PlayLists", (string)null);
+                            b1.ToTable("PlayLists");
 
                             b1.WithOwner()
                                 .HasForeignKey("PlayListId");
@@ -992,7 +997,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                             b1.HasKey("TrackId");
 
-                            b1.ToTable("Tracks", (string)null);
+                            b1.ToTable("Tracks");
 
                             b1.WithOwner()
                                 .HasForeignKey("TrackId");
@@ -1029,7 +1034,7 @@ namespace Musify.Infrastructure.Persistence.Migrations
 
                             b1.HasKey("TrackId");
 
-                            b1.ToTable("Tracks", (string)null);
+                            b1.ToTable("Tracks");
 
                             b1.WithOwner()
                                 .HasForeignKey("TrackId");

backend/Core/Musify.Infrastructure/Services/ServicesDependencyInjection.cs

@@ -74,6 +74,7 @@ namespace Musify.Infrastructure.Services
 
             serviceDescriptors.AddHangfireServer();
             serviceDescriptors.AddScoped<DailyMixGenerationJob>();
+            serviceDescriptors.AddScoped<ListeningHistoryCleanupJob>();
 
             return serviceDescriptors;
         }

backend/Hosts/Musify.Api/DataTransferObjects/Tracks/RecordListeningProgressRequest.cs

@@ -0,0 +1,3 @@
+namespace Musify.Api.DataTransferObjects.Tracks;
+
+public record RecordListeningProgressRequest(double PlayedSeconds);

backend/Hosts/Musify.Api/Endpoints/GenreEndpoints.cs

@@ -0,0 +1,39 @@
+using Mediator;
+using Musify.Application.Genres;
+
+namespace Musify.Api.Endpoints;
+
+public static class GenreEndpoints
+{
+    public static IEndpointRouteBuilder MapGenreEndpoints(this IEndpointRouteBuilder app)
+    {
+        var group = app.MapGroup("/genres")
+            .WithTags("Genres");
+
+        group.MapGet("/", GetGenres)
+            .WithName("GetGenres")
+            .WithSummary("Get The Genres That Have At Least One Track, Most Populated First. Works Anonymously.")
+            .Produces<IReadOnlyList<GenreResponse>>();
+
+        group.MapGet("/available", GetAvailableGenres)
+            .WithName("GetAvailableGenres")
+            .WithSummary("Get Every Genre A Track Can Be Tagged With, Including The Genres It Cannot Be Combined With. Works Anonymously.")
+            .Produces<IReadOnlyList<AvailableGenreResponse>>();
+
+        return app;
+    }
+
+    private static async Task<IReadOnlyList<AvailableGenreResponse>> GetAvailableGenres(
+        IMediator mediator,
+        CancellationToken cancellationToken)
+    {
+        return await mediator.Send(new GetAvailableGenresQuery(), cancellationToken);
+    }
+
+    private static async Task<IReadOnlyList<GenreResponse>> GetGenres(
+        IMediator mediator,
+        CancellationToken cancellationToken)
+    {
+        return await mediator.Send(new GetGenresQuery(), cancellationToken);
+    }
+}

backend/Hosts/Musify.Api/Endpoints/TrackEndpoints.cs

@@ -1,4 +1,5 @@
 using Mediator;
+using Musify.Domain.ValueObjects;
 using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
 using Musify.Application.Shared;
@@ -19,8 +20,9 @@ public static class TrackEndpoints
 
         group.MapGet("/", GetTracks)
             .WithName("GetTracks")
-            .WithSummary("Get Paginated Tracks, Optionally Filtered By Name.")
-            .Produces<TracksSearchResponse>();
+            .WithSummary("Get Paginated Tracks, Optionally Filtered By Name And Genre.")
+            .Produces<TracksSearchResponse>()
+            .ProducesValidationProblem();
 
         group.MapGet("/{id}", GetTrackById)
             .WithName("GetTrackById")
@@ -41,6 +43,14 @@ public static class TrackEndpoints
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
+        group.MapPut("/listens/{listenId}/progress", RecordListeningProgress)
+            .WithName("RecordListeningProgress")
+            .WithSummary("Report The Total Seconds Actually Played For A Listen Started By The Stream Endpoint.")
+            .RequireAuthorization()
+            .Produces(StatusCodes.Status204NoContent)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces(StatusCodes.Status404NotFound);
+
         group.MapGet("/users/{userId}", GetTracksByUserId)
             .WithName("GetTracksByUserId")
             .WithSummary("Get Paginated Tracks For A User.")
@@ -84,10 +94,25 @@ public static class TrackEndpoints
         IMediator mediator,
         CancellationToken cancellationToken,
         string? name,
+        string? genre,
         int pageNumber = 1,
         int pageSize = 10)
     {
-        var result = await mediator.Send(new GetTracksQuery(name, pageNumber, pageSize), cancellationToken);
+        Genre? parsedGenre = null;
+        if (!string.IsNullOrWhiteSpace(genre))
+        {
+            if (!Enum.TryParse<Genre>(genre, ignoreCase: true, out var value) || !Enum.IsDefined(value))
+            {
+                return Results.ValidationProblem(new Dictionary<string, string[]>
+                {
+                    [nameof(genre)] = [$"'{genre}' is not a valid genre."]
+                });
+            }
+
+            parsedGenre = value;
+        }
+
+        var result = await mediator.Send(new GetTracksQuery(name, pageNumber, pageSize, parsedGenre), cancellationToken);
         return result.ToHttpResult();
     }
 
@@ -128,6 +153,19 @@ public static class TrackEndpoints
         return result.ToHttpResult();
     }
 
+    private static async Task<IResult> RecordListeningProgress(
+        IMediator mediator,
+        CurrentUser currentUser,
+        Guid listenId,
+        RecordListeningProgressRequest request,
+        CancellationToken cancellationToken)
+    {
+        var result = await mediator.Send(
+            new RecordListeningProgressCommand(currentUser.RequiredId, listenId, request.PlayedSeconds),
+            cancellationToken);
+        return result.ToHttpResult();
+    }
+
     private static async Task<IResult> GetTracksByUserId(
         IMediator mediator,
         long userId,

backend/Hosts/Musify.Api/Program.cs

@@ -40,6 +40,7 @@ app.UseAuthorization();
 app
     .MapAlbumEndpoints()
     .MapConfigEndpoints()
+    .MapGenreEndpoints()
     .MapLikeEndpoints()
     .MapMixEndpoints()
     .MapPlayListEndpoints()

backend/Hosts/Musify.Worker/Program.cs

@@ -41,6 +41,11 @@ using (var scope = host.Services.CreateScope())
         job => job.RunAsync(CancellationToken.None),
         Cron.Daily(),
         new RecurringJobOptions { TimeZone = TimeZoneInfo.Utc });
+    recurringJobManager.AddOrUpdate<ListeningHistoryCleanupJob>(
+        "listening-history-cleanup",
+        job => job.RunAsync(CancellationToken.None),
+        Cron.Daily(3),
+        new RecurringJobOptions { TimeZone = TimeZoneInfo.Utc });
 }
 
 host.Run();

backend/Tests/Musify.Api.Tests/Endpoints/GenreEndpointsTests.cs

@@ -0,0 +1,106 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.DependencyInjection;
+using Musify.Api.Tests.TestSupport;
+using Musify.Application.Genres;
+using Musify.Application.Tracks.Responses;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.Persistence;
+using Xunit;
+
+namespace Musify.Api.Tests.Endpoints
+{
+    [Collection(ApiCollection.Name)]
+    public sealed class GenreEndpointsTests(ApiTestFixture fixture)
+    {
+        private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+        {
+            Converters = { new JsonStringEnumConverter() }
+        };
+
+        private async Task<string> SeedTrackAsync(Genre genre)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var owner = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = "genre-owner", NormalizedName = "GENRE-OWNER" };
+            var title = $"Genre track {Guid.NewGuid():N}";
+            var track = new Track
+            {
+                Title = title,
+                NormalizedTitle = title.ToUpperInvariant(),
+                OwnerUserId = owner.Id,
+                Owner = owner,
+                Tags = [new TrackTag { TrackId = Guid.Empty, Tag = genre }]
+            };
+            foreach (var tag in track.Tags)
+                tag.TrackId = track.Id;
+            database.Users.Add(owner);
+            database.Tracks.Add(track);
+            database.UserHasTracks.Add(new UserHasTrack { UserId = owner.Id, TrackId = track.Id });
+            await database.SaveChangesAsync(TestContext.Current.CancellationToken);
+            return title;
+        }
+
+        [Fact]
+        public async Task GetGenres_Anonymous_ListsGenresInUse()
+        {
+            await SeedTrackAsync(Genre.Funk);
+
+            var response = await fixture.CreateAnonymousClient().GetAsync("/genres", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await response.Content.ReadFromJsonAsync<List<GenreResponse>>(JsonOptions, TestContext.Current.CancellationToken);
+            Assert.Contains(body!, g => g.Genre == Genre.Funk && g.TrackCount >= 1);
+        }
+
+        [Fact]
+        public async Task GetAvailableGenres_Anonymous_ListsEveryGenreWithIncompatibilities()
+        {
+            var response = await fixture.CreateAnonymousClient().GetAsync("/genres/available", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await response.Content.ReadFromJsonAsync<List<AvailableGenreResponse>>(JsonOptions, TestContext.Current.CancellationToken);
+            Assert.Equal(Enum.GetValues<Genre>().Length, body!.Count);
+            Assert.Contains(Genre.Lofi, body.Single(g => g.Genre == Genre.Metal).IncompatibleWith);
+        }
+
+        [Theory]
+        [InlineData("Nope")]
+        [InlineData("999")]
+        public async Task GetTracks_UnknownGenre_ReturnsBadRequest(string genre)
+        {
+            var response = await fixture.CreateAnonymousClient().GetAsync($"/tracks?genre={genre}", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetTracks_GenreQuery_IsCaseInsensitive()
+        {
+            var title = await SeedTrackAsync(Genre.Blues);
+
+            var response = await fixture.CreateAnonymousClient().GetAsync("/tracks?genre=blues&pageSize=100", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await response.Content.ReadFromJsonAsync<TracksSearchResponse>(JsonOptions, TestContext.Current.CancellationToken);
+            Assert.Contains(body!.Items, item => item.Track.Title == title);
+        }
+
+        [Fact]
+        public async Task GetTracks_GenreQuery_FiltersByTag()
+        {
+            var title = await SeedTrackAsync(Genre.Ambient);
+            await SeedTrackAsync(Genre.Techno);
+
+            var response = await fixture.CreateAnonymousClient().GetAsync("/tracks?genre=Ambient&pageSize=100", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await response.Content.ReadFromJsonAsync<TracksSearchResponse>(JsonOptions, TestContext.Current.CancellationToken);
+            Assert.Contains(body!.Items, item => item.Track.Title == title);
+            Assert.All(body.Items, item => Assert.Contains(Genre.Ambient, item.Track.Tags));
+        }
+    }
+}

backend/Tests/Musify.Api.Tests/Endpoints/ListeningProgressEndpointsTests.cs

@@ -0,0 +1,109 @@
+using System.Net;
+using System.Net.Http.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Musify.Api.DataTransferObjects.Tracks;
+using Musify.Api.DataTransferObjects.Users;
+using Musify.Domain.Entities;
+using Musify.Infrastructure.Persistence;
+using Xunit;
+using Musify.Api.Tests.TestSupport;
+
+namespace Musify.Api.Tests.Endpoints
+{
+    [Collection(ApiCollection.Name)]
+    public sealed class ListeningProgressEndpointsTests(ApiTestFixture fixture)
+    {
+        private async Task<long> CreateUserAsync()
+        {
+            var userId = Random.Shared.NextInt64(1, long.MaxValue);
+            var response = await fixture.CreateAnonymousClient().PostAsJsonAsync(
+                "/users", new CreateUserRequest(userId, $"user-{userId}", null, null), TestContext.Current.CancellationToken);
+            response.EnsureSuccessStatusCode();
+            return userId;
+        }
+
+        private async Task<Guid> SeedListenAsync(long userId, double durationSeconds)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var owner = await database.Users.SingleAsync(u => u.Id == userId, TestContext.Current.CancellationToken);
+            var track = new Track
+            {
+                Title = "Progress track",
+                NormalizedTitle = "PROGRESS TRACK",
+                OwnerUserId = owner.Id,
+                Owner = owner,
+                DurationSeconds = durationSeconds
+            };
+            var listen = new ListeningHistory
+            {
+                UserId = userId,
+                TrackId = track.Id,
+                ListenedAt = DateTime.UtcNow.AddMinutes(-10)
+            };
+            database.Tracks.Add(track);
+            database.ListeningHistories.Add(listen);
+            await database.SaveChangesAsync(TestContext.Current.CancellationToken);
+            return listen.Id;
+        }
+
+        private async Task<ListeningHistory> LoadListenAsync(Guid listenId)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            return await database.ListeningHistories.AsNoTracking()
+                .SingleAsync(l => l.Id == listenId, TestContext.Current.CancellationToken);
+        }
+
+        [Fact]
+        public async Task PutProgress_Anonymous_ReturnsUnauthorized()
+        {
+            var response = await fixture.CreateAnonymousClient().PutAsJsonAsync(
+                $"/tracks/listens/{Guid.NewGuid()}/progress", new RecordListeningProgressRequest(10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task PutProgress_OwnListen_StoresSecondsAndMarksCounted()
+        {
+            var userId = await CreateUserAsync();
+            var listenId = await SeedListenAsync(userId, durationSeconds: 200);
+
+            var response = await fixture.CreateAuthenticatedClient(userId).PutAsJsonAsync(
+                $"/tracks/listens/{listenId}/progress", new RecordListeningProgressRequest(45), TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+            var stored = await LoadListenAsync(listenId);
+            Assert.Equal(45, stored.PlayedSeconds);
+            Assert.True(stored.IsCounted);
+        }
+
+        [Fact]
+        public async Task PutProgress_OtherUsersListen_ReturnsNotFound()
+        {
+            var ownerId = await CreateUserAsync();
+            var otherId = await CreateUserAsync();
+            var listenId = await SeedListenAsync(ownerId, durationSeconds: 200);
+
+            var response = await fixture.CreateAuthenticatedClient(otherId).PutAsJsonAsync(
+                $"/tracks/listens/{listenId}/progress", new RecordListeningProgressRequest(45), TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+            Assert.Null((await LoadListenAsync(listenId)).PlayedSeconds);
+        }
+
+        [Fact]
+        public async Task PutProgress_NegativeSeconds_ReturnsBadRequest()
+        {
+            var userId = await CreateUserAsync();
+            var listenId = await SeedListenAsync(userId, durationSeconds: 200);
+
+            var response = await fixture.CreateAuthenticatedClient(userId).PutAsJsonAsync(
+                $"/tracks/listens/{listenId}/progress", new RecordListeningProgressRequest(-5), TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Albums/GetRecentlyListenedAlbumsQueryHandlerTests.cs

@@ -57,5 +57,25 @@ namespace Musify.Application.Tests.Albums
             Assert.False(result.IsError);
             Assert.Equal(2, result.Value.Count);
         }
+
+        [Fact]
+        public async Task Handle_UncountedListens_AreIgnored()
+        {
+            var owner = TestEntities.User();
+            var countedAlbum = TestEntities.Album(owner.Id, "Counted album");
+            var skippedAlbum = TestEntities.Album(owner.Id, "Skipped album");
+            var countedTrack = TestEntities.Track(owner, "In counted");
+            var skippedTrack = TestEntities.Track(owner, "In skipped");
+            await SeedAsync(
+                owner, countedAlbum, skippedAlbum, countedTrack, skippedTrack,
+                new AlbumHasTrack { AlbumId = countedAlbum.Id, TrackId = countedTrack.Id, TrackNumber = 1 },
+                new AlbumHasTrack { AlbumId = skippedAlbum.Id, TrackId = skippedTrack.Id, TrackNumber = 1 },
+                TestEntities.ListeningHistory(owner.Id, countedTrack.Id, DateTime.UtcNow.AddDays(-1), playedSeconds: 120),
+                TestEntities.ListeningHistory(owner.Id, skippedTrack.Id, DateTime.UtcNow, playedSeconds: 1, isCounted: false));
+
+            var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(["Counted album"], result.Value.Select(album => album.Title));
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Genres/GetAvailableGenresQueryHandlerTests.cs

@@ -0,0 +1,32 @@
+using Musify.Application.Genres;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Genres
+{
+    public sealed class GetAvailableGenresQueryHandlerTests
+    {
+        private static async Task<IReadOnlyList<AvailableGenreResponse>> RunAsync() =>
+            await new GetAvailableGenresQueryHandler().Handle(new GetAvailableGenresQuery(), TestContext.Current.CancellationToken);
+
+        [Fact]
+        public async Task Handle_ReturnsEveryGenre()
+        {
+            var result = await RunAsync();
+
+            Assert.Equal(Enum.GetValues<Genre>(), result.Select(r => r.Genre));
+        }
+
+        [Fact]
+        public async Task Handle_ListsIncompatibleGenresSymmetrically()
+        {
+            var result = await RunAsync();
+
+            var metal = result.Single(r => r.Genre == Genre.Metal);
+            var lofi = result.Single(r => r.Genre == Genre.Lofi);
+            Assert.Contains(Genre.Lofi, metal.IncompatibleWith);
+            Assert.Contains(Genre.Metal, lofi.IncompatibleWith);
+            Assert.Empty(result.Single(r => r.Genre == Genre.Pop).IncompatibleWith);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Genres/GetGenresQueryHandlerTests.cs

@@ -0,0 +1,69 @@
+using Musify.Application.Genres;
+using Musify.Application.Tests.TestSupport;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Genres
+{
+    public sealed class GetGenresQueryHandlerTests : HandlerTestBase
+    {
+        private GetGenresQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_NoTracks_ReturnsEmpty()
+        {
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Empty(result);
+        }
+
+        [Fact]
+        public async Task Handle_ReturnsOnlyGenresInUse_MostPopulatedFirst()
+        {
+            var owner = TestEntities.User();
+            var rockA = TestEntities.Track(owner, "Rock A", tags: [Genre.Rock]);
+            var rockB = TestEntities.Track(owner, "Rock B", tags: [Genre.Rock, Genre.Indie]);
+            var jazz = TestEntities.Track(owner, "Jazz", tags: [Genre.Jazz]);
+            await SeedAsync(
+                owner, rockA, rockB, jazz,
+                new UserHasTrack { UserId = owner.Id, TrackId = rockA.Id },
+                new UserHasTrack { UserId = owner.Id, TrackId = rockB.Id },
+                new UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
+
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(
+                [(Genre.Rock, 2), (Genre.Jazz, 1), (Genre.Indie, 1)],
+                result.Select(r => (r.Genre, r.TrackCount)));
+        }
+
+        [Fact]
+        public async Task Handle_TrackInSeveralLibraries_IsCountedOnce()
+        {
+            var owner = TestEntities.User();
+            var other = TestEntities.User(id: 2, name: "other-user");
+            var track = TestEntities.Track(owner, tags: [Genre.Pop]);
+            await SeedAsync(
+                owner, other, track,
+                new UserHasTrack { UserId = owner.Id, TrackId = track.Id },
+                new UserHasTrack { UserId = other.Id, TrackId = track.Id });
+
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, Assert.Single(result).TrackCount);
+        }
+
+        [Fact]
+        public async Task Handle_TrackNotInAnyLibrary_IsIgnored()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner, tags: [Genre.Metal]);
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Empty(result);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Mixes/GenerateMixesForUserCommandHandlerTests.cs

@@ -72,5 +72,21 @@ namespace Musify.Application.Tests.Mixes
                 .ToListAsync(TestContext.Current.CancellationToken);
             Assert.All(discoveryItems, item => Assert.Equal(unheardTrack.Id, item.TrackId));
         }
+
+        [Fact]
+        public async Task Handle_TrackWithOnlyUncountedListens_IsTreatedAsUnheard()
+        {
+            var user = TestEntities.User();
+            var skipped = TestEntities.Track(user, "Only skipped");
+            await SeedAsync(
+                user, skipped,
+                new UserHasTrack { UserId = user.Id, TrackId = skipped.Id },
+                TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
+
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+
+            var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
+        }
     }
 }

backend/Tests/Musify.Application.Tests/TestSupport/TestEntities.cs

@@ -177,12 +177,16 @@ namespace Musify.Application.Tests.TestSupport
         public static ListeningHistory ListeningHistory(
             long userId,
             Guid trackId,
-            DateTime? listenedAt = null) =>
+            DateTime? listenedAt = null,
+            double? playedSeconds = null,
+            bool isCounted = true) =>
             new()
             {
                 UserId = userId,
                 TrackId = trackId,
-                ListenedAt = listenedAt ?? DateTime.UtcNow
+                ListenedAt = listenedAt ?? DateTime.UtcNow,
+                PlayedSeconds = playedSeconds,
+                IsCounted = isCounted
             };
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/DeleteStaleUncountedListensCommandHandlerTests.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class DeleteStaleUncountedListensCommandHandlerTests : HandlerTestBase
+    {
+        private DeleteStaleUncountedListensCommandHandler CreateHandler() =>
+            new(Database, NoOpLogger<DeleteStaleUncountedListensCommandHandler>());
+
+        [Fact]
+        public async Task Handle_DeletesOnlyOldUncountedListens()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            var oldUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 2, isCounted: false);
+            var oldCounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 100);
+            var recentUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-2), playedSeconds: 2, isCounted: false);
+            await SeedAsync(owner, track, oldUncounted, oldCounted, recentUncounted);
+
+            var deleted = await CreateHandler().Handle(new DeleteStaleUncountedListensCommand(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, deleted);
+            var remaining = await Database.ListeningHistories.Select(l => l.Id).ToListAsync(TestContext.Current.CancellationToken);
+            Assert.DoesNotContain(oldUncounted.Id, remaining);
+            Assert.Contains(oldCounted.Id, remaining);
+            Assert.Contains(recentUncounted.Id, remaining);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Tracks/GetListeningHistoryQueryHandlerTests.cs

@@ -35,5 +35,21 @@ namespace Musify.Application.Tests.Tracks
 
             Assert.Empty(result);
         }
+
+        [Fact]
+        public async Task Handle_UncountedListens_AreIgnored()
+        {
+            var owner = TestEntities.User();
+            var counted = TestEntities.Track(owner, "Counted");
+            var skipped = TestEntities.Track(owner, "Skipped");
+            await SeedAsync(
+                owner, counted, skipped,
+                TestEntities.ListeningHistory(owner.Id, counted.Id, DateTime.UtcNow.AddMinutes(-5), playedSeconds: 90),
+                TestEntities.ListeningHistory(owner.Id, skipped.Id, DateTime.UtcNow, playedSeconds: 2, isCounted: false));
+
+            var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(["Counted"], result.Select(track => track.Title));
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/GetTrackByIdQueryHandlerTests.cs

@@ -33,5 +33,21 @@ namespace Musify.Application.Tests.Tracks
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_ListensCount_OnlyCountsCountedListens()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(
+                owner, track,
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 1, isCounted: false));
+
+            var result = await CreateHandler().Handle(new GetTrackByIdQuery(track.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(2, result.Value.ListensCount);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/GetTrackStreamQueryHandlerTests.cs

@@ -45,6 +45,9 @@ namespace Musify.Application.Tests.Tracks
             var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
             Assert.Equal(owner.Id, history.UserId);
             Assert.Equal(track.Id, history.TrackId);
+            Assert.Equal(history.Id, result.Value.ListenId);
+            Assert.False(history.IsCounted);
+            Assert.Null(history.PlayedSeconds);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/Tracks/GetTracksQueryHandlerTests.cs

@@ -1,5 +1,6 @@
 using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Tracks
@@ -43,5 +44,23 @@ namespace Musify.Application.Tests.Tracks
             var item = Assert.Single(result.Value.Items);
             Assert.Equal("Bohemian Rhapsody", item.Track.Title);
         }
+
+        [Fact]
+        public async Task Handle_GenreFilter_ReturnsOnlyTracksWithThatTag()
+        {
+            var owner = TestEntities.User();
+            var rock = TestEntities.Track(owner, "Loud", tags: [Genre.Rock, Genre.Indie]);
+            var jazz = TestEntities.Track(owner, "Smooth", tags: [Genre.Jazz]);
+            await SeedAsync(
+                owner, rock, jazz,
+                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = rock.Id },
+                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
+
+            var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var item = Assert.Single(result.Value.Items);
+            Assert.Equal("Loud", item.Track.Title);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/RecordListeningProgressCommandHandlerTests.cs

@@ -0,0 +1,127 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Musify.Domain.Entities;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class RecordListeningProgressCommandHandlerTests : HandlerTestBase
+    {
+        private RecordListeningProgressCommandHandler CreateHandler() => new(Database);
+
+        private async Task<ListeningHistory> ReloadAsync(Guid id) =>
+            await Database.ListeningHistories.AsNoTracking()
+                .SingleAsync(l => l.Id == id, TestContext.Current.CancellationToken);
+
+        private async Task<(User User, ListeningHistory Listen)> SeedListenAsync(
+            double durationSeconds, DateTime listenedAt)
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user, durationSeconds: durationSeconds);
+            var listen = TestEntities.ListeningHistory(user.Id, track.Id, listenedAt, isCounted: false);
+            await SeedAsync(user, track, listen);
+            return (user, listen);
+        }
+
+        [Fact]
+        public async Task Handle_BelowThreshold_StoresSecondsWithoutCounting()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            var result = await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var stored = await ReloadAsync(listen.Id);
+            Assert.Equal(10, stored.PlayedSeconds);
+            Assert.False(stored.IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_ReachesThirtySeconds_MarksAsCounted()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 30), TestContext.Current.CancellationToken);
+
+            Assert.True((await ReloadAsync(listen.Id)).IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_ShortTrack_CountsAtHalfDuration()
+        {
+            var (user, listen) = await SeedListenAsync(20, DateTime.UtcNow.AddSeconds(-60));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.True((await ReloadAsync(listen.Id)).IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_LowerValueThanStored_KeepsHighest()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+            var handler = CreateHandler();
+
+            await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 40), TestContext.Current.CancellationToken);
+            await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 15), TestContext.Current.CancellationToken);
+
+            var stored = await ReloadAsync(listen.Id);
+            Assert.Equal(40, stored.PlayedSeconds);
+            Assert.True(stored.IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_MoreThanElapsedClock_IsCappedToElapsedTime()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-20));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 150), TestContext.Current.CancellationToken);
+
+            var stored = await ReloadAsync(listen.Id);
+            Assert.InRange(stored.PlayedSeconds!.Value, 24, 27);
+        }
+
+        [Fact]
+        public async Task Handle_MoreThanTrackDuration_IsCappedToDuration()
+        {
+            var (user, listen) = await SeedListenAsync(50, DateTime.UtcNow.AddMinutes(-30));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 900), TestContext.Current.CancellationToken);
+
+            Assert.Equal(52, (await ReloadAsync(listen.Id)).PlayedSeconds);
+        }
+
+        [Fact]
+        public async Task Handle_OtherUsersListen_ReturnsNotFound()
+        {
+            var (_, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            var result = await CreateHandler().Handle(
+                new RecordListeningProgressCommand(long.MaxValue, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.True(result.IsError);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(double.NaN)]
+        [InlineData(double.PositiveInfinity)]
+        public async Task Handle_InvalidSeconds_ReturnsValidationError(double seconds)
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            var result = await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, seconds), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/GetListeningStatsQueryHandlerTests.cs

@@ -40,6 +40,37 @@ namespace Musify.Application.Tests.Users
             Assert.Equal(500, result.SecondsThisWeek);
         }
 
+        [Fact]
+        public async Task Handle_PlayedSeconds_SumsPlayedTimeInsteadOfDuration()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user, durationSeconds: 200);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 200),
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 12, isCounted: false));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(212, result.SecondsThisWeek);
+        }
+
+        [Fact]
+        public async Task Handle_UncountedListens_AreExcludedFromTracksAndStreak()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 3, isCounted: false));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(0, result.TracksThisWeek);
+            Assert.Equal(0, result.StreakDays);
+            Assert.Equal(3, result.SecondsThisWeek);
+        }
+
         [Fact]
         public async Task Handle_ListenedTodayAndYesterday_StreakIsTwo()
         {

backend/Tests/Musify.Infrastructure.Tests/Persistence/AuditableEntityInterceptorTests.cs

@@ -1,3 +1,4 @@
+using Microsoft.EntityFrameworkCore;
 using Musify.Domain.Entities;
 using Musify.Infrastructure.Tests.TestSupport;
 using Xunit;
@@ -43,6 +44,11 @@ namespace Musify.Infrastructure.Tests.Persistence
             Assert.Equal(originalCreatedAt, user.CreatedAt);
             Assert.True(user.UpdatedAt > originalCreatedAt,
                 $"original-created-at={originalCreatedAt:O}, final-updated-at={user.UpdatedAt:O}");
+
+            await using var reader = fixture.CreateDatabase();
+            var stored = await reader.Users.SingleAsync(u => u.Id == user.Id, TestContext.Current.CancellationToken);
+            Assert.True(stored.UpdatedAt > stored.CreatedAt,
+                $"stored-created-at={stored.CreatedAt:O}, stored-updated-at={stored.UpdatedAt:O}");
         }
     }
 }

deploy/.env.prod.example

@@ -1,11 +1,14 @@
 # Production configuration for deploy/compose.yml + compose.prod.yml.
 # Copy to deploy/.env.prod, then:
 #
-#   1. replace every `example.com` with your domain,
+#   1. replace every `*.example.com` with your actual domains (each service
+#      below has its own, independent domain — they don't need to share a
+#      root, e.g. for DNS providers that don't allow multi-level
+#      subdomains),
 #   2. replace every CHANGE_ME with a strong random value
 #      (`openssl rand -hex 24`),
-#   3. point these DNS records at the server, all proxied/TLS-terminated the
-#      same way: example.com, www, api, auth, stream, s3.
+#   3. point each domain below at the server and add its vhost to the shared
+#      edge (Infrastructure's edge/conf.d).
 #
 # Requires ../../../Infrastructure running first, on the same Docker host,
 # with its own `infra-net` network already created. See
@@ -14,12 +17,13 @@
 
 DOTNET_ENVIRONMENT=Production
 
-# --- Domain ------------------------------------------------------------------
-# ROOT_DOMAIN drives the nginx vhosts; the URLs below must agree with it.
-ROOT_DOMAIN=example.com
-PUBLIC_WEB_URL=https://example.com
-PUBLIC_API_URL=https://api.example.com
-PUBLIC_STREAM_URL=https://stream.example.com
+# --- Domains -------------------------------------------------------------
+# Public URLs. They must match the vhosts of the shared edge nginx
+# (Infrastructure's edge/conf.d), which is what serves them; the domains are
+# independent, they don't need to share a root.
+PUBLIC_WEB_URL=https://musify.example.com
+PUBLIC_API_URL=https://musifyapi.example.com
+PUBLIC_STREAM_URL=https://musifystream.example.com
 PUBLIC_AUTH_URL=https://auth.example.com
 S3_PUBLIC_URL=https://s3.example.com
 
@@ -62,6 +66,4 @@ SESSION_SECRET=CHANGE_ME
 AUTH_ALLOW_INSECURE_HTTP=false
 
 # --- Misc --------------------------------------------------------------------
-AUTH_REQUIRE_HTTPS=true
-# Largest request body nginx accepts (audio uploads go through the web player).
-MAX_UPLOAD_SIZE=1024m
+AUTH_REQUIRE_HTTPS=true

deploy/README.md

@@ -13,7 +13,7 @@ wherever you actually cloned it.
 |---|---|
 | `compose.yml` | Musify's own services, including the one-shot bootstrap jobs. No published ports, no domains, no environment-specific values. |
 | `compose.dev.yml` | Development overlay: publishes Musify's ports to the host. |
-| `compose.prod.yml` | Production overlay: adds the nginx edge and joins Infrastructure's `infra-net` network. |
+| `compose.prod.yml` | Production overlay: joins Infrastructure's `infra-net` network. |
 | `.env` / `.env.prod` | The values compose interpolates. Not versioned; templates in `.env.example` / `.env.prod.example`. |
 
 The four applications (`api`, `worker`, `gateway`, `web-player`) sit behind
@@ -113,26 +113,26 @@ SeaweedFS is done from the `Infrastructure` repo instead.
 
 ## Production
 
-On a server with a domain:
+Musify doesn't run its own nginx: the shared edge in Infrastructure
+(`edge/`) owns host ports 80/443, terminates TLS for every project's domains
+and proxies to Musify's containers over `infra-net`. On a server with
+domains:
 
 1. Bring up the `Infrastructure` repo first, with its own `.env.prod` filled
    in. It creates the `infra-net` network this stack joins.
-2. From this repository's root:
+2. Bring up its `edge/` (see Infrastructure's README) and add Musify's
+   vhosts and certificate there (`edge/conf.d/musify.conf`). The five
+   public hostnames (web, api, stream, auth, s3) are independent: they
+   don't need to share a root domain.
+3. From this repository's root:
 
 ```sh
 cp deploy/.env.prod.example deploy/.env.prod
 ```
 
-Fill it in:
-
-1. Replace every `example.com` with your domain and every `CHANGE_ME` with a
-   random value (`openssl rand -hex 24`). `chmod 600 deploy/.env.prod`.
-2. Drop **`deploy/nginx/certs/origin.pem` and `origin.key`**, the origin
-   certificate nginx serves. The stack assumes Cloudflare in *Full (strict)*
-   mode in front of it, so a Cloudflare Origin Certificate is enough; any
-   certificate valid for the five hostnames works.
-3. Point `example.com`, `www`, `api`, `auth`, `stream` and `s3` at the server,
-   proxied and TLS-terminated the same way.
+   Replace every `*.example.com` with your domains (they must match the
+   edge's vhosts) and every `CHANGE_ME` with a random value
+   (`openssl rand -hex 24`). `chmod 600 deploy/.env.prod`.
 
 Then:
 
@@ -141,14 +141,45 @@ docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compo
 docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compose.prod.yml --profile apps up -d --build
 ```
 
-The first command starts Musify's bootstrap jobs and the nginx edge; the
-second builds and starts the applications, already wired to the OIDC client
-ids the first one produced. Both are idempotent, so running them again
-deploys a new version (`... --profile apps up -d --build` alone is enough for
-an update once the stack already exists).
+The first command starts Musify's bootstrap jobs (`zitadel-init` and
+`seaweedfs-init` reach Zitadel/SeaweedFS through the public `auth.`/`s3.`
+URLs, so the edge has to be serving them by then); the second builds and
+starts the applications, already wired to the OIDC client ids the first one
+produced. Both are idempotent, so running them again deploys a new version
+(`... --profile apps up -d --build` alone is enough for an update once the
+stack already exists).
 
-Only nginx publishes ports (80/443). Every other Musify service, and all of
-Infrastructure's, is reachable only on the internal `infra-net` network.
+Nothing in this stack publishes a port; everything is reachable only on the
+internal `infra-net` network, through the edge.
+
+### Continuous deployment
+
+`.gitea/workflows/ci-cd.yml` runs the backend and web-player checks on every
+push/PR, and on a successful push to `master` deploys automatically. The
+deploy job runs on `gitea-runner`, the self-hosted Gitea Actions runner on
+the production host (`~/gitea/docker-compose.yml`), configured by
+`~/gitea/runner-data/config.yaml` (`CONFIG_FILE`): job containers are pinned
+to the `gitea_gitea` network so `actions/checkout` can resolve `gitea`,
+`ubuntu-latest` is `node:22` (JS actions need Node inside the job
+container), and a `production:host` label runs steps natively.
+
+Native mode means the label's steps execute inside the runner container
+itself rather than a fresh one. That container has `/var/run/docker.sock`
+mounted, so `docker`/`docker compose` there still control the host's real
+Docker daemon (sibling containers, "Docker outside of Docker"). Its compose
+service also bind-mounts `/home/ubuntu/deploys` into itself at the *same*
+path, which matters because compose's own relative bind mounts (`./keys`)
+are resolved by the host daemon against that literal path; mounting it
+anywhere else would silently bind the wrong (empty) directory.
+
+`DEPLOY_PATH` (hardcoded in the workflow as `/home/ubuntu/deploys/musify`)
+is a persistent clone on that host, reused instead of a fresh checkout each
+run since `deploy/.env.prod` is untracked and only lives there.
+`/home/ubuntu/deploys/SharedServices` is the sibling clone of the
+`Infrastructure` repo (shared services + `edge/`), already running; its
+`.env.prod` shares the Postgres/RabbitMQ/S3 credentials with Musify's own
+`deploy/.env.prod` by design (see that repo's README). The edge is deployed
+from that repo, not from this pipeline.
 
 ---
 
@@ -159,13 +190,9 @@ deploy/
 ├─ compose.yml                     # Musify's own services: wait-for-postgres, keys-init,
 │                                   #   migrate, seaweedfs-init, zitadel-init, api/worker/gateway/web-player
 ├─ compose.dev.yml                 # dev overlay: host ports
-├─ compose.prod.yml                # prod overlay: nginx edge, joins infra-net
+├─ compose.prod.yml                # prod overlay: joins infra-net
 ├─ .env.example / .env.prod.example
-├─ keys/                           # RS256 stream-ticket key pair (generated)
-└─ nginx/
-   ├─ templates/default.conf.template # vhosts, rendered with the domain by envsubst
-   ├─ snippets/proxy.conf             # proxy headers shared by every vhost
-   └─ certs/                          # origin.pem + origin.key (not versioned)
+└─ keys/                           # RS256 stream-ticket key pair (generated)
 ```
 
 The application images are built from `backend/Musify.*.Dockerfile` (build

deploy/compose.prod.yml

@@ -1,11 +1,10 @@
 name: musify-prod
 
-# Production overlay: adds the nginx edge and joins Infrastructure's shared
-# `infra-net` network so this project's containers can reach Postgres,
-# Zitadel, SeaweedFS, RabbitMQ and Jaeger by container name. None of them
-# run as part of this compose project anymore (see
-# ../../../Infrastructure/README.md, which must already be up). Nothing but
-# nginx publishes a port; every other service is reachable only on infra-net.
+# Production overlay: joins Infrastructure's shared `infra-net` network so
+# this project's containers can reach Postgres, Zitadel, SeaweedFS, RabbitMQ
+# and Jaeger by container name, and so the shared edge nginx (Infrastructure's
+# `edge/`, which owns host ports 80/443 and terminates TLS for every domain)
+# can reach api, gateway and web-player. Nothing here publishes a port.
 #
 #   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
@@ -20,31 +19,3 @@ services:
   zitadel-init:
     volumes:
       - ./.env.prod:/workspace/.env
-
-  # Every vhost proxies through `set $upstream ...; proxy_pass $upstream;`
-  # with the embedded Docker DNS resolver (see nginx/templates), so nginx
-  # does not need api/gateway/web-player to exist at its own startup, only
-  # at request time. That is what lets it start in the FIRST command
-  # (profile-gated services aren't part of that invocation yet) and still be
-  # reachable at the auth domain for zitadel-init to provision through.
-  nginx:
-    image: nginx:1.27-alpine
-    container_name: musify-nginx
-    environment:
-      # The entrypoint renders /etc/nginx/templates/*.template with envsubst.
-      # The filter keeps it from eating nginx's own $host / $remote_addr.
-      MUSIFY_ROOT_DOMAIN: ${ROOT_DOMAIN}
-      MUSIFY_MAX_UPLOAD_SIZE: ${MAX_UPLOAD_SIZE:-1024m}
-      NGINX_ENVSUBST_FILTER: ^MUSIFY_
-    ports:
-      - "80:80"
-      - "443:443"
-    volumes:
-      - ./nginx/templates:/etc/nginx/templates:ro
-      - ./nginx/snippets:/etc/nginx/snippets:ro
-      - ./nginx/certs:/etc/nginx/certs:ro
-      - nginx_cache:/var/cache/nginx
-    restart: unless-stopped
-
-volumes:
-  nginx_cache:

deploy/compose.yml

@@ -381,6 +381,10 @@ services:
     environment:
       NODE_ENV: production
       PORT: 3000
+      # adapter-node rejects request bodies over 512K by default; audio
+      # uploads are posted to /upload. Keep in line with the edge's
+      # client_max_body_size.
+      BODY_SIZE_LIMIT: 1G
       ORIGIN: ${PUBLIC_WEB_URL}
       ZITADEL_ISSUER: ${PUBLIC_AUTH_URL}
       ZITADEL_CLIENT_ID: ${WEB_CLIENT_ID}

deploy/nginx/snippets/proxy.conf

@@ -1,9 +0,0 @@
-# Shared proxy settings for every Musify vhost.
-proxy_http_version 1.1;
-proxy_set_header Host              $host;
-proxy_set_header X-Real-IP         $remote_addr;
-proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
-proxy_set_header X-Forwarded-Proto https;
-proxy_set_header X-Forwarded-Host  $host;
-proxy_set_header Upgrade           $http_upgrade;
-proxy_set_header Connection        $connection_upgrade;

deploy/nginx/templates/default.conf.template

@@ -1,119 +0,0 @@
-# Musify edge. The nginx entrypoint renders this with envsubst into
-# /etc/nginx/conf.d/default.conf (replacing the image's stock file) using the
-# MUSIFY_* variables set in compose.prod.yml.
-#
-# Cloudflare (Full strict) terminates the public edge; this box only needs to
-# serve the Cloudflare Origin Certificate in nginx/certs/. Each vhost proxies to
-# a compose service by name through the embedded Docker DNS resolver, so nginx
-# re-resolves it instead of caching the IP of a container that may be recreated.
-
-resolver 127.0.0.11 valid=10s;
-
-map $http_upgrade $connection_upgrade {
-    default upgrade;
-    ''      close;
-}
-
-server {
-    listen 80;
-    listen [::]:80;
-    server_name ${MUSIFY_ROOT_DOMAIN} www.${MUSIFY_ROOT_DOMAIN}
-                api.${MUSIFY_ROOT_DOMAIN} auth.${MUSIFY_ROOT_DOMAIN}
-                stream.${MUSIFY_ROOT_DOMAIN} s3.${MUSIFY_ROOT_DOMAIN};
-    return 301 https://$host$request_uri;
-}
-
-# Web player (SvelteKit, adapter-node). Uploads are posted to its own form
-# actions, so it needs the large body size too.
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name ${MUSIFY_ROOT_DOMAIN};
-    client_max_body_size ${MUSIFY_MAX_UPLOAD_SIZE};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    location / {
-        set $upstream http://web-player:3000;
-        proxy_pass $upstream;
-        include /etc/nginx/snippets/proxy.conf;
-    }
-}
-
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name www.${MUSIFY_ROOT_DOMAIN};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    return 301 https://${MUSIFY_ROOT_DOMAIN}$request_uri;
-}
-
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name api.${MUSIFY_ROOT_DOMAIN};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    location / {
-        set $upstream http://api:5111;
-        proxy_pass $upstream;
-        include /etc/nginx/snippets/proxy.conf;
-    }
-}
-
-# Audio bytes. Buffering off keeps range requests (seeking) responsive.
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name stream.${MUSIFY_ROOT_DOMAIN};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    location / {
-        set $upstream http://gateway:8081;
-        proxy_pass $upstream;
-        include /etc/nginx/snippets/proxy.conf;
-        proxy_buffering off;
-    }
-}
-
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name auth.${MUSIFY_ROOT_DOMAIN};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    location / {
-        set $upstream http://zitadel:8080;
-        proxy_pass $upstream;
-        include /etc/nginx/snippets/proxy.conf;
-        grpc_set_header Host $host;
-    }
-}
-
-# Presigned S3 PUT/GET straight from the browser.
-server {
-    listen 443 ssl;
-    http2 on;
-    server_name s3.${MUSIFY_ROOT_DOMAIN};
-    client_max_body_size ${MUSIFY_MAX_UPLOAD_SIZE};
-
-    ssl_certificate     /etc/nginx/certs/origin.pem;
-    ssl_certificate_key /etc/nginx/certs/origin.key;
-
-    location / {
-        set $upstream http://seaweedfs:8333;
-        proxy_pass $upstream;
-        include /etc/nginx/snippets/proxy.conf;
-        proxy_request_buffering off;
-    }
-}

web-player/docs/paginas.md

@@ -9,12 +9,12 @@ Status legend: ✅ done · 🟡 partial / mockup · ⬜ pending.
 ## Home (app) `/` 🟡
 
 - **Hero**: a greeting plus "Your music. No limits." with a color wash taken from the current track's hue.
-- **Quick access, meaning recently played** (`player.recentlyPlayed`, client side for now). Empty state with an icon and an "Explore" CTA.
+- **Quick access, meaning recently played** (`GET /users/{id}/listening-history` merged with `player.recentlyPlayed` via `mergeRecentlyPlayed`). Empty state with an icon and an "Explore" CTA.
 - **Your playlists**: mosaic cards for the user's playlists (sample data for now). Has an empty state.
+- **Resume on load**: the root layout fetches `GET /users/{id}/last-listened-track` and hydrates the player (`player.hydrate`) with it, paused, so the player bar isn't empty on a fresh session. Only applies when nothing is already loaded (won't override an in-progress session).
 
 ### Pending backend work (ASP.NET) for Home
 
-- **Recently played**: track plays per user (a history table with `userId`, `trackId`, `playedAt`) and expose `GET /me/recently-played?limit=` (or `/users/{id}/recently-played`), returning tracks ordered by `playedAt` descending, with no duplicates. The frontend would load this in a `load` function and pass it to the store instead of using `recentlyPlayed`.
 - **Playlists by last listen**: add `lastPlayedAt` to the playlist (the schema currently only has `createdAt`/`updatedAt`) and allow sorting `GET /playlists/users/{userId}` by that field (for example `?sort=lastPlayed`), to show "your most recently played" playlists.
 - Tracks will need an **artist** and a **color/hue** (or a real cover to extract one from) for the artwork and the dynamic accent. Right now `TrackApplicationResponse` carries neither artist nor color.
 

web-player/package-lock.json

@@ -39,6 +39,40 @@
 				"vite": "^8.0.16"
 			}
 		},
+		"node_modules/@emnapi/core": {
+			"version": "1.11.3",
+			"resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.3.tgz",
+			"integrity": "sha512-zLpS5asjEb7lq8jYLq37N6XKaE41DIexlY1rF/z4/tIl3wo13Sqm28fRyfIsKZD+NZ8mM5RoKkpW/rBcuoSZSg==",
+			"license": "MIT",
+			"optional": true,
+			"peer": true,
+			"dependencies": {
+				"@emnapi/wasi-threads": "1.2.3",
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.3.tgz",
+			"integrity": "sha512-ELEBe8PsLvvJ6QMr0zLt8ffvOHW/dc1m3CEzNMg7aJUv3bMaoDtw2TXyDAwkYBuroxxuHEwhRTLJSe5sya547g==",
+			"license": "MIT",
+			"optional": true,
+			"peer": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@emnapi/runtime": {
+			"version": "1.11.3",
+			"resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+			"integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+			"license": "MIT",
+			"optional": true,
+			"peer": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
 		"node_modules/@emnapi/wasi-threads": {
 			"version": "1.2.2",
 			"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz",
@@ -1118,7 +1152,6 @@
 			"resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.69.1.tgz",
 			"integrity": "sha512-+nz8Fx/cElzb2ZPHC+6Ll3y3NEVIe4Na75PeplLlyTmd1dBXAjz2KR14y1ZgNjb2ThfAYzulu+PFy1UE3RCUzA==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@standard-schema/spec": "^1.0.0",
 				"@sveltejs/acorn-typescript": "^1.0.9",
@@ -1170,7 +1203,6 @@
 			"resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-7.1.2.tgz",
 			"integrity": "sha512-DrUBA2UXRfDmUX/ZTiEopd3X40yavsJF1FX2RygcuIScHL7o5YX1fMvoYnDhjeJQC4weCOklirpNWlcb2NiSeA==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"deepmerge": "^4.3.1",
 				"magic-string": "^0.30.21",
@@ -1408,6 +1440,27 @@
 				"node": ">=14.0.0"
 			}
 		},
+		"node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": {
+			"version": "1.11.1",
+			"dev": true,
+			"inBundle": true,
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"@emnapi/wasi-threads": "1.2.2",
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": {
+			"version": "1.11.1",
+			"dev": true,
+			"inBundle": true,
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
 		"node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
 			"version": "1.2.2",
 			"dev": true,
@@ -1544,7 +1597,6 @@
 			"integrity": "sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==",
 			"devOptional": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~6.21.0"
 			}
@@ -1606,7 +1658,6 @@
 			"integrity": "sha512-KA0OshtlcCCXmbfqyZkM5pV3/WNraJf7DkJRLpyrmwPtud57H5BDX7C3k0LPSPxpprfRL+cJDGabF10mvNCoCw==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@typescript-eslint/scope-manager": "8.64.0",
 				"@typescript-eslint/types": "8.64.0",
@@ -1714,7 +1765,6 @@
 			"integrity": "sha512-qjhfuTfLXjA4IOzXvz0rTjT01BqEiIgPoUeMwiEjnaHKJMTNo8rH5pYW1a2L/0Dnux2fPC85AeyJoWaGa8WxTA==",
 			"devOptional": true,
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
 			},
@@ -1798,7 +1848,6 @@
 			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
 			"integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"acorn": "bin/acorn"
 			},
@@ -2033,7 +2082,6 @@
 			"integrity": "sha512-GVTD7s1vdIl6UYvAfriOPeY1Df8LIZjfofLvHwde+erDHGGuHyuM6xoxRxmHiebhYuD2p1vN4wWh0XzPARSGDQ==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"workspaces": [
 				"packages/*"
 			],
@@ -3112,7 +3160,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"nanoid": "^3.3.12",
 				"picocolors": "^1.1.1",
@@ -3246,7 +3293,6 @@
 			"integrity": "sha512-/FVl766LpUfB5vXgCYOYa0MeV/441Ia99AeICQIQFTY/Nw0roZwULcXpku5i1/m5kt/baz+s4Zogspd839HSMg==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"prettier": "bin/prettier.cjs"
 			},
@@ -3263,7 +3309,6 @@
 			"integrity": "sha512-wXvbXMjSvb4C9ENWTHXyd+ihakKCsJ6rJhLP6/8HFNj4GkZr48jqL9PoKsl2sk7SyCZRTnJ7O2TTowUpOxP/KA==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=20"
 			},
@@ -3434,7 +3479,6 @@
 			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
 			"integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@types/estree": "1.0.9"
 			},
@@ -3569,7 +3613,6 @@
 			"resolved": "https://registry.npmjs.org/svelte/-/svelte-5.56.4.tgz",
 			"integrity": "sha512-/d0QHehmRuJW8gVz395MTkPcPozxzdjBMBE8oEYGz8O3b9KTMzzQ9ZHJQLuFKOHOPQbU6kx/X4iid/EBBzH7iw==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@jridgewell/remapping": "^2.3.4",
 				"@jridgewell/sourcemap-codec": "^1.5.0",
@@ -3781,7 +3824,6 @@
 			"integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
 			"devOptional": true,
 			"license": "Apache-2.0",
-			"peer": true,
 			"bin": {
 				"tsc": "bin/tsc",
 				"tsserver": "bin/tsserver"
@@ -3843,7 +3885,6 @@
 			"resolved": "https://registry.npmjs.org/vite/-/vite-8.1.3.tgz",
 			"integrity": "sha512-Ds+gBRbj0lwRO2Y5hwnUBdxSwlAve9LeRyU4sNnAr0ewW0gWF0n5bgXgUzbgZ49MV9BVUAQUFYVcDUcilUExMA==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"lightningcss": "^1.32.0",
 				"picomatch": "^4.0.4",

web-player/src/hooks.server.ts

@@ -1,15 +1,16 @@
 import type { Handle } from '@sveltejs/kit';
 import {
+	clearSessionCookie,
 	decodeSession,
 	encodeSession,
+	readSessionCookie,
 	refreshSession,
-	sessionCookieOptions,
-	SESSION_COOKIE
+	writeSessionCookie
 } from '$lib/server/auth';
 import { authConfig } from '$lib/server/config';
 
 export const handle: Handle = async ({ event, resolve }) => {
-	let session = await decodeSession(event.cookies.get(SESSION_COOKIE));
+	let session = await decodeSession(readSessionCookie(event.cookies));
 
 	if (
 		session &&
@@ -17,13 +18,9 @@ export const handle: Handle = async ({ event, resolve }) => {
 	) {
 		session = await refreshSession(session);
 		if (session) {
-			event.cookies.set(
-				SESSION_COOKIE,
-				await encodeSession(session),
-				sessionCookieOptions(event.url)
-			);
+			writeSessionCookie(event.cookies, await encodeSession(session), event.url);
 		} else {
-			event.cookies.delete(SESSION_COOKIE, { path: '/' });
+			clearSessionCookie(event.cookies);
 		}
 	}
 

web-player/src/lib/components/layout/MobileHeader.svelte

@@ -18,7 +18,7 @@
 </script>
 
 <header
-	class="sticky top-0 z-(--z-sticky) flex h-14 items-center justify-between border-b border-hairline bg-bg/85 page-x backdrop-blur-md sm:hidden"
+	class="sticky top-0 z-(--z-sticky) flex h-14 items-center justify-between bg-transparent page-x backdrop-blur-md sm:hidden"
 >
 	<a href="/">
 		<Logo size="sm" />

web-player/src/lib/components/layout/Sidebar.svelte

@@ -7,6 +7,7 @@
 	import ListRow from '../ui/media/ListRow.svelte';
 	import IconButton from '../ui/primitives/IconButton.svelte';
 	import Plus from '@lucide/svelte/icons/plus';
+	import Logo from '../ui/primitives/Logo.svelte';
 
 	interface SidebarPlaylist {
 		id: string;
@@ -33,6 +34,10 @@
 	class="hidden shrink-0 flex-col border-r border-hairline p-5 lg:flex"
 	style="width:var(--mf-sidebar-w)"
 >
+	<a href="/" class="mb-4">
+		<Logo size="sm" />
+	</a>
+
 	<nav class="flex flex-col gap-1">
 		{#each navLinks as link (link.href)}
 			{@const active = isActive(link.href)}

web-player/src/lib/components/ui/primitives/Chip.svelte

@@ -3,20 +3,21 @@
 
 	interface Props {
 		selected?: boolean;
+		disabled?: boolean;
 		count?: number;
 		href?: string;
 		onclick?: () => void;
 		children: Snippet;
 	}
 
-	let { selected = false, count, href, onclick, children }: Props = $props();
+	let { selected = false, disabled = false, count, href, onclick, children }: Props = $props();
 
 	const classes = $derived(
 		href
 			? 'rounded-full border border-line-strong px-3.5 py-2 text-xs text-fg-2 transition-colors hover:bg-hover hover:text-fg'
 			: `flex items-center gap-2 rounded-full px-3.5 py-2 text-xs font-medium transition ${
 					selected ? 'bg-cta-strong text-ink' : 'bg-btn text-fg-2 hover:bg-btn-hover hover:text-fg'
-				}`
+				} ${disabled ? 'cursor-not-allowed opacity-40' : ''}`
 	);
 </script>
 
@@ -30,5 +31,5 @@
 {#if href}
 	<a {href} class={classes}>{@render content()}</a>
 {:else}
-	<button type="button" {onclick} class={classes}>{@render content()}</button>
+	<button type="button" {onclick} {disabled} class={classes}>{@render content()}</button>
 {/if}

web-player/src/lib/components/ui/primitives/Logo.svelte

@@ -5,18 +5,10 @@
 
 	let { size = 'sm' }: Props = $props();
 
-	const MARK: Record<'sm' | 'lg', string> = {
-		sm: 'size-5.5 rounded-thumb',
-		lg: 'size-8 rounded-control'
-	};
-
 	const TEXT: Record<'sm' | 'lg', string> = {
 		sm: 'font-display text-lg font-semibold tracking-tight text-fg',
 		lg: 'font-display text-[clamp(1.5rem,3vw,2.5rem)] font-semibold tracking-tight'
 	};
 </script>
 
-<span class="flex items-center gap-3">
-	<span class="{MARK[size]} bg-(image:--mf-logo-grad)"></span>
-	<span class={TEXT[size]}>Musify</span>
-</span>
+<span class={TEXT[size]}>Musify</span>

web-player/src/lib/data/genres.ts

@@ -1,22 +1,75 @@
-export const GENRE_INFO: Record<string, { label: string; tagline: string }> = {
-	pop: { label: 'Pop', tagline: 'Éxitos que suenan en todas partes' },
-	rock: { label: 'Rock', tagline: 'Guitarras, actitud y ruido' },
-	reggaeton: { label: 'Reggaetón', tagline: 'El ritmo que no para' },
-	'lo-fi': { label: 'Lo-fi', tagline: 'Para concentrarte o relajarte' },
-	indie: { label: 'Indie', tagline: 'Voces fuera del radar' },
-	salsa: { label: 'Salsa', tagline: 'Para mover el cuerpo' },
-	'k-pop': { label: 'K-pop', tagline: 'Coreografías pegajosas' },
-	electrónica: { label: 'Electrónica', tagline: 'Beats para perderte' },
-	jazz: { label: 'Jazz', tagline: 'Improvisación y elegancia' },
-	baladas: { label: 'Baladas', tagline: 'Para sentir con calma' },
-	trap: { label: 'Trap', tagline: 'Autotune y bajos pesados' },
-	cumbia: { label: 'Cumbia', tagline: 'El sabor de siempre' },
-	'hip hop': { label: 'Hip hop', tagline: 'Rimas con actitud' },
-	'música clásica': { label: 'Clásica', tagline: 'Siglos de composición' }
+const GENRE_INFO: Record<string, { label: string; tagline: string }> = {
+	Pop: { label: 'Pop', tagline: 'Éxitos que suenan en todas partes' },
+	Rock: { label: 'Rock', tagline: 'Guitarras, actitud y ruido' },
+	HipHop: { label: 'Hip hop', tagline: 'Rimas con actitud' },
+	RnB: { label: 'R&B', tagline: 'Ritmo suave y voces con alma' },
+	Jazz: { label: 'Jazz', tagline: 'Improvisación y elegancia' },
+	Blues: { label: 'Blues', tagline: 'Sentimiento en cada nota' },
+	Classical: { label: 'Clásica', tagline: 'Siglos de composición' },
+	Electronic: { label: 'Electrónica', tagline: 'Beats para perderte' },
+	House: { label: 'House', tagline: 'Pista de baile sin fin' },
+	Techno: { label: 'Techno', tagline: 'Pulso hipnótico' },
+	Trance: { label: 'Trance', tagline: 'Melodías que te elevan' },
+	Dubstep: { label: 'Dubstep', tagline: 'Bajos que hacen temblar' },
+	DrumAndBass: { label: 'Drum and bass', tagline: 'Velocidad y graves' },
+	Metal: { label: 'Metal', tagline: 'Riffs pesados' },
+	Punk: { label: 'Punk', tagline: 'Rápido, crudo y directo' },
+	Reggae: { label: 'Reggae', tagline: 'Buenas vibraciones' },
+	Reggaeton: { label: 'Reggaetón', tagline: 'El ritmo que no para' },
+	Country: { label: 'Country', tagline: 'Historias con guitarra' },
+	Folk: { label: 'Folk', tagline: 'Raíces y acústico' },
+	Indie: { label: 'Indie', tagline: 'Voces fuera del radar' },
+	KPop: { label: 'K-pop', tagline: 'Coreografías pegajosas' },
+	Latin: { label: 'Latina', tagline: 'Sabor y ritmo' },
+	Soul: { label: 'Soul', tagline: 'Emoción en estado puro' },
+	Funk: { label: 'Funk', tagline: 'Groove imposible de quedarse quieto' },
+	Ambient: { label: 'Ambient', tagline: 'Paisajes sonoros' },
+	Lofi: { label: 'Lo-fi', tagline: 'Para concentrarte o relajarte' }
 };
 
-export const genreTiles = Object.entries(GENRE_INFO).map(([query, info], i, all) => ({
-	query,
-	hue: Math.round((i * 360) / all.length),
-	...info
-}));
+const KNOWN_GENRES = Object.keys(GENRE_INFO);
+
+function humanize(name: string): string {
+	return name.replace(/([a-z])([A-Z])/g, '$1 $2');
+}
+
+export function genreInfo(genre: string) {
+	return GENRE_INFO[genre] ?? { label: humanize(genre), tagline: '' };
+}
+
+export function genreHue(genre: string): number {
+	const known = KNOWN_GENRES.indexOf(genre);
+	if (known >= 0) return Math.round((known * 360) / KNOWN_GENRES.length);
+	let hash = 0;
+	for (const char of genre) hash = (hash * 31 + char.charCodeAt(0)) % 360;
+	return hash;
+}
+
+export function genreTiles(genres: { genre: string }[]) {
+	return genres.map(({ genre }) => ({
+		genre,
+		hue: genreHue(genre),
+		...genreInfo(genre)
+	}));
+}
+
+export function genreOptions(genres: { genre: string; incompatibleWith: string[] }[]) {
+	return genres.map(({ genre, incompatibleWith }) => ({
+		genre,
+		incompatibleWith,
+		label: genreInfo(genre).label
+	}));
+}
+
+export function findConflict(
+	tags: string[],
+	options: { genre: string; incompatibleWith: string[] }[]
+): [string, string] | undefined {
+	const byGenre = new Map(options.map((option) => [option.genre, option.incompatibleWith]));
+	for (let i = 0; i < tags.length; i++) {
+		for (let j = i + 1; j < tags.length; j++) {
+			if (byGenre.get(tags[i])?.includes(tags[j])) return [tags[i], tags[j]];
+		}
+	}
+	return undefined;
+}

web-player/src/lib/player/listenTracker.ts

@@ -0,0 +1,52 @@
+const MAX_TICK_GAP_SECONDS = 2.5;
+const FLUSH_EVERY_SECONDS = 30;
+
+export class ListenTracker {
+	#listenId: string | null = null;
+	#played = 0;
+	#sent = 0;
+	#lastTime: number | null = null;
+	#lastFlushAt = 0;
+
+	begin(listenId: string | null | undefined) {
+		this.flush();
+		this.#listenId = listenId ?? null;
+		this.#played = 0;
+		this.#sent = 0;
+		this.#lastTime = null;
+		this.#lastFlushAt = Date.now();
+	}
+
+	resync(currentTime: number) {
+		this.#lastTime = currentTime;
+	}
+
+	interrupt() {
+		this.#lastTime = null;
+	}
+
+	tick(currentTime: number) {
+		if (this.#listenId === null) return;
+		const last = this.#lastTime;
+		this.#lastTime = currentTime;
+		if (last === null) return;
+		const delta = currentTime - last;
+		if (delta > 0 && delta <= MAX_TICK_GAP_SECONDS) this.#played += delta;
+		if (Date.now() - this.#lastFlushAt >= FLUSH_EVERY_SECONDS * 1000) this.flush();
+	}
+
+	flush() {
+		const id = this.#listenId;
+		if (id === null || this.#played <= this.#sent) return;
+		this.#sent = this.#played;
+		this.#lastFlushAt = Date.now();
+		fetch(`/api/listens/${id}/progress`, {
+			method: 'PUT',
+			headers: { 'content-type': 'application/json' },
+			body: JSON.stringify({ playedSeconds: this.#played }),
+			keepalive: true
+		}).catch(() => {
+			this.#sent = 0;
+		});
+	}
+}

web-player/src/lib/player/player.svelte.ts

@@ -3,6 +3,7 @@ import { DEFAULT_ACCENT } from '$lib/theme/color';
 import { extractAccent, type Accent } from '$lib/theme/palette';
 import { shuffle } from '$lib/data/collections';
 import { dialog } from '$lib/state/dialog.svelte';
+import { ListenTracker } from './listenTracker';
 
 export interface PlayerTrack {
 	id: string | number;
@@ -131,6 +132,7 @@ class PlayerState {
 	#loadToken = 0;
 	#accentCache = new Map<string, Accent>();
 	#rafId: number | null = null;
+	#listen = new ListenTracker();
 
 	current = $derived(this.tracks.find((t) => t.id === this.currentId) ?? EMPTY);
 	accent = $derived(this.accentColor ?? DEFAULT_ACCENT);
@@ -150,19 +152,30 @@ class PlayerState {
 		audio.volume = this.volume / 100;
 		audio.addEventListener('durationchange', () => this.#syncDuration(audio.duration));
 		audio.addEventListener('loadedmetadata', () => this.#syncDuration(audio.duration));
+		audio.addEventListener('timeupdate', () => {
+			if (!audio.paused) this.#listen.tick(audio.currentTime);
+		});
+		audio.addEventListener('seeking', () => this.#listen.interrupt());
+		audio.addEventListener('seeked', () => this.#listen.resync(audio.currentTime));
 		audio.addEventListener('play', () => {
+			this.#listen.resync(audio.currentTime);
 			this.playing = true;
 			this.#startProgressLoop();
 			this.#syncMediaSessionPlaybackState();
 		});
 		audio.addEventListener('pause', () => {
+			this.#listen.interrupt();
+			this.#listen.flush();
 			this.playing = false;
 			this.#stopProgressLoop();
 			this.#syncMediaSessionPlaybackState();
 		});
 		audio.addEventListener('ended', () => {
 			this.#stopProgressLoop();
+			this.#listen.tick(audio.currentTime);
+			this.#listen.begin(null);
 			if (this.repeat) {
+				this.#beginRepeatListen();
 				audio.currentTime = 0;
 				audio.play().catch(() => {});
 				return;
@@ -176,6 +189,10 @@ class PlayerState {
 			this.#fail();
 		});
 		this.#audio = audio;
+		document.addEventListener('visibilitychange', () => {
+			if (document.visibilityState === 'hidden') this.#listen.flush();
+		});
+		window.addEventListener('pagehide', () => this.#listen.flush());
 		this.#setupMediaSession(audio);
 		return audio;
 	}
@@ -266,14 +283,16 @@ class PlayerState {
 		const track = this.tracks.find((t) => t.id === id);
 		this.#applyAccent(id);
 		if (track) this.#syncMediaSessionMetadata(track);
+		this.#listen.begin(null);
 		const token = ++this.#loadToken;
 		this.loading = true;
 		this.progress = 0;
 		try {
-			const src = await this.#resolveLocalSrc(String(id));
+			const { src, listenId } = await this.#resolveLocalSrc(String(id));
 			if (token !== this.#loadToken) return;
 			audio.src = src;
 			audio.volume = this.volume / 100;
+			this.#listen.begin(listenId);
 			await audio.play();
 			this.loading = false;
 			this.#pushRecent(this.current);
@@ -299,14 +318,28 @@ class PlayerState {
 		);
 	}
 
-	async #resolveLocalSrc(id: string): Promise<string> {
+	async #resolveLocalSrc(id: string): Promise<{ src: string; listenId: string | null }> {
 		const res = await fetch(`/api/tracks/${id}/stream`);
 		if (!res.ok) throw new Error(await readErrorMessage(res));
-		const { manifestUrl, ticket } = (await res.json()) as {
+		const { manifestUrl, ticket, listenId } = (await res.json()) as {
 			manifestUrl: string;
 			ticket: string;
+			listenId?: string | null;
 		};
-		return this.#withTicket(manifestUrl, ticket);
+		return { src: this.#withTicket(manifestUrl, ticket), listenId: listenId ?? null };
+	}
+
+	async #beginRepeatListen() {
+		const id = this.currentId;
+		if (id === null) return;
+		try {
+			const res = await fetch(`/api/tracks/${id}/stream`);
+			if (!res.ok) return;
+			const { listenId } = (await res.json()) as { listenId?: string | null };
+			if (this.currentId === id) this.#listen.begin(listenId ?? null);
+		} catch {
+			return;
+		}
 	}
 
 	#withTicket(url: string, ticket: string): string {
@@ -315,6 +348,15 @@ class PlayerState {
 		return `${url}${sep}t=${encodeURIComponent(ticket)}`;
 	}
 
+	hydrate(item: ApiTrackLike) {
+		if (this.currentId !== null || this.tracks.length > 0) return;
+		const track = toTrack(toQueueItem(item));
+		this.tracks = [track];
+		this.currentId = track.id;
+		this.#applyAccent(track.id);
+		this.#syncMediaSessionMetadata(track);
+	}
+
 	playlistTracks(ids: (string | number)[]): PlayerTrack[] {
 		return ids
 			.map((id) => this.tracks.find((t) => t.id === id))
@@ -384,6 +426,10 @@ class PlayerState {
 	toggle() {
 		const audio = this.#audioEl();
 		if (!audio || this.currentId === null) return;
+		if (!audio.src) {
+			this.#loadCurrent();
+			return;
+		}
 		if (audio.paused) audio.play().catch(() => {});
 		else audio.pause();
 	}

web-player/src/lib/server/api.ts

@@ -52,9 +52,27 @@ export function unwrapOrError<T>(
 	return result.data;
 }
 
+export function apiErrorDetail(error: unknown): string | undefined {
+	if (typeof error !== 'object' || error === null) return undefined;
+	const { errors, detail, title } = error as {
+		errors?: Record<string, unknown>;
+		detail?: unknown;
+		title?: unknown;
+	};
+	if (errors && typeof errors === 'object') {
+		const messages = Object.values(errors)
+			.flat()
+			.filter((entry): entry is string => typeof entry === 'string');
+		if (messages.length > 0) return messages.join(' ');
+	}
+	if (typeof detail === 'string' && detail !== '') return detail;
+	if (typeof title === 'string' && title !== '') return title;
+	return undefined;
+}
+
 export function unwrapOrFail(
 	result: { error?: unknown },
 	message: string
-): ActionFailure<{ message: string }> | undefined {
-	return result.error ? fail(502, { message }) : undefined;
+): ActionFailure<{ message: string; detail?: string }> | undefined {
+	return result.error ? fail(502, { message, detail: apiErrorDetail(result.error) }) : undefined;
 }

web-player/src/lib/server/auth.ts

@@ -1,3 +1,4 @@
+import type { Cookies } from '@sveltejs/kit';
 import * as client from 'openid-client';
 import { EncryptJWT, jwtDecrypt } from 'jose';
 import { dev } from '$app/environment';
@@ -53,6 +54,44 @@ export function sessionCookieOptions(url: URL) {
 	};
 }
 
+const SESSION_CHUNK_SIZE = 3600;
+
+function sessionChunkName(index: number): string {
+	return index === 0 ? SESSION_COOKIE : `${SESSION_COOKIE}.${index}`;
+}
+
+export function readSessionCookie(cookies: Cookies): string | undefined {
+	const parts: string[] = [];
+	for (let index = 0; ; index++) {
+		const part = cookies.get(sessionChunkName(index));
+		if (part === undefined) break;
+		parts.push(part);
+	}
+	return parts.length > 0 ? parts.join('') : undefined;
+}
+
+export function clearSessionCookie(cookies: Cookies, keep = 0): void {
+	for (const { name } of cookies.getAll()) {
+		const match =
+			name === SESSION_COOKIE
+				? 0
+				: name.startsWith(`${SESSION_COOKIE}.`)
+					? Number(name.slice(SESSION_COOKIE.length + 1))
+					: -1;
+		if (Number.isInteger(match) && match >= keep) cookies.delete(name, { path: '/' });
+	}
+}
+
+export function writeSessionCookie(cookies: Cookies, token: string, url: URL): void {
+	const options = sessionCookieOptions(url);
+	const count = Math.ceil(token.length / SESSION_CHUNK_SIZE);
+	for (let index = 0; index < count; index++) {
+		const chunk = token.slice(index * SESSION_CHUNK_SIZE, (index + 1) * SESSION_CHUNK_SIZE);
+		cookies.set(sessionChunkName(index), chunk, options);
+	}
+	clearSessionCookie(cookies, count);
+}
+
 export async function encodeSession(session: Session): Promise<string> {
 	const now = Math.floor(Date.now() / 1000);
 	return new EncryptJWT({ ...session })

web-player/src/lib/server/config.ts

@@ -9,12 +9,17 @@ function positiveInt(value: string | undefined, fallback: number): number {
 	return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function required(name: string, value: string | undefined): string {
+	if (!value) throw new Error(`Missing required environment variable: ${name}`);
+	return value;
+}
+
 export const authConfig = {
 	get issuer() {
-		return env.ZITADEL_ISSUER;
+		return required('ZITADEL_ISSUER', env.ZITADEL_ISSUER);
 	},
 	get clientId() {
-		return env.ZITADEL_CLIENT_ID;
+		return required('ZITADEL_CLIENT_ID', env.ZITADEL_CLIENT_ID);
 	},
 	get clientSecret(): string | undefined {
 		const secret = env.ZITADEL_CLIENT_SECRET;
@@ -24,10 +29,10 @@ export const authConfig = {
 		return env.OIDC_SCOPE || DEFAULT_OIDC_SCOPE;
 	},
 	get redirectUri() {
-		return env.AUTH_REDIRECT_URI;
+		return required('AUTH_REDIRECT_URI', env.AUTH_REDIRECT_URI);
 	},
 	get postLogoutUri() {
-		return env.AUTH_POST_LOGOUT_URI;
+		return required('AUTH_POST_LOGOUT_URI', env.AUTH_POST_LOGOUT_URI);
 	},
 	get sessionSecret() {
 		return env.SESSION_SECRET;

web-player/src/lib/state/navigation.svelte.ts

@@ -68,6 +68,10 @@ export function searchHref(query: string): string {
 	return query ? `/explore?q=${encodeURIComponent(query)}` : '/explore';
 }
 
+export function genreHref(genre: string): string {
+	return `/explore?genre=${encodeURIComponent(genre)}`;
+}
+
 export interface AppNavLink {
 	href: string;
 	label: string;

web-player/src/lib/theme/tokens.ts

@@ -63,7 +63,6 @@ export function buildThemeTokens(hue: number, mode: 'dark' | 'light' = 'dark'):
 		'--mf-spotlight-bg': light
 			? `linear-gradient(120deg, ${glow(0.9, 0.04, 0.55)}, ${glow(0.96, 0.02, 0.35)} 55%)`
 			: `linear-gradient(120deg, ${glow(0.22, 0.04, 0.5)}, ${glow(0.13, 0.02, 0.3)} 55%, ${glow(0.11, 0.015, 0.2)})`,
-		'--mf-logo-grad': `linear-gradient(${accent}, ${accent})`,
 		'--mf-cover-grad': light
 			? `linear-gradient(150deg, oklch(0.84 0.03 ${H}), oklch(0.74 0.02 ${H}))`
 			: `linear-gradient(150deg, oklch(0.34 0.03 ${H}), oklch(0.18 0.015 ${H}))`

web-player/src/routes/(app)/explore/+page.server.ts

@@ -9,13 +9,25 @@ import {
 
 export const load: PageServerLoad = async ({ url, locals, fetch }) => {
 	const query = url.searchParams.get('q')?.trim() ?? '';
+	const genreParam = url.searchParams.get('genre')?.trim() || null;
 	const page = Math.max(1, Number(url.searchParams.get('page')) || 1);
 
 	const user = locals.user;
 	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
 
+	const genresRes = await api.GET('/genres');
+	const genres = genresRes.data ?? [];
+	const genre = genres.find((item) => item.genre === genreParam)?.genre ?? null;
+
 	const tracksPromise = api.GET('/tracks', {
-		params: { query: { name: query || undefined, pageNumber: page, pageSize: PAGE_SIZE } }
+		params: {
+			query: {
+				name: query || undefined,
+				genre: genre ?? undefined,
+				pageNumber: page,
+				pageSize: PAGE_SIZE
+			}
+		}
 	});
 
 	const playlistsPromise = user
@@ -47,6 +59,8 @@ export const load: PageServerLoad = async ({ url, locals, fetch }) => {
 
 	return {
 		query,
+		genre,
+		genres,
 		tracks,
 		albums: (albumsRes?.data?.items ?? []).map((item) => item.album),
 		users: usersRes?.data?.items ?? [],

web-player/src/routes/(app)/explore/+page.svelte

@@ -16,13 +16,13 @@
 	import Chip from '$lib/components/ui/primitives/Chip.svelte';
 	import SectionHeading from '$lib/components/ui/layout/SectionHeading.svelte';
 	import { EXPLORE_PAGE_SIZE } from '$lib/config';
-	import { searchHref } from '$lib/state/navigation.svelte';
+	import { genreHref } from '$lib/state/navigation.svelte';
 	import { createTrackMenu } from '$lib/state/menus.svelte';
 	import ContextMenu, { contextMenuPosition } from '$lib/components/ui/overlay/ContextMenu.svelte';
 	import ListPlus from '@lucide/svelte/icons/list-plus';
 	import ListEnd from '@lucide/svelte/icons/list-end';
 	import { appendUnique } from '$lib/data/collections';
-	import { genreTiles } from '$lib/data/genres';
+	import { genreInfo, genreTiles } from '$lib/data/genres';
 	import {
 		type SearchFilter,
 		showGroup,
@@ -58,7 +58,7 @@
 	$effect(() => {
 		trackMenu.close();
 		albumMenu = null;
-		sfilter = 'Todo';
+		sfilter = data.genre ? 'Canciones' : 'Todo';
 		localItems = data.tracks.items.map((item) => item.track);
 		localPage = Number(data.tracks.pageNumber);
 		hasMore = data.tracks.hasNextPage;
@@ -73,6 +73,9 @@
 
 	const items = $derived(songRows.map((row) => row.track));
 
+	const tiles = $derived(genreTiles(data.genres));
+	const activeGenre = $derived(data.genre ? genreInfo(data.genre) : null);
+
 	const albums = $derived(data.albums);
 	const users = $derived(data.users);
 
@@ -169,6 +172,7 @@
 				pageSize: String(EXPLORE_PAGE_SIZE)
 			});
 			if (data.query) params.set('name', data.query);
+			if (data.genre) params.set('genre', data.genre);
 			const res = await fetch(`/api/tracks?${params}`);
 			if (!res.ok) throw new Error(String(res.status));
 			const next = (await res.json()) as typeof data.tracks;
@@ -188,7 +192,9 @@
 </script>
 
 <svelte:head>
-	<title>{data.query ? `Buscar «${data.query}»` : 'Descubrir'}</title>
+	<title
+		>{activeGenre ? activeGenre.label : data.query ? `Buscar «${data.query}»` : 'Descubrir'}</title
+	>
 	<meta
 		name="description"
 		content="Busca canciones, álbumes y personas, o descubre por género en Musify."
@@ -196,7 +202,9 @@
 </svelte:head>
 
 <Page>
-	{#if !data.query}
+	{#if activeGenre}
+		<PageHeader eyebrow="Género" title={activeGenre.label} description={activeGenre.tagline} />
+	{:else if !data.query}
 		<PageHeader
 			title="Descubrir"
 			description="Encuentra tu próxima canción favorita explorando por género."
@@ -300,31 +308,34 @@
 				por playlist.
 			</p>
 			<div class="mt-5.5 flex flex-wrap justify-center gap-2">
-				{#each genreTiles.slice(0, 4) as genre (genre.query)}
-					<Chip href={searchHref(genre.query)}>{genre.label}</Chip>
+				{#each tiles.slice(0, 4) as tile (tile.genre)}
+					<Chip href={genreHref(tile.genre)}>{tile.label}</Chip>
 				{/each}
 			</div>
 		</div>
 	{/if}
 
-	{#if !data.query}
+	{#if !data.query && !data.genre}
 		<div class="grid-wide">
-			{#each genreTiles as genre, i (genre.query)}
+			{#each tiles as tile, i (tile.genre)}
 				<a
-					href={searchHref(genre.query)}
+					href={genreHref(tile.genre)}
 					class="animate-enter group relative flex h-28 flex-col gap-1 overflow-hidden rounded-panel p-4 transition-[filter] genre-tile hover:brightness-110"
-					style="--i:{i}; --tile-hue:{genre.hue}"
+					style="--i:{i}; --tile-hue:{tile.hue}"
 				>
 					<div class="text-on-art">
-						{genre.label}
+						{tile.label}
 					</div>
-					<div class="text-xs text-on-art-2">{genre.tagline}</div>
+					<div class="text-xs text-on-art-2">{tile.tagline}</div>
 				</a>
 			{/each}
 		</div>
+		{#if tiles.length === 0}
+			<EmptyState icon={Music} description="Todavía no hay géneros. Sube música para empezar." />
+		{/if}
 	{/if}
 
-	{#if data.query && !nothingFound}
+	{#if (data.query || data.genre) && !nothingFound}
 		<div class="mt-9 flex flex-col gap-9">
 			{#if showGroup(sfilter, 'Canciones')}
 				<div>
@@ -364,7 +375,9 @@
 					{:else}
 						<EmptyState
 							icon={Music}
-							description="No hay canciones que coincidan con «{data.query}»."
+							description={activeGenre
+								? 'Todavía no hay canciones de este género.'
+								: `No hay canciones que coincidan con «${data.query}».`}
 						/>
 					{/if}
 				</div>

web-player/src/routes/(app)/upload/+page.server.ts

@@ -7,11 +7,18 @@ import {
 	unwrapOrFail
 } from '$lib/server/api';
 import { putPresigned, extOf, contentTypeOf, AUDIO_TYPES, IMAGE_TYPES } from '$lib/server/upload';
+import { findConflict, genreInfo } from '$lib/data/genres';
+import type { components } from '$lib/api/schema';
+
+type Genre = components['schemas']['Genre'];
 
 const MAX_TITLE = 100;
 
-export const load: PageServerLoad = ({ locals, url }) => {
+export const load: PageServerLoad = async ({ locals, url, fetch }) => {
 	requireUser(locals, url);
+	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
+	const { data } = await api.GET('/genres/available');
+	return { genres: data ?? [] };
 };
 
 export const actions: Actions = {
@@ -23,6 +30,7 @@ export const actions: Actions = {
 		const title = String(form.get('title') ?? '').trim();
 		const audio = form.get('audio');
 		const cover = form.get('cover');
+		const rawTags = form.getAll('tags').map(String);
 
 		if (title === '' || title.length > MAX_TITLE) {
 			return fail(400, { message: 'El título es obligatorio (máx. 100 caracteres).' });
@@ -34,9 +42,26 @@ export const actions: Actions = {
 			return fail(400, { message: 'Selecciona una portada.' });
 		}
 
+		if (rawTags.length === 0) {
+			return fail(400, { message: 'Elige al menos un género.' });
+		}
+		const api = createApiClient({ fetch, accessToken });
+		const { data: available } = await api.GET('/genres/available');
+		const options = available ?? [];
+		const known = new Set<string>(options.map((option) => option.genre));
+		if (!rawTags.every((tag) => known.has(tag))) {
+			return fail(400, { message: 'Alguno de los géneros no es válido.' });
+		}
+		const tags = [...new Set(rawTags)] as Genre[];
+		const conflict = findConflict(tags, options);
+		if (conflict) {
+			return fail(400, {
+				message: `Los géneros ${genreInfo(conflict[0]).label} y ${genreInfo(conflict[1]).label} no se pueden combinar.`
+			});
+		}
+
 		const audioContentType = contentTypeOf(audio, AUDIO_TYPES);
 		const pictureContentType = contentTypeOf(cover, IMAGE_TYPES);
-		const api = createApiClient({ fetch, accessToken });
 
 		const urlsResult = await api.POST('/tracks/upload-urls', {
 			body: {
@@ -73,7 +98,8 @@ export const actions: Actions = {
 			body: {
 				title,
 				pictureIntentId: urls.pictureIntentId,
-				audioIntentId: urls.audioIntentId
+				audioIntentId: urls.audioIntentId,
+				tags
 			}
 		});
 

web-player/src/routes/(app)/upload/+page.svelte

@@ -13,12 +13,16 @@
 	import Input from '$lib/components/ui/primitives/Input.svelte';
 	import Checkbox from '$lib/components/ui/primitives/Checkbox.svelte';
 	import Button from '$lib/components/ui/primitives/Button.svelte';
+	import Chip from '$lib/components/ui/primitives/Chip.svelte';
+	import { genreOptions } from '$lib/data/genres';
 
 	type Status = 'idle' | 'uploading' | 'done' | 'error';
 	type StepState = 'idle' | 'active' | 'done';
 
 	const MAX_TITLE = 100;
 
+	let { data } = $props();
+
 	let title = $state('');
 	let audioName = $state('');
 	let audioSize = $state(0);
@@ -28,6 +32,8 @@
 	let status = $state<Status>('idle');
 	let acceptedTerms = $state(false);
 	let errorMsg = $state('');
+	let errorDetail = $state('');
+	let tags = $state<string[]>([]);
 	let publishedTitle = $state('');
 	let audioInput = $state<HTMLInputElement>();
 
@@ -37,10 +43,19 @@
 		{ key: 'publish', label: 'Publicar', hint: 'Disponible en el catálogo.' }
 	];
 
+	const options = $derived(genreOptions(data.genres));
+	const blocked = $derived(
+		new Set(
+			options
+				.filter((option) => tags.includes(option.genre))
+				.flatMap((option) => option.incompatibleWith)
+		)
+	);
+
 	const busy = $derived(status === 'uploading');
 
 	const canPublish = $derived(
-		title.trim() !== '' && audioName !== '' && hasCover && acceptedTerms && !busy
+		title.trim() !== '' && audioName !== '' && hasCover && tags.length > 0 && acceptedTerms && !busy
 	);
 
 	const stepStates = $derived.by<StepState[]>(() => {
@@ -81,6 +96,10 @@
 		pickAudio(file);
 	}
 
+	function toggleTag(tag: string) {
+		tags = tags.includes(tag) ? tags.filter((current) => current !== tag) : [...tags, tag];
+	}
+
 	function reset() {
 		title = '';
 		audioName = '';
@@ -90,6 +109,8 @@
 		status = 'idle';
 		acceptedTerms = false;
 		errorMsg = '';
+		errorDetail = '';
+		tags = [];
 	}
 </script>
 
@@ -153,6 +174,7 @@
 			use:enhance={() => {
 				status = 'uploading';
 				errorMsg = '';
+				errorDetail = '';
 				return async ({ result }) => {
 					if (result.type === 'success') {
 						publishedTitle = title;
@@ -160,6 +182,7 @@
 					} else if (result.type === 'failure') {
 						status = 'error';
 						errorMsg = (result.data?.message as string) ?? 'No se pudo subir la canción.';
+						errorDetail = (result.data?.detail as string | undefined) ?? '';
 					} else {
 						status = 'error';
 						errorMsg = 'Error inesperado durante la subida.';
@@ -236,6 +259,26 @@
 				</Field>
 			</div>
 
+			<Field label="Géneros">
+				<div class="flex flex-wrap gap-2">
+					{#each options as option (option.genre)}
+						<Chip
+							selected={tags.includes(option.genre)}
+							disabled={blocked.has(option.genre)}
+							onclick={() => toggleTag(option.genre)}
+						>
+							{option.label}
+						</Chip>
+					{/each}
+				</div>
+				{#each tags as tag (tag)}
+					<input type="hidden" name="tags" value={tag} />
+				{/each}
+				{#snippet hint()}
+					<p>Elige al menos uno. Algunos géneros no se pueden combinar, como Metal con Ambient.</p>
+				{/snippet}
+			</Field>
+
 			<Checkbox bind:checked={acceptedTerms}>
 				Acepto los
 				<a
@@ -260,7 +303,10 @@
 			{/if}
 
 			{#if status === 'error'}
-				<Alert tone="danger">{errorMsg}</Alert>
+				<Alert tone="danger">
+					{errorMsg}
+					{#if errorDetail}<span class="mt-1 block text-xs opacity-80">{errorDetail}</span>{/if}
+				</Alert>
 			{/if}
 
 			<div class="flex flex-col-reverse gap-3 sm:flex-row sm:items-center sm:justify-end sm:gap-4">

web-player/src/routes/+layout.server.ts

@@ -39,6 +39,22 @@ async function fetchLikedTracks(fetchFn: typeof fetch, accessToken: string | nul
 	}
 }
 
+async function fetchLastPlayedTrack(
+	fetchFn: typeof fetch,
+	accessToken: string | null,
+	userId: string
+) {
+	try {
+		const api = createApiClient({ fetch: fetchFn, accessToken: accessToken ?? undefined });
+		const { data } = await api.GET('/users/{id}/last-listened-track', {
+			params: { path: { id: userId } }
+		});
+		return data ?? null;
+	} catch {
+		return null;
+	}
+}
+
 export const load: LayoutServerLoad = async ({ locals, url, fetch }) => {
 	const allowAnonymousListening = await getAllowAnonymousListening(fetch);
 
@@ -56,13 +72,15 @@ export const load: LayoutServerLoad = async ({ locals, url, fetch }) => {
 			allowAnonymousListening,
 			sidebarPlaylists: [],
 			likedTracks: [],
+			lastPlayedTrack: null,
 			accountUrl
 		};
 	}
 
-	const [sidebarPlaylists, likedTracks] = await Promise.all([
+	const [sidebarPlaylists, likedTracks, lastPlayedTrack] = await Promise.all([
 		fetchSidebarPlaylists(fetch, locals.accessToken, locals.user.sub),
-		fetchLikedTracks(fetch, locals.accessToken)
+		fetchLikedTracks(fetch, locals.accessToken),
+		fetchLastPlayedTrack(fetch, locals.accessToken, locals.user.sub)
 	]);
 
 	return {
@@ -70,6 +88,7 @@ export const load: LayoutServerLoad = async ({ locals, url, fetch }) => {
 		allowAnonymousListening,
 		sidebarPlaylists,
 		likedTracks,
+		lastPlayedTrack,
 		accountUrl
 	};
 };

web-player/src/routes/+layout.svelte

@@ -30,15 +30,19 @@
 		if (data.likedTracks?.length) liked.hydrate(data.likedTracks);
 	});
 
+	$effect(() => {
+		if (data.lastPlayedTrack) player.hydrate(data.lastPlayedTrack);
+	});
+
 	const isAuthPage = $derived(page.url.pathname === '/auth');
 	const hasTrack = $derived(player.currentId !== null);
 
 	const initialThemeCss = `:root{${tokensToCss(buildThemeTokens(ACCENT_HUE, 'dark'))}}:root[data-theme='light']{${tokensToCss(buildThemeTokens(ACCENT_HUE, 'light'))}}`;
 
-	let hadTrack = false;
+	let wasPlaying = false;
 	$effect(() => {
-		if (hasTrack && !hadTrack) queuePanel.show();
-		hadTrack = hasTrack;
+		if (player.playing && !wasPlaying) queuePanel.show();
+		wasPlaying = player.playing;
 	});
 
 	function isTypingTarget(target: EventTarget | null): boolean {

web-player/src/routes/api/listens/[id]/progress/+server.ts

@@ -0,0 +1,25 @@
+import type { RequestHandler } from './$types';
+import { json } from '@sveltejs/kit';
+import { createApiClient } from '$lib/server/api';
+
+export const PUT: RequestHandler = async ({ params, request, locals, fetch }) => {
+	if (!locals.accessToken) return json({ message: 'Inicia sesión.' }, { status: 401 });
+
+	const { playedSeconds } = (await request.json()) as { playedSeconds?: number };
+	if (typeof playedSeconds !== 'number' || !Number.isFinite(playedSeconds) || playedSeconds < 0)
+		return json({ message: 'Tiempo inválido.' }, { status: 400 });
+
+	const api = createApiClient({ fetch, accessToken: locals.accessToken });
+	const result = await api.PUT('/tracks/listens/{listenId}/progress', {
+		params: { path: { listenId: params.id } },
+		body: { playedSeconds }
+	});
+
+	if (result.error !== undefined)
+		return json(
+			{ message: 'No se pudo registrar la escucha.' },
+			{ status: result.response.status === 404 ? 404 : 502 }
+		);
+
+	return new Response(null, { status: 204 });
+};

web-player/src/routes/api/tracks/+server.ts

@@ -5,12 +5,13 @@ import { EXPLORE_PAGE_SIZE } from '$lib/config';
 
 export const GET: RequestHandler = async ({ url, locals, fetch }) => {
 	const name = url.searchParams.get('name')?.trim() || undefined;
+	const genre = url.searchParams.get('genre')?.trim() || undefined;
 	const pageNumber = Math.max(1, Number(url.searchParams.get('pageNumber')) || 1);
 	const pageSize = Math.max(1, Number(url.searchParams.get('pageSize')) || EXPLORE_PAGE_SIZE);
 
 	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
 	const result = await api.GET('/tracks', {
-		params: { query: { name, pageNumber, pageSize } }
+		params: { query: { name, genre, pageNumber, pageSize } }
 	});
 
 	return json(unwrapOrError(result, 'No se pudieron cargar las canciones.'));

web-player/src/routes/auth/callback/+server.ts

@@ -4,10 +4,9 @@ import type { RequestHandler } from './$types';
 import {
 	getOidcConfig,
 	encodeSession,
-	sessionCookieOptions,
 	toSessionUser,
+	writeSessionCookie,
 	type Session,
-	SESSION_COOKIE,
 	STATE_COOKIE,
 	VERIFIER_COOKIE,
 	NONCE_COOKIE,
@@ -55,7 +54,7 @@ export const GET: RequestHandler = async ({ url, cookies }) => {
 		expiresAt: Math.floor(Date.now() / 1000) + (tokens.expires_in ?? 3600)
 	};
 
-	cookies.set(SESSION_COOKIE, await encodeSession(session), sessionCookieOptions(url));
+	writeSessionCookie(cookies, await encodeSession(session), url);
 
 	for (const name of [STATE_COOKIE, VERIFIER_COOKIE, NONCE_COOKIE, RETURN_COOKIE]) {
 		cookies.delete(name, { path: '/' });

web-player/src/routes/auth/logout/+server.ts

@@ -1,12 +1,17 @@
 import { redirect } from '@sveltejs/kit';
 import * as client from 'openid-client';
 import type { RequestHandler } from './$types';
-import { getOidcConfig, decodeSession, SESSION_COOKIE } from '$lib/server/auth';
+import {
+	clearSessionCookie,
+	decodeSession,
+	getOidcConfig,
+	readSessionCookie
+} from '$lib/server/auth';
 import { authConfig } from '$lib/server/config';
 
 const handleLogout: RequestHandler = async ({ cookies }) => {
-	const session = await decodeSession(cookies.get(SESSION_COOKIE));
-	cookies.delete(SESSION_COOKIE, { path: '/' });
+	const session = await decodeSession(readSessionCookie(cookies));
+	clearSessionCookie(cookies);
 
 	const config = await getOidcConfig();
 	const endSessionUrl = client.buildEndSessionUrl(config, {