Merge branch 'master' into profile-customization-drop-cover

.env.example

···
 # NOTIFICATION_CLEANUP_MAX_DELETE=50000
 
 # The open source bounty info page/form url
-#OS_BOUNTY_URL=http://example.com/bounty_form
+# OS_BOUNTY_URL=http://example.com/bounty_form
 
 # OAUTH_MAX_USER_CLIENTS=1
 
···
 # PAGINATION_MAX_COUNT=10000
 
 ## Limits for the allowed number of simultaneous beatmapset uploads (displayed on the support page: /home/support)
-#BEATMAPSET_UPLOAD_ALLOWED=4
-#BEATMAPSET_UPLOAD_BONUS_PER_RANKED=1
-#BEATMAPSET_UPLOAD_BONUS_PER_RANKED_MAX=2
-#BEATMAPSET_UPLOAD_ALLOWED_SUPPORTER=8
-#BEATMAPSET_UPLOAD_BONUS_PER_RANKED_SUPPORTER=1
-#BEATMAPSET_UPLOAD_BONUS_PER_RANKED_MAX_SUPPORTER=12
+# BEATMAPSET_UPLOAD_ALLOWED=4
+# BEATMAPSET_UPLOAD_BONUS_PER_RANKED=1
+# BEATMAPSET_UPLOAD_BONUS_PER_RANKED_MAX=2
+# BEATMAPSET_UPLOAD_ALLOWED_SUPPORTER=8
+# BEATMAPSET_UPLOAD_BONUS_PER_RANKED_SUPPORTER=1
+# BEATMAPSET_UPLOAD_BONUS_PER_RANKED_MAX_SUPPORTER=12
 
-#RECAPTCHA_SECRET=
-#RECAPTCHA_SITEKEY=
-#RECAPTCHA_THRESHOLD=
+# RECAPTCHA_SECRET=
+# RECAPTCHA_SITEKEY=
+# RECAPTCHA_THRESHOLD=
 
 # TWITCH_CLIENT_ID=
 # TWITCH_CLIENT_SECRET=
···
 
 # USER_COUNTRY_CHANGE_MAX_MIXED_MONTHS=2
 # USER_COUNTRY_CHANGE_MIN_MONTHS=6
+
+# USER_INACTIVE_DAYS_VERIFICATION=180
+# USER_INACTIVE_FORCE_PASSWORD_RESET=false

app/Http/Controllers/Forum/TopicsController.php

···
 use App\Models\Forum\TopicCover;
 use App\Models\Forum\TopicPoll;
 use App\Models\Forum\TopicWatch;
+use App\Models\UserProfileCustomization;
 use App\Transformers\Forum\TopicCoverTransformer;
 use Auth;
 use DB;
···
         $params['limit'] = clamp($params['limit'] ?? 20, 1, 50);
 
         if ($userCanModerate) {
-            $params['with_deleted'] = $params['with_deleted'] ?? $currentUser->profileCustomization()->forum_posts_show_deleted;
+            $params['with_deleted'] ??= ($currentUser->userProfileCustomization ?? UserProfileCustomization::DEFAULTS)['forum_posts_show_deleted'];
         } else {
             $params['with_deleted'] = false;
         }

app/Http/Controllers/ScorePinsController.php

···
             $rulesetId = Beatmap::MODES[$score->getMode()];
             $currentMinDisplayOrder = $user->scorePins()->where('ruleset_id', $rulesetId)->min('display_order') ?? 2500;
 
+            $soloScore = $score instanceof Solo\Score
+                ? $score
+                : Solo\Score::firstWhere(['ruleset_id' => $rulesetId, 'legacy_score_id' => $score->getKey()]);
+
             try {
-                (new ScorePin(['display_order' => $currentMinDisplayOrder - 100, 'ruleset_id' => $rulesetId]))
-                    ->user()->associate($user)
+                (new ScorePin([
+                    'display_order' => $currentMinDisplayOrder - 100,
+                    'ruleset_id' => $rulesetId,
+                    'new_score_id' => $soloScore?->getKey(),
+                ]))->user()->associate($user)
                     ->score()->associate($score)
                     ->saveOrExplode();
             } catch (Exception $ex) {

app/Http/Controllers/ScoresController.php

···
 
 use App\Models\Score\Best\Model as ScoreBest;
 use App\Models\Solo\Score as SoloScore;
-use App\Models\UserCountryHistory;
 use App\Transformers\ScoreTransformer;
 use App\Transformers\UserCompactTransformer;
-use Carbon\CarbonImmutable;
 
 class ScoresController extends Controller
 {
+    const REPLAY_DOWNLOAD_COUNT_INTERVAL = 86400; // 1 day
+
     public function __construct()
     {
         parent::__construct();
···
             abort(404);
         }
 
-        if (\Auth::user()->getKey() !== $score->user_id) {
-            $score->user->statistics($score->getMode(), true)->increment('replay_popularity');
+        $currentUser = \Auth::user();
+        if (
+            !$currentUser->isRestricted()
+            && $currentUser->getKey() !== $score->user_id
+            && ($currentUser->token()?->client->password_client ?? false)
+        ) {
+            $countLock = \Cache::lock(
+                "view:score_replay:{$score->getKey()}:{$currentUser->getKey()}",
+                static::REPLAY_DOWNLOAD_COUNT_INTERVAL,
+            );
 
-            $month = CarbonImmutable::now();
-            $currentMonth = UserCountryHistory::formatDate($month);
+            if ($countLock->get()) {
+                $score->user->statistics($score->getMode(), true)->increment('replay_popularity');
 
-            $score->user->replaysWatchedCounts()
-                ->firstOrCreate(['year_month' => $currentMonth], ['count' => 0])
-                ->incrementInstance('count');
+                $currentMonth = format_month_column(new \DateTime());
+                $score->user->replaysWatchedCounts()
+                    ->firstOrCreate(['year_month' => $currentMonth], ['count' => 0])
+                    ->incrementInstance('count');
 
-            if ($score instanceof ScoreBest) {
-                $score->replayViewCount()
-                    ->firstOrCreate([], ['play_count' => 0])
-                    ->incrementInstance('play_count');
+                if ($score instanceof ScoreBest) {
+                    $score->replayViewCount()
+                        ->firstOrCreate([], ['play_count' => 0])
+                        ->incrementInstance('play_count');
+                }
             }
         }
 

app/Http/Controllers/SessionsController.php

···
             $forceReactivation = new ForceReactivation($user, $request);
 
             if ($forceReactivation->isRequired()) {
+                DatadogLoginAttempt::log('password_reset');
                 $forceReactivation->run();
 
                 \Session::flash('password_reset_start', [
···
                 return ujs_redirect(route('password-reset'));
             }
 
+            DatadogLoginAttempt::log(null);
             $this->login($user, $remember);
 
             return [

app/Http/Controllers/UserCoverPresetsController.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace App\Http\Controllers;
+
+use App\Models\UserCoverPreset;
+use Symfony\Component\HttpFoundation\Response;
+
+class UserCoverPresetsController extends Controller
+{
+    public function __construct()
+    {
+        $this->middleware('auth');
+
+        parent::__construct();
+    }
+
+    public function batchActivate(): Response
+    {
+        $params = get_params(\Request::all(), null, [
+            'ids:int[]',
+            'active:bool',
+        ]);
+        if (!isset($params['active'])) {
+            abort(422, 'parameter "active" is missing');
+        }
+        UserCoverPreset::whereKey($params['ids'] ?? [])->update(['active' => $params['active']]);
+
+        return response(null, 204);
+    }
+
+    public function index(): Response
+    {
+        priv_check('UserCoverPresetManage')->ensureCan();
+
+        return ext_view('user_cover_presets.index', [
+            'items' => UserCoverPreset::orderBy('id', 'ASC')->get(),
+        ]);
+    }
+
+    public function store(): Response
+    {
+        priv_check('UserCoverPresetManage')->ensureCan();
+
+        try {
+            $files = \Request::file('files') ?? [];
+            foreach ($files as $file) {
+                $item = \DB::transaction(function () use ($file) {
+                    $item = UserCoverPreset::create();
+                    $item->file()->store($file->getRealPath());
+                    $item->saveOrExplode();
+
+                    return $item;
+                });
+                $hash ??= "#cover-{$item->getKey()}";
+            }
+            \Session::flash('popup', osu_trans('user_cover_presets.store.ok'));
+        } catch (\Throwable $e) {
+            \Session::flash('popup', osu_trans('user_cover_presets.store.failed', ['error' => $e->getMessage()]));
+        }
+
+        return ujs_redirect(route('user-cover-presets.index').($hash ?? ''));
+    }
+
+    public function update(string $id): Response
+    {
+        priv_check('UserCoverPresetManage')->ensureCan();
+
+        $item = UserCoverPreset::findOrFail($id);
+        $params = get_params(\Request::all(), null, [
+            'file:file',
+            'active:bool',
+        ], ['null_missing' => true]);
+
+        if ($params['file'] !== null) {
+            $item->file()->store($params['file']);
+            $item->save();
+        }
+        if ($params['active'] !== null) {
+            $item->update(['active' => $params['active']]);
+        }
+
+        return ujs_redirect(route('user-cover-presets.index').'#cover-'.$item->getKey());
+    }
+}

app/Http/Controllers/UsersController.php

···
         } else {
             $achievements = json_collection(app('medals')->all(), 'Achievement');
 
-            $extras = [];
-
             $initialData = [
                 'achievements' => $achievements,
                 'current_mode' => $currentMode,

app/Jobs/Notifications/BeatmapsetDiscussionQualifiedProblem.php

···
 
         $ids = [];
 
-        $notificationOptions = UserNotificationOption
+        UserNotificationOption
             ::where(['name' => Notification::BEATMAPSET_DISCUSSION_QUALIFIED_PROBLEM])
             ->whereNotNull('details')
-            ->get();
-
-        foreach ($notificationOptions as $notificationOption) {
-            if (count(array_intersect($notificationOption->details['modes'] ?? [], $modes)) > 0) {
-                $ids[] = $notificationOption->user_id;
-            }
-        }
+            ->chunkById(1000, function ($options) use (&$ids, $modes) {
+                foreach ($options as $option) {
+                    if (count(array_intersect($option->details['modes'] ?? [], $modes)) > 0) {
+                        $ids[] = $option->user_id;
+                    }
+                }
+            });
 
         return $ids;
     }

app/Jobs/Notifications/BeatmapsetDisqualify.php

···
             return Beatmap::modeStr($modeInt);
         }, $modes);
 
-        $notificationOptions = UserNotificationOption
-            ::where(['name' => Notification::BEATMAPSET_DISQUALIFY])
+        UserNotificationOption::where(['name' => Notification::BEATMAPSET_DISQUALIFY])
             ->whereNotNull('details')
-            ->get();
-
-        foreach ($notificationOptions as $notificationOption) {
-            if (count(array_intersect($notificationOption->details['modes'] ?? [], $modes)) > 0) {
-                $ids[] = $notificationOption->user_id;
-            }
-        }
+            ->chunkById(1000, function ($options) use (&$ids, $modes) {
+                foreach ($options as $option) {
+                    if (count(array_intersect($option->details['modes'] ?? [], $modes)) > 0) {
+                        $ids[] = $option->user_id;
+                    }
+                }
+            });
 
         return $ids;
     }

app/Libraries/CommentBundleParams.php

···
         $this->cursor = null;
         $this->limit = static::DEFAULT_LIMIT;
         $this->page = static::DEFAULT_PAGE;
-        $this->sort = optional($user)->profileCustomization()->comments_sort ?? null;
+        $this->sort = $user->userProfileCustomization->comments_sort ?? null;
 
         $this->setAll($params);
     }

app/Libraries/Search/BeatmapsetSearch.php

···
     private function getPlayedBeatmapIds(?array $rank = null)
     {
         $query = Solo\Score
-            ::where('user_id', $this->params->user->getKey())
+            ::indexable()
+            ->where('user_id', $this->params->user->getKey())
             ->whereIn('ruleset_id', $this->getSelectedModes());
 
         if ($rank === null) {
···
         }
 
         $topScores = [];
-        $scoreField = ScoreSearchParams::showLegacyForUser($this->params->user)
-            ? 'legacy_total_score'
-            : 'total_score';
+        $showLegacyOnly = ScoreSearchParams::showLegacyForUser($this->params->user) ?? false;
+        $scoreField = $showLegacyOnly ? 'legacy_total_score' : 'total_score';
         foreach ($query->get() as $score) {
             $prevScore = $topScores[$score->beatmap_id] ?? null;
 
             $scoreValue = $score->$scoreField;
             if ($scoreValue !== null && ($prevScore === null || $prevScore->$scoreField < $scoreValue)) {
                 $topScores[$score->beatmap_id] = $score;
+            }
+        }
+
+        if ($showLegacyOnly) {
+            foreach ($topScores as $beatmapId => $score) {
+                $topScores[$beatmapId] = $score->makeLegacyEntry();
             }
         }
 

app/Libraries/Search/BeatmapsetSearchRequestParams.php

···
             $this->showRecommended = in_array('recommended', $generals, true);
             $this->showSpotlights = in_array('spotlights', $generals, true);
 
-            $includeNsfw = $params['nsfw'];
-            if (!isset($includeNsfw) && $user !== null && $user->userProfileCustomization !== null) {
-                $includeNsfw = $user->userProfileCustomization->beatmapset_show_nsfw;
-            }
-
-            if (isset($includeNsfw)) {
-                $this->includeNsfw = $includeNsfw;
-            }
+            $this->includeNsfw = $params['nsfw']
+                ?? $user->userProfileCustomization->beatmapset_show_nsfw
+                ?? $this->includeNsfw;
         } else {
             $sort = null;
         }

app/Libraries/Search/ScoreSearch.php

···
                 $query->mustNot(['term' => ['mods' => $excludedMod]]);
             }
         }
+        if ($this->params->excludeWithoutPp === true) {
+            $query->filter(['exists' => ['field' => 'pp']]);
+        }
 
         $this->addModsFilter($query);
 

app/Libraries/Search/ScoreSearchParams.php

···
     public bool $excludeConverts = false;
     public ?array $excludeMods = null;
     public ?bool $isLegacy = null;
+    public bool $excludeWithoutPp = false;
     public ?array $mods = null;
     public ?int $rulesetId = null;
     public $size = 50;
···
         $params->beatmapIds = $rawParams['beatmap_ids'] ?? null;
         $params->excludeConverts = $rawParams['exclude_converts'] ?? $params->excludeConverts;
         $params->excludeMods = $rawParams['exclude_mods'] ?? null;
+        $params->excludeWithoutPp = $rawParams['exclude_without_pp'] ?? $params->excludeWithoutPp;
         $params->isLegacy = $rawParams['is_legacy'] ?? null;
         $params->mods = $rawParams['mods'] ?? null;
         $params->rulesetId = $rawParams['ruleset_id'] ?? null;
···
             return null;
         }
 
-        return $user?->userProfileCustomization?->legacy_score_only ?? UserProfileCustomization::DEFAULT_LEGACY_ONLY_ATTRIBUTE
+        return ($user->userProfileCustomization ?? UserProfileCustomization::DEFAULTS)['legacy_score_only']
             ? true
             : null;
     }

app/Libraries/User/CountryChangeTarget.php

···
 use App\Models\Tournament;
 use App\Models\TournamentRegistration;
 use App\Models\User;
-use App\Models\UserCountryHistory;
 use Carbon\CarbonImmutable;
 
 class CountryChangeTarget
···
             ->userCountryHistory()
             ->whereBetween('year_month', [
                 // one year maximum range. Offset by 1 because the range is inclusive
-                UserCountryHistory::formatDate($until->subMonths(11)),
-                UserCountryHistory::formatDate($until),
+                format_month_column($until->subMonths(11)),
+                format_month_column($until),
             ])->distinct()
             ->orderBy('year_month', 'DESC')
             ->limit($minMonths)

app/Libraries/User/Cover.php

···
 
     private const AVAILABLE_PRESET_IDS = ['1', '2', '3', '4', '5', '6', '7', '8'];
 
-    private ?array $json;
-
     public function __construct(private User $user)
     {
     }
···
         return $this->user->customCover()->url();
     }
 
-    public function presetId(): ?string
+    public function defaultPresetId(): string
     {
-        if ($this->hasCustomCover()) {
-            return null;
-        }
+        $id = max(0, $this->user->getKey() ?? 0);
 
-        $id = $this->user->getKey();
+        return static::AVAILABLE_PRESET_IDS[$id % count(static::AVAILABLE_PRESET_IDS)];
+    }
 
-        if ($id === null || $id < 1) {
-            return null;
-        }
-
-        $presetId = (string) $this->user->cover_preset_id;
-
-        return static::isValidPresetId($presetId)
-            ? $presetId
-            : static::AVAILABLE_PRESET_IDS[$id % count(static::AVAILABLE_PRESET_IDS)];
+    public function presetId(): ?string
+    {
+        return $this->hasCustomCover()
+            ? null
+            : (string) ($this->user->cover_preset_id ?? $this->defaultPresetId());
     }
 
     public function set(?string $presetId, ?string $filePath): void

app/Libraries/User/ForceReactivation.php

···
 
 class ForceReactivation
 {
+    const INACTIVE = 'inactive';
     const INACTIVE_DIFFERENT_COUNTRY = 'inactive_different_country';
 
     private $country;
···
 
         $this->country = request_country($this->request);
 
-        if ($this->user->isInactive() && $this->user->country_acronym !== $this->country) {
-            $this->reason = static::INACTIVE_DIFFERENT_COUNTRY;
+        if ($this->user->isInactive()) {
+            if ($this->user->country_acronym !== $this->country) {
+                $this->reason = static::INACTIVE_DIFFERENT_COUNTRY;
+            } elseif ($GLOBALS['cfg']['osu']['user']['inactive_force_password_reset']) {
+                $this->reason = static::INACTIVE;
+            }
         }
     }
 
···
 
     private function addHistoryNote()
     {
-        if ($this->reason === static::INACTIVE_DIFFERENT_COUNTRY) {
-            $message = "First login after {$this->user->user_lastvisit->diffInDays()} days from {$this->country}. Forcing password reset.";
-        }
+        $message = match ($this->reason) {
+            static::INACTIVE => "First login after {$this->user->user_lastvisit->diffInDays()} days. Forcing password reset.",
+            static::INACTIVE_DIFFERENT_COUNTRY => "First login after {$this->user->user_lastvisit->diffInDays()} days from {$this->country}. Forcing password reset.",
+            default => null,
+        };
 
         if ($message !== null) {
             UserAccountHistory::addNote($this->user, $message);

app/Models/BeatmapPack.php

···
             ];
             if ($this->no_diff_reduction) {
                 $params['exclude_mods'] = app('mods')->difficultyReductionIds->toArray();
+                if ($isLegacy !== true) {
+                    // the intended meaning of this check is that the scores should not include mods
+                    // that disqualify them from granting pp.
+                    // mods are not the only reason why pp might be missing, but it's the best that we have for now.
+                    // see also: https://github.com/ppy/osu-queue-score-statistics/pull/234
+                    $params['exclude_without_pp'] = true;
+                }
             }
 
             static $aggName = 'by_beatmap';

app/Models/Beatmapset.php

···
         }
 
         $statusCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+        // archive file is gone, nothing to do for now
+        if ($statusCode === 302) {
+            return false;
+        }
         if ($statusCode !== 200) {
             throw new BeatmapProcessorException('Failed downloading osz: HTTP Error '.$statusCode);
         }
 
-        return new BeatmapsetArchive(get_stream_filename($oszFile));
+        try {
+            return new BeatmapsetArchive(get_stream_filename($oszFile));
+        } catch (BeatmapProcessorException $e) {
+            // zip file is broken, nothing to do for now
+            return false;
+        }
     }
 
     public function regenerateCovers(array $sizesToRegenerate = null)
···
 
         if ($backgroundFilename !== false) {
             $tmpFile = tmpfile();
-            $bytesWritten = fwrite($tmpFile, $osz->readFile($backgroundFilename));
-            fseek($tmpFile, 0); // reset file position cursor, required for storeCover below
+            fwrite($tmpFile, $osz->readFile($backgroundFilename));
             $backgroundImage = get_stream_filename($tmpFile);
             if (!static::isValidBackgroundImage($backgroundImage)) {
                 return false;
···
 
     public function getDisplayArtist(?User $user)
     {
-        $profileCustomization = $user->userProfileCustomization ?? new UserProfileCustomization();
-        if ($profileCustomization->beatmapset_title_show_original) {
-            return $this->artist_unicode;
-        }
+        $profileCustomization = $user->userProfileCustomization ?? UserProfileCustomization::DEFAULTS;
 
-        return $this->artist;
+        return $profileCustomization['beatmapset_title_show_original']
+            ? $this->artist_unicode
+            : $this->artist;
     }
 
     public function getDisplayTitle(?User $user)
     {
-        $profileCustomization = $user->userProfileCustomization ?? new UserProfileCustomization();
-        if ($profileCustomization->beatmapset_title_show_original) {
-            return $this->title_unicode;
-        }
+        $profileCustomization = $user->userProfileCustomization ?? UserProfileCustomization::DEFAULTS;
 
-        return $this->title;
+        return $profileCustomization['beatmapset_title_show_original']
+            ? $this->title_unicode
+            : $this->title;
     }
 
     public function freshHype()

app/Models/Comment.php

···
     {
         return [
             'reason' => 'Spam',
-            'user_id' => $this->user_id,
+            'user_id' => $this->user_id ?? 0,
         ];
     }
 

app/Models/Multiplayer/ScoreLink.php

···
     public static function complete(ScoreToken $token, array $params): static
     {
         return \DB::transaction(function () use ($params, $token) {
-            $score = Score::createFromJsonOrExplode($params);
+            // multiplayer scores are always preserved.
+            $score = Score::createFromJsonOrExplode([...$params, 'preserve' => true]);
 
             $playlistItem = $token->playlistItem;
             $requiredMods = array_column($playlistItem->required_mods, 'acronym');

app/Models/Multiplayer/UserScoreAggregate.php

···
     {
         $agg = PlaylistItemUserHighScore
             ::whereHas('playlistItem', fn ($q) => $q->where('room_id', $this->room_id))
+            ->whereNotNull('score_id')
             ->selectRaw('
                 SUM(accuracy) AS accuracy_sum,
                 SUM(total_score) AS total_score_sum,

app/Models/Solo/Score.php

···
 use App\Models\ScoreToken;
 use App\Models\Traits;
 use App\Models\User;
+use Illuminate\Contracts\Filesystem\Filesystem;
 use Illuminate\Database\Eloquent\Builder;
 use LaravelRedis;
-use Storage;
 
 /**
  * @property float $accuracy
···
         $params['started_at'] = $scoreToken->created_at;
         $params['user_id'] = $scoreToken->user_id;
 
+        $params['passed'] ??= false;
+        $params['preserve'] = $params['passed'];
+
         $beatmap = $scoreToken->beatmap;
         // anything that have leaderboard
-        $params['ranked'] = $beatmap !== null && $beatmap->approved > 0;
+        $params['ranked'] = $params['passed'] && $beatmap !== null && $beatmap->approved > 0;
+
+        return $params;
+    }
 
-        $params['preserve'] = $params['passed'] ?? false;
+    public static function replayFileDiskName(): string
+    {
+        return "{$GLOBALS['cfg']['osu']['score_replays']['storage']}-solo-replay";
+    }
 
-        return $params;
+    public static function replayFileStorage(): Filesystem
+    {
+        return \Storage::disk(static::replayFileDiskName());
     }
 
     public function beatmap()
···
 
     public function getReplayFile(): ?string
     {
-        return Storage::disk($GLOBALS['cfg']['osu']['score_replays']['storage'].'-solo-replay')
-            ->get($this->getKey());
+        return static::replayFileStorage()->get($this->getKey());
     }
 
     public function isLegacy(): bool

app/Models/User.php

···
             }
         }
 
-        DatadogLoginAttempt::log($authError);
 
         if ($authError !== null) {
+            DatadogLoginAttempt::log($authError);
             LoginAttempt::logAttempt($ip, $user, 'fail', $password);
 
             return osu_trans('users.login.failed');
···
 
     public function save(array $options = [])
     {
+        if (!$this->exists) {
+            $this->cover_preset_id ??= $this->cover()->defaultPresetId();
+        }
+
         if ($options['skipValidations'] ?? false) {
             return parent::save($options);
         }

app/Models/UserCountryHistory.php

···
     protected $primaryKeys = ['user_id', 'year_month', 'country_acronym'];
     protected $table = 'user_country_history';
 
-    public static function formatDate(\DateTimeInterface $date): string
-    {
-        return $date->format('ym');
-    }
-
     public function country(): BelongsTo
     {
         return $this->belongsTo(Country::class, 'country_acronym');
···
     public function setYearMonthAttribute(\DateTimeInterface|string $value): void
     {
         $this->attributes['year_month'] = $value instanceof \DateTimeInterface
-            ? static::formatDate($value)
+            ? format_month_column($value)
             : $value;
     }
 }

app/Models/UserCoverPreset.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace App\Models;
+
+use App\Libraries\Uploader;
+use App\Libraries\User\Cover;
+
+/**
+ * @property bool $active
+ * @property \Carbon\Carbon|null $created_at
+ * @property string|null $filename
+ * @property int $id
+ * @property \Carbon\Carbon|null $updated_at
+ */
+class UserCoverPreset extends Model
+{
+    private Uploader $file;
+
+    public function file(): Uploader
+    {
+        return $this->file ??= new Uploader(
+            'user-cover-presets',
+            $this,
+            'filename',
+            ['image' => ['maxDimensions' => Cover::CUSTOM_COVER_MAX_DIMENSIONS]],
+        );
+    }
+}

app/Models/UserProfileCustomization.php

···
  */
 class UserProfileCustomization extends Model
 {
+    const DEFAULTS = [
+        'audio_autoplay' => false,
+        'audio_muted' => false,
+        'audio_volume' => 0.45,
+        'beatmapset_card_size' => self::BEATMAPSET_CARD_SIZES[0],
+        'beatmapset_download' => self::BEATMAPSET_DOWNLOAD[0],
+        'beatmapset_show_nsfw' => false,
+        'beatmapset_title_show_original' => false,
+        'comments_show_deleted' => false,
+        'comments_sort' => Comment::DEFAULT_SORT,
+        'extras_order' => self::SECTIONS,
+        'forum_posts_show_deleted' => true,
+        'legacy_score_only' => true,
+        'profile_cover_expanded' => true,
+        'user_list_filter' => self::USER_LIST['filters']['default'],
+        'user_list_sort' => self::USER_LIST['sorts']['default'],
+        'user_list_view' => self::USER_LIST['views']['default'],
+    ];
+
     /**
      * An array of all possible profile sections, also in their default order.
      */
···
     const BEATMAPSET_CARD_SIZES = ['normal', 'extra'];
 
     const BEATMAPSET_DOWNLOAD = ['all', 'no_video', 'direct'];
-
-    const DEFAULT_LEGACY_ONLY_ATTRIBUTE = true;
 
     const USER_LIST = [
         'filters' => ['all' => ['all', 'online', 'offline'], 'default' => 'all'],
···
 
     public function getAudioAutoplayAttribute()
     {
-        return $this->options['audio_autoplay'] ?? false;
+        return $this->options['audio_autoplay'] ?? static::DEFAULTS['audio_autoplay'];
     }
 
     public function setAudioAutoplayAttribute($value)
···
 
     public function getAudioMutedAttribute()
     {
-        return $this->options['audio_muted'] ?? false;
+        return $this->options['audio_muted'] ?? static::DEFAULTS['audio_muted'];
     }
 
     public function setAudioMutedAttribute($value)
···
 
     public function getAudioVolumeAttribute()
     {
-        return $this->options['audio_volume'] ?? 0.45;
+        return $this->options['audio_volume'] ?? static::DEFAULTS['audio_volume'];
     }
 
     public function setAudioVolumeAttribute($value)
···
 
     public function getBeatmapsetCardSizeAttribute()
     {
-        return $this->options['beatmapset_card_size'] ?? static::BEATMAPSET_CARD_SIZES[0];
+        return $this->options['beatmapset_card_size'] ?? static::DEFAULTS['beatmapset_card_size'];
     }
 
     public function setBeatmapsetCardSizeAttribute($value)
···
 
     public function getBeatmapsetDownloadAttribute()
     {
-        return $this->options['beatmapset_download'] ?? static::BEATMAPSET_DOWNLOAD[0];
+        return $this->options['beatmapset_download'] ?? static::DEFAULTS['beatmapset_download'];
     }
 
     public function setBeatmapsetDownloadAttribute($value)
···
 
     public function getBeatmapsetShowNsfwAttribute()
     {
-        return $this->options['beatmapset_show_nsfw'] ?? false;
+        return $this->options['beatmapset_show_nsfw'] ?? static::DEFAULTS['beatmapset_show_nsfw'];
     }
 
     public function setBeatmapsetShowNsfwAttribute($value)
···
 
     public function getBeatmapsetTitleShowOriginalAttribute()
     {
-        return $this->options['beatmapset_title_show_original'] ?? false;
+        return $this->options['beatmapset_title_show_original'] ?? static::DEFAULTS['beatmapset_title_show_original'];
     }
 
     public function setBeatmapsetTitleShowOriginalAttribute($value)
···
 
     public function getCommentsShowDeletedAttribute()
     {
-        return $this->options['comments_show_deleted'] ?? false;
+        return $this->options['comments_show_deleted'] ?? static::DEFAULTS['comments_show_deleted'];
     }
 
     public function setCommentsShowDeletedAttribute($value)
···
 
     public function getCommentsSortAttribute()
     {
-        return $this->options['comments_sort'] ?? Comment::DEFAULT_SORT;
+        return $this->options['comments_sort'] ?? static::DEFAULTS['comments_sort'];
     }
 
     public function setCommentsSortAttribute($value)
···
 
     public function getForumPostsShowDeletedAttribute()
     {
-        return $this->options['forum_posts_show_deleted'] ?? true;
+        return $this->options['forum_posts_show_deleted'] ?? static::DEFAULTS['forum_posts_show_deleted'];
     }
 
     public function setForumPostsShowDeletedAttribute($value)
···
 
     public function getLegacyScoreOnlyAttribute(): bool
     {
-        return $this->options['legacy_score_only'] ?? static::DEFAULT_LEGACY_ONLY_ATTRIBUTE;
+        return $this->options['legacy_score_only'] ?? static::DEFAULTS['legacy_score_only'];
     }
 
     public function setLegacyScoreOnlyAttribute($value): void
···
 
     public function getUserListFilterAttribute()
     {
-        return $this->options['user_list_filter'] ?? static::USER_LIST['filters']['default'];
+        return $this->options['user_list_filter'] ?? static::DEFAULTS['user_list_filter'];
     }
 
     public function setUserListFilterAttribute($value)
···
 
     public function getUserListSortAttribute()
     {
-        return $this->options['user_list_sort'] ?? static::USER_LIST['sorts']['default'];
+        return $this->options['user_list_sort'] ?? static::DEFAULTS['user_list_sort'];
     }
 
     public function setUserListSortAttribute($value)
···
 
     public function getUserListViewAttribute()
     {
-        return $this->options['user_list_view'] ?? static::USER_LIST['views']['default'];
+        return $this->options['user_list_view'] ?? static::DEFAULTS['user_list_view'];
     }
 
     public function setUserListViewAttribute($value)
···
         }
 
         if ($newValue === null) {
-            return static::SECTIONS;
+            return static::DEFAULTS['extras_order'];
         }
 
         return static::repairExtrasOrder($newValue);
···
 
     public function getProfileCoverExpandedAttribute()
     {
-        return $this->options['profile_cover_expanded'] ?? true;
+        return $this->options['profile_cover_expanded'] ?? static::DEFAULTS['profile_cover_expanded'];
     }
 
     public function setProfileCoverExpandedAttribute($value)

app/Singletons/OsuAuthorize.php

···
         return 'unauthorized';
     }
 
+    public function checkUserCoverPresetManage(?User $user): ?string
+    {
+        return null;
+    }
+
     /**
      * @param User|null $user
      * @return string

app/Transformers/UserCompactTransformer.php

···
 use App\Models\Beatmap;
 use App\Models\User;
 use App\Models\UserProfileCustomization;
+use Illuminate\Support\Arr;
 use League\Fractal\Resource\ResourceInterface;
 
 class UserCompactTransformer extends TransformerAbstract
···
 
     public function includeUserPreferences(User $user)
     {
-        $customization = $user->userProfileCustomization ?? new UserProfileCustomization();
-
-        return $this->primitive($customization->only([
+        static $fields = [
             'audio_autoplay',
             'audio_muted',
             'audio_volume',
···
             'user_list_filter',
             'user_list_sort',
             'user_list_view',
-        ]));
+        ];
+
+        $customization = $user->userProfileCustomization;
+
+        return $this->primitive($customization === null
+            ? Arr::only(UserProfileCustomization::DEFAULTS, $fields)
+            : $customization->only($fields));
     }
 
     public function setMode(string $mode)

app/Transformers/UserTransformer.php

···
     {
         $result = parent::transform($user);
 
-        $profileOrder = $user->userProfileCustomization->extras_order
-            ?? UserProfileCustomization::SECTIONS;
+        $profileOrder = ($user->userProfileCustomization ?? UserProfileCustomization::DEFAULTS)['extras_order'];
 
-        return array_merge($result, [
+        return [
+            ...$result,
             'cover_url' => $user->cover()->url(), // TODO: deprecated.
             'discord' => $user->user_discord,
             'has_supported' => $user->hasSupported(),
···
             'title_url' => $user->titleUrl(),
             'twitter' => $user->user_twitter,
             'website' => $user->user_website,
-        ]);
+        ];
     }
 }

app/helpers.php

···
     return "/assets/images/flags/{$baseFileName}.svg";
 }
 
+function format_month_column(\DateTimeInterface $date): string
+{
+    return $date->format('ym');
+}
+
 function format_rank(?int $rank): string
 {
     return $rank !== null ? '#'.i18n_number_format($rank) : '-';
···
             ]);
             $data = curl_exec($curl);
 
-            $errorCode = curl_errno($curl);
-            if ($errorCode !== 0 && $logErrorId !== null) {
+            $ret = read_image_properties_from_string($data);
+
+            if ($ret === null && $logErrorId !== null) {
                 log_error(new FastImagesizeFetchException(), [
-                    'curl_error_code' => $errorCode,
-                    'curl_error_message' => curl_error($curl),
+                    'curl_error_code' => curl_errno($curl),
+                    'curl_error_message' => presence(curl_error($curl)) ?? 'ok',
+                    'curl_status_code' => curl_getinfo($curl, CURLINFO_HTTP_CODE),
                     'error_id' => $logErrorId,
+                    'url' => $url,
                 ]);
             }
 
             // null isn't cached
-            return read_image_properties_from_string($data) ?? false;
+            return $ret ?? false;
         },
     ));
 }

config/osu.php

···
         'allowed_rename_groups' => explode(' ', env('USER_ALLOWED_RENAME_GROUPS', 'default')),
         'bypass_verification' => get_bool(env('USER_BYPASS_VERIFICATION')) ?? false,
         'hide_pinned_solo_scores' => get_bool(env('USER_HIDE_PINNED_SOLO_SCORES')) ?? true,
+        'inactive_force_password_reset' => get_bool(env('USER_INACTIVE_FORCE_PASSWORD_RESET') ?? false),
         'inactive_seconds_verification' => (get_int(env('USER_INACTIVE_DAYS_VERIFICATION')) ?? 180) * 86400,
         'min_plays_for_posting' => get_int(env('USER_MIN_PLAYS_FOR_POSTING')) ?? 10,
         'min_plays_allow_verified_bypass' => get_bool(env('USER_MIN_PLAYS_ALLOW_VERIFIED_BYPASS')) ?? true,

database/factories/Solo/ScoreFactory.php

···
         ]);
     }
 
+    public function withReplay(): static
+    {
+        return $this
+            ->state(['has_replay' => true])
+            ->afterCreating(function ($score) {
+                Score::replayFileStorage()->put($score->getKey(), 'placeholder replay file');
+            });
+    }
+
     private function makeData(?array $overrides = null): callable
     {
         return fn (array $attr): array => array_map(

database/migrations/2024_02_15_115214_add_new_score_id_to_score_pins.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('score_pins', function (Blueprint $table) {
+            $table->unsignedBigInteger('new_score_id')->after('score_id')->nullable(true);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('score_pins', function (Blueprint $table) {
+            $table->dropColumn('new_score_id');
+        });
+    }
+};

database/migrations/2024_03_12_110401_create_user_cover_presets.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('user_cover_presets', function (Blueprint $table) {
+            $table->mediumIncrements('id');
+            $table->string('filename')->nullable(true);
+            $table->boolean('active')->default(false)->nullable(false);
+            $table->timestamps();
+            $table->index('active');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('user_cover_presets');
+    }
+};

docker-compose.yml

···
       # important to use 127.0.0.1 instead of localhost as mysql starts twice.
       # the first time it listens on sockets but isn't actually ready
       # see https://github.com/docker-library/mysql/issues/663
+      start_interval: 1s
+      start_period: 60s
       test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1"]
-      interval: 1s
       timeout: 60s
-      start_period: 60s
 
   redis:
     command: ['redis-server', '--save', '60', '1', '--loglevel', 'warning']
···
     ports:
       - "${REDIS_EXTERNAL_PORT:-127.0.0.1:6379}:6379"
     healthcheck:
+      start_interval: 1s
+      start_period: 60s
       test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
-      interval: 1s
       timeout: 60s
-      start_period: 60s
     volumes:
       - redis:/data
 
···
       ES_JAVA_OPTS: "-Xms512m -Xmx512m" # less OOM on default settings.
       ingest.geoip.downloader.enabled: false
     healthcheck:
+      start_interval: 1s
+      start_period: 60s
       test: curl -s http://localhost:9200/_cluster/health?wait_for_status=yellow >/dev/null || exit 1
-      interval: 1s
       timeout: 60s
-      start_period: 60s
 
   nginx:
     image: nginx:latest

resources/css/bem-index.less

···
 @import "bem/user-card";
 @import "bem/user-card-brick";
 @import "bem/user-cards";
+@import "bem/user-cover-preset-replace";
+@import "bem/user-cover-preset-table";
 @import "bem/user-group-badge";
 @import "bem/user-home";
 @import "bem/user-home-beatmapset";

resources/css/bem/blackout.less

···
   z-index: @z-index--blackout;
   backface-visibility: hidden;
   background-color: #000;
-  opacity: 0.75;
+  opacity: 0.5;
 
   &--overlay {
     z-index: @z-index--overlay;

resources/css/bem/btn-osu-big.less

···
     border-radius: 100000px;
   }
 
+  &--rounded-small {
+    border-radius: 100000px;
+    padding: 4px 10px;
+  }
+
   &--rounded-thin {
     padding: 8px 15px;
     border-radius: 100000px;

resources/css/bem/osu-switch-v2.less

···
     }
 
     .@{_top}__input[type=checkbox][data-indeterminate='true'] + & {
+      color: hsl(var(--hsl-h1));
+
       &::after {
         .fas();
         content: '\f068';
+        opacity: 1;
       }
     }
 

resources/css/bem/store-slider.less

···
 
   // inset slider to prevent overflows making the page wider.
   // the 2px is to add a gap between the callout and the page edge.
-  padding: 0 ((@callout-extension / 2) - (@callout-padding * 2) + 2px);
   padding: 0 (@slider-callout--width / 2 - @gutter-v2 + 2px);
 
   @media @desktop {
···
     text-align: center;
     border-radius: 10px;
 
-    .js-store--disabled & {
+    &--active {
+      background-color: @osu-colour-pink-1;
+    }
+
+    &--disabled {
       background-color: @osu-colour-b1;
       pointer-events: none;
       cursor: default;
-    }
-
-    &.js-slider-preset--active {
-      background-color: @osu-colour-pink-1;
-      .js-store--disabled & {
-        background-color: @osu-colour-b1;
-      }
     }
   }
 
···
 
   .ui-slider {
     background-color: @osu-colour-b3;
-    .js-store--disabled & {
-      .ui-slider-handle, .ui-slider-range {
-        background-color: @osu-colour-b1;
-      }
-    }
+
     .ui-slider-handle {
       background-color: @osu-colour-pink-1;
     }
+
     .ui-slider-range {
       background-color: @osu-colour-pink-1;
+    }
+
+    &--disabled {
+      .ui-slider-handle, .ui-slider-range {
+        background-color: @osu-colour-b1;
+      }
     }
   }
 }

resources/css/bem/user-cover-preset-replace.less

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+.user-cover-preset-replace {
+  display: grid;
+  gap: 10px;
+  padding-top: 10px;
+  border-top: 1px solid hsl(var(--hsl-b1));
+
+  &__input {
+    width: 100%;
+  }
+}

resources/css/bem/user-cover-preset-table.less

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+.user-cover-preset-table {
+  display: grid;
+  grid-template-columns: auto 150px 1fr;
+
+  &__image {
+    width: 100%;
+  }
+
+  &__toolbar {
+    grid-column-start: 2;
+    grid-column-end: 4;
+  }
+
+  &__row {
+    padding: 10px;
+    gap: 10px;
+
+    display: grid;
+    grid-column: ~"1 / 4";
+    grid-template-columns: subgrid;
+
+    &--item {
+      background: var(--row-bg);
+      --row-bg: hsl(var(--hsl-b4));
+
+      &:hover {
+        background: hsl(var(--hsl-b2));
+      }
+
+      &:nth-child(even) {
+        --row-bg: hsl(var(--hsl-b3));
+      }
+    }
+  }
+}

resources/js/_classes/store-supporter-tag-price.coffee

···
-# Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
-# See the LICENCE file in the repository root for full licence text.
-
-import { trans, transChoice } from 'utils/lang'
-
-class window.StoreSupporterTagPrice
-  @durationToPrice: (duration) ->
-    duration = +duration
-    switch
-      when duration >= 12 then Math.ceil(duration / 12.0 * 26)
-      when duration == 10 then 24
-      when duration == 9 then 22
-      when duration == 8 then 20
-      when duration == 6 then 16
-      when duration == 4 then 12
-      when duration == 2 then 8
-      when duration == 1 then 4
-
-  constructor: (price) ->
-    @_price = price
-
-  price: ->
-    @_price
-
-  duration: ->
-    @_duration ?= switch
-      when @_price >= 26 then Math.floor(@_price / 26.0 * 12)
-      when @_price >= 24 then 10
-      when @_price >= 22 then 9
-      when @_price >= 20 then 8
-      when @_price >= 16 then 6
-      when @_price >= 12 then 4
-      when @_price >= 8 then 2
-      when @_price >= 4 then 1
-      else 0
-
-  discount: ->
-    if @duration() >= 12
-      46
-    else
-      raw = ((1 - (@_price / @duration()) / 4) * 100)
-      Math.max(0, Math.round(raw, 0))
-
-  discountText: ->
-    trans('store.discount', percent: @discount())
-
-  durationInYears: ->
-    years: Math.floor(@duration() / 12)
-    months: Math.floor(@duration() % 12)
-
-  durationText: ->
-    # don't forget to update SupporterTag::getDurationText() in php
-    duration = @durationInYears()
-    texts = []
-
-    if duration.years > 0
-      texts.push transChoice('common.count.years', duration.years)
-
-    if duration.months > 0
-      texts.push transChoice('common.count.months', duration.months)
-
-    texts.join(', ')

resources/js/beatmap-discussions/beatmap-list.tsx

···
 import BeatmapListItem from 'components/beatmap-list-item';
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import UserJson from 'interfaces/user-json';
-import { action, computed, makeObservable, observable } from 'mobx';
-import { observer } from 'mobx-react';
+import { action, autorun, computed, makeObservable, observable } from 'mobx';
+import { disposeOnUnmount, observer } from 'mobx-react';
 import { deletedUserJson } from 'models/user';
 import * as React from 'react';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
···
     super(props);
 
     makeObservable(this);
+    disposeOnUnmount(this, autorun(() => {
+      blackoutToggle(this, this.showingSelector);
+    }));
   }
 
   componentDidMount() {
     $(document).on(`click.${this.eventId}`, this.onDocumentClick);
     $(document).on(`turbolinks:before-cache.${this.eventId}`, this.handleBeforeCache);
-    blackoutToggle(this.showingSelector, 0.5);
   }
 
   componentWillUnmount() {
     $(document).off(`.${this.eventId}`);
+    blackoutToggle(this, false);
   }
 
   render() {
···
   @action
   private setShowingSelector(state: boolean) {
     this.showingSelector = state;
-    blackoutToggle(state, 0.5);
   }
 
   @action

resources/js/components/modal.tsx

···
 
   private readonly close = () => {
     modals.delete(this);
-    if (modals.size === 0) {
-      blackoutToggle(false);
-    }
+    blackoutToggle(this, false);
   };
 
   private readonly handleBeforeCache = () => {
···
 
   private readonly open = () => {
     modals.add(this);
-    blackoutToggle(true, 0.5);
+    blackoutToggle(this, true);
   };
 }

resources/js/components/select-options.tsx

···
     super(props);
     makeObservable(this);
     disposeOnUnmount(this, autorun(() => {
-      blackoutToggle(this.props.blackout && this.showingSelector, 0.5);
+      blackoutToggle(this, this.props.blackout && this.showingSelector);
     }));
   }
 
···
 
   componentWillUnmount() {
     document.removeEventListener('click', this.hideSelector);
+    blackoutToggle(this, false);
   }
 
   render() {

resources/js/components/user-card-store.tsx

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
-// See the LICENCE file in the repository root for full licence text.
-
-import UserJson from 'interfaces/user-json';
-import * as React from 'react';
-import { UserCard } from './user-card';
-
-interface Props {
-  user: UserJson | null;
-}
-
-interface State {
-  user?: UserJson | null;
-}
-
-/**
- * This component's job shims UserCard for store-supporter-tag to update UserCard's props.
- */
-export class UserCardStore extends React.PureComponent<Props, State> {
-  state: Readonly<State> = { user: this.props.user };
-
-  componentDidMount() {
-    $.subscribe('store-supporter-tag:update-user', this.setUser);
-  }
-
-  componentWillUnmount() {
-    $.unsubscribe('store-supporter-tag:update-user', this.setUser);
-  }
-
-  render() {
-    return <UserCard user={this.state.user} />;
-  }
-
-  setUser = (event: JQuery.Event, user?: UserJson) => {
-    this.setState({ user });
-  };
-}

resources/js/core-legacy/nav2.coffee

···
 # Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 # See the LICENCE file in the repository root for full licence text.
 
-import { blackoutHide, blackoutShow } from 'utils/blackout'
+import { blackoutToggle } from 'utils/blackout'
 import { fadeToggle } from 'utils/fade'
 
 export default class Nav2
···
 
     if @showingMobileNav
       document.body.classList.add('js-nav2--active')
-      blackoutShow()
+      blackoutToggle(this, true)
     else if previousTree.indexOf('mobile-menu') != -1
-      blackoutHide()
+      blackoutToggle(this, false)
       Timeout.set 0, =>
         $(@clickMenu.menu('mobile-menu')).finish().slideUp 150, =>
           # use actual state instead of always removing the class in case

resources/js/core-legacy/store-supporter-tag.coffee

···
-# Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
-# See the LICENCE file in the repository root for full licence text.
-
-import { route } from 'laroute'
-import { fadeToggle } from 'utils/fade'
-import { toggleCart } from 'utils/store-cart'
-
-export default class StoreSupporterTag
-  RESOLUTION: 8
-  MIN_VALUE: 4
-  MAX_VALUE: 52
-
-  @initialize: ->
-    new StoreSupporterTag(elem) for elem in document.getElementsByClassName('js-store-supporter-tag')
-
-  constructor: (rootElement) ->
-    @debouncedGetUser = _.debounce @getUser, 300
-    @el = rootElement
-    @searching = false
-
-    # Everything should be scoped under the root @el
-    @priceElement = @el.querySelector('.js-price')
-    @durationElement = @el.querySelector('.js-duration')
-    @discountElement = @el.querySelector('.js-discount')
-    @messageInput = @el.querySelector('.js-store-supporter-tag-message')
-    @slider = @el.querySelector('.js-slider')
-    @sliderPresets = @el.querySelectorAll('.js-slider-preset')
-    @targetIdElement = @el.querySelector('input[name="item[extra_data][target_id]"]')
-    @usernameInput = @el.querySelector('.js-username-input')
-
-    @reactElement = @el.querySelector('.js-react--user-card-store')
-    @user = JSON.parse(@reactElement.dataset.user)
-    if !@user?
-      @user = currentUser
-      @reactElement.dataset.user = JSON.stringify(@user)
-
-    $(document).one 'turbolinks:before-cache', =>
-      @reactElement.dataset.user = JSON.stringify(@user)
-
-    @cost = @calculate(@initializeSlider().slider('value'))
-    @initializeSliderPresets()
-    @initializeUsernameInput()
-    @updateCostDisplay()
-
-    # force initial values for consistency.
-    @updateSearchResult()
-
-    $(@usernameInput).trigger('input') if @usernameInput.value != ''
-
-
-  initializeSlider: =>
-    # remove leftover from previous initialization
-    $(@slider).find('.ui-slider-range').remove()
-
-    $(@slider).slider
-      range: 'min'
-      value: @slider.dataset.lastValue ? @sliderValue(@MIN_VALUE)
-      min: @sliderValue(@MIN_VALUE)
-      max: @sliderValue(@MAX_VALUE)
-      step: 1
-      animate: true
-      slide: @onSliderValueChanged
-      change: @onSliderValueChanged
-
-
-  initializeSliderPresets: =>
-    $(@sliderPresets).on 'click', (event) =>
-      target = event.currentTarget
-      price = StoreSupporterTagPrice.durationToPrice(target.dataset.months)
-      $(@slider).slider('value', @sliderValue(price)) if price
-
-
-  initializeUsernameInput: =>
-    $(@usernameInput).on 'input', @onInput
-
-
-  getUser: (username) =>
-    if !username # reset to current user on empty
-      @user = window.currentUser
-      @searching = false
-      @updateSearchResult()
-      return
-
-    $.ajax
-      data:
-        username: username
-      dataType: 'json',
-      type: 'POST'
-      url: route('users.check-username-exists')
-    .done (data) =>
-      @user = data
-
-    .fail (xhr, status) =>
-      $(@usernameInput)
-        .trigger 'ajax:error', [xhr, status]
-        .one 'click', @onInput
-
-    .always =>
-      @searching = false
-      @updateSearchResult()
-
-
-  calculate: (position) =>
-    new StoreSupporterTagPrice(Math.floor(position / @RESOLUTION))
-
-
-  onSliderValueChanged: (event, ui) =>
-    @slider.dataset.lastValue = ui.value
-    @cost = @calculate(ui.value)
-    @updateCostDisplay()
-
-
-  onInput: (event) =>
-    if !@searching
-      @searching = true
-      @user = null
-      @updateSearchResult()
-    @debouncedGetUser(event.currentTarget.value)
-
-
-  sliderValue: (price) ->
-    price * @RESOLUTION
-
-
-  updateCostDisplay: =>
-    @el.querySelector('input[name="item[cost]"]').value = @cost.price()
-    @priceElement.textContent = "USD #{@cost.price()}"
-    @durationElement.textContent = @cost.durationText()
-    @discountElement.textContent = @cost.discountText()
-    @updateSliderPreset(elem, @cost) for elem in @sliderPresets
-
-
-  updateSearchResult: =>
-    $.publish 'store-supporter-tag:update-user', @user
-    @updateTargetId()
-    @updateUserInteraction()
-
-
-  updateSliderPreset: (elem, cost) ->
-    $(elem).toggleClass('js-slider-preset--active', cost.duration() >= +elem.dataset.months)
-
-
-  updateTargetId: =>
-    @targetIdElement.value = @user?.id
-
-
-  updateUserInteraction: =>
-    enabled = @user?.id? && Number.isFinite(@user.id) && @user.id > 0
-    messageInputVisible = enabled && @user?.id != window.currentUser.id
-    fadeToggle(@messageInput, messageInputVisible)
-
-    toggleCart(enabled)
-    # TODO: need to elevate this element when switching over to new store design.
-    $(@el).toggleClass('js-store--disabled', !enabled)
-    $('.js-slider').slider('disabled': !enabled)

resources/js/core-legacy/twitch-player.coffee

···
-# Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
-# See the LICENCE file in the repository root for full licence text.
-
-import { fadeOut } from 'utils/fade'
-
-export default class TwitchPlayer
-  constructor: (@turbolinksReload) ->
-    @playerDivs = document.getElementsByClassName('js-twitch-player')
-
-    addEventListener 'turbolinks:load', @startAll
-
-
-  initializeEmbed: =>
-    @turbolinksReload
-      .load 'https://player.twitch.tv/js/embed/v1.js'
-      ?.then @startAll
-
-
-  startAll: =>
-    return if @playerDivs.length == 0
-
-    if !Twitch?
-      @initializeEmbed()
-    else
-      @start(div) for div in @playerDivs
-
-
-  start: (div) =>
-    return if div.dataset.twitchPlayerStarted
-
-    div.dataset.twitchPlayerStarted = true
-    options =
-      width: '100%'
-      height: '100%'
-      channel: div.dataset.channel
-
-    player = new Twitch.Player(div.id, options)
-    player.addEventListener Twitch.Player.PLAY, => @openPlayer(div)
-
-
-  noCookieDiv: (playerDivId) =>
-    document.querySelector(".js-twitch-player--no-cookie[data-player-id='#{playerDivId}']")
-
-
-  openPlayer: (div) =>
-    return unless div.classList.contains 'hidden'
-
-    div.classList.remove 'hidden'
-    fadeOut @noCookieDiv(div.id)

resources/js/core/twitch-embed-player.d.ts

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+declare module 'twitch-embed-player' {
+  // (2024-03-26) see https://dev.twitch.tv/docs/embed/video-and-clips/ for all options.
+  export default class TwitchEmbedPlayer {
+    static PLAY: string;
+
+    constructor (id: string, options: Record<string, unknown>);
+    addEventListener(action: string, callback: () => void): void;
+  }
+}

resources/js/core/twitch-player.tsx

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+import type TwitchEmbedPlayer from 'twitch-embed-player';
+import { fadeOut } from 'utils/fade';
+import TurbolinksReload from './turbolinks-reload';
+
+declare global {
+  interface Window {
+    Twitch?: {
+      Embed: unknown; // unused
+      Player: typeof TwitchEmbedPlayer;
+    };
+  }
+}
+
+export default class TwitchPlayer {
+  private readonly playerDivs = document.getElementsByClassName('js-twitch-player');
+
+  constructor(private readonly turbolinksReload: TurbolinksReload) {
+    document.addEventListener('turbolinks:load', this.startAll);
+  }
+
+  initializeEmbed() {
+    this.turbolinksReload
+      .load('https://player.twitch.tv/js/embed/v1.js')
+      ?.then(this.startAll);
+  }
+
+  noCookieDiv(playerDivId: string) {
+    return document.querySelector<HTMLElement>(`.js-twitch-player--no-cookie[data-player-id='${playerDivId}']`);
+  }
+
+  openPlayer(div: HTMLElement) {
+    if (!div.classList.contains('hidden')) return;
+
+    div.classList.remove('hidden');
+    fadeOut(this.noCookieDiv(div.id));
+  }
+
+  start(div: HTMLElement) {
+    if (window.Twitch == null
+      || div.dataset.twitchPlayerStarted === 'true') return;
+
+    div.dataset.twitchPlayerStarted = 'true';
+    const options = {
+      channel: div.dataset.channel,
+      height: '100%',
+      width: '100%',
+    };
+
+    const player = new window.Twitch.Player(div.id, options);
+    player.addEventListener(window.Twitch.Player.PLAY, () => this.openPlayer(div));
+  }
+
+  startAll = () => {
+    if (this.playerDivs.length === 0) return;
+
+    if (window.Twitch == null) {
+      this.initializeEmbed();
+    } else {
+      for (const div of this.playerDivs) {
+        if (div instanceof HTMLElement) {
+          this.start(div);
+        }
+      }
+    }
+  };
+}

resources/js/entrypoints/app.ts

···
 
 import 'jquery-pubsub.coffee';
 
-import '_classes/store-supporter-tag-price.coffee';
 import '_classes/timeout.coffee';
 
 import 'spoilerbox.coffee';

resources/js/entrypoints/user-cover-presets.ts

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+import UserCoverPresetBatchActivate from 'user-cover-preset-batch-activate';
+
+new UserCoverPresetBatchActivate();

resources/js/main.coffee

···
 import Search from 'core-legacy/search'
 import StickyFooter from 'core-legacy/sticky-footer'
 import { StoreCheckout } from 'core-legacy/store-checkout'
-import StoreSupporterTag from 'core-legacy/store-supporter-tag'
 import SyncHeight from 'core-legacy/sync-height'
 import TooltipDefault from 'core-legacy/tooltip-default'
-import TwitchPlayer from 'core-legacy/twitch-player'
 import { hideLoadingOverlay, showLoadingOverlay } from 'utils/loading-overlay'
 import { navigate } from 'utils/turbolinks'
 
···
 
 $(document).on 'turbolinks:load', ->
   BeatmapPack.initialize()
-  StoreSupporterTag.initialize()
   StoreCheckout.initialize()
 
 # ensure currentUser is updated early enough.
···
 window.forumTopicPostJump ?= new ForumTopicPostJump(window.forum)
 window.forumTopicReply ?= new ForumTopicReply(bbcodePreview: window.bbcodePreview, forum: window.forum, stickyFooter: window.stickyFooter)
 window.nav2 ?= new Nav2(osuCore.clickMenu)
-window.twitchPlayer ?= new TwitchPlayer(osuCore.turbolinksReload)
 
 
 $(document).on 'change', '.js-url-selector', (e) ->

resources/js/osu-core.ts

···
 import StickyHeader from 'core/sticky-header';
 import Timeago from 'core/timeago';
 import TurbolinksReload from 'core/turbolinks-reload';
+import TwitchPlayer from 'core/twitch-player';
 import ScorePins from 'core/user/score-pins';
 import UserLogin from 'core/user/user-login';
 import UserLoginObserver from 'core/user/user-login-observer';
···
   readonly stickyHeader;
   readonly timeago;
   readonly turbolinksReload;
+  readonly twitchPlayer;
   readonly userLogin;
   readonly userLoginObserver;
   readonly userPreferences;
···
     this.enchant = new Enchant(this.turbolinksReload);
     this.osuAudio = new OsuAudio(this.userPreferences);
     this.reactTurbolinks = new ReactTurbolinks(this, this.turbolinksReload);
+    this.twitchPlayer = new TwitchPlayer(this.turbolinksReload);
+
     this.userLogin = new UserLogin(this.captcha);
     // should probably figure how to conditionally or lazy initialize these so they don't all init when not needed.
     // TODO: requires dynamic imports to lazy load modules.

resources/js/register-components.tsx

···
 import RankingVariantFilter from 'components/ranking-variant-filter';
 import SpotlightSelectOptions from 'components/spotlight-select-options';
 import { UserCard } from 'components/user-card';
-import { UserCardStore } from 'components/user-card-store';
 import { startListening, UserCardTooltip } from 'components/user-card-tooltip';
 import { UserCards } from 'components/user-cards';
 import { WikiSearch } from 'components/wiki-search';
···
 import QuickSearch from 'quick-search/main';
 import QuickSearchWorker from 'quick-search/worker';
 import * as React from 'react';
+import StoreSupporterTag from 'store/store-supporter-tag';
 import { parseJson } from 'utils/json';
 import { mapBy } from 'utils/map';
+import { getInt } from 'utils/math';
 
 function reqJson<T>(input: string|undefined): T {
   // This will throw when input is missing and thus parsing empty string.
···
   <RankingVariantFilter {...parseJson('json-variant-filter')} />
 ));
 
+core.reactTurbolinks.register('store-supporter-tag', (container) => {
+  const maxMessageLength = getInt(container.dataset.maxMessageLength);
+  if (maxMessageLength == null) {
+    throw new Error('missing maxMessageLength');
+  }
+
+  return <StoreSupporterTag maxMessageLength={maxMessageLength} />;
+});
+
 core.reactTurbolinks.register('user-card', (container) => (
   <UserCard
     modifiers={reqJson(container.dataset.modifiers ?? 'null')}
     user={container.dataset.isCurrentUser === '1' ? core.currentUser : reqJson(container.dataset.user ?? 'null')}
   />
-));
-
-core.reactTurbolinks.register('user-card-store', (container) => (
-  <UserCardStore user={reqJson(container.dataset.user)} />
 ));
 
 core.reactTurbolinks.register('user-card-tooltip', (container) => (

resources/js/store/store-supporter-tag.tsx

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+import { UserCard } from 'components/user-card';
+import UserJson from 'interfaces/user-json';
+import { route } from 'laroute';
+import { debounce } from 'lodash';
+import { action, autorun, computed, makeObservable, observable, runInAction } from 'mobx';
+import { disposeOnUnmount, observer } from 'mobx-react';
+import core from 'osu-core-singleton';
+import React from 'react';
+import { onError } from 'utils/ajax';
+import { classWithModifiers } from 'utils/css';
+import { parseJsonNullable, storeJson } from 'utils/json';
+import { trans, transChoice } from 'utils/lang';
+import { toggleCart } from 'utils/store-cart';
+import { currentUrlParams } from 'utils/turbolinks';
+
+const jsonId = 'json-store-supporter-tag';
+
+const maxValue = 52;
+const minValue = 4;
+
+interface Props {
+  maxMessageLength: number;
+}
+
+interface SavedState {
+  savedGiftMessage: string;
+  sliderValue: number;
+  username: string;
+}
+
+interface SliderUIParams {
+  handle?: JQuery | undefined;
+  value?: number | undefined;
+  values?: number[] | undefined;
+}
+
+const monthPresets = [1, 2, 4, 6, 12, 18, 24] as const;
+
+function durationToPrice(duration: number) {
+  switch (true) {
+    case duration >= 12: return Math.ceil(duration / 12.0 * 26);
+    case duration === 10: return 24;
+    case duration === 9: return 22;
+    case duration === 8: return 20;
+    case duration === 6: return 16;
+    case duration === 4: return 12;
+    case duration === 2: return 8;
+    case duration === 1: return 4;
+  }
+}
+
+@observer
+export default class StoreSupporterTag extends React.Component<Props> {
+  private readonly debouncedGetUser;
+  private readonly giftMessageRef = React.createRef<HTMLTextAreaElement>();
+  private readonly savedGiftMessage: string = '';
+  private readonly sliderRef = React.createRef<HTMLDivElement>();
+  @observable private sliderValue = minValue;
+  @observable private user: UserJson | null;
+  @observable private username = currentUrlParams().get('target') ?? '';
+  private xhr: JQuery.jqXHR<UserJson> | null = null;
+
+  @computed
+  get cost() {
+    return Math.floor(this.sliderValue);
+  }
+
+  get discount() {
+    if (this.duration >= 12) {
+      return 46;
+    }
+
+    const raw = ((1 - (this.cost / this.duration) / 4) * 100);
+    return Math.max(0, Math.round(raw));
+  }
+
+  @computed
+  get duration() {
+    switch (true) {
+      case this.cost >= 26: return Math.floor(this.cost / 26.0 * 12);
+      case this.cost >= 24: return 10;
+      case this.cost >= 22: return 9;
+      case this.cost >= 20: return 8;
+      case this.cost >= 16: return 6;
+      case this.cost >= 12: return 4;
+      case this.cost >= 8: return 2;
+      case this.cost >= 4: return 1;
+      default: return 0;
+    }
+  }
+
+  get durationInYears() {
+    return {
+      months: Math.floor(this.duration % 12),
+      years: Math.floor(this.duration / 12),
+    };
+  }
+
+  get durationText() {
+    // don't forget to update SupporterTag::getDurationText() in php
+    const duration = this.durationInYears;
+    const texts: string[] = [];
+
+    if (duration.years > 0) {
+      texts.push(transChoice('common.count.years', duration.years));
+    }
+
+    if (duration.months > 0) {
+      texts.push(transChoice('common.count.months', duration.months));
+    }
+
+    return texts.join(', ');
+  }
+
+  get isGiftingSelf() {
+    return this.user != null && this.user.id === core.currentUser?.id;
+  }
+
+  get isValidUser() {
+    return this.user != null && Number.isFinite(this.user.id) && this.user.id > 0;
+  }
+
+  constructor(props: Props) {
+    super(props);
+
+    this.debouncedGetUser = debounce(this.getUser, 300);
+    document.addEventListener('turbolinks:before-cache', this.handleBeforeCache);
+
+    makeObservable(this);
+
+    const json = parseJsonNullable<SavedState>(jsonId, true);
+    if (json != null) {
+      this.savedGiftMessage = json.savedGiftMessage;
+      this.sliderValue = json.sliderValue;
+      this.username = json.username;
+    }
+
+    if (this.username !== '') {
+      this.user = null;
+      this.debouncedGetUser(this.username);
+    } else {
+      this.user = core.currentUserOrFail;
+    }
+
+    disposeOnUnmount(
+      this,
+      autorun(() => {
+        toggleCart(this.isValidUser);
+        if (this.sliderRef.current != null) {
+          $(this.sliderRef.current).slider({ disabled: !this.isValidUser });
+        }
+      }),
+    );
+  }
+
+  componentDidMount() {
+    this.initializeSlider();
+  }
+
+  componentWillUnmount() {
+    document.removeEventListener('turbolinks:before-cache', this.handleBeforeCache);
+    this.xhr?.abort();
+  }
+
+  render() {
+    return (
+      <div className='store-supporter-tag'>
+        <input defaultValue={this.cost} id='supporter-tag-form-price' name='item[cost]' type='hidden' />
+        <input defaultValue={this.user?.id} name='item[extra_data][target_id]' type='hidden' />
+        <div className='store-supporter-tag__user-search'>
+          <UserCard user={this.user} />
+          <input
+            autoComplete='off'
+            className='store-supporter-tag__input'
+            id='username'
+            name='item[extra_data][username]'
+            onChange={this.handleUsernameChange}
+            placeholder={trans('store.supporter_tag.gift')}
+            value={this.username}
+          />
+          <div data-visibility={!this.isValidUser || this.isGiftingSelf ? 'hidden' : 'visible'}>
+            <textarea
+              ref={this.giftMessageRef}
+              className='store-supporter-tag__input store-supporter-tag__input--message'
+              defaultValue={this.savedGiftMessage}
+              maxLength={this.props.maxMessageLength}
+              name='item[extra_data][message]'
+              placeholder={trans('store.supporter_tag.gift_message', { length: this.props.maxMessageLength })}
+              rows={3}
+            />
+          </div>
+        </div>
+        <div className='store-slider'>
+          <div ref={this.sliderRef} className={`${classWithModifiers('ui-slider', { disabled: !this.isValidUser })} ui-slider-horizontal`}>
+            <div className='ui-slider-handle'>
+              <div className='store-slider__fake-callout'>
+                <div className='store-slider__callout'>
+                  <div className='store-slider__bigtext'>USD {this.cost}</div>
+                  <div>{this.durationText}</div>
+                  <div className='store-slider__subtext'>{trans('store.discount', { percent: this.discount })}</div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div className='store-slider__presets'>
+            <span className='store-slider__presets-blurb'>{trans('supporter_tag.months')}</span>
+            {monthPresets.map((preset) => (
+              // TODO: button
+              <div
+                key={preset}
+                className={classWithModifiers('store-slider__preset', {
+                  active: this.duration >= preset,
+                  disabled: !this.isValidUser,
+                })}
+                data-months={preset}
+                onClick={this.handlePresetClick}
+              >
+                {preset}
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  @action
+  private readonly getUser = (username: string) => {
+    this.xhr = $.ajax({
+      data: { username },
+      dataType: 'json',
+      type: 'POST',
+      url: route('users.check-username-exists'),
+    });
+
+    this.xhr
+      .done((data) => runInAction(() => {
+        this.user = data;
+      }))
+      .fail(onError)
+      .always(() => {
+        this.xhr = null;
+      });
+  };
+
+  private readonly handleBeforeCache = () => {
+    storeJson<SavedState>(jsonId, {
+      savedGiftMessage: this.giftMessageRef.current?.value ?? '',
+      sliderValue: this.sliderValue,
+      username: this.username,
+    });
+  };
+
+  private readonly handlePresetClick = (event: React.SyntheticEvent<HTMLElement>) => {
+    const price = durationToPrice(+(event.currentTarget.dataset?.months ?? 0));
+    if (price != null && this.sliderRef.current != null) {
+      $(this.sliderRef.current).slider('value', price);
+    }
+  };
+
+  @action
+  private readonly handleSliderValueChanged = (_event: JQueryEventObject, ui: SliderUIParams) => {
+    if (ui.value == null) return;
+    this.sliderValue = ui.value;
+  };
+
+  @action
+  private readonly handleUsernameChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.username = event.currentTarget.value;
+
+    this.debouncedGetUser.cancel();
+    this.xhr?.abort();
+
+    // reset to current user on empty
+    if (this.username === '') {
+      this.user = core.currentUserOrFail;
+    } else {
+      this.user = null;
+      this.debouncedGetUser(this.username);
+    }
+  };
+
+  private initializeSlider() {
+    const slider = this.sliderRef.current;
+    if (slider == null) return;
+
+    return $(slider).slider({
+      animate: true,
+      change: this.handleSliderValueChanged,
+      max: maxValue,
+      min: minValue,
+      range: 'min',
+      slide: this.handleSliderValueChanged,
+      step: 0.125,
+      value: this.sliderValue,
+    });
+  }
+}

resources/js/user-cover-preset-batch-activate/index.ts

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+import { route } from 'laroute';
+import { trans, transChoice } from 'utils/lang';
+import { popup } from 'utils/popup';
+import { reloadPage } from 'utils/turbolinks';
+
+const checkboxSelector = '.js-user-cover-preset-batch-enable--checkbox';
+
+export default class UserCoverPresetBatchActivate {
+  private lastSelected: HTMLInputElement | null = null;
+  private xhr: JQuery.jqXHR<void> | null = null;
+
+  constructor() {
+    $(document)
+      .on('click', '.js-user-cover-preset-batch-enable', this.handleEvent)
+      .on('turbolinks:before-cache', this.cleanup);
+  }
+
+  private applySelected(active: boolean) {
+    const ids = [...this.checkboxes()]
+      .filter((el) => el.checked)
+      .map((el) => el.dataset.id);
+    const count = ids.length;
+
+    if (count === 0) {
+      popup('no covers selected');
+      return;
+    }
+
+    if (!confirm(trans('user_cover_presets.index.batch_confirm._', {
+      action: trans(`user_cover_presets.index.batch_confirm.${active ? 'enable' : 'disable'}`),
+      items: transChoice('user_cover_presets.index.batch_confirm.items', count),
+    }))) {
+      return;
+    }
+
+    this.xhr = $.post(route('user-cover-presets.batch-activate'), { active, ids });
+    this.xhr
+      .done(() => {
+        reloadPage();
+      })
+      .fail((xhr, status) => {
+        if (status !== 'abort') {
+          popup('Update failed', 'danger');
+        }
+      });
+  }
+
+  private checkboxes() {
+    return document.querySelectorAll<HTMLInputElement>(checkboxSelector);
+  }
+
+  private readonly cleanup = () => {
+    this.lastSelected = null;
+    this.xhr?.abort();
+    this.xhr = null;
+  };
+
+  private readonly handleEvent = (e: JQuery.ClickEvent<Document, unknown, HTMLElement, HTMLElement>) => {
+    const target = e.currentTarget;
+
+    switch (target.dataset.action) {
+      case 'disable-selected': return this.applySelected(false);
+      case 'enable-selected': return this.applySelected(true);
+      case 'select': return this.select(target, e);
+      case 'select-all': return this.toggleAll(target as HTMLInputElement);
+    }
+  };
+
+  private readonly select = (target: HTMLElement, e: JQuery.ClickEvent) => {
+    const checkbox = target.querySelector(checkboxSelector);
+    if (checkbox instanceof HTMLInputElement) {
+      if ((e.originalEvent?.shiftKey ?? false) && this.lastSelected != null) {
+        const checked = this.lastSelected.checked;
+        let started = false;
+        for (const el of this.checkboxes()) {
+          if (el === checkbox) {
+            el.checked = checked;
+          }
+          if (el === this.lastSelected || el === checkbox) {
+            if (started) {
+              break;
+            } else {
+              started = true;
+            }
+            continue;
+          }
+          if (started) {
+            el.checked = checked;
+          }
+        }
+      }
+      this.lastSelected = checkbox;
+    }
+    this.syncToggleState();
+  };
+
+  private selectAllCheckbox() {
+    const ret = document.querySelector('.js-user-cover-preset-batch-enable--select-all');
+    if (!(ret instanceof HTMLInputElement)) {
+      throw new Error('select all checkbox element is not HTMLInputElement');
+    }
+
+    return ret;
+  }
+
+  private syncToggleState() {
+    const selectAllCheckbox = this.selectAllCheckbox();
+    let state: boolean | null = null;
+    for (const el of this.checkboxes()) {
+      if (state == null) {
+        selectAllCheckbox.checked = state = el.checked;
+        selectAllCheckbox.dataset.indeterminate = 'false';
+      } else {
+        if (state !== el.checked) {
+          selectAllCheckbox.dataset.indeterminate = 'true';
+          break;
+        }
+      }
+    }
+  }
+
+  private readonly toggleAll = (target: HTMLInputElement) => {
+    const checked = target.checked;
+    for (const el of this.checkboxes()) {
+      el.checked = checked;
+    }
+    target.dataset.indeterminate = 'false';
+  };
+}

resources/js/utils/blackout.ts

···
 
 import { fadeToggle } from './fade';
 
-export function blackoutHide() {
-  blackoutToggle(false);
-}
-
-export function blackoutShow() {
-  blackoutToggle(true);
-}
-
-export function blackoutToggle(state: boolean, opacity?: number) {
-  const el = window.newBody?.querySelector('.js-blackout');
+const elements = new Set<unknown>();
 
-  if (el instanceof HTMLElement) {
-    el.style.opacity = !state || opacity == null ? '' : String(opacity);
-    fadeToggle(el, state);
+export function blackoutToggle(element: unknown, state: boolean) {
+  if (state) {
+    elements.add(element);
+  } else {
+    elements.delete(element);
   }
+
+  fadeToggle(
+    window.newBody?.querySelector('.js-blackout'),
+    blackoutVisible(),
+  );
 }
 
 export function blackoutVisible() {
-  const el = document.querySelector('.js-blackout');
-
-  return el instanceof HTMLElement && el.style.opacity !== '';
+  return elements.size > 0;
 }

resources/js/utils/json.ts

···
  * @param id id of the element to store to. Contents of an existing HTMLScriptElement will be overriden.
  * @param object state to store.
  */
-export function storeJson(id: string, object: unknown) {
+export function storeJson<T = unknown>(id: string, object: T) {
   const json = JSON.stringify(object);
   const maybeElement = document.getElementById(id);
 

resources/js/utils/store-cart.ts

···
 // See the LICENCE file in the repository root for full licence text.
 
 export function toggleCart(flag: boolean) {
-  $('.js-store-add-to-cart').prop('disabled', !flag);
-  $('#product-form').data('disabled', !flag);
+  const body = window.newBody;
+  if (body == null) return;
+
+  const button = body.querySelector<HTMLButtonElement>('.js-store-add-to-cart');
+  if (button != null) {
+    button.disabled = !flag;
+  }
+
+  const form = body.querySelector<HTMLFormElement>('#product-form');
+  if (form != null) {
+    $(form).data('disabled', !flag);
+  }
 }

resources/lang/be/contest.php

···
         'hide_judged' => '',
         'nav_title' => '',
         'no_current_vote' => '',
-        'update' => '',
+        'update' => 'абнавіць',
         'validation' => [
-            'missing_score' => '',
+            'missing_score' => 'адсутны вынік',
             'contest_vote_judged' => '',
         ],
         'voted' => '',
···
     'judge_results' => [
         '_' => '',
         'creator' => '',
-        'score' => '',
+        'score' => 'Вынік',
         'total_score' => '',
     ],
 

resources/lang/be/score_tokens.php

···
 
 return [
     'create' => [
-        'beatmap_hash_invalid' => '',
-        'submission_disabled' => '',
+        'beatmap_hash_invalid' => 'няслушны ці адсутны beatmap_hash',
+        'submission_disabled' => 'адпраўка рэкордаў на сервер адключана',
     ],
 ];

resources/lang/cs/page_title.php

···
             '_' => 'komentáře',
         ],
         'contest_entries_controller' => [
-            'judge_results' => '',
+            'judge_results' => 'výsledky hodnocení soutěže',
         ],
         'contests_controller' => [
             '_' => 'soutěže',
-            'judge' => '',
+            'judge' => 'hodnocení soutěže',
         ],
         'groups_controller' => [
             'show' => 'skupiny',

resources/lang/cs/wiki.php

···
         'missing' => 'Požadovaná stránka ":keyword" nebyla nalezena.',
         'missing_title' => 'Nenalezeno',
         'missing_translation' => 'Požadovaná stránka nebyla nalezena pro zvolený jazyk.',
-        'needs_cleanup_or_rewrite' => 'Tato stránka nesplňuje standardy osu! wiki a potřebuje být vylepšena nebo přepsáno. Pokud chcete, můžete pomoci s aktualizací článku!',
+        'needs_cleanup_or_rewrite' => 'Tato stránka nesplňuje standardy osu! wiki a potřebuje být vylepšena nebo přepsána. Pokud chcete, můžete pomoci s aktualizací článku!',
         'search' => 'Prohledat existující stránky pro :link.',
         'stub' => 'Tento článek je neúplný a čeká na někoho, kdo ho rozšíří.',
         'toc' => 'Obsah',

resources/lang/de/authorization.php

···
     ],
 
     'contest' => [
-        'judging_not_active' => '',
+        'judging_not_active' => 'Bewertung für diesen Wettbewerb ist nicht aktiv.',
         'voting_over' => 'Stimmen können nach dem Abstimmungsende nicht mehr geändert werden.',
 
         'entry' => [

resources/lang/de/contest.php

···
     ],
 
     'judge' => [
-        'hide_judged' => '',
-        'nav_title' => '',
-        'no_current_vote' => '',
+        'hide_judged' => 'bewertete Einträge ausblenden',
+        'nav_title' => 'Bewerten',
+        'no_current_vote' => 'Du hast noch nicht abgestimmt.',
         'update' => 'aktualisieren',
         'validation' => [
-            'missing_score' => '',
-            'contest_vote_judged' => '',
+            'missing_score' => 'fehlende Punktzahl',
+            'contest_vote_judged' => 'Abstimmen bei bewerteten Wettbewerben nicht möglich',
         ],
-        'voted' => '',
+        'voted' => 'Du hast für diesen Eintrag bereits abgestimmt.',
     ],
 
     'judge_results' => [
-        '_' => '',
-        'creator' => '',
+        '_' => 'Jury-Ergebnisse',
+        'creator' => 'Ersteller',
         'score' => 'Ergebnis',
         'total_score' => 'Gesamtergebnis',
     ],
 
     'voting' => [
-        'judge_link' => '',
-        'judged_notice' => '',
+        'judge_link' => 'Du bist ein Juror bei diesem Wettbewerb. Bewerte die Beiträge hier!',
+        'judged_notice' => 'Dieser Wettbewerb läuft über das Bewertungssystem, die Jury bearbeitet derzeit die Beiträge.',
         'login_required' => 'Bitte einloggen, um abzustimmen',
         'over' => 'Die Abstimmung für diesen Wettbewerb ist beendet',
         'show_voted_only' => 'Stimmen anzeigen',

resources/lang/de/page_title.php

···
             '_' => 'kommentare',
         ],
         'contest_entries_controller' => [
-            'judge_results' => '',
+            'judge_results' => 'Ergebnisse der Wettbewerbsbewertung',
         ],
         'contests_controller' => [
             '_' => 'Wettbewerbe',
-            'judge' => '',
+            'judge' => 'Wettbewerbsbewertung',
         ],
         'groups_controller' => [
             'show' => 'gruppen',

resources/lang/de/rankings.php

···
     ],
 
     'type' => [
-        'charts' => 'Spotlights',
+        'charts' => 'Spotlights (alt)',
         'country' => 'Länder',
         'kudosu' => 'Kudosu',
         'multiplayer' => 'Mehrspieler',

resources/lang/de/scores.php

···
         'non_passing' => 'Nur erfolgreiche Scores geben pp',
         'no_pp' => 'Für diesen Score werden keine pp vergeben',
         'processing' => 'Dieser Score wird noch berechnet und in Kürze angezeigt',
-        'no_rank' => '',
+        'no_rank' => 'Diese Punktzahl hat keinen Rang, da sie unranked oder zum Löschen markiert ist',
     ],
 ];

resources/lang/en/page_title.php

···
         'tournaments_controller' => [
             '_' => 'tournaments',
         ],
+        'user_cover_presets_controller' => [
+            '_' => 'user cover presets',
+        ],
         'users_controller' => [
             '_' => 'player info',
             'create' => 'create account',

resources/lang/en/user_cover_presets.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+return [
+    'index' => [
+        'batch_disable' => 'Disable Selected',
+        'batch_enable' => 'Enable Selected',
+
+        'batch_confirm' => [
+            '_' => ':action :items?',
+            'disable' => 'Disable',
+            'enable' => 'Enable',
+            'items' => ':count_delimited cover|:count_delimited covers',
+        ],
+
+        'create_form' => [
+            'files' => 'Files',
+            'submit' => 'Save',
+            'title' => 'Add New',
+        ],
+
+        'item' => [
+            'click_to_disable' => 'Click to disable',
+            'click_to_enable' => 'Click to enable',
+            'enabled' => 'Enabled',
+            'disabled' => 'Disabled',
+            'image_store' => 'Set Image',
+            'image_update' => 'Replace Image',
+        ],
+    ],
+    'store' => [
+        'failed' => 'Error occurred when creating cover: :error',
+        'ok' => 'Covers created',
+    ],
+];

resources/lang/en/users.php

···
 
     'force_reactivation' => [
         'reason' => [
+            'inactive' => "Your account hasn't been used in a long time.",
             'inactive_different_country' => "Your account hasn't been used in a long time.",
         ],
     ],

resources/lang/fi/accounts.php

···
     ],
 
     'options' => [
-        'beatmapset_show_nsfw' => 'piilota varoitukset sopimattomasta sisällöstä beatmapeissa',
+        'beatmapset_show_nsfw' => 'piilota varoitukset sopimattomasta sisällöstä rytmikartoissa',
         'beatmapset_title_show_original' => 'näytä rytmikarttojen kuvailutiedot alkuperäisellä kielellä',
         'title' => 'Asetukset',
 
         'beatmapset_download' => [
             '_' => 'rytmikarttojen oletuslataustyyppi',
             'all' => 'videon kanssa jos saatavilla',
-            'direct' => 'avaa osu!-directissä',
+            'direct' => 'avaa osu!directissä',
             'no_video' => 'ilman videota',
         ],
     ],

resources/lang/fi/client_verifications.php

···
         'home' => 'Siirry yleiskatsaukseen',
         'logout' => 'Kirjaudu ulos',
         'text' => 'Voit nyt sulkea tämän välilehden/ikkunan',
-        'title' => 'osu!-klientin vahvistaminen on valmis',
+        'title' => 'osu!-asiakasohjelman vahvistaminen on valmis',
     ],
 
     'create' => [
-        'confirm' => 'Klikkaa allaolevaa valtuutuspainiketta viimeistelläksesi klientin vahvistamisen.',
-        'title' => 'osu!-klientin vahvistaminen',
+        'confirm' => 'Napsauta allaolevaa valtuutuspainiketta viimeistelläksesi asiakasohjelman vahvistamisen.',
+        'title' => 'osu!-asiakasohjelman vahvistaminen',
     ],
 ];

resources/lang/fi/common.php

···
         'post' => ':count_delimited viesti|:count_delimited viestiä',
         'second_short_unit' => 's|s',
         'star_priority' => ':count_delimited tähtitaso|:count_delimited tähtitasoja',
-        'update' => ':count_delimited päivitys|:count_delimited päivityksiä',
+        'update' => ':count_delimited päivitys|:count_delimited päivitystä',
         'view' => ':count_delimited katselukerta|:count_delimited katselukertaa',
         'years' => ':count vuosi|:count vuotta',
     ],

resources/lang/fi/events.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
-    'achievement' => '<strong><em>:user</em></strong> on saanut "<strong>:achievement</strong>" mitalin!',
+    'achievement' => '<strong><em>:user</em></strong> on saanut "<strong>:achievement</strong>" -mitalin!',
     'beatmap_playcount' => 'Karttaa :beatmap on pelattu :count kertaa!',
     'beatmapset_approve' => ':beatmapset käyttäjältä <strong>:user</strong> on nyt :approval',
     'beatmapset_delete' => ':beatmapset on poistettu.',

resources/lang/fi/follows.php

···
     ],
 
     'modding' => [
-        'title' => 'rytmikartan keskustelu',
+        'title' => 'rytmikartan keskustelut',
     ],
 ];

resources/lang/fi/forum.php

···
 
             'feature_vote' => [
                 'current' => 'Tärkeys tällä hetkellä: +:count',
-                'do' => 'Ehdota tätä',
+                'do' => 'Ehdota tätä pyyntöä',
 
                 'info' => [
                     '_' => 'Tämä on :feature_request. :supporters voivat äänestää ominaisuuspyyntöjä.',
                     'feature_request' => 'ominaisuuspyyntö',
-                    'supporters' => 'tukijat',
+                    'supporters' => 'Tukijat',
                 ],
 
                 'user' => [

resources/lang/fi/store.php

···
         'cancel_not_allowed' => 'Tätä tilausta ei voi peruuttaa tällä hetkellä.',
         'invoice' => 'Näytä lasku',
         'no_orders' => 'Ei tilauksia katsottavissa.',
-        'paid_on' => 'Tilaus laitettu :date',
+        'paid_on' => 'Tilaus tehty :date',
         'resume' => 'Jatka kassalle',
         'shipping_and_handling' => 'Toimitus & käsittely',
         'shopify_expired' => 'Tämän tilauksen kassalinkki on vanhentunut.',
···
 
         'not_modifiable_exception' => [
             'cancelled' => 'Et voi muokata tilaustasi, sillä se on peruuntunut.',
-            'checkout' => 'Et voi muokata tilaustasi, koska sitä käsitellään vielä.', // checkout and processing should have the same message.
+            'checkout' => 'Et voi muokata tilaustasi silloin kun sitä käsitellään.', // checkout and processing should have the same message.
             'default' => 'Tilausta ei voi muokata',
             'delivered' => 'Et voi muokata tilaustasi, sillä se on jo toimitettu.',
             'paid' => 'Et voi muokata tilaustasi, sillä se on jo maksettu.',
-            'processing' => 'Et voi muokata tilaustasi, koska sitä käsitellään vielä.',
+            'processing' => 'Et voi muokata tilaustasi silloin kun sitä käsitellään.',
             'shipped' => 'Et voi muokata tilaustasi, sillä se on jo matkalla.',
         ],
 

resources/lang/fi/users.php

···
             'discussions' => [
                 'title' => 'Keskustelut',
                 'title_longer' => 'Viimeaikaiset keskustelut',
-                'show_more' => 'nää lisää keskusteluja',
+                'show_more' => 'katso lisää keskusteluja',
             ],
             'events' => [
                 'title' => 'Tapahtumat',
-                'title_longer' => 'Viimeisimmät tapahtumat',
-                'show_more' => 'nää lisää tapahtumia',
+                'title_longer' => 'Viimeaikaiset tapahtumat',
+                'show_more' => 'katso lisää tapahtumia',
             ],
             'historical' => [
                 'title' => 'Historialliset',
···
                 ],
                 'recent_plays' => [
                     'accuracy' => 'tarkkuus: :percentage',
-                    'title' => 'Viimeisimmät pelaukset (24t)',
+                    'title' => 'Viimeaikaiset pelaukset (24t)',
                 ],
                 'replays_watched_counts' => [
                     'title' => 'Uusintojen katsomishistoria',
···
             ],
             'posts' => [
                 'title' => 'Julkaisut',
-                'title_longer' => 'Viimeisimmät julkaisut',
-                'show_more' => 'Katso lisää julkaisuja',
+                'title_longer' => 'Viimeaikaiset julkaisut',
+                'show_more' => 'katso lisää julkaisuja',
             ],
             'recent_activity' => [
                 'title' => 'Viimeisimmät',
···
                 'given' => 'Annetut äänet (viimeiset 3 kuukautta)',
                 'received' => 'Saadut äänet (viimeiset 3 kuukautta)',
                 'title' => 'Äänet',
-                'title_longer' => 'Viimeisimmät Äänet',
+                'title_longer' => 'Viimeaikaiset äänet',
                 'vote_count' => ':count_delimited ääni|:count_delimited ääntä',
             ],
             'account_standing' => [
···
                 'remaining_silence' => '<strong>:username</strong> pystyy puhumaan seuraavan kerran :duration.',
 
                 'recent_infringements' => [
-                    'title' => 'Viimeisimmät rikkomukset',
+                    'title' => 'Viimeaikaiset rikkomukset',
                     'date' => 'päivä',
                     'action' => 'toiminto',
                     'length' => 'pituus',
···
         ],
         'not_found' => [
             'reason_1' => 'Käyttäjänimi saattaa olla vaihtunut.',
-            'reason_2' => 'Käyttäjä voi olla tilapaisesti poissa käytöstä tietoturvasyistä tai väärinkäytön seurauksena.',
+            'reason_2' => 'Käyttäjätunnus voi olla tilapäisesti pois käytöstä tietoturvasyistä tai väärinkäytön seurauksena.',
             'reason_3' => 'Teit mahdollisesti kirjoitusvirheen!',
-            'reason_header' => 'Tähän on lukuisia mahdollisia syitä:',
+            'reason_header' => 'Tähän on muutama mahdollinen syy:',
             'title' => 'Käyttäjää ei löytynyt! ;_;',
         ],
         'page' => [
-            'button' => 'Muokkaa profiilisivua',
+            'button' => 'muokkaa profiilisivua',
             'description' => '<strong>minä!</strong> on henkilökohtainen alue profiilisivullasi, jota voit muokata.',
             'edit_big' => 'Muokkaa minua!',
             'placeholder' => 'Kirjoita sivun sisältö tähän',

resources/lang/fr/rankings.php

···
     ],
 
     'type' => [
-        'charts' => 'spotlights',
+        'charts' => 'spotlights (ancien)',
         'country' => 'pays',
         'kudosu' => 'kudosu',
         'multiplayer' => 'multijoueur',

resources/lang/hr-HR/accounts.php

···
 
             'country_change' => [
                 '_' => "",
-                'update_link' => '',
+                'update_link' => 'Promjeni na :country',
             ],
 
             'user' => [
···
     'github_user' => [
         'info' => "",
         'link' => '',
-        'title' => '',
+        'title' => 'GitHub',
         'unlink' => '',
 
         'error' => [
-            'already_linked' => '',
+            'already_linked' => 'Ovaj GitHub nalog je vec povezan drugom korisniku.',
             'no_contribution' => '',
             'unverified_email' => '',
         ],

resources/lang/hr-HR/authorization.php

···
     ],
 
     'beatmapset' => [
-        'discussion_locked' => '',
+        'discussion_locked' => 'Ovaj beatmap je zakljucan za diskusiju.',
 
         'metadata' => [
             'nominated' => 'Ne možeš promijeniti metapodatke nominirane mape. Obratite se BN ili NAT članu ako mislite da su pogrešno postavljeni.',

resources/lang/hr-HR/bbcode.php

···
 return [
     'bold' => 'Podebljano',
     'heading' => 'Zaglavlje',
-    'help' => '',
+    'help' => 'Pomoc',
     'image' => 'Fotografija',
     'imagemap' => '',
     'italic' => 'Ukošen',

resources/lang/hr-HR/beatmappacks.php

···
 return [
     'index' => [
         'description' => 'Unaprijed zapakirane zbirke beatmapa temeljenih na zajedničkoj temi.',
-        'empty' => '',
+        'empty' => 'Dolazi uskoro!',
         'nav_title' => 'popis',
         'title' => 'Paketi beatmapa',
 
···
         'loved' => '',
         'standard' => 'Standardni',
         'theme' => 'Tema',
-        'tournament' => '',
+        'tournament' => 'Turnir',
     ],
 
     'require_login' => [

resources/lang/hr-HR/beatmaps.php

···
         ],
 
         'message_type_title' => [
-            'disqualify' => '',
+            'disqualify' => 'Poslije diskvalifikacije',
             'hype' => '',
             'mapper_note' => '',
-            'nomination_reset' => '',
+            'nomination_reset' => 'Ukloni sve nominacije',
             'praise' => '',
             'problem' => '',
-            'problem_warning' => '',
+            'problem_warning' => 'Postavi problem',
             'review' => '',
             'suggestion' => '',
         ],
···
             '_' => 'Procjenjuje se da će ova beatmapa biti rangirana :date ako nema problema. To je :position. u :queue.',
             'unresolved_problems' => '',
             'problems' => '',
-            'on' => '',
+            'on' => 'na :date',
             'queue' => 'red čekanja na rangiranje',
             'soon' => 'uskoro',
         ],

resources/lang/hr-HR/beatmapset_events.php

···
         'qualify' => 'Ova beatmapa je dosegla potreban broj nominacija i kvalificirana je.',
         'rank' => 'Rangirano.',
         'remove_from_loved' => 'Uklonjeno iz Voljeno od :user. (:text)',
-        'tags_edit' => '',
+        'tags_edit' => 'Oznake promjenjene sa ":old" na ":new".',
 
         'nsfw_toggle' => [
             'to_0' => 'Uklonjena eksplicitna oznaka',

resources/lang/hr-HR/beatmapsets.php

···
         ],
 
         'deleted_banner' => [
-            'title' => '',
-            'message' => '',
+            'title' => 'Ovaj beatmap je obrisan.',
+            'message' => '(samo moderatori mogu ovo da vide)',
         ],
 
         'details' => [
···
             'genre' => 'Žanr',
             'language' => 'Jezik',
             'no_scores' => 'Podaci se još kalkuliraju...',
-            'nominators' => '',
+            'nominators' => 'Nominatori',
             'nsfw' => 'Eksplicitni sadržaj',
             'offset' => 'Online razmak',
             'points-of-failure' => 'Točke neuspjeha',

resources/lang/hr-HR/community.php

···
 return [
     'support' => [
         'convinced' => [
-            'title' => '',
+            'title' => 'Ubjedjen/a sam! :D',
             'support' => '',
             'gift' => '',
             'instructions' => '',
···
         'perks' => [
             'title' => '',
             'osu_direct' => [
-                'title' => '',
+                'title' => 'osu!direct',
                 'description' => '',
             ],
 
···
             ],
 
             'mod_filtering' => [
-                'title' => '',
+                'title' => 'Filtriraj prema Modovima',
                 'description' => '',
             ],
 
···
             ],
 
             'speedy_downloads' => [
-                'title' => '',
+                'title' => 'Brza preuzimanja',
                 'description' => '',
             ],
 
             'change_username' => [
-                'title' => '',
+                'title' => 'Promjeni korisnicko ime',
                 'description' => '',
             ],
 
···
                 'description' => '',
             ],
             'more_friends' => [
-                'title' => '',
+                'title' => 'Vise prijatelja',
                 'description' => '',
             ],
             'more_beatmaps' => [

resources/lang/hr-HR/contest.php

···
         'hide_judged' => '',
         'nav_title' => '',
         'no_current_vote' => '',
-        'update' => '',
+        'update' => 'azuriraj',
         'validation' => [
             'missing_score' => '',
             'contest_vote_judged' => '',

resources/lang/hr-HR/events.php

···
     'username_change' => '',
 
     'beatmapset_status' => [
-        'approved' => '',
+        'approved' => 'odobreno',
         'loved' => 'voljeno',
-        'qualified' => '',
-        'ranked' => '',
+        'qualified' => 'kvalificiran/a',
+        'ranked' => 'rangirano',
     ],
 
     'value' => [

resources/lang/hr-HR/forum.php

···
 
 return [
     'pinned_topics' => '',
-    'slogan' => "",
+    'slogan' => "opasno je igrati sam.",
     'subforums' => '',
     'title' => 'Forumi',
 
···
         'posted_by_in' => '',
 
         'actions' => [
-            'destroy' => '',
-            'edit' => '',
-            'report' => '',
-            'restore' => '',
+            'destroy' => 'Obrisi objavu',
+            'edit' => 'Izmeni objavu',
+            'report' => 'Prijavi objavu',
+            'restore' => 'Povrati objavu',
         ],
 
         'create' => [
             'title' => [
-                'reply' => '',
+                'reply' => 'Novi odgovor',
             ],
         ],
 
···
         'latest_reply_by' => '',
         'new_topic' => '',
         'new_topic_login' => '',
-        'post_reply' => '',
+        'post_reply' => 'Objava',
         'reply_box_placeholder' => '',
         'reply_title_prefix' => 'Re',
         'started_by' => 'od :user',
···
             'preview' => 'Pretpregled',
             // TL note: this is used in the topic reply preview, when
             // the user goes back from previewing to editing the reply
-            'preview_hide' => '',
+            'preview_hide' => 'Izmjeni',
             'submit' => '',
 
             'necropost' => [
···
                 'restore_post' => '',
                 'restore_topic' => '',
                 'split_destination' => '',
-                'split_source' => '',
+                'split_source' => 'Podijeli objave',
                 'topic_type' => '',
                 'topic_type_changed' => '',
                 'unlock' => '',
···
         '_' => '',
 
         'actions' => [
-            'login_reply' => '',
-            'reply' => '',
+            'login_reply' => 'Prijavi se da odgovoriš',
+            'reply' => 'Odgovori',
             'reply_with_quote' => '',
             'search' => 'Pretraži',
         ],
···
             'preview' => '',
 
             'create_poll_button' => [
-                'add' => '',
+                'add' => 'Napravi anketu',
                 'remove' => '',
             ],
 
···
                 'max_options_info' => '',
                 'options' => 'Opcije',
                 'options_info' => '',
-                'title' => '',
+                'title' => 'Pitanje',
                 'vote_change' => '',
                 'vote_change_info' => '',
             ],
         ],
 
         'edit_title' => [
-            'start' => '',
+            'start' => 'Uredi naslov',
         ],
 
         'index' => [
-            'feature_votes' => '',
-            'replies' => '',
+            'feature_votes' => 'prioritet zvijezda',
+            'replies' => 'odgovori',
             'views' => '',
         ],
 

resources/lang/id/authorization.php

···
 
     'forum' => [
         'moderate' => [
-            'no_permission' => 'Kamu tdak memiliki izin untuk memoderasi forum ini.',
+            'no_permission' => 'Kamu tidak memiliki izin untuk memoderasi forum ini.',
         ],
 
         'post' => [

resources/lang/it/artist.php

···
 
     'beatmaps' => [
         '_' => 'Beatmap',
-        'download' => 'Scarica il Template della Beatmap',
-        'download-na' => 'Template della Beatmap non ancora disponibile',
+        'download' => 'scarica il template della beatmap',
+        'download-na' => 'template della beatmap non ancora disponibile',
     ],
 
     'index' => [

resources/lang/it/authorization.php

···
     'require_verification' => 'Esegui la verifica per poter continuare.',
     'restricted' => "Non puoi farlo mentre sei limitato.",
     'silenced' => "Non puoi farlo mentre sei silenziato.",
-    'unauthorized' => 'Accesso Negato.',
+    'unauthorized' => 'Accesso negato.',
 
     'beatmap_discussion' => [
         'destroy' => [
···
             'bot' => "Non puoi votare in una discussione creata da un bot",
             'limit_exceeded' => 'Attendi un po\' prima di aggiungere più voti',
             'owner' => "Non puoi votare la tua discussione.",
-            'wrong_beatmapset_state' => 'Puoi votare solo su discussioni di beatmap in attesa.',
+            'wrong_beatmapset_state' => 'Puoi votare solo sulle discussioni di beatmap in attesa.',
         ],
     ],
 

resources/lang/it/bbcode.php

···
     'heading' => 'Intestazione',
     'help' => 'Aiuto',
     'image' => 'Immagine',
-    'imagemap' => 'Mappa Immagine',
+    'imagemap' => 'Immagine Mappata',
     'italic' => 'Corsivo',
     'link' => 'Link',
     'list' => 'Lista',

resources/lang/it/rankings.php

···
     ],
 
     'type' => [
-        'charts' => 'spotlight',
+        'charts' => 'spotlight (archivio)',
         'country' => 'paese',
         'kudosu' => 'kudosu',
         'multiplayer' => 'multigiocatore',

resources/lang/ja/bbcode.php

···
 return [
     'bold' => '太字',
     'heading' => 'ヘッダー',
-    'help' => '',
+    'help' => 'ヘルプ',
     'image' => '画像',
     'imagemap' => '',
     'italic' => '斜体',

resources/lang/ja/beatmappacks.php

···
 return [
     'index' => [
         'description' => '共通のテーマを有するビートマップを集めたパックです。',
-        'empty' => '',
+        'empty' => '近日公開！',
         'nav_title' => '一覧',
         'title' => 'ビートマップパック',
 

resources/lang/ja/contest.php

···
 
     'judge_results' => [
         '_' => '',
-        'creator' => '',
-        'score' => '',
-        'total_score' => '',
+        'creator' => '作成者',
+        'score' => 'スコア',
+        'total_score' => '合計スコア',
     ],
 
     'voting' => [

resources/lang/ja/store.php

···
 
     'invoice' => [
         'contact' => '',
-        'date' => '',
+        'date' => '日付:',
         'echeck_delay' => '決済方法がeCheckのため、PayPalを介した支払いが完了するまで、さらに最大10日を要します。予めご了承ください。',
         'hide_from_activity' => 'osu!サポータータグは最近のアクティビティには表示されません。',
         'sent_via' => '',
···
         'total' => '',
 
         'details' => [
-            'order_number' => '',
+            'order_number' => '注文 #',
             'payment_terms' => '',
             'salesperson' => '',
             'shipping_method' => '',

resources/lang/ja/users.php

···
     ],
 
     'ogp' => [
-        'modding_description' => '',
-        'modding_description_empty' => '',
+        'modding_description' => 'ビートマップ: :counts',
+        'modding_description_empty' => 'このユーザーにはビートマップがありません...',
 
         'description' => [
-            '_' => '',
-            'country' => '',
-            'global' => '',
+            '_' => 'ランク (:ruleset): :global | :country',
+            'country' => '国 :rank',
+            'global' => '世界 :rank',
         ],
     ],
 

resources/lang/ko/events.php

···
     'beatmapset_update' => '<strong><em>:user</em></strong>님이 "<em>:beatmapset</em>" 맵셋을 업데이트했습니다.',
     'beatmapset_upload' => '<strong><em>:user</em></strong>님이 새 비트맵 ":beatmapset"을 제출했습니다.',
     'empty' => "최근에 눈에 띄는 활동이 없네요!",
-    'rank' => '<strong><em>:user</em></strong>님이 <em>:beatmap</em> (:mode)맵에서 #:rank등을 기록했습니다',
+    'rank' => ':user님이 :beatmap (:mode) 맵에서 :rank등을 기록했습니다.',
     'rank_lost' => '<strong><em>:user</em></strong>님이 <em>:beatmap</em> (:mode)맵에서 1등 자리를 빼앗겼습니다.',
     'user_support_again' => '<strong>:user</strong>님이 다시 한번 osu!를 지원하기로 결정하셨습니다. - 감사합니다!',
     'user_support_first' => '<strong>:user</strong>님이 osu! 서포터가 되셨습니다. - 감사합니다!',

resources/lang/lv-LV/news.php

···
 
 return [
     'index' => [
-        'title_page' => '',
+        'title_page' => 'osu!jaunumi',
 
         'nav' => [
-            'newer' => '',
-            'older' => '',
+            'newer' => 'Jaunākie raksti',
+            'older' => 'Vecāki raksti',
         ],
 
         'title' => [
-            '_' => '',
-            'info' => '',
+            '_' => 'jaunumi',
+            'info' => 'sākumlapa',
         ],
     ],
 
     'show' => [
-        'by' => '',
+        'by' => 'no :user',
 
         'nav' => [
-            'newer' => '',
-            'older' => '',
+            'newer' => 'Jaunāks raksts',
+            'older' => 'Vecāks raksts',
         ],
 
         'title' => [

resources/lang/nl/authorization.php

···
     ],
 
     'contest' => [
-        'judging_not_active' => '',
+        'judging_not_active' => 'Beoordeling is niet actief voor deze wedstrijd.',
         'voting_over' => 'Je kan je stem niet meer veranderen nadat de stemperiode van deze wedstrijd is afgelopen.',
 
         'entry' => [

resources/lang/nl/beatmaps.php

···
 
         'rank_estimate' => [
             '_' => 'Deze map staat gepland om ranked te worden op :date als er geen problemen worden gevonden. Het is #:position in de :queue.',
-            'unresolved_problems' => '',
-            'problems' => '',
+            'unresolved_problems' => 'Deze map is momenteel geblokkeerd om de Gekwalificeerde sectie te verlaten totdat :problems zijn opgelost.',
+            'problems' => 'deze problemen',
             'on' => 'op :date',
             'queue' => 'ranking wachtlijst',
             'soon' => 'binnenkort',

resources/lang/nl/contest.php

···
     ],
 
     'judge' => [
-        'hide_judged' => '',
-        'nav_title' => '',
-        'no_current_vote' => '',
-        'update' => '',
+        'hide_judged' => 'verberg beoordeelde items',
+        'nav_title' => 'beoordeel',
+        'no_current_vote' => 'je hebt nog niet gestemd.',
+        'update' => 'werk bij',
         'validation' => [
-            'missing_score' => '',
-            'contest_vote_judged' => '',
+            'missing_score' => 'ontbrekende score',
+            'contest_vote_judged' => 'kan niet stemmen in beoordeelde wedstrijden',
         ],
-        'voted' => '',
+        'voted' => 'Je hebt al een stem ingediend voor dit item.',
     ],
 
     'judge_results' => [
-        '_' => '',
-        'creator' => '',
-        'score' => '',
-        'total_score' => '',
+        '_' => 'Beoordelingsresultaten',
+        'creator' => 'maker',
+        'score' => 'Score',
+        'total_score' => 'totale score',
     ],
 
     'voting' => [
-        'judge_link' => '',
-        'judged_notice' => '',
+        'judge_link' => 'Jij bent een jurylid voor deze wedstrijd. Beoordeel de inzendingen hier!',
+        'judged_notice' => 'Deze wedstrijd maakt gebruik van het jurysysteem, de jury verwerkt momenteel de inzendingen.',
         'login_required' => 'Log in om te kunnen stemmen.',
         'over' => 'Je kan niet meer stemmen in deze wedstrijd',
         'show_voted_only' => 'Toon gestemde stemmen',

resources/lang/nl/layout.php

···
             'account-edit' => 'Instellingen',
             'follows' => 'Volglijsten',
             'friends' => 'Vrienden',
-            'legacy_score_only_toggle' => '',
-            'legacy_score_only_toggle_tooltip' => '',
+            'legacy_score_only_toggle' => 'Lazermodus',
+            'legacy_score_only_toggle_tooltip' => 'Lazermodus toont scores gezet op lazer met een nieuw scoringsalgoritme',
             'logout' => 'Log Uit',
             'profile' => 'Mijn Profiel',
         ],

resources/lang/nl/notifications.php

···
                 'beatmapset_discussion_unlock_compact' => 'Discussie is ontgrendeld',
 
                 'review_count' => [
-                    'praises' => '',
+                    'praises' => ':count_delimited lof|:count_delimited lof',
                     'problems' => ':count_delimited probleem|:count_delimited problemen',
                     'suggestions' => ':count_delimited suggestie|:count_delimited suggesties',
                 ],

resources/lang/nl/page_title.php

···
             '_' => 'opmerkingen',
         ],
         'contest_entries_controller' => [
-            'judge_results' => '',
+            'judge_results' => 'wedstrijd beoordelingsresultaten',
         ],
         'contests_controller' => [
             '_' => 'wedstrijden',
-            'judge' => '',
+            'judge' => 'wedstrijd beoordeling',
         ],
         'groups_controller' => [
             'show' => 'groepen',

resources/lang/nl/password_reset.php

···
         'username' => 'Vul e-mail adres of gebruikersnaam in',
 
         'reason' => [
-            'inactive_different_country' => "",
+            'inactive_different_country' => "Uw account is een lange tijd niet gebruikt. Om uw accountbeveiliging te verzekeren, reset uw wachtwoord.",
         ],
         'support' => [
             '_' => 'Meer hulp nodig? Neem contact met ons op via onze :button.',

resources/lang/nl/score_tokens.php

···
 return [
     'create' => [
         'beatmap_hash_invalid' => '',
-        'submission_disabled' => '',
+        'submission_disabled' => 'score inzending is uitgeschakeld',
     ],
 ];

resources/lang/nl/scores.php

···
     'status' => [
         'non_best' => 'Enkel je beste score op een beatmap levert pp op',
         'non_passing' => 'Alleen geslaagde scores leveren pp op',
-        'no_pp' => '',
+        'no_pp' => 'pp word niet opgeleverd voor deze score',
         'processing' => 'Deze score wordt nog berekend en zal zo dadelijk getoond worden',
-        'no_rank' => '',
+        'no_rank' => 'Deze score heeft geen rang omdat deze ongerangschikt is of gemarkeerd is voor verwijdering',
     ],
 ];

resources/lang/nl/store.php

···
             ],
             'prepared' => [
                 'title' => 'Je bestelling wordt voorbereid!',
-                'line_1' => '',
-                'line_2' => '',
+                'line_1' => 'Wacht alsjeblieft iets langer voor de verzending. Tracking-informatie zal hier verschijnen zodra de bestelling is verwerkt en verzonden. Dit kan tot 5 dagen duren (maar vaak minder!) afhankelijk van hoe druk we zijn.',
+                'line_2' => 'We verzenden alle bestellingen vanuit Japan d.m.v. een aantal bezorgdiensten afhankelijk van het gewicht en de waarde. Dit gebied zal worden bijgewerkt met details zodra we de bestelling hebben verzonden.',
             ],
             'processing' => [
                 'title' => 'Uw betaling is nog niet bevestigd!',
···
             ],
             'shipped' => [
                 'title' => 'Je bestelling is verzonden!',
-                'tracking_details' => '',
+                'tracking_details' => 'Tracking-details volgen:',
                 'no_tracking_details' => [
-                    '_' => "",
+                    '_' => "We hebben geen tracking-details omdat we jouw pakket via Air Mail verzonden hebben, maar je kunt deze verwachten binnen 1-3 weken. In Europa kan de douane soms vertraging buiten onze controle veroorzaken. Als je vragen hebt, antwoord op de bestelbevestigings-e-mail die je hebt ontvangen (of :link).",
                     'link_text' => 'stuur ons een email',
                 ],
             ],
···
         'thanks' => [
             'title' => 'Bedankt voor je bestelling!',
             'line_1' => [
-                '_' => '',
+                '_' => 'Je zal binnenkort een bevestigings-e-mail ontvangen. Als je vragen hebt, :link!',
                 'link_text' => 'contacteer ons',
             ],
         ],

resources/lang/nl/users.php

···
     ],
 
     'ogp' => [
-        'modding_description' => '',
+        'modding_description' => 'Beatmaps: :counts',
         'modding_description_empty' => 'Gebruiker heeft geen beatmaps...',
 
         'description' => [

resources/lang/ru/rankings.php

···
     ],
 
     'type' => [
-        'charts' => 'по чартам',
+        'charts' => 'по чартам (устар.)',
         'country' => 'по странам',
         'kudosu' => 'по кудосу',
         'multiplayer' => 'в мультиплеере',

resources/lang/sk/accounts.php

···
             'new_confirmation' => 'potvrdenie emailu',
             'title' => 'Email',
             'locked' => [
-                '_' => '',
-                'accounts' => '',
+                '_' => 'Prosím kontaktuje :accounts ak potrebujete aktualizovať svoj email.',
+                'accounts' => 'tím podpory účtu',
             ],
         ],
 
         'legacy_api' => [
-            'api' => '',
-            'irc' => '',
+            'api' => 'api',
+            'irc' => 'irc',
             'title' => '',
         ],
 
···
         ],
 
         'profile' => [
-            'country' => '',
+            'country' => 'krajina',
             'title' => 'Profil',
 
             'country_change' => [
-                '_' => "",
-                'update_link' => '',
+                '_' => "Krajina vášho účtu nezodpovedá krajine vášho bydliska. :update_link.",
+                'update_link' => 'Aktualizovať na :country',
             ],
 
             'user' => [
···
     ],
 
     'github_user' => [
-        'info' => "",
-        'link' => '',
-        'title' => '',
-        'unlink' => '',
+        'info' => "Ak ste prispievateľom do úložisiek s otvoreným zdrojovým kódom osu!, prepojenie účtu GitHub tu priradí vaše záznamy z denníku zmien k vášmu osu! profilu. Účty GitHub bez histórie príspevkov do osu! nemožno prepojiť.",
+        'link' => 'Prepoj GitHub účet',
+        'title' => 'GitHub',
+        'unlink' => 'Preruš prepojenie GitHub účtu',
 
         'error' => [
-            'already_linked' => '',
-            'no_contribution' => '',
-            'unverified_email' => '',
+            'already_linked' => 'Tento GitHub účet je už prepojený na iného užívateľa.',
+            'no_contribution' => 'GitHub účet bez histórie príspevkov do úložisiek osu! nemožno prepojiť.',
+            'unverified_email' => 'Prosím skontrolujte svoj primárny email v GitHub, potom skúste znova prepojiť svoj účet.',
         ],
     ],
 

resources/lang/sk/api.php

···
         'identify' => 'Identifikovať vás a prezerať váš verejný profil.',
 
         'chat' => [
-            'read' => '',
+            'read' => 'Prečítajte si správy vo vašom mene.
+',
             'write' => 'Posielajte správy vo vašom mene.',
-            'write_manage' => '',
+            'write_manage' => 'Pripojte sa a opustite kanály vo vašom mene.',
         ],
 
         'forum' => [

resources/lang/sk/authorization.php

···
     ],
 
     'contest' => [
-        'judging_not_active' => '',
+        'judging_not_active' => 'Hodnotenie tejto súťaže nie je aktívne.',
         'voting_over' => 'Po tom, čo sa hlasovacie obdobie pre túto súťaž ukončilo, svoj hlas nemôžete zmeniť.',
 
         'entry' => [
···
 
     'score' => [
         'pin' => [
-            'disabled_type' => "",
+            'disabled_type' => "Tento typ skóre sa nedá pripnúť",
             'failed' => "",
             'not_owner' => 'Skóre môže pripnúť iba pôvodný hráč.',
             'too_many' => 'Už bolo pripnuté maximum skóre.',

resources/lang/zh-tw/beatmapsets.php

···
             'all' => '下載',
             'video' => '下載並包含影片',
             'no_video' => '下載並不包含影片',
-            'direct' => '在osu!direct中查看',
+            'direct' => '在 osu!direct 中查看',
         ],
     ],
 

resources/lang/zh-tw/mail.php

···
     'common' => [
         'closing' => '祝順，',
         'hello' => '嗨 :user,',
-        'report' => '如果您沒有進行此項操作，請「立刻」回覆此信件!',
+        'report' => '如果您沒有進行此項操作，請「立刻」回覆此信件！',
         'ignore' => '若您未請求，則可以安全忽略這封信。',
     ],
 
···
     ],
 
     'user_password_updated' => [
-        'confirmation' => '提醒您，您的osu!密碼已被修改',
+        'confirmation' => '提醒您，您的 osu! 密碼已被修改。',
         'subject' => 'osu! 帳號密碼變更',
     ],
 
     'user_verification' => [
         'code' => '您的驗證碼是:',
-        'code_hint' => '你可以帶或不帶空格地輸入該驗證碼',
-        'link' => '或者，你也可以點擊下列連結以完成認證:',
+        'code_hint' => '你可以帶或不帶空格地輸入該驗證碼。',
+        'link' => '或者，你也可以點擊下列連結以完成認證：',
         'report' => '如果您並沒有進行此項操作，請「立刻」回覆此信件，您的帳戶可能有危險。',
         'subject' => 'osu! 帳號驗證',
 
         'action_from' => [
-            '_' => '有一項來自 :country 對您的帳戶所執行的操作需要認證',
+            '_' => '有一項來自 :country 對您的帳戶所執行的操作需要認證。',
             'unknown_country' => '未知國家',
         ],
     ],

resources/lang/zh-tw/oauth.php

···
     ],
 
     'authorized_clients' => [
-        'confirm_revoke' => '您確定要撤消此客戶端的權限嗎？',
+        'confirm_revoke' => '您確定要撤銷此客戶端的權限嗎？',
         'scopes_title' => '這個應用程式可以:',
         'owned_by' => '擁有者 :user',
         'none' => '沒有客戶端',
···
         'header' => '註冊一個新的 OAuth 應用程式',
         'register' => '註冊應用程式',
         'terms_of_use' => [
-            '_' => '在使用API之前您必須同意 :link.',
+            '_' => '在使用 API 之前您必須同意 :link 。',
             'link' => '使用條款',
         ],
     ],
 
     'own_clients' => [
         'confirm_delete' => '您確定要刪除此客戶端嗎？',
-        'confirm_reset' => '您確定鑰重置客戶端密鑰嗎? 這將撤銷現有的所有token。',
+        'confirm_reset' => '您確定要重置客戶端密鑰嗎？這將撤銷現有的所有 token。',
         'new' => '新增 OAuth 應用程式',
         'none' => '沒有客戶端',
 

resources/views/accounts/_edit_options.blade.php

···
     See the LICENCE file in the repository root for full licence text.
 --}}
 @php
-    $customization = auth()->user()->profileCustomization();
+    $customization = Auth::user()->profileCustomization();
 @endphp
 <div class="account-edit">
     <div class="account-edit__section">

resources/views/objects/_beatmapset_cover.blade.php

···
 
     $isNsfw = $beatmapset->nsfw;
     if ($isNsfw) {
-        $attributesBag = request()->attributes;
+        $attributesBag = Request::instance()->attributes;
         $userShowNsfw = $attributesBag->get('user_beatmapset_show_nsfw');
         if ($userShowNsfw === null) {
-            $user = auth()->user();
-            $userShowNsfw = $user !== null
-                ? ($user->userProfileCustomization ?? $user->userProfileCustomization()->make())->beatmapset_show_nsfw
-                : false;
+            $userShowNsfw = (Auth::user()->userProfileCustomization ?? App\Models\UserProfileCustomization::DEFAULTS)['beatmapset_show_nsfw'];
             $attributesBag->set('user_beatmapset_show_nsfw', $userShowNsfw);
         }
     }

resources/views/store/products/show.blade.php

···
         </div>
 
         <div class="store-page store-page--footer" id="add-to-cart">
-            @if($product->inStock())
-                <button type="submit" class="btn-osu-big btn-osu-big--store-action js-store-add-to-cart js-login-required--click">
+            @if ($product->inStock())
+                <button
+                    class="btn-osu-big btn-osu-big--store-action js-login-required--click js-store-add-to-cart"
+                    type="submit"
+                    {{ $product->custom_class === App\Models\Store\Product::SUPPORTER_TAG_NAME ? 'disabled' : '' }}
+                >
                     {{ osu_trans('store.product.add_to_cart') }}
                 </button>
-
-            @elseif(!$requestedNotification)
+            @elseif (!$requestedNotification)
                 <a
                     class="btn-osu-big btn-osu-big--store-action js-login-required--click"
                     href="{{ route('store.notification-request', ['product' => $product->product_id]) }}"

resources/views/store/products/supporter-tag.blade.php

···
 @if(!Auth::user())
     {!! require_login('store.supporter_tag.require_login._', 'store.supporter_tag.require_login.link_text') !!}
 @else
-<div class="js-store js-store-supporter-tag store-supporter-tag">
-    <input type="hidden" name="item[product_id]" value="{{ $product->product_id }}" />
-    <input type="hidden" name="item[quantity]" class="js-store-item-quantity" value="1" />
-    <input type="hidden" id="supporter-tag-form-price" name="item[cost]" value="4" />
-    <input type="hidden" name="item[extra_data][target_id]" value="{{ Auth::user()->user_id }}" />
-    <div class="store-supporter-tag__user-search">
-        <div class="js-react--user-card-store" data-user="null"></div>
-        <input
-            autocomplete="off"
-            class="js-username-input store-supporter-tag__input"
-            id="username"
-            name="item[extra_data][username]"
-            placeholder="{{ osu_trans('store.supporter_tag.gift') }}"
-            value="{{ get_string(request('target')) }}"
-        />
-        <div class="js-store-supporter-tag-message">
-            <textarea
-                class="store-supporter-tag__input store-supporter-tag__input--message"
-                maxlength="{{ ExtraDataSupporterTag::MAX_MESSAGE_LENGTH }}"
-                name="item[extra_data][message]"
-                placeholder="{{ osu_trans('store.supporter_tag.gift_message', [
-                    'length' => ExtraDataSupporterTag::MAX_MESSAGE_LENGTH,
-                ]) }}"
-                rows="3"
-            ></textarea>
-        </div>
-    </div>
-    <div class="store-slider">
-        <div class="js-slider ui-slider ui-slider-horizontal">
-            <div class="ui-slider-handle">
-                <div class="store-slider__fake-callout">
-                    <div class="store-slider__callout">
-                        <div class="js-price store-slider__bigtext"></div>
-                        <div class="js-duration"></div>
-                        <div class="js-discount store-slider__subtext"></div>
-                    </div>
-                </div>
-            </div>
-        </div>
-        <div class="store-slider__presets">
-            <span class="store-slider__presets-blurb">{{ osu_trans('supporter_tag.months') }}</span>
-            @foreach([1, 2, 4, 6, 12, 18, 24] as $months)
-                <div class="js-slider-preset store-slider__preset" data-months="{{$months}}">{{$months}}</div>
-            @endforeach
-        </div>
-    </div>
-</div>
+    <div
+        class="js-react--store-supporter-tag"
+        data-max-message-length={{ ExtraDataSupporterTag::MAX_MESSAGE_LENGTH }}
+    ></div>
+    <input name="item[product_id]" type="hidden" value={{ $product->product_id }} />
+    <input class="js-store-item-quantity" name="item[quantity]" type="hidden" value="1" />
 @endif

resources/views/user_cover_presets/index.blade.php

···
+{{--
+    Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+    See the LICENCE file in the repository root for full licence text.
+--}}
+@extends('master')
+
+@section('content')
+    @include('layout._page_header_v4')
+    <div class="osu-page osu-page--generic">
+        <form
+            class="simple-form simple-form--search-box"
+            action="{{ route('user-cover-presets.store') }}"
+            method="POST"
+            enctype="multipart/form-data"
+        >
+            @csrf
+            <h2 class="simple-form__row simple-form__row--title">
+                {{ osu_trans('user_cover_presets.index.create_form.title') }}
+            </h2>
+            <div class="simple-form__row">
+                <div class="simple-form__label">
+                    {{ osu_trans('user_cover_presets.index.create_form.files') }}
+                </div>
+                <input class="simple-form__input" type="file" multiple="1" name="files[]" accept="image/*" />
+            </div>
+
+            <div class="simple-form__row simple-form__row--no-label">
+                <button class="btn-osu-big btn-osu-big--rounded-thin">
+                    {{ osu_trans('user_cover_presets.index.create_form.submit') }}
+                </button>
+            </div>
+        </form>
+
+        <div class="user-cover-preset-table">
+            <div class="user-cover-preset-table__row">
+                    @include('objects._switch', ['locals' => [
+                        'additionalClass' => '
+                            js-user-cover-preset-batch-enable
+                            js-user-cover-preset-batch-enable--select-all
+                        ',
+                        'attributes' => ['data-action' => 'select-all'],
+                        'modifiers' => 'grid',
+                        'name' => 'select-all',
+                    ]])
+
+                <div class="user-cover-preset-table__toolbar">
+                    <button
+                        class="js-user-cover-preset-batch-enable btn-osu-big btn-osu-big--rounded-small"
+                        data-action="enable-selected"
+                        type="button"
+                    >
+                        {{ osu_trans('user_cover_presets.index.batch_enable') }}
+                    </button>
+
+                    <button
+                        class="js-user-cover-preset-batch-enable btn-osu-big btn-osu-big--rounded-small"
+                        data-action="disable-selected"
+                        type="button"
+                    >
+                        {{ osu_trans('user_cover_presets.index.batch_disable') }}
+                    </button>
+                </div>
+            </div>
+
+            @foreach ($items as $item)
+                @php
+                    $id = $item->getKey();
+                    $imageUrl = $item->file()->url();
+                    $isActive = $item->active;
+                @endphp
+                <div
+                    class="user-cover-preset-table__row user-cover-preset-table__row--item"
+                    id="cover-{{ $id }}"
+                >
+                    {{-- wrap in u-contents because shift-click on label doesn't trigger click on the checkbox --}}
+                    <div
+                        class="u-contents js-user-cover-preset-batch-enable"
+                        data-action="select"
+                    >
+                        @include('objects._switch', ['locals' => [
+                            'additionalClass' => 'js-user-cover-preset-batch-enable--checkbox',
+                            'attributes' => [
+                                'data-id' => $id,
+                            ],
+                            'modifiers' => 'grid',
+                            'name' => 'ids[]',
+                        ]])
+                    </div>
+
+                    <div>
+                        <p>
+                            <button
+                                class="btn-osu-big btn-osu-big--rounded-small"
+                                data-url="{{ route('user-cover-presets.update', [
+                                    'user_cover_preset' => $item->getKey(),
+                                    'active' => $item->active ? '0' : '1',
+                                ]) }}"
+                                data-method="PUT"
+                                data-reload-on-success="1"
+                                data-remote="1"
+                                title="{{ osu_trans('user_cover_presets.index.item.'.(
+                                    $isActive ? 'click_to_disable' : 'click_to_enable'
+                                )) }}"
+                            >
+                                @if ($isActive)
+                                    <span class="fas fa-circle"></span>
+                                    {{ osu_trans('user_cover_presets.index.item.enabled') }}
+                                @else
+                                    <span class="far fa-circle"></span>
+                                    {{ osu_trans('user_cover_presets.index.item.disabled') }}
+                                @endif
+                            </button>
+                        </p>
+                        <p>
+                            <form
+                                action="{{ route('user-cover-presets.update', $item) }}"
+                                enctype="multipart/form-data"
+                                method="POST"
+                                class="user-cover-preset-replace"
+                            >
+                                @csrf
+                                <input type="hidden" name="_method" value="PUT" />
+                                <input class="user-cover-preset-replace__input" type="file" name="file" accept="image/*" required />
+                                <button class="btn-osu-big btn-osu-big--rounded-small">
+                                    {{ osu_trans('user_cover_presets.index.item.'.(
+                                        $imageUrl === null ? 'image_store' : 'image_update'
+                                    )) }}
+                                </button>
+                            </form>
+                        </p>
+                    </div>
+
+                    @if ($imageUrl === null)
+                        <p>{{ osu_trans('user_cover_presets.index.item.no_image') }}</p>
+                    @else
+                        <img class="user-cover-preset-table__image" src="{{ $imageUrl }}" alt="" />
+                    @endif
+                </div>
+            @endforeach
+        </table>
+    </div>
+
+    @include('layout._extra_js', ['src' => 'js/user-cover-presets.js'])
+@endsection

routes/web.php

···
     Route::post('session', 'SessionsController@store')->name('login');
     Route::delete('session', 'SessionsController@destroy')->name('logout');
 
+    Route::post('user-cover-presets/batch-activate', 'UserCoverPresetsController@batchActivate')->name('user-cover-presets.batch-activate');
+    Route::resource('user-cover-presets', 'UserCoverPresetsController', ['only' => ['index', 'store', 'update']]);
+
     Route::post('users/check-username-availability', 'UsersController@checkUsernameAvailability')->name('users.check-username-availability');
     Route::post('users/check-username-exists', 'UsersController@checkUsernameExists')->name('users.check-username-exists');
     Route::get('users/disabled', 'UsersController@disabled')->name('users.disabled');

tests/Browser/SanityTest.php

···
 
     private function checkAdminPermission(Browser $browser, LaravelRoute $route)
     {
-        $adminRestricted = ['chat.users.index', 'forum.topics.logs.index'];
+        $adminRestricted = ['chat.users.index', 'forum.topics.logs.index', 'user-cover-presets.index'];
 
         if (starts_with($route->uri, 'admin') || in_array($route->getName(), $adminRestricted, true)) {
             // TODO: retry and check page as admin? (will affect subsequent tests though, so figure out how to deal with that..)

tests/Controllers/ScoresControllerTest.php

···
 
 namespace Tests\Controllers;
 
-use App\Models\Beatmap;
+use App\Models\OAuth\Client;
 use App\Models\Score\Best\Osu;
 use App\Models\Solo\Score as SoloScore;
 use App\Models\User;
-use App\Models\UserCountryHistory;
 use App\Models\UserStatistics;
-use Carbon\CarbonImmutable;
 use Illuminate\Filesystem\Filesystem;
 use Storage;
 use Tests\TestCase;
···
     private User $user;
     private User $otherUser;
 
-    public function testDownloadSameUser()
+    private static function getLegacyScoreReplayViewCount(Osu $score): int
+    {
+        return $score->replayViewCount()->first()?->play_count ?? 0;
+    }
+
+    private static function getUserReplaysWatchedCount(Osu|SoloScore $score): int
+    {
+        $month = format_month_column(new \DateTime());
+
+        return $score->user->replaysWatchedCounts()->firstWhere('year_month', $month)?->count ?? 0;
+    }
+
+    private static function getUserReplayPopularity(Osu|SoloScore $score): int
+    {
+        return $score->user->statistics($score->getMode(), true)->first()?->replay_popularity ?? 0;
+    }
+
+    public function testDownloadApiSameUser()
     {
-        $this->expectCountChange(fn () => $this->score->user->statistics($this->score->getMode())->replay_popularity, 0);
+        $this->expectCountChange(fn () => static::getLegacyScoreReplayViewCount($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($this->score), 0);
 
         $this
-            ->actingAs($this->user)
-            ->withHeaders(['HTTP_REFERER' => $GLOBALS['cfg']['app']['url'].'/'])
+            ->actAsPasswordClientUser($this->user)
             ->json(
                 'GET',
-                route('scores.download-legacy', $this->params())
+                route('api.scores.download-legacy', $this->params())
             )
             ->assertSuccessful();
-
-        $month = CarbonImmutable::now();
-        $currentMonth = UserCountryHistory::formatDate($month);
-        $this->assertNull($this->score->user->replaysWatchedCounts()->where('year_month', $currentMonth)->first());
-
-        $this->assertNull($this->score->replayViewCount()->first());
     }
 
-    public function testDownloadSoloScoreSameUser()
+    public function testDownloadApiSoloScoreSameUser()
     {
         $soloScore = SoloScore::factory()
-            ->create([
-                'legacy_score_id' => $this->score->getKey(),
-                'ruleset_id' => Beatmap::MODES[$this->score->getMode()],
-                'user_id' => $this->score->user_id,
-                'has_replay' => true,
-            ]);
+            ->withReplay()
+            ->create(['user_id' => $this->user->getKey()]);
 
-        $this->expectCountChange(fn () => $this->score->user->statistics($this->score->getMode())->replay_popularity, 0);
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($soloScore), 0);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($soloScore), 0);
 
         $this
-            ->actingAs($this->user)
-            ->withHeaders(['HTTP_REFERER' => $GLOBALS['cfg']['app']['url'].'/'])
+            ->actAsPasswordClientUser($this->user)
             ->json(
                 'GET',
-                route('scores.download', $soloScore)
+                route('api.scores.download', $soloScore)
             )
             ->assertSuccessful();
-
-        $month = CarbonImmutable::now();
-        $currentMonth = UserCountryHistory::formatDate($month);
-        $this->assertNull($this->score->user->replaysWatchedCounts()->where('year_month', $currentMonth)->first());
     }
 
     public function testDownload()
     {
+        $this->expectCountChange(fn () => static::getLegacyScoreReplayViewCount($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($this->score), 0);
+
         $this
             ->actingAs($this->otherUser)
             ->withHeaders(['HTTP_REFERER' => $GLOBALS['cfg']['app']['url'].'/'])
···
                 route('scores.download-legacy', $this->params())
             )
             ->assertSuccessful();
+    }
 
-        $this->assertEquals($this->score->user->statistics($this->score->getMode())->replay_popularity, 1);
+    public function testDownloadApi(): void
+    {
+        $this->expectCountChange(fn () => static::getLegacyScoreReplayViewCount($this->score), 1);
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($this->score), 1);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($this->score), 1);
 
-        $month = CarbonImmutable::now();
-        $currentMonth = UserCountryHistory::formatDate($month);
-        $this->assertEquals($this->score->user->replaysWatchedCounts()->where('year_month', $currentMonth)->first()->count, 1);
+        $this
+            ->actAsPasswordClientUser($this->otherUser)
+            ->json(
+                'GET',
+                route('api.scores.download-legacy', $this->params())
+            )
+            ->assertSuccessful();
+    }
 
-        $this->assertEquals($this->score->replayViewCount()->first()->play_count, 1);
+    public function testDownloadApiTwiceNoCountChange(): void
+    {
+        $this
+            ->actAsPasswordClientUser($this->otherUser)
+            ->json(
+                'GET',
+                route('api.scores.download-legacy', $this->params())
+            )
+            ->assertSuccessful();
+
+        $this->expectCountChange(fn () => static::getLegacyScoreReplayViewCount($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($this->score), 0);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($this->score), 0);
+
+        $this
+            ->actAsPasswordClientUser($this->otherUser)
+            ->json(
+                'GET',
+                route('api.scores.download-legacy', $this->params())
+            )
+            ->assertSuccessful();
     }
 
     public function testDownloadSoloScore()
     {
         $soloScore = SoloScore::factory()
-            ->create([
-                'legacy_score_id' => $this->score->getKey(),
-                'ruleset_id' => Beatmap::MODES[$this->score->getMode()],
-                'user_id' => $this->score->user_id,
-                'has_replay' => true,
-            ]);
+            ->withReplay()
+            ->create(['user_id' => $this->user->getKey()]);
+
+        $this->expectCountChange(fn () => static::getUserReplayPopularity($soloScore), 0);
+        $this->expectCountChange(fn () => static::getUserReplaysWatchedCount($soloScore), 0);
 
         $this
             ->actingAs($this->otherUser)
···
                 route('scores.download', $soloScore)
             )
             ->assertSuccessful();
-
-        $this->assertEquals($soloScore->user->statistics($soloScore->getMode())->replay_popularity, 1);
-
-        $month = CarbonImmutable::now();
-        $currentMonth = UserCountryHistory::formatDate($month);
-        $this->assertEquals($soloScore->user->replaysWatchedCounts()->where('year_month', $currentMonth)->first()->count, 1);
     }
 
     public function testDownloadDeletedBeatmap()
···
     {
         $this
             ->actingAs($this->user)
+            ->withHeaders(['HTTP_REFERER' => rtrim($GLOBALS['cfg']['app']['url'], '/').'.example.com'])
             ->json(
                 'GET',
                 route('scores.download-legacy', $this->params())
             )
             ->assertRedirect(route('scores.show', $this->params()));
+    }
 
+    public function testDownloadNoReferer()
+    {
         $this
             ->actingAs($this->user)
-            ->withHeaders(['HTTP_REFERER' => rtrim($GLOBALS['cfg']['app']['url'], '/').'.example.com'])
             ->json(
                 'GET',
                 route('scores.download-legacy', $this->params())
···
             ->assertRedirect(route('scores.show', $this->params()));
     }
 
-    public function testDownloadInvalidMode()
+    public function testDownloadInvalidRuleset()
     {
         $this
             ->actingAs($this->user)
···
         parent::setUp();
 
         // fake all the replay disks
-        $disks = [];
-        foreach (array_keys($GLOBALS['cfg']['filesystems']['disks']['replays']) as $key) {
-            foreach (array_keys($GLOBALS['cfg']['filesystems']['disks']['replays'][$key]) as $type) {
-                $disk = "replays.{$key}.{$type}";
-                $disks[] = $disk;
-                Storage::fake($disk);
+        $disks = [SoloScore::replayFileDiskName()];
+        foreach ($GLOBALS['cfg']['filesystems']['disks']['replays'] as $ruleset => $types) {
+            foreach ($types as $type => $_config) {
+                $disks[] = "replays.{$ruleset}.{$type}";
             }
+        }
+        foreach ($disks as $disk) {
+            Storage::fake($disk);
         }
 
         // Laravel doesn't remove the directory created for fakes and
···
 
         UserStatistics\Osu::factory()->create(['user_id' => $this->user->user_id]);
         $this->score = Osu::factory()->withReplay()->create(['user_id' => $this->user->user_id]);
+    }
+
+    private function actAsPasswordClientUser(User $user): static
+    {
+        $this->actAsScopedUser($user, ['*'], Client::factory()->create(['password_client' => true]));
+
+        return $this;
     }
 
     private function params()

tests/Controllers/SessionsControllerTest.php

···
         $this->get(route('home'))->assertStatus(401);
     }
 
+    public function testLoginInactiveUserForceReset(): void
+    {
+        config_set('osu.user.inactive_force_password_reset', true);
+
+        $password = 'password1';
+        $countryAcronym = (Country::first() ?? Country::factory()->create())->getKey();
+        $user = User::factory()->create(['password' => $password, 'country_acronym' => $countryAcronym]);
+        $user->update(['user_lastvisit' => time() - $GLOBALS['cfg']['osu']['user']['inactive_seconds_verification'] - 1]);
+
+        $this->post(route('login'), [
+            'username' => $user->username,
+            'password' => $password,
+        ], [
+            'CF_IPCOUNTRY' => $countryAcronym,
+        ])->assertStatus(302);
+
+        $this->assertGuest();
+    }
+
     public function testLoginInactiveUserDifferentCountry()
     {
         $password = 'password1';

tests/Libraries/User/CountryChangeTargetTest.php

···
 use App\Models\Country;
 use App\Models\Tournament;
 use App\Models\User;
-use App\Models\UserCountryHistory;
 use Carbon\CarbonImmutable;
 use Database\Factories\UserFactory;
 use Tests\TestCase;
···
 
         $user
             ->userCountryHistory()
-            ->where('year_month', '>', UserCountryHistory::formatDate(CountryChangeTarget::currentMonth()->subMonths($minMonths)))
+            ->where('year_month', '>', format_month_column(CountryChangeTarget::currentMonth()->subMonths($minMonths)))
             ->inRandomOrder()
             ->limit(1)
             ->delete();
···
 
         $user
             ->userCountryHistory()
-            ->where('year_month', '>', UserCountryHistory::formatDate(CountryChangeTarget::currentMonth()->subMonths($minMonths)))
+            ->where('year_month', '>', format_month_column(CountryChangeTarget::currentMonth()->subMonths($minMonths)))
             ->inRandomOrder()
             ->limit(2)
             ->delete();

tests/Libraries/UserRegistrationTest.php

···
     {
         $attrs = $this->basicAttributes();
 
-        $origCount = User::count();
-        $origCountCache = Count::totalUsers()->count;
+        $this->expectCountChange(fn () => User::count(), 1);
+        $this->expectCountChange(fn () => Count::totalUsers()->count, 1);
         $reg = new UserRegistration($attrs);
         $thrown = $this->runSubject($reg);
 
         $this->assertFalse($thrown);
-        $this->assertSame($origCount + 1, User::count());
-        $this->assertTrue($reg->user()->userGroups->every(function ($userGroup) {
-            return $userGroup->user_pending === false;
-        }));
-        $this->assertSame($origCountCache + 1, Count::totalUsers()->count);
+
+        $user = $reg->user()->fresh();
+        $this->assertNotNull($user->cover_preset_id);
+        $this->assertTrue($user->userGroups->every(fn ($userGroup) =>
+            $userGroup->user_pending === false));
     }
 
     public function testRequiresUsername()

tests/Models/Multiplayer/ScoreLinkTest.php

···
             'user_id' => $scoreToken->user_id,
         ]);
     }
+
+    public function testFailedMultiplayerScoresArePreserved()
+    {
+        $playlistItem = PlaylistItem::factory()->create();
+        $scoreToken = ScoreToken::factory()->create([
+            'beatmap_id' => $playlistItem->beatmap_id,
+            'playlist_item_id' => $playlistItem,
+        ]);
+
+        $scoreLink = ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
+            'beatmap_id' => $playlistItem->beatmap_id,
+            'ruleset_id' => $playlistItem->ruleset_id,
+            'user_id' => $scoreToken->user_id,
+            'passed' => false,
+        ]);
+        $this->assertTrue($scoreLink->score->preserve);
+    }
 }

tests/Models/Multiplayer/UserScoreAggregateTest.php

···
             'total_score' => 10,
         ]);
 
-        $this->addPlay($user, $playlistItem, [
+        $playlistItem2 = $this->createPlaylistItem();
+        $this->addPlay($user, $playlistItem2, [
             'accuracy' => 1,
             'passed' => true,
             'total_score' => 1,
···
 
         $this->assertSame(2, $agg->attempts);
         $this->assertSame(1, $agg->completed);
+        $this->assertSame(1.0, $agg->averageAccuracy());
         $this->assertSame(1, $agg->total_score);
     }
 

yarn.lock

···
   integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==
 
 follow-redirects@^1.0.0:
-  version "1.15.4"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.4.tgz#cdc7d308bf6493126b17ea2191ea0ccf3e535adf"
-  integrity sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==
+  version "1.15.6"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b"
+  integrity sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==
 
 for-in@^1.0.2:
   version "1.0.2"