Merge branch 'master' into contest-judging

.env.example

···
 # CHAT_PUBLIC_BACKLOG_LIMIT_HOURS=24
 
 # ALLOW_REGISTRATION=true
+# REGISTRATION_MODE_CLIENT=true
+# REGISTRATION_MODE_WEB=false
 
 # USER_ALLOW_EMAIL_LOGIN=true
 # USER_BYPASS_VERIFICATION=false
···
 # SCORES_EXPERIMENTAL_RANK_AS_DEFAULT=false
 # SCORES_EXPERIMENTAL_RANK_AS_EXTRA=false
 # SCORES_PROCESSING_QUEUE=osu-queue:score-statistics
+# SCORES_SUBMISSION_ENABLED=1
 # SCORES_RANK_CACHE_LOCAL_SERVER=0
 # SCORES_RANK_CACHE_MIN_USERS=35000
 # SCORES_RANK_CACHE_SERVER_URL=

.github/workflows/lint.yml

···
       - name: Install js dependencies
         run: yarn --frozen-lockfile
 
-      - run: 'yarn lint --max-warnings 90 > /dev/null'
+      - run: 'yarn lint --max-warnings 89 > /dev/null'
 
       - run: ./bin/update_licence.sh -nf
 

app/Exceptions/ClientCheckParseTokenException.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);
+
+namespace App\Exceptions;
+
+class ClientCheckParseTokenException extends \Exception
+{
+}

app/Http/Controllers/BeatmapPacksController.php

···
 
 namespace App\Http\Controllers;
 
+use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Beatmap;
 use App\Models\BeatmapPack;
 use App\Transformers\BeatmapPackTransformer;
-use Auth;
 
 /**
  * @group Beatmap Packs
···
         $pack = $query->where('tag', $idOrTag)->firstOrFail();
         $mode = Beatmap::modeStr($pack->playmode ?? 0);
         $sets = $pack->beatmapsets;
-        $userCompletionData = $pack->userCompletionData(Auth::user());
+        $currentUser = \Auth::user();
+        $userCompletionData = $pack->userCompletionData(
+            $currentUser,
+            ScoreSearchParams::showLegacyForUser($currentUser),
+        );
 
         if (is_api_request()) {
             return json_item(

app/Http/Controllers/BeatmapsController.php

···
 use App\Jobs\Notifications\BeatmapOwnerChange;
 use App\Libraries\BeatmapDifficultyAttributes;
 use App\Libraries\Score\BeatmapScores;
+use App\Libraries\Score\UserRank;
+use App\Libraries\Search\ScoreSearch;
+use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Beatmap;
 use App\Models\BeatmapsetEvent;
 use App\Models\Score\Best\Model as BestModel;
···
         }
 
         return $query;
+    }
+
+    private static function beatmapScores(string $id, ?string $scoreTransformerType, ?bool $isLegacy): array
+    {
+        $beatmap = Beatmap::findOrFail($id);
+        if ($beatmap->approved <= 0) {
+            return ['scores' => []];
+        }
+
+        $params = get_params(request()->all(), null, [
+            'limit:int',
+            'mode',
+            'mods:string[]',
+            'type:string',
+        ], ['null_missing' => true]);
+
+        if ($params['mode'] !== null) {
+            $rulesetId = Beatmap::MODES[$params['mode']] ?? null;
+            if ($rulesetId === null) {
+                throw new InvariantException('invalid mode specified');
+            }
+        }
+        $rulesetId ??= $beatmap->playmode;
+        $mods = array_values(array_filter($params['mods'] ?? []));
+        $type = presence($params['type'], 'global');
+        $currentUser = \Auth::user();
+
+        static::assertSupporterOnlyOptions($currentUser, $type, $mods);
+
+        $esFetch = new BeatmapScores([
+            'beatmap_ids' => [$beatmap->getKey()],
+            'is_legacy' => $isLegacy,
+            'limit' => $params['limit'],
+            'mods' => $mods,
+            'ruleset_id' => $rulesetId,
+            'type' => $type,
+            'user' => $currentUser,
+        ]);
+        $scores = $esFetch->all()->loadMissing(['beatmap', 'user.country', 'user.userProfileCustomization']);
+        $userScore = $esFetch->userBest();
+        $scoreTransformer = new ScoreTransformer($scoreTransformerType);
+
+        $results = [
+            'scores' => json_collection(
+                $scores,
+                $scoreTransformer,
+                static::DEFAULT_SCORE_INCLUDES
+            ),
+        ];
+
+        if (isset($userScore)) {
+            $results['user_score'] = [
+                'position' => $esFetch->rank($userScore),
+                'score' => json_item($userScore, $scoreTransformer, static::DEFAULT_SCORE_INCLUDES),
+            ];
+            // TODO: remove this old camelCased json field
+            $results['userScore'] = $results['user_score'];
+        }
+
+        return $results;
     }
 
     public function __construct()
···
     /**
      * Get Beatmap scores
      *
-     * Returns the top scores for a beatmap
+     * Returns the top scores for a beatmap. Depending on user preferences, this may only show legacy scores.
      *
      * ---
      *
···
      */
     public function scores($id)
     {
-        $beatmap = Beatmap::findOrFail($id);
-        if ($beatmap->approved <= 0) {
-            return ['scores' => []];
-        }
-
-        $params = get_params(request()->all(), null, [
-            'limit:int',
-            'mode:string',
-            'mods:string[]',
-            'type:string',
-        ], ['null_missing' => true]);
-
-        $mode = presence($params['mode']) ?? $beatmap->mode;
-        $mods = array_values(array_filter($params['mods'] ?? []));
-        $type = presence($params['type']) ?? 'global';
-        $currentUser = auth()->user();
-
-        static::assertSupporterOnlyOptions($currentUser, $type, $mods);
-
-        $query = static::baseScoreQuery($beatmap, $mode, $mods, $type);
-
-        if ($currentUser !== null) {
-            // own score shouldn't be filtered by visibleUsers()
-            $userScore = (clone $query)->where('user_id', $currentUser->user_id)->first();
-        }
-
-        $scoreTransformer = new ScoreTransformer();
-
-        $results = [
-            'scores' => json_collection(
-                $query->visibleUsers()->forListing($params['limit']),
-                $scoreTransformer,
-                static::DEFAULT_SCORE_INCLUDES
-            ),
-        ];
-
-        if (isset($userScore)) {
-            $results['user_score'] = [
-                'position' => $userScore->userRank(compact('type', 'mods')),
-                'score' => json_item($userScore, $scoreTransformer, static::DEFAULT_SCORE_INCLUDES),
-            ];
-            // TODO: remove this old camelCased json field
-            $results['userScore'] = $results['user_score'];
-        }
-
-        return $results;
+        return static::beatmapScores(
+            $id,
+            null,
+            // TODO: change to imported name after merge with other PRs
+            \App\Libraries\Search\ScoreSearchParams::showLegacyForUser(\Auth::user()),
+        );
     }
 
     /**
-     * Get Beatmap scores (temp)
+     * Get Beatmap scores (non-legacy)
      *
-     * Returns the top scores for a beatmap from newer client.
-     *
-     * This is a temporary endpoint.
+     * Returns the top scores for a beatmap.
      *
      * ---
      *
···
      *
      * @urlParam beatmap integer required Id of the [Beatmap](#beatmap).
      *
+     * @queryParam legacy_only Set to true to only return legacy scores. Example: 0
      * @queryParam mode The [Ruleset](#ruleset) to get scores for.
      * @queryParam mods An array of matching Mods, or none // TODO.
      * @queryParam type Beatmap score ranking type // TODO.
      */
     public function soloScores($id)
     {
-        $beatmap = Beatmap::findOrFail($id);
-        if ($beatmap->approved <= 0) {
-            return ['scores' => []];
-        }
-
-        $params = get_params(request()->all(), null, [
-            'limit:int',
-            'mode',
-            'mods:string[]',
-            'type:string',
-        ], ['null_missing' => true]);
-
-        if ($params['mode'] !== null) {
-            $rulesetId = Beatmap::MODES[$params['mode']] ?? null;
-            if ($rulesetId === null) {
-                throw new InvariantException('invalid mode specified');
-            }
-        }
-        $rulesetId ??= $beatmap->playmode;
-        $mods = array_values(array_filter($params['mods'] ?? []));
-        $type = presence($params['type'], 'global');
-        $currentUser = auth()->user();
-
-        static::assertSupporterOnlyOptions($currentUser, $type, $mods);
-
-        $esFetch = new BeatmapScores([
-            'beatmap_ids' => [$beatmap->getKey()],
-            'is_legacy' => false,
-            'limit' => $params['limit'],
-            'mods' => $mods,
-            'ruleset_id' => $rulesetId,
-            'type' => $type,
-            'user' => $currentUser,
-        ]);
-        $scores = $esFetch->all()->loadMissing(['beatmap', 'performance', 'user.country', 'user.userProfileCustomization']);
-        $userScore = $esFetch->userBest();
-        $scoreTransformer = new ScoreTransformer(ScoreTransformer::TYPE_SOLO);
-
-        $results = [
-            'scores' => json_collection(
-                $scores,
-                $scoreTransformer,
-                static::DEFAULT_SCORE_INCLUDES
-            ),
-        ];
-
-        if (isset($userScore)) {
-            $results['user_score'] = [
-                'position' => $esFetch->rank($userScore),
-                'score' => json_item($userScore, $scoreTransformer, static::DEFAULT_SCORE_INCLUDES),
-            ];
-            // TODO: remove this old camelCased json field
-            $results['userScore'] = $results['user_score'];
-        }
-
-        return $results;
+        return static::beatmapScores($id, ScoreTransformer::TYPE_SOLO, null);
     }
 
     public function updateOwner($id)
···
         $mode = presence($params['mode'] ?? null, $beatmap->mode);
         $mods = array_values(array_filter($params['mods'] ?? []));
 
-        $score = static::baseScoreQuery($beatmap, $mode, $mods)
-            ->visibleUsers()
-            ->where('user_id', $userId)
-            ->firstOrFail();
+        $baseParams = ScoreSearchParams::fromArray([
+            'beatmap_ids' => [$beatmap->getKey()],
+            'is_legacy' => ScoreSearchParams::showLegacyForUser(\Auth::user()),
+            'limit' => 1,
+            'mods' => $mods,
+            'ruleset_id' => Beatmap::MODES[$mode],
+            'sort' => 'score_desc',
+            'user_id' => (int) $userId,
+        ]);
+        $score = (new ScoreSearch($baseParams))->records()->first();
+        abort_if($score === null, 404);
+
+        $rankParams = clone $baseParams;
+        $rankParams->beforeScore = $score;
+        $rankParams->userId = null;
+        $rank = UserRank::getRank($rankParams);
 
         return [
-            'position' => $score->userRank(compact('mods')),
+            'position' => $rank,
             'score' => json_item(
                 $score,
                 new ScoreTransformer(),
···
     {
         $beatmap = Beatmap::scoreable()->findOrFail($beatmapId);
         $mode = presence(get_string(request('mode'))) ?? $beatmap->mode;
-        $scores = BestModel::getClass($mode)
-            ::default()
-            ->where([
-                'beatmap_id' => $beatmap->getKey(),
-                'user_id' => $userId,
-            ])->get();
+        $params = ScoreSearchParams::fromArray([
+            'beatmap_ids' => [$beatmap->getKey()],
+            'is_legacy' => ScoreSearchParams::showLegacyForUser(\Auth::user()),
+            'ruleset_id' => Beatmap::MODES[$mode],
+            'sort' => 'score_desc',
+            'user_id' => (int) $userId,
+        ]);
+        $scores = (new ScoreSearch($params))->records();
 
         return [
             'scores' => json_collection($scores, new ScoreTransformer()),

app/Http/Controllers/Multiplayer/Rooms/Playlist/ScoresController.php

···
         $room = Room::findOrFail($roomId);
         $playlistItem = $room->playlist()->where('id', $playlistId)->firstOrFail();
         $user = auth()->user();
-        $params = request()->all();
+        $request = \Request::instance();
+        $params = $request->all();
 
-        $buildId = ClientCheck::findBuild($user, $params)?->getKey()
-            ?? $GLOBALS['cfg']['osu']['client']['default_build_id'];
+        $buildId = ClientCheck::parseToken($request)['buildId'];
 
         $scoreToken = $room->startPlay($user, $playlistItem, $buildId);
 
···
      */
     public function update($roomId, $playlistItemId, $tokenId)
     {
+        $request = \Request::instance();
+        $clientTokenData = ClientCheck::parseToken($request);
         $scoreLink = \DB::transaction(function () use ($roomId, $playlistItemId, $tokenId) {
             $room = Room::findOrFail($roomId);
 
···
         });
 
         $score = $scoreLink->score;
-        $transformer = ScoreTransformer::newSolo();
         if ($score->wasRecentlyCreated) {
-            $scoreJson = json_item($score, $transformer);
-            $score::queueForProcessing($scoreJson);
+            ClientCheck::queueToken($clientTokenData, $score->getKey());
+            $score->queueForProcessing();
         }
 
         return json_item(
             $scoreLink,
-            $transformer,
+            ScoreTransformer::newSolo(),
             [
                 ...ScoreTransformer::MULTIPLAYER_BASE_INCLUDES,
                 'position',

app/Http/Controllers/ScoreTokensController.php

···
 
     public function store($beatmapId)
     {
+        if (!$GLOBALS['cfg']['osu']['scores']['submission_enabled']) {
+            abort(422, 'score submission is disabled');
+        }
+
         $beatmap = Beatmap::increasesStatistics()->findOrFail($beatmapId);
         $user = auth()->user();
-        $rawParams = request()->all();
-        $params = get_params($rawParams, null, [
+        $request = \Request::instance();
+        $params = get_params($request->all(), null, [
             'beatmap_hash',
             'ruleset_id:int',
         ]);
···
             }
         }
 
-        $build = ClientCheck::findBuild($user, $rawParams);
+        $buildId = ClientCheck::parseToken($request)['buildId'];
 
         try {
             $scoreToken = ScoreToken::create([
                 'beatmap_id' => $beatmap->getKey(),
-                'build_id' => $build?->getKey() ?? $GLOBALS['cfg']['osu']['client']['default_build_id'],
+                'build_id' => $buildId,
                 'ruleset_id' => $params['ruleset_id'],
                 'user_id' => $user->getKey(),
             ]);

app/Http/Controllers/Solo/ScoresController.php

···
 namespace App\Http\Controllers\Solo;
 
 use App\Http\Controllers\Controller as BaseController;
+use App\Libraries\ClientCheck;
 use App\Models\ScoreToken;
 use App\Models\Solo\Score;
 use App\Transformers\ScoreTransformer;
···
 
     public function store($beatmapId, $tokenId)
     {
-        $score = DB::transaction(function () use ($beatmapId, $tokenId) {
+        $request = \Request::instance();
+        $clientTokenData = ClientCheck::parseToken($request);
+        $score = DB::transaction(function () use ($beatmapId, $request, $tokenId) {
             $user = auth()->user();
             $scoreToken = ScoreToken::where([
                 'beatmap_id' => $beatmapId,
···
 
             // return existing score otherwise (assuming duplicated submission)
             if ($scoreToken->score_id === null) {
-                $params = Score::extractParams(\Request::all(), $scoreToken);
+                $params = Score::extractParams($request->all(), $scoreToken);
                 $score = Score::createFromJsonOrExplode($params);
-                $score->createLegacyEntryOrExplode();
                 $scoreToken->fill(['score_id' => $score->getKey()])->saveOrExplode();
             } else {
                 // assume score exists and is valid
···
             return $score;
         });
 
-        $scoreJson = json_item($score, new ScoreTransformer(ScoreTransformer::TYPE_SOLO));
         if ($score->wasRecentlyCreated) {
-            $score::queueForProcessing($scoreJson);
+            ClientCheck::queueToken($clientTokenData, $score->getKey());
+            $score->queueForProcessing();
         }
 
-        return $scoreJson;
+        return json_item($score, new ScoreTransformer(ScoreTransformer::TYPE_SOLO));
     }
 }

app/Http/Controllers/UsersController.php

···
 use App\Exceptions\UserProfilePageLookupException;
 use App\Exceptions\ValidationException;
 use App\Http\Middleware\RequestCost;
+use App\Libraries\ClientCheck;
 use App\Libraries\RateLimiter;
 use App\Libraries\Search\ForumSearch;
 use App\Libraries\Search\ForumSearchRequestParams;
+use App\Libraries\Search\ScoreSearchParams;
 use App\Libraries\User\FindForProfilePage;
 use App\Libraries\UserRegistration;
 use App\Models\Beatmap;
···
 use App\Models\Country;
 use App\Models\IpBan;
 use App\Models\Log;
+use App\Models\Solo\Score as SoloScore;
 use App\Models\User;
 use App\Models\UserAccountHistory;
 use App\Models\UserNotFound;
···
 use NoCaptcha;
 use Request;
 use Sentry\State\Scope;
+use Symfony\Component\HttpKernel\Exception\HttpException;
 
 /**
  * @group Users
···
         parent::__construct();
     }
 
+    private static function storeClientDisabledError()
+    {
+        return response([
+            'error' => osu_trans('users.store.from_web'),
+            'url' => route('users.create'),
+        ], 403);
+    }
+
     public function card($id)
     {
         try {
···
 
     public function create()
     {
-        if ($GLOBALS['cfg']['osu']['user']['registration_mode'] !== 'web') {
+        if (!$GLOBALS['cfg']['osu']['user']['registration_mode']['web']) {
             return abort(403, osu_trans('users.store.from_client'));
         }
 
···
                     'monthly_playcounts' => json_collection($this->user->monthlyPlaycounts, new UserMonthlyPlaycountTransformer()),
                     'recent' => $this->getExtraSection(
                         'scoresRecent',
-                        $this->user->scores($this->mode, true)->includeFails(false)->count()
+                        $this->user->soloScores()->recent($this->mode, false)->count(),
                     ),
                     'replays_watched_counts' => json_collection($this->user->replaysWatchedCounts, new UserReplaysWatchedCountTransformer()),
                 ];
···
                 return [
                     'best' => $this->getExtraSection(
                         'scoresBest',
-                        count($this->user->beatmapBestScoreIds($this->mode))
+                        count($this->user->beatmapBestScoreIds($this->mode, ScoreSearchParams::showLegacyForUser(\Auth::user())))
                     ),
                     'firsts' => $this->getExtraSection(
                         'scoresFirsts',
···
 
     public function store()
     {
-        if ($GLOBALS['cfg']['osu']['user']['registration_mode'] !== 'client') {
-            return response([
-                'error' => osu_trans('users.store.from_web'),
-                'url' => route('users.create'),
-            ], 403);
+        if (!$GLOBALS['cfg']['osu']['user']['registration_mode']['client']) {
+            return static::storeClientDisabledError();
         }
 
-        if (!starts_with(Request::header('User-Agent'), $GLOBALS['cfg']['osu']['client']['user_agent'])) {
+        $request = \Request::instance();
+
+        if (!starts_with($request->header('User-Agent'), $GLOBALS['cfg']['osu']['client']['user_agent'])) {
             return error_popup(osu_trans('users.store.from_client'), 403);
         }
 
-        return $this->storeUser(request()->all());
+        try {
+            ClientCheck::parseToken($request);
+        } catch (HttpException $e) {
+            return static::storeClientDisabledError();
+        }
+
+        return $this->storeUser($request->all());
     }
 
     public function storeWeb()
     {
-        if ($GLOBALS['cfg']['osu']['user']['registration_mode'] !== 'web') {
+        if (!$GLOBALS['cfg']['osu']['user']['registration_mode']['web']) {
             return error_popup(osu_trans('users.store.from_client'), 403);
         }
 
···
      *
      * See [Get User](#get-user).
      *
+     * `session_verified` attribute is included.
      * Additionally, `statistics_rulesets` is included, containing statistics for all rulesets.
      *
      * @urlParam mode string [Ruleset](#ruleset). User default mode will be used if not specified. Example: osu
···
      */
     public function me($mode = null)
     {
-        $user = auth()->user();
+        $user = \Auth::user();
         $currentMode = $mode ?? $user->playmode;
 
         if (!Beatmap::isModeValid($currentMode)) {
···
             $user,
             (new UserTransformer())->setMode($currentMode),
             [
+                'session_verified',
                 ...$this->showUserIncludes(),
                 ...array_map(
                     fn (string $ruleset) => "statistics_rulesets.{$ruleset}",
···
             case 'scoresBest':
                 $transformer = new ScoreTransformer();
                 $includes = [...ScoreTransformer::USER_PROFILE_INCLUDES, 'weight'];
-                $collection = $this->user->beatmapBestScores($this->mode, $perPage, $offset, ScoreTransformer::USER_PROFILE_INCLUDES_PRELOAD);
+                $collection = $this->user->beatmapBestScores(
+                    $this->mode,
+                    $perPage,
+                    $offset,
+                    ScoreTransformer::USER_PROFILE_INCLUDES_PRELOAD,
+                    ScoreSearchParams::showLegacyForUser(\Auth::user()),
+                );
                 $userRelationColumn = 'user';
                 break;
             case 'scoresFirsts':
                 $transformer = new ScoreTransformer();
                 $includes = ScoreTransformer::USER_PROFILE_INCLUDES;
-                $query = $this->user->scoresFirst($this->mode, true)
-                    ->visibleUsers()
-                    ->reorderBy('score_id', 'desc')
+                $scoreQuery = $this->user->scoresFirst($this->mode, true)->unorder();
+                $userFirstsQuery = $scoreQuery->select($scoreQuery->qualifyColumn('score_id'));
+                $query = SoloScore
+                    ::whereIn('legacy_score_id', $userFirstsQuery)
+                    ->where('ruleset_id', Beatmap::MODES[$this->mode])
+                    ->default()
+                    ->reorderBy('id', 'desc')
                     ->with(ScoreTransformer::USER_PROFILE_INCLUDES_PRELOAD);
                 $userRelationColumn = 'user';
                 break;
···
             case 'scoresRecent':
                 $transformer = new ScoreTransformer();
                 $includes = ScoreTransformer::USER_PROFILE_INCLUDES;
-                $query = $this->user->scores($this->mode, true)
-                    ->includeFails($options['includeFails'] ?? false)
-                    ->with([...ScoreTransformer::USER_PROFILE_INCLUDES_PRELOAD, 'best']);
+                $query = $this->user->soloScores()
+                    ->recent($this->mode, $options['includeFails'] ?? false)
+                    ->reorderBy('unix_updated_at', 'desc')
+                    ->with(ScoreTransformer::USER_PROFILE_INCLUDES_PRELOAD);
                 $userRelationColumn = 'user';
                 break;
         }
···
                 );
             }
 
-            if ($GLOBALS['cfg']['osu']['user']['registration_mode'] === 'web') {
+            if (is_json_request()) {
+                return json_item($user->fresh(), new CurrentUserTransformer());
+            } else {
                 $this->login($user);
                 session()->flash('popup', osu_trans('users.store.saved'));
 
                 return ujs_redirect(route('home'));
-            } else {
-                return json_item($user->fresh(), new CurrentUserTransformer());
             }
         } catch (ValidationException $e) {
             return ModelNotSavedException::makeResponse($e, [

app/Http/Kernel.php

···
             Middleware\SetLocaleApi::class,
             Middleware\CheckUserBanStatus::class,
             Middleware\UpdateUserLastvisit::class,
+            Middleware\VerifyUserAlways::class,
         ],
         'web' => [
             Middleware\StripCookies::class,

app/Http/Middleware/AuthApi.php

···
 
 namespace App\Http\Middleware;
 
+use App\Libraries\SessionVerification;
 use Closure;
 use Illuminate\Auth\AuthenticationException;
 use Laravel\Passport\ClientRepository;
···
         }
 
         if ($user !== null) {
-            auth()->setUser($user);
+            \Auth::setUser($user);
             $user->withAccessToken($token);
-            // this should match osu-notification-server OAuthVerifier
-            $user->markSessionVerified();
+
+            if ($token->isVerified()) {
+                $user->markSessionVerified();
+            } else {
+                SessionVerification\Helper::issue($token, $user, true);
+            }
         }
 
         return $token;

app/Http/Middleware/UpdateUserLastvisit.php

···
 
 namespace App\Http\Middleware;
 
+use App\Libraries\SessionVerification;
 use App\Models\Country;
 use Carbon\Carbon;
 use Closure;
···
             if ($shouldUpdate) {
                 $isInactive = $user->isInactive();
                 if ($isInactive) {
-                    $isVerified = $user->isSessionVerified();
+                    $isVerified = SessionVerification\Helper::currentSession()->isVerified();
                 }
 
                 if (!$isInactive || $isVerified) {

app/Http/Middleware/VerifyUser.php

···
         'notifications_controller@endpoint' => true,
         'sessions_controller@destroy' => true,
         'sessions_controller@store' => true,
+        'users_controller@me' => true,
         'wiki_controller@image' => true,
         'wiki_controller@show' => true,
         'wiki_controller@sitemap' => true,

app/Jobs/RemoveBeatmapsetSoloScores.php

···
 use App\Models\Beatmap;
 use App\Models\Beatmapset;
 use App\Models\Solo\Score;
-use App\Models\Solo\ScorePerformance;
 use DB;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
···
         $scoresQuery->update(['preserve' => false]);
         $this->scoreSearch->queueForIndex($this->schemas, $ids);
         DB::transaction(function () use ($ids, $scoresQuery): void {
-            ScorePerformance::whereKey($ids)->delete();
             $scoresQuery->delete();
         });
     }

app/Libraries/ClientCheck.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);
+
 namespace App\Libraries;
 
+use App\Exceptions\ClientCheckParseTokenException;
 use App\Models\Build;
+use Illuminate\Http\Request;
 
 class ClientCheck
 {
-    public static function findBuild($user, $params): ?Build
+    public static function parseToken(Request $request): array
     {
-        $assertValid = $GLOBALS['cfg']['osu']['client']['check_version'] && $user->findUserGroup(app('groups')->byIdentifier('admin'), true) === null;
+        $token = $request->header('x-token');
+        $assertValid = $GLOBALS['cfg']['osu']['client']['check_version'];
+        $ret = [
+            'buildId' => $GLOBALS['cfg']['osu']['client']['default_build_id'],
+            'token' => null,
+        ];
+
+        try {
+            if ($token === null) {
+                throw new ClientCheckParseTokenException('missing token header');
+            }
+
+            $input = static::splitToken($token);
+
+            $build = Build::firstWhere([
+                'hash' => $input['clientHash'],
+                'allow_ranking' => true,
+            ]);
+
+            if ($build === null) {
+                throw new ClientCheckParseTokenException('invalid client hash');
+            }
+
+            $ret['buildId'] = $build->getKey();
 
-        $clientHash = presence(get_string($params['version_hash'] ?? null));
-        if ($clientHash === null) {
-            if ($assertValid) {
-                abort(422, 'missing client version');
-            } else {
-                return null;
+            $computed = hash_hmac(
+                'sha1',
+                $input['clientData'],
+                static::getKey($build),
+                true,
+            );
+
+            if (!hash_equals($computed, $input['expected'])) {
+                throw new ClientCheckParseTokenException('invalid verification hash');
             }
+
+            $now = time();
+            static $maxTime = 15 * 60;
+            if (abs($now - $input['clientTime']) > $maxTime) {
+                throw new ClientCheckParseTokenException('expired token');
+            }
+
+            $ret['token'] = $token;
+            // to be included in queue
+            $ret['body'] = base64_encode($request->getContent());
+            $ret['url'] = $request->getRequestUri();
+        } catch (ClientCheckParseTokenException $e) {
+            abort_if($assertValid, 422, $e->getMessage());
         }
 
-        // temporary measure to allow android builds to submit without access to the underlying dll to hash
-        if (strlen($clientHash) !== 32) {
-            $clientHash = md5($clientHash);
+        return $ret;
+    }
+
+    public static function queueToken(?array $tokenData, int $scoreId): void
+    {
+        if ($tokenData['token'] === null) {
+            return;
         }
 
-        $build = Build::firstWhere([
-            'hash' => hex2bin($clientHash),
-            'allow_ranking' => true,
-        ]);
+        \LaravelRedis::lpush($GLOBALS['cfg']['osu']['client']['token_queue'], json_encode([
+            'body' => $tokenData['body'],
+            'id' => $scoreId,
+            'token' => $tokenData['token'],
+            'url' => $tokenData['url'],
+        ]));
+    }
 
-        if ($build === null && $assertValid) {
-            abort(422, 'invalid client hash');
-        }
+    private static function getKey(Build $build): string
+    {
+        return $GLOBALS['cfg']['osu']['client']['token_keys'][$build->platform()]
+            ?? $GLOBALS['cfg']['osu']['client']['token_keys']['default']
+            ?? '';
+    }
 
-        return $build;
+    private static function splitToken(string $token): array
+    {
+        $data = substr($token, -82);
+        $clientTimeHex = substr($data, 32, 8);
+        $clientTime = strlen($clientTimeHex) === 8
+            ? unpack('V', hex2bin($clientTimeHex))[1]
+            : 0;
+
+        return [
+            'clientData' => substr($data, 0, 40),
+            'clientHash' => hex2bin(substr($data, 0, 32)),
+            'clientTime' => $clientTime,
+            'expected' => hex2bin(substr($data, 40, 40)),
+            'version' => substr($data, 80, 2),
+        ];
     }
 }

app/Libraries/Elasticsearch/Search.php

···
     /**
      * A tag to use when logging timing of fetches.
      * FIXME: context-based tagging would be nicer.
-     *
-     * @var string|null
      */
-    public $loggingTag;
+    public ?string $loggingTag;
 
     protected $aggregations;
     protected $index;

app/Libraries/OAuth/EncodeToken.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);
+
+namespace App\Libraries\OAuth;
+
+use App\Models\OAuth\Token;
+use Defuse\Crypto\Crypto;
+use Firebase\JWT\JWT;
+use Laravel\Passport\Passport;
+use Laravel\Passport\RefreshToken;
+
+class EncodeToken
+{
+    public static function encodeAccessToken(Token $token): string
+    {
+        $privateKey = $GLOBALS['cfg']['passport']['private_key']
+            ?? file_get_contents(Passport::keyPath('oauth-private.key'));
+
+        return JWT::encode([
+            'aud' => $token->client_id,
+            'exp' => $token->expires_at->timestamp,
+            'iat' => $token->created_at->timestamp, // issued at
+            'jti' => $token->getKey(),
+            'nbf' => $token->created_at->timestamp, // valid after
+            'sub' => $token->user_id,
+            'scopes' => $token->scopes,
+        ], $privateKey, 'RS256');
+    }
+
+    public static function encodeRefreshToken(RefreshToken $refreshToken, Token $accessToken): string
+    {
+        return Crypto::encryptWithPassword(json_encode([
+            'client_id' => (string) $accessToken->client_id,
+            'refresh_token_id' => $refreshToken->getKey(),
+            'access_token_id' => $accessToken->getKey(),
+            'scopes' => $accessToken->scopes,
+            'user_id' => $accessToken->user_id,
+            'expire_time' => $refreshToken->expires_at->timestamp,
+        ]), \Crypt::getKey());
+    }
+}

app/Libraries/OAuth/RefreshTokenGrant.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);
+
+namespace App\Libraries\OAuth;
+
+use App\Models\OAuth\Token;
+use League\OAuth2\Server\Grant\RefreshTokenGrant as BaseRefreshTokenGrant;
+use League\OAuth2\Server\ResponseTypes\ResponseTypeInterface;
+use Psr\Http\Message\ServerRequestInterface;
+
+class RefreshTokenGrant extends BaseRefreshTokenGrant
+{
+    private ?array $oldRefreshToken = null;
+
+    public function respondToAccessTokenRequest(
+        ServerRequestInterface $request,
+        ResponseTypeInterface $responseType,
+        \DateInterval $accessTokenTTL
+    ) {
+        $refreshTokenData = parent::respondToAccessTokenRequest($request, $responseType, $accessTokenTTL);
+
+        // Copy previous verification state
+        $accessToken = (new \ReflectionProperty($refreshTokenData, 'accessToken'))->getValue($refreshTokenData);
+        Token::where('id', $accessToken->getIdentifier())->update([
+            'verified' => Token::select('verified')->find($this->oldRefreshToken['access_token_id'])->verified,
+        ]);
+        $this->oldRefreshToken = null;
+
+        return $refreshTokenData;
+    }
+
+    protected function validateOldRefreshToken(ServerRequestInterface $request, $clientId)
+    {
+        return $this->oldRefreshToken = parent::validateOldRefreshToken($request, $clientId);
+    }
+}

app/Libraries/Score/FetchDedupedScores.php

···
     private int $limit;
     private array $result;
 
-    public function __construct(private string $dedupeColumn, private ScoreSearchParams $params)
-    {
+    public function __construct(
+        private string $dedupeColumn,
+        private ScoreSearchParams $params,
+        private ?string $searchLoggingTag = null
+    ) {
         $this->limit = $this->params->size;
     }
 
···
     {
         $this->params->size = $this->limit + 50;
         $search = new ScoreSearch($this->params);
+        $search->loggingTag = $this->searchLoggingTag;
 
         $nextCursor = null;
         $hasNext = true;

app/Libraries/Search/BeatmapsetSearch.php

···
 use App\Models\Beatmap;
 use App\Models\Beatmapset;
 use App\Models\Follow;
-use App\Models\Score;
+use App\Models\Solo;
 use App\Models\User;
+use Ds\Set;
 
 class BeatmapsetSearch extends RecordSearch
 {
···
 
     private function getPlayedBeatmapIds(?array $rank = null)
     {
-        $unionQuery = null;
+        $query = Solo\Score
+            ::where('user_id', $this->params->user->getKey())
+            ->whereIn('ruleset_id', $this->getSelectedModes());
 
-        $select = $rank === null ? 'beatmap_id' : ['beatmap_id', 'score', 'rank'];
+        if ($rank === null) {
+            return $query->distinct('beatmap_id')->pluck('beatmap_id');
+        }
 
-        foreach ($this->getSelectedModes() as $mode) {
-            $newQuery = Score\Best\Model::getClassByRulesetId($mode)
-                ::forUser($this->params->user)
-                ->select($select);
+        $topScores = [];
+        $scoreField = ScoreSearchParams::showLegacyForUser($this->params->user)
+            ? 'legacy_total_score'
+            : 'total_score';
+        foreach ($query->get() as $score) {
+            $prevScore = $topScores[$score->beatmap_id] ?? null;
 
-            if ($unionQuery === null) {
-                $unionQuery = $newQuery;
-            } else {
-                $unionQuery->union($newQuery);
+            $scoreValue = $score->$scoreField;
+            if ($scoreValue !== null && ($prevScore === null || $prevScore->$scoreField < $scoreValue)) {
+                $topScores[$score->beatmap_id] = $score;
             }
         }
 
-        if ($rank === null) {
-            return model_pluck($unionQuery, 'beatmap_id');
-        } else {
-            $allScores = $unionQuery->get();
-            $beatmapRank = collect();
-
-            foreach ($allScores as $score) {
-                $prevScore = $beatmapRank[$score->beatmap_id] ?? null;
-
-                if ($prevScore === null || $prevScore->score < $score->score) {
-                    $beatmapRank[$score->beatmap_id] = $score;
-                }
+        $ret = [];
+        $rankSet = new Set($rank);
+        foreach ($topScores as $beatmapId => $score) {
+            if ($rankSet->contains($score->rank)) {
+                $ret[] = $beatmapId;
             }
+        }
 
-            return $beatmapRank->whereInStrict('rank', $rank)->pluck('beatmap_id')->all();
-        }
+        return $ret;
     }
 
     private function getSelectedModes()

app/Libraries/Search/ScoreSearch.php

···
         if ($this->params->userId !== null) {
             $query->filter(['term' => ['user_id' => $this->params->userId]]);
         }
+        if ($this->params->excludeConverts) {
+            $query->filter(['term' => ['convert' => false]]);
+        }
         if ($this->params->excludeMods !== null && count($this->params->excludeMods) > 0) {
             foreach ($this->params->excludeMods as $excludedMod) {
                 $query->mustNot(['term' => ['mods' => $excludedMod]]);
···
 
         $beforeTotalScore = $this->params->beforeTotalScore;
         if ($beforeTotalScore === null && $this->params->beforeScore !== null) {
-            $beforeTotalScore = $this->params->beforeScore->isLegacy()
-                ? $this->params->beforeScore->data->legacyTotalScore
-                : $this->params->beforeScore->data->totalScore;
+            $beforeTotalScore = $this->params->isLegacy
+                ? $this->params->beforeScore->legacy_total_score
+                : $this->params->beforeScore->total_score;
         }
         if ($beforeTotalScore !== null) {
             $scoreQuery = (new BoolQuery())->shouldMatch(1);
+            $scoreField = $this->params->isLegacy ? 'legacy_total_score' : 'total_score';
             $scoreQuery->should((new BoolQuery())->filter(['range' => [
-                'total_score' => ['gt' => $beforeTotalScore],
+                $scoreField => ['gt' => $beforeTotalScore],
             ]]));
             if ($this->params->beforeScore !== null) {
                 $scoreQuery->should((new BoolQuery())
                     ->filter(['range' => ['id' => ['lt' => $this->params->beforeScore->getKey()]]])
-                    ->filter(['term' => ['total_score' => $beforeTotalScore]]));
+                    ->filter(['term' => [$scoreField => $beforeTotalScore]]));
             }
 
             $query->must($scoreQuery);
···
         $allMods = $this->params->rulesetId === null
             ? $modsHelper->allIds
             : new Set(array_keys($modsHelper->mods[$this->params->rulesetId]));
-        $allMods->remove('PF', 'SD', 'MR');
+        // CL is currently considered a "preference" mod
+        $allMods->remove('CL', 'PF', 'SD', 'MR');
 
         $allSearchMods = [];
         foreach ($mods as $mod) {

app/Libraries/Search/ScoreSearchParams.php

···
     public ?array $beatmapIds = null;
     public ?Score $beforeScore = null;
     public ?int $beforeTotalScore = null;
+    public bool $excludeConverts = false;
     public ?array $excludeMods = null;
     public ?bool $isLegacy = null;
     public ?array $mods = null;
···
     {
         $params = new static();
         $params->beatmapIds = $rawParams['beatmap_ids'] ?? null;
+        $params->excludeConverts = $rawParams['exclude_converts'] ?? $params->excludeConverts;
         $params->excludeMods = $rawParams['exclude_mods'] ?? null;
         $params->isLegacy = $rawParams['is_legacy'] ?? null;
         $params->mods = $rawParams['mods'] ?? null;
···
     }
 
     /**
-     * This returns value for isLegacy based on user preference
+     * This returns value for isLegacy based on user preference, request type, and `legacy_only` parameter
      */
-    public static function showLegacyForUser(?User $user): null | true
-    {
+    public static function showLegacyForUser(
+        ?User $user = null,
+        ?bool $legacyOnly = null,
+        ?bool $isApiRequest = null
+    ): null | true {
+        $isApiRequest ??= is_api_request();
+        // `null` is actual parameter value for the other two parameters so
+        // only try filling them up if not passed at all.
+        $argLen = func_num_args();
+        if ($argLen < 2) {
+            $legacyOnly = get_bool(Request('legacy_only'));
+
+            if ($argLen < 1) {
+                $user = \Auth::user();
+            }
+        }
+
+        if ($legacyOnly !== null) {
+            return $legacyOnly ? true : null;
+        }
+
+        if ($isApiRequest) {
+            return null;
+        }
+
         return $user?->userProfileCustomization?->legacy_score_only ?? UserProfileCustomization::DEFAULT_LEGACY_ONLY_ATTRIBUTE
             ? true
             : null;
···
     {
         switch ($sort) {
             case 'score_desc':
+                $sortColumn = $this->isLegacy ? 'legacy_total_score' : 'total_score';
                 $this->sorts = [
-                    new Sort('is_legacy', 'asc'),
-                    new Sort('total_score', 'desc'),
+                    new Sort($sortColumn, 'desc'),
+                    new Sort('id', 'asc'),
+                ];
+                break;
+            case 'pp_desc':
+                $this->sorts = [
+                    new Sort('pp', 'desc'),
                     new Sort('id', 'asc'),
                 ];
                 break;

app/Libraries/SessionVerification/Controller.php

···
         $user = Helper::currentUserOrFail();
         $email = $user->user_email;
 
-        $session = \Session::instance();
-        if (State::fromSession($session) === null) {
-            Helper::logAttempt('input', 'new');
+        $session = Helper::currentSession();
+        Helper::issue($session, $user, true);
 
-            Helper::issue($session, $user);
+        if (is_api_request()) {
+            return response(null, $statusCode);
         }
 
         if (\Request::ajax()) {
···
 
     public static function reissue()
     {
-        $session = \Session::instance();
+        $session = Helper::currentSession();
         if ($session->isVerified()) {
-            return response(null, 204);
+            return response(null, 422);
         }
 
         Helper::issue($session, Helper::currentUserOrFail());
···
 
     public static function verify()
     {
+        $session = Helper::currentSession();
+        if ($session->isVerified()) {
+            return response(null, 204);
+        }
+
         $key = strtr(get_string(\Request::input('verification_key')) ?? '', [' ' => '']);
         $user = Helper::currentUserOrFail();
-        $session = \Session::instance();
         $state = State::fromSession($session);
 
         try {

app/Libraries/SessionVerification/Helper.php

···
 
 class Helper
 {
+    public static function currentSession(): ?SessionVerificationInterface
+    {
+        return is_api_request() ? oauth_token() : \Session::instance();
+    }
+
     public static function currentUserOrFail(): User
     {
         $user = \Auth::user();
···
         return $user;
     }
 
-    public static function issue(SessionVerificationInterface $session, User $user): void
+    public static function issue(SessionVerificationInterface $session, User $user, bool $initial = false): void
     {
+        if ($initial) {
+            if (State::fromSession($session) === null) {
+                static::logAttempt('input', 'new');
+            } else {
+                return;
+            }
+        }
+
         if (!is_valid_email_format($user->user_email)) {
             return;
         }

app/Models/BeatmapPack.php

···
 
 namespace App\Models;
 
+use App\Libraries\Search\ScoreSearch;
+use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Traits\WithDbCursorHelper;
-use Exception;
+use Ds\Set;
 
 /**
  * @property string $author
···
         return 'tag';
     }
 
-    public function userCompletionData($user)
+    public function userCompletionData($user, ?bool $isLegacy)
     {
         if ($user !== null) {
             $userId = $user->getKey();
-            $beatmapsetIds = $this->items()->pluck('beatmapset_id')->all();
-            $query = Beatmap::select('beatmapset_id')->distinct()->whereIn('beatmapset_id', $beatmapsetIds);
-
-            if ($this->playmode === null) {
-                static $scoreRelations;
-
-                // generate list of beatmap->score relation names for each modes
-                // store int mode as well as it'll be used for filtering the scores
-                if (!isset($scoreRelations)) {
-                    $scoreRelations = [];
-                    foreach (Beatmap::MODES as $modeStr => $modeInt) {
-                        $scoreRelations[] = [
-                            'playmode' => $modeInt,
-                            'relation' => camel_case("scores_best_{$modeStr}"),
-                        ];
-                    }
-                }
-
-                // outer where function
-                // The idea is SELECT ... WHERE ... AND (<has osu scores> OR <has taiko scores> OR ...).
-                $query->where(function ($q) use ($scoreRelations, $userId) {
-                    foreach ($scoreRelations as $scoreRelation) {
-                        // The <has <mode> scores> mentioned above is generated here.
-                        // As it's "playmode = <mode> AND EXISTS (<<mode> score for user>)",
-                        // wrap them so it's not flat "playmode = <mode> AND EXISTS ... OR playmode = <mode> AND EXISTS ...".
-                        $q->orWhere(function ($qq) use ($scoreRelation, $userId) {
-                            $qq
-                                // this playmode filter ensures the scores are limited to non-convert maps
-                                ->where('playmode', '=', $scoreRelation['playmode'])
-                                ->whereHas($scoreRelation['relation'], function ($scoreQuery) use ($userId) {
-                                    $scoreQuery->where('user_id', '=', $userId);
-
-                                    if ($this->no_diff_reduction) {
-                                        $scoreQuery->withoutMods(app('mods')->difficultyReductionIds->toArray());
-                                    }
-                                });
-                        });
-                    }
-                });
-            } else {
-                $modeStr = Beatmap::modeStr($this->playmode);
-
-                if ($modeStr === null) {
-                    throw new Exception("beatmapset pack {$this->getKey()} has invalid playmode: {$this->playmode}");
-                }
-
-                $scoreRelation = camel_case("scores_best_{$modeStr}");
-
-                $query->whereHas($scoreRelation, function ($query) use ($userId) {
-                    $query->where('user_id', '=', $userId);
 
-                    if ($this->no_diff_reduction) {
-                        $query->withoutMods(app('mods')->difficultyReductionIds->toArray());
-                    }
-                });
+            $beatmaps = Beatmap
+                ::whereIn('beatmapset_id', $this->items()->select('beatmapset_id'))
+                ->select(['beatmap_id', 'beatmapset_id', 'playmode'])
+                ->get();
+            $beatmapsetIdsByBeatmapId = [];
+            foreach ($beatmaps as $beatmap) {
+                $beatmapsetIdsByBeatmapId[$beatmap->beatmap_id] = $beatmap->beatmapset_id;
+            }
+            $params = [
+                'beatmap_ids' => array_keys($beatmapsetIdsByBeatmapId),
+                'exclude_converts' => $this->playmode === null,
+                'is_legacy' => $isLegacy,
+                'limit' => 0,
+                'ruleset_id' => $this->playmode,
+                'user_id' => $userId,
+            ];
+            if ($this->no_diff_reduction) {
+                $params['exclude_mods'] = app('mods')->difficultyReductionIds->toArray();
             }
 
-            $completedBeatmapsetIds = $query->pluck('beatmapset_id')->all();
-            $completed = count($completedBeatmapsetIds) === count($beatmapsetIds);
+            static $aggName = 'by_beatmap';
+
+            $search = new ScoreSearch(ScoreSearchParams::fromArray($params));
+            $search->size(0);
+            $search->setAggregations([$aggName => [
+                'terms' => [
+                    'field' => 'beatmap_id',
+                    'size' => max(1, count($params['beatmap_ids'])),
+                ],
+                'aggs' => [
+                    'scores' => [
+                        'top_hits' => [
+                            'size' => 1,
+                        ],
+                    ],
+                ],
+            ]]);
+            $response = $search->response();
+            $search->assertNoError();
+            $completedBeatmapIds = array_map(
+                fn (array $hit): int => (int) $hit['key'],
+                $response->aggregations($aggName)['buckets'],
+            );
+            $completedBeatmapsetIds = (new Set(array_map(
+                fn (int $beatmapId): int => $beatmapsetIdsByBeatmapId[$beatmapId],
+                $completedBeatmapIds,
+            )))->toArray();
+            $completed = count($completedBeatmapsetIds) === count(array_unique($beatmapsetIdsByBeatmapId));
         }
 
         return [

app/Models/Build.php

···
         // no image
     }
 
+    public function platform(): string
+    {
+        $version = $this->version;
+        $suffixPos = strpos($version, '-');
+
+        return $suffixPos === false
+            ? ''
+            : substr($version, $suffixPos + 1);
+    }
+
     public function url()
     {
         return build_url($this);

app/Models/Multiplayer/PlaylistItemUserHighScore.php

···
     {
         $placeholder = new static([
             'score_id' => $scoreLink->getKey(),
-            'total_score' => $scoreLink->score->data->totalScore,
+            'total_score' => $scoreLink->score->total_score,
         ]);
 
         static $typeOptions = [
···
         $score = $scoreLink->score;
 
         $this->fill([
-            'accuracy' => $score->data->accuracy,
+            'accuracy' => $score->accuracy,
             'pp' => $score->pp,
             'score_id' => $scoreLink->getKey(),
-            'total_score' => $score->data->totalScore,
+            'total_score' => $score->total_score,
         ])->save();
     }
 }

app/Models/Multiplayer/ScoreLink.php

···
         $query = PlaylistItemUserHighScore
             ::where('playlist_item_id', $this->playlist_item_id)
             ->cursorSort('score_asc', [
-                'total_score' => $score->data->totalScore,
+                'total_score' => $score->total_score,
                 'score_id' => $this->getKey(),
             ]);
 

app/Models/Multiplayer/UserScoreAggregate.php

···
                 $scoreLink->playlist_item_id,
             );
 
-            if ($score->data->passed && $score->data->totalScore > $highestScore->total_score) {
+            if ($score->passed && $score->total_score > $highestScore->total_score) {
                 $this->updateUserTotal($scoreLink, $highestScore);
                 $highestScore->updateWithScoreLink($scoreLink);
             }
···
             $scoreLinks = ScoreLink
                 ::whereHas('playlistItem', fn ($q) => $q->where('room_id', $this->room_id))
                 ->where('user_id', $this->user_id)
-                ->with('score.performance')
+                ->with('score')
                 ->get();
             foreach ($scoreLinks as $scoreLink) {
                 $this->addScoreLink(
···
 
         $current = $currentScoreLink->score;
 
-        $this->total_score += $current->data->totalScore;
-        $this->accuracy += $current->data->accuracy;
+        $this->total_score += $current->total_score;
+        $this->accuracy += $current->accuracy;
         $this->pp += $current->pp;
         $this->completed++;
         $this->last_score_id = $currentScoreLink->getKey();

app/Models/OAuth/Token.php

···
 
 use App\Events\UserSessionEvent;
 use App\Exceptions\InvalidScopeException;
+use App\Interfaces\SessionVerificationInterface;
 use App\Models\Traits\FasterAttributes;
 use App\Models\User;
 use Ds\Set;
···
 use Laravel\Passport\RefreshToken;
 use Laravel\Passport\Token as PassportToken;
 
-class Token extends PassportToken
+class Token extends PassportToken implements SessionVerificationInterface
 {
     // PassportToken doesn't have factory
     use HasFactory, FasterAttributes;
 
+    protected $casts = [
+        'expires_at' => 'datetime',
+        'revoked' => 'boolean',
+        'scopes' => 'array',
+        'verified' => 'boolean',
+    ];
+
     private ?Set $scopeSet;
 
+    public static function findForVerification(string $id): ?static
+    {
+        return static::find($id);
+    }
+
     public function refreshToken()
     {
         return $this->hasOne(RefreshToken::class, 'access_token_id');
···
             'name',
             'user_id' => $this->getRawAttribute($key),
 
-            'revoked' => (bool) $this->getRawAttribute($key),
-            'scopes' => json_decode($this->getRawAttribute($key), true),
+            'revoked',
+            'verified' => $this->getNullableBool($key),
+
+            'scopes' => json_decode($this->getRawAttribute($key) ?? 'null', true),
 
             'created_at',
             'expires_at',
···
         };
     }
 
+    public function getKeyForEvent(): string
+    {
+        return "oauth:{$this->getKey()}";
+    }
+
     /**
      * Resource owner for the token.
      *
···
         return $clientUserId !== null && $clientUserId === $this->user_id;
     }
 
+    public function isVerified(): bool
+    {
+        return $this->verified;
+    }
+
+    public function markVerified(): void
+    {
+        $this->update(['verified' => true]);
+    }
+
     public function revokeRecursive()
     {
         $result = $this->revoke();
···
         $saved = parent::revoke();
 
         if ($saved && $this->user_id !== null) {
-            UserSessionEvent::newLogout($this->user_id, ["oauth:{$this->getKey()}"])->broadcast();
+            UserSessionEvent::newLogout($this->user_id, [$this->getKeyForEvent()])->broadcast();
         }
 
         return $saved;
···
         $this->attributes['scopes'] = $this->castAttributeAsJson('scopes', $value);
     }
 
+    public function userId(): ?int
+    {
+        return $this->user_id;
+    }
+
     public function validate(): void
     {
         static $scopesRequireDelegation = new Set(['chat.write', 'chat.write_manage', 'delegate']);
···
     {
         // Forces error if passport tries to issue an invalid client_credentials token.
         $this->validate();
+        if (!$this->exists) {
+            $this->setVerifiedState();
+        }
 
         return parent::save($options);
     }
···
     private function scopeSet(): Set
     {
         return $this->scopeSet ??= new Set($this->scopes ?? []);
+    }
+
+    private function setVerifiedState(): void
+    {
+        // client credential doesn't have user attached and auth code is
+        // already verified during grant process
+        $this->verified ??= $GLOBALS['cfg']['osu']['user']['bypass_verification']
+            || $this->user === null
+            || !$this->client->password_client;
     }
 }

app/Models/Score/Best/Model.php

···
             'date_json' => $this->getJsonTimeFast($key),
 
             'best' => $this,
-            'data' => $this->getData(),
             'enabled_mods' => $this->getEnabledModsAttribute($this->getRawAttribute('enabled_mods')),
             'pass' => true,
 
+            'best_id' => $this->getKey(),
+            'has_replay' => $this->replay,
+
             'beatmap',
             'replayViewCount',
             'reportedIn',
             'user' => $this->getRelationValue($key),
+
+            default => $this->getNewScoreAttribute($key),
         };
     }
 

app/Models/Score/Model.php

···
 
 namespace App\Models\Score;
 
+use App\Enums\Ruleset;
 use App\Exceptions\ClassNotFoundException;
 use App\Libraries\Mods;
 use App\Models\Beatmap;
···
 
             'date_json' => $this->getJsonTimeFast($key),
 
-            'data' => $this->getData(),
             'enabled_mods' => $this->getEnabledModsAttribute($this->getRawAttribute('enabled_mods')),
 
+            'best_id' => $this->getRawAttribute('high_score_id'),
+            'has_replay' => $this->best?->replay,
+            'pp' => $this->best?->pp,
+
             'beatmap',
             'best',
             'replayViewCount',
             'user' => $this->getRelationValue($key),
+
+            default => $this->getNewScoreAttribute($key),
+        };
+    }
+
+    public function getNewScoreAttribute(string $key)
+    {
+        return match ($key) {
+            'accuracy' => $this->accuracy(),
+            'build_id' => null,
+            'data' => $this->getData(),
+            'ended_at_json' => $this->date_json,
+            'legacy_perfect' => $this->perfect,
+            'legacy_score_id' => $this->getKey(),
+            'legacy_total_score' => $this->score,
+            'max_combo' => $this->maxcombo,
+            'passed' => $this->pass,
+            'ruleset_id' => Ruleset::tryFromName($this->getMode())->value,
+            'started_at_json' => null,
+            'total_score' => $this->score,
         };
     }
 
···
         return snake_case(get_class_basename(static::class));
     }
 
-    protected function getData()
+    public function getData(): ScoreData
     {
         $mods = array_map(fn ($m) => ['acronym' => $m, 'settings' => []], $this->enabled_mods);
+
         $statistics = [
             'miss' => $this->countmiss,
             'great' => $this->count300,
         ];
-        $ruleset = $this->getMode();
+        $ruleset = Ruleset::tryFromName($this->getMode());
         switch ($ruleset) {
-            case 'osu':
+            case Ruleset::osu:
                 $statistics['ok'] = $this->count100;
                 $statistics['meh'] = $this->count50;
                 break;
-            case 'taiko':
+            case Ruleset::taiko:
                 $statistics['ok'] = $this->count100;
                 break;
-            case 'fruits':
+            case Ruleset::catch:
                 $statistics['large_tick_hit'] = $this->count100;
                 $statistics['small_tick_hit'] = $this->count50;
                 $statistics['small_tick_miss'] = $this->countkatu;
                 break;
-            case 'mania':
+            case Ruleset::mania:
                 $statistics['perfect'] = $this->countgeki;
                 $statistics['good'] = $this->countkatu;
                 $statistics['ok'] = $this->count100;
···
                 break;
         }
 
-        return new ScoreData([
-            'accuracy' => $this->accuracy(),
-            'beatmap_id' => $this->beatmap_id,
-            'ended_at' => $this->date_json,
-            'max_combo' => $this->maxcombo,
-            'mods' => $mods,
-            'passed' => $this->pass,
-            'rank' => $this->rank,
-            'ruleset_id' => Beatmap::modeInt($ruleset),
-            'statistics' => $statistics,
-            'total_score' => $this->score,
-            'user_id' => $this->user_id,
-        ]);
+        return new ScoreData(compact('mods', 'statistics'));
     }
 }

app/Models/Solo/Score.php

···
 
 namespace App\Models\Solo;
 
+use App\Enums\ScoreRank;
+use App\Exceptions\InvariantException;
 use App\Libraries\Score\UserRank;
 use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Beatmap;
+use App\Models\Beatmapset;
 use App\Models\Model;
 use App\Models\Multiplayer\ScoreLink as MultiplayerScoreLink;
 use App\Models\Score as LegacyScore;
 use App\Models\ScoreToken;
 use App\Models\Traits;
 use App\Models\User;
-use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Builder;
 use LaravelRedis;
 use Storage;
 
 /**
+ * @property float $accuracy
  * @property int $beatmap_id
- * @property \Carbon\Carbon|null $created_at
- * @property string|null $created_at_json
+ * @property int $build_id
  * @property ScoreData $data
+ * @property \Carbon\Carbon|null $ended_at
+ * @property string|null $ended_at_json
  * @property bool $has_replay
  * @property int $id
+ * @property int $legacy_score_id
+ * @property int $legacy_total_score
+ * @property int $max_combo
+ * @property bool $passed
+ * @property float $pp
  * @property bool $preserve
+ * @property string $rank
  * @property bool $ranked
  * @property int $ruleset_id
+ * @property \Carbon\Carbon|null $started_at
+ * @property string|null $started_at_json
+ * @property int $total_score
  * @property int $unix_updated_at
  * @property User $user
  * @property int $user_id
···
 
     protected $casts = [
         'data' => ScoreData::class,
+        'ended_at' => 'datetime',
         'has_replay' => 'boolean',
+        'passed' => 'boolean',
         'preserve' => 'boolean',
+        'ranked' => 'boolean',
+        'started_at' => 'datetime',
     ];
 
-    public static function createFromJsonOrExplode(array $params)
+    public static function createFromJsonOrExplode(array $params): static
     {
-        $score = new static([
-            'beatmap_id' => $params['beatmap_id'],
-            'ruleset_id' => $params['ruleset_id'],
-            'user_id' => $params['user_id'],
-            'data' => $params,
-        ]);
+        $params['data'] = [
+            'maximum_statistics' => $params['maximum_statistics'] ?? [],
+            'mods' => $params['mods'] ?? [],
+            'statistics' => $params['statistics'] ?? [],
+        ];
+        unset(
+            $params['maximum_statistics'],
+            $params['mods'],
+            $params['statistics'],
+        );
+
+        $score = new static($params);
 
-        $score->data->assertCompleted();
+        $score->assertCompleted();
 
         // this should potentially just be validation rather than applying this logic here, but
         // older lazer builds potentially submit incorrect details here (and we still want to
         // accept their scores.
-        if (!$score->data->passed) {
-            $score->data->rank = 'F';
+        if (!$score->passed) {
+            $score->rank = 'F';
         }
 
         $score->saveOrExplode();
···
         return $score;
     }
 
-    public static function extractParams(array $params, ScoreToken|MultiplayerScoreLink $scoreToken): array
+    public static function extractParams(array $rawParams, ScoreToken|MultiplayerScoreLink $scoreToken): array
     {
-        return [
-            ...get_params($params, null, [
-                'accuracy:float',
-                'max_combo:int',
-                'maximum_statistics:array',
-                'passed:bool',
-                'rank:string',
-                'statistics:array',
-                'total_score:int',
-            ]),
-            'beatmap_id' => $scoreToken->beatmap_id,
-            'build_id' => $scoreToken->build_id,
-            'ended_at' => json_time(Carbon::now()),
-            'mods' => app('mods')->parseInputArray($scoreToken->ruleset_id, get_arr($params['mods'] ?? null) ?? []),
-            'ruleset_id' => $scoreToken->ruleset_id,
-            'started_at' => $scoreToken->created_at_json,
-            'user_id' => $scoreToken->user_id,
-        ];
-    }
+        $params = get_params($rawParams, null, [
+            'accuracy:float',
+            'max_combo:int',
+            'maximum_statistics:array',
+            'mods:array',
+            'passed:bool',
+            'rank:string',
+            'statistics:array',
+            'total_score:int',
+        ]);
 
-    /**
-     * Queue the item for score processing
-     *
-     * @param array $scoreJson JSON of the score generated using ScoreTransformer of type Solo
-     */
-    public static function queueForProcessing(array $scoreJson): void
-    {
-        LaravelRedis::lpush($GLOBALS['cfg']['osu']['scores']['processing_queue'], json_encode([
-            'Score' => [
-                'beatmap_id' => $scoreJson['beatmap_id'],
-                'id' => $scoreJson['id'],
-                'ruleset_id' => $scoreJson['ruleset_id'],
-                'user_id' => $scoreJson['user_id'],
-                // TODO: processor is currently order dependent and requires
-                // this to be located at the end
-                'data' => json_encode($scoreJson),
-            ],
-        ]));
+        $params['maximum_statistics'] ??= [];
+        $params['statistics'] ??= [];
+
+        $params['mods'] = app('mods')->parseInputArray($scoreToken->ruleset_id, $params['mods'] ?? []);
+
+        $params['beatmap_id'] = $scoreToken->beatmap_id;
+        $params['build_id'] = $scoreToken->build_id;
+        $params['ended_at'] = new \DateTime();
+        $params['ruleset_id'] = $scoreToken->ruleset_id;
+        $params['started_at'] = $scoreToken->created_at;
+        $params['user_id'] = $scoreToken->user_id;
+
+        $beatmap = $scoreToken->beatmap;
+        $params['ranked'] = $beatmap !== null && in_array($beatmap->approved, [
+            Beatmapset::STATES['approved'],
+            Beatmapset::STATES['ranked'],
+        ], true);
+
+        return $params;
     }
 
     public function beatmap()
     {
         return $this->belongsTo(Beatmap::class, 'beatmap_id');
-    }
-
-    public function performance()
-    {
-        return $this->hasOne(ScorePerformance::class, 'score_id');
     }
 
     public function user()
···
         return $query->whereHas('beatmap.beatmapset');
     }
 
+    public function scopeForRuleset(Builder $query, string $ruleset): Builder
+    {
+        return $query->where('ruleset_id', Beatmap::MODES[$ruleset]);
+    }
+
+    public function scopeIncludeFails(Builder $query, bool $includeFails): Builder
+    {
+        return $includeFails
+            ? $query
+            : $query->where('passed', true);
+    }
+
     /**
      * This should match the one used in osu-elastic-indexer.
      */
···
             ->whereHas('user', fn (Builder $q): Builder => $q->default());
     }
 
+    public function scopeRecent(Builder $query, string $ruleset, bool $includeFails): Builder
+    {
+        return $query
+            ->default()
+            ->forRuleset($ruleset)
+            ->includeFails($includeFails)
+            // 2 days (2 * 24 * 3600)
+            ->where('unix_updated_at', '>', time() - 172_800);
+    }
+
     public function getAttribute($key)
     {
         return match ($key) {
+            'accuracy',
             'beatmap_id',
+            'build_id',
             'id',
+            'legacy_score_id',
+            'legacy_total_score',
+            'max_combo',
+            'pp',
             'ruleset_id',
+            'total_score',
             'unix_updated_at',
             'user_id' => $this->getRawAttribute($key),
 
+            'rank' => $this->getRawAttribute($key) ?? 'F',
+
             'data' => $this->getClassCastableAttributeValue($key, $this->getRawAttribute($key)),
 
             'has_replay',
-            'preserve',
-            'ranked' => (bool) $this->getRawAttribute($key),
+            'passed',
+            'preserve' => (bool) $this->getRawAttribute($key),
 
-            'created_at' => $this->getTimeFast($key),
-            'created_at_json' => $this->getJsonTimeFast($key),
+            'ranked' => (bool) ($this->getRawAttribute($key) ?? true),
 
-            'pp' => $this->performance?->pp,
+            'ended_at',
+            'started_at' => $this->getTimeFast($key),
+
+            'ended_at_json',
+            'started_at_json' => $this->getJsonTimeFast($key),
+
+            'best_id' => null,
+            'legacy_perfect' => null,
 
             'beatmap',
             'performance',
···
         };
     }
 
-    public function createLegacyEntryOrExplode()
+    public function assertCompleted(): void
     {
-        $score = $this->makeLegacyEntry();
+        if (ScoreRank::tryFrom($this->rank ?? '') === null) {
+            throw new InvariantException("'{$this->rank}' is not a valid rank.");
+        }
 
-        $score->saveOrExplode();
+        foreach (['total_score', 'accuracy', 'max_combo', 'passed'] as $field) {
+            if (!present($this->$field)) {
+                throw new InvariantException("field missing: '{$field}'");
+            }
+        }
 
-        return $score;
+        if ($this->data->statistics->isEmpty()) {
+            throw new InvariantException("field cannot be empty: 'statistics'");
+        }
     }
 
     public function getMode(): string
···
 
     public function isLegacy(): bool
     {
-        return $this->data->buildId === null;
+        return $this->legacy_score_id !== null;
     }
 
     public function legacyScore(): ?LegacyScore\Best\Model
     {
-        $id = $this->data->legacyScoreId;
+        $id = $this->legacy_score_id;
 
         return $id === null
             ? null
···
             'beatmapset_id' => $this->beatmap?->beatmapset_id ?? 0,
             'countmiss' => $statistics->miss,
             'enabled_mods' => app('mods')->idsToBitset(array_column($data->mods, 'acronym')),
-            'maxcombo' => $data->maxCombo,
-            'pass' => $data->passed,
-            'perfect' => $data->passed && $statistics->miss + $statistics->large_tick_miss === 0,
-            'rank' => $data->rank,
-            'score' => $data->totalScore,
+            'maxcombo' => $this->max_combo,
+            'pass' => $this->passed,
+            'perfect' => $this->passed && $statistics->miss + $statistics->large_tick_miss === 0,
+            'rank' => $this->rank,
+            'score' => $this->total_score,
             'scorechecksum' => "\0",
             'user_id' => $this->user_id,
         ]);
···
         return $score;
     }
 
+    public function queueForProcessing(): void
+    {
+        LaravelRedis::lpush($GLOBALS['cfg']['osu']['scores']['processing_queue'], json_encode([
+            'Score' => $this->getAttributes(),
+        ]));
+    }
+
     public function trashed(): bool
     {
         return false;
···
 
     public function userRank(?array $params = null): int
     {
-        return UserRank::getRank(ScoreSearchParams::fromArray(array_merge($params ?? [], [
+        // Non-legacy score always has its rank checked against all score types.
+        if (!$this->isLegacy()) {
+            $params['is_legacy'] = null;
+        }
+
+        return UserRank::getRank(ScoreSearchParams::fromArray([
+            ...($params ?? []),
             'beatmap_ids' => [$this->beatmap_id],
             'before_score' => $this,
-            'is_legacy' => $this->isLegacy(),
             'ruleset_id' => $this->ruleset_id,
             'user' => $this->user,
-        ])));
+        ]));
     }
 
     protected function newReportableExtraParams(): array

app/Models/Solo/ScoreData.php

···
 
 namespace App\Models\Solo;
 
-use App\Enums\ScoreRank;
-use App\Exceptions\InvariantException;
 use Illuminate\Contracts\Database\Eloquent\Castable;
 use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
 use JsonSerializable;
 
 class ScoreData implements Castable, JsonSerializable
 {
-    public float $accuracy;
-    public int $beatmapId;
-    public ?int $buildId;
-    public string $endedAt;
-    public ?int $legacyScoreId;
-    public ?int $legacyTotalScore;
-    public int $maxCombo;
     public ScoreDataStatistics $maximumStatistics;
     public array $mods;
-    public bool $passed;
-    public string $rank;
-    public int $rulesetId;
-    public ?string $startedAt;
     public ScoreDataStatistics $statistics;
-    public int $totalScore;
-    public int $userId;
 
     public function __construct(array $data)
     {
···
             }
         }
 
-        $this->accuracy = $data['accuracy'] ?? 0;
-        $this->beatmapId = $data['beatmap_id'];
-        $this->buildId = $data['build_id'] ?? null;
-        $this->endedAt = $data['ended_at'];
-        $this->legacyScoreId = $data['legacy_score_id'] ?? null;
-        $this->legacyTotalScore = $data['legacy_total_score'] ?? null;
-        $this->maxCombo = $data['max_combo'] ?? 0;
         $this->maximumStatistics = new ScoreDataStatistics($data['maximum_statistics'] ?? []);
         $this->mods = $mods;
-        $this->passed = $data['passed'] ?? false;
-        $this->rank = $data['rank'] ?? 'F';
-        $this->rulesetId = $data['ruleset_id'];
-        $this->startedAt = $data['started_at'] ?? null;
         $this->statistics = new ScoreDataStatistics($data['statistics'] ?? []);
-        $this->totalScore = $data['total_score'] ?? 0;
-        $this->userId = $data['user_id'];
     }
 
     public static function castUsing(array $arguments)
···
         {
             public function get($model, $key, $value, $attributes)
             {
-                $dataJson = json_decode($value, true);
-                $dataJson['beatmap_id'] ??= $attributes['beatmap_id'];
-                $dataJson['ended_at'] ??= $model->created_at_json;
-                $dataJson['ruleset_id'] ??= $attributes['ruleset_id'];
-                $dataJson['user_id'] ??= $attributes['user_id'];
-
-                return new ScoreData($dataJson);
+                return new ScoreData(json_decode($value, true));
             }
 
             public function set($model, $key, $value, $attributes)
             {
                 if (!($value instanceof ScoreData)) {
-                    $value = new ScoreData([
-                        'beatmap_id' => $attributes['beatmap_id'] ?? null,
-                        'ended_at' => $attributes['created_at'] ?? null,
-                        'ruleset_id' => $attributes['ruleset_id'] ?? null,
-                        'user_id' => $attributes['user_id'] ?? null,
-                        ...$value,
-                    ]);
+                    $value = new ScoreData($value);
                 }
 
                 return ['data' => json_encode($value)];
···
         };
     }
 
-    public function assertCompleted(): void
-    {
-        if (ScoreRank::tryFrom($this->rank) === null) {
-            throw new InvariantException("'{$this->rank}' is not a valid rank.");
-        }
-
-        foreach (['totalScore', 'accuracy', 'maxCombo', 'passed'] as $field) {
-            if (!present($this->$field)) {
-                throw new InvariantException("field missing: '{$field}'");
-            }
-        }
-
-        if ($this->statistics->isEmpty()) {
-            throw new InvariantException("field cannot be empty: 'statistics'");
-        }
-    }
-
     public function jsonSerialize(): array
     {
-        $ret = [
-            'accuracy' => $this->accuracy,
-            'beatmap_id' => $this->beatmapId,
-            'build_id' => $this->buildId,
-            'ended_at' => $this->endedAt,
-            'legacy_score_id' => $this->legacyScoreId,
-            'legacy_total_score' => $this->legacyTotalScore,
-            'max_combo' => $this->maxCombo,
+        return [
             'maximum_statistics' => $this->maximumStatistics,
             'mods' => $this->mods,
-            'passed' => $this->passed,
-            'rank' => $this->rank,
-            'ruleset_id' => $this->rulesetId,
-            'started_at' => $this->startedAt,
             'statistics' => $this->statistics,
-            'total_score' => $this->totalScore,
-            'user_id' => $this->userId,
         ];
-
-        foreach ($ret as $field => $value) {
-            if ($value === null) {
-                unset($ret[$field]);
-            }
-        }
-
-        return $ret;
     }
 }

app/Models/Solo/ScorePerformance.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\Solo;
-
-use App\Models\Model;
-
-/**
- * @property int $score_id
- * @property float|null $pp
- */
-class ScorePerformance extends Model
-{
-    public $incrementing = false;
-    public $timestamps = false;
-
-    protected $primaryKey = 'score_id';
-    protected $table = 'score_performance';
-}

app/Models/Traits/FasterAttributes.php

···
         return $this->attributes[$key] ?? null;
     }
 
+    protected function getNullableBool(string $key)
+    {
+        $raw = $this->getRawAttribute($key);
+
+        return $raw === null ? null : (bool) $raw;
+    }
+
     /**
      * Fast Time Attribute to Json Transformer
      *

app/Models/Traits/UserScoreable.php

···
 
 namespace App\Models\Traits;
 
-use App\Libraries\Elasticsearch\BoolQuery;
-use App\Libraries\Elasticsearch\SearchResponse;
-use App\Libraries\Search\BasicSearch;
-use App\Models\Score\Best;
+use App\Libraries\Score\FetchDedupedScores;
+use App\Libraries\Search\ScoreSearchParams;
+use App\Models\Beatmap;
+use App\Models\Solo\Score;
+use Illuminate\Database\Eloquent\Collection;
 
 trait UserScoreable
 {
-    private $beatmapBestScoreIds = [];
+    private array $beatmapBestScoreIds = [];
+    private array $beatmapBestScores = [];
 
-    public function aggregatedScoresBest(string $mode, int $size): SearchResponse
+    public function aggregatedScoresBest(string $mode, null | true $legacyOnly, int $size): array
     {
-        $index = $GLOBALS['cfg']['osu']['elasticsearch']['prefix']."high_scores_{$mode}";
-
-        $search = new BasicSearch($index, "aggregatedScoresBest_{$mode}");
-        $search->connectionName = 'scores';
-        $search
-            ->size(0) // don't care about hits
-            ->query(
-                (new BoolQuery())
-                    ->filter(['term' => ['user_id' => $this->getKey()]])
-            )
-            ->setAggregations([
-                'by_beatmaps' => [
-                    'terms' => [
-                        'field' => 'beatmap_id',
-                        // sort by sub-aggregation max_pp, with score_id as tie breaker
-                        'order' => [['max_pp' => 'desc'], ['min_score_id' => 'asc']],
-                        'size' => $size,
-                    ],
-                    'aggs' => [
-                        'top_scores' => [
-                            'top_hits' => [
-                                'size' => 1,
-                                'sort' => [['pp' => ['order' => 'desc']]],
-                            ],
-                        ],
-                        // top_hits aggregation is not useable for sorting, so we need an extra aggregation to sort on.
-                        'max_pp' => ['max' => ['field' => 'pp']],
-                        'min_score_id' => ['min' => ['field' => 'score_id']],
-                    ],
-                ],
-            ]);
-
-        $response = $search->response();
-        $search->assertNoError();
-
-        return $response;
+        return (new FetchDedupedScores('beatmap_id', ScoreSearchParams::fromArray([
+            'is_legacy' => $legacyOnly,
+            'limit' => $size,
+            'ruleset_id' => Beatmap::MODES[$mode],
+            'sort' => 'pp_desc',
+            'user_id' => $this->getKey(),
+        ]), "aggregatedScoresBest_{$mode}"))->all();
     }
 
-    public function beatmapBestScoreIds(string $mode)
+    public function beatmapBestScoreIds(string $mode, null | true $legacyOnly)
     {
-        if (!isset($this->beatmapBestScoreIds[$mode])) {
+        $key = $mode.'-'.($legacyOnly ? '1' : '0');
+
+        if (!isset($this->beatmapBestScoreIds[$key])) {
             // aggregations do not support regular pagination.
             // always fetching 100 to cache; we're not supporting beyond 100, either.
-            $this->beatmapBestScoreIds[$mode] = cache_remember_mutexed(
-                "search-cache:beatmapBestScores:{$this->getKey()}:{$mode}",
+            $this->beatmapBestScoreIds[$key] = cache_remember_mutexed(
+                "search-cache:beatmapBestScoresSolo:{$this->getKey()}:{$key}",
                 $GLOBALS['cfg']['osu']['scores']['es_cache_duration'],
                 [],
-                function () use ($mode) {
-                    // FIXME: should return some sort of error on error
-                    $buckets = $this->aggregatedScoresBest($mode, 100)->aggregations('by_beatmaps')['buckets'] ?? [];
+                function () use ($key, $legacyOnly, $mode) {
+                    $this->beatmapBestScores[$key] = $this->aggregatedScoresBest($mode, $legacyOnly, 100);
 
-                    return array_map(function ($bucket) {
-                        return array_get($bucket, 'top_scores.hits.hits.0._id');
-                    }, $buckets);
+                    return array_column($this->beatmapBestScores[$key], 'id');
                 },
                 function () {
                     // TODO: propagate a more useful message back to the client
···
             );
         }
 
-        return $this->beatmapBestScoreIds[$mode];
+        return $this->beatmapBestScoreIds[$key];
     }
 
-    public function beatmapBestScores(string $mode, int $limit, int $offset = 0, $with = [])
+    public function beatmapBestScores(string $mode, int $limit, int $offset, array $with, null | true $legacyOnly): Collection
     {
-        $ids = array_slice($this->beatmapBestScoreIds($mode), $offset, $limit);
-        $clazz = Best\Model::getClass($mode);
+        $ids = $this->beatmapBestScoreIds($mode, $legacyOnly);
+        $key = $mode.'-'.($legacyOnly ? '1' : '0');
+
+        if (isset($this->beatmapBestScores[$key])) {
+            $results = new Collection(array_slice($this->beatmapBestScores[$key], $offset, $limit));
+        } else {
+            $ids = array_slice($ids, $offset, $limit);
+            $results = Score::whereKey($ids)->orderByField('id', $ids)->default()->get();
+        }
 
-        $results = $clazz::whereIn('score_id', $ids)->orderByField('score_id', $ids)->with($with)->get();
+        $results->load($with);
 
         // fill in positions for weighting
         // also preload the user relation

app/Models/User.php

···
             'scoresMania',
             'scoresOsu',
             'scoresTaiko',
+            'soloScores',
             'statisticsFruits',
             'statisticsMania',
             'statisticsMania4k',
···
         $relation = 'scoresBest'.studly_case($mode);
 
         return $returnQuery ? $this->$relation() : $this->$relation;
+    }
+
+    public function soloScores(): HasMany
+    {
+        return $this->hasMany(Solo\Score::class);
     }
 
     public function topicWatches()

app/Providers/PassportServiceProvider.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);
+
+namespace App\Providers;
+
+use App\Libraries\OAuth\RefreshTokenGrant;
+use Laravel\Passport\Bridge\RefreshTokenRepository;
+use Laravel\Passport\Passport;
+use Laravel\Passport\PassportServiceProvider as BasePassportServiceProvider;
+
+class PassportServiceProvider extends BasePassportServiceProvider
+{
+    /**
+     * Overrides RefreshTokenGrant to copy verified attribute of the token
+     */
+    protected function makeRefreshTokenGrant()
+    {
+        $repository = $this->app->make(RefreshTokenRepository::class);
+
+        $grant = new RefreshTokenGrant($repository);
+        $grant->setRefreshTokenTTL(Passport::refreshTokensExpireIn());
+
+        return $grant;
+    }
+}

app/Transformers/ScoreTransformer.php

···
 
 namespace App\Transformers;
 
+use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Beatmap;
 use App\Models\DeletedUser;
 use App\Models\LegacyMatch;
···
     const MULTIPLAYER_BASE_INCLUDES = ['user.country', 'user.cover'];
     // warning: the preload is actually for PlaylistItemUserHighScore, not for Score
     const MULTIPLAYER_BASE_PRELOAD = [
-        'scoreLink.score.performance',
+        'scoreLink.score',
         'scoreLink.user.country',
         'scoreLink.user.userProfileCustomization',
     ];
···
 
     public function transformSolo(MultiplayerScoreLink|ScoreModel|SoloScore $score)
     {
-        if ($score instanceof ScoreModel) {
-            $legacyPerfect = $score->perfect;
-            $best = $score->best;
+        $extraAttributes = [];
 
-            if ($best !== null) {
-                $bestId = $best->getKey();
-                $pp = $best->pp;
-                $hasReplay = $best->replay;
-            }
-        } else {
-            if ($score instanceof MultiplayerScoreLink) {
-                $multiplayerAttributes = [
-                    'playlist_item_id' => $score->playlist_item_id,
-                    'room_id' => $score->playlistItem->room_id,
-                    'solo_score_id' => $score->score_id,
-                ];
-                $score = $score->score;
-            }
+        if ($score instanceof MultiplayerScoreLink) {
+            $extraAttributes['playlist_item_id'] = $score->playlist_item_id;
+            $extraAttributes['room_id'] = $score->playlistItem->room_id;
+            $extraAttributes['solo_score_id'] = $score->score_id;
+            $score = $score->score;
+        }
 
-            $pp = $score->pp;
-            $hasReplay = $score->has_replay;
+        if ($score instanceof SoloScore) {
+            $extraAttributes['ranked'] = $score->ranked;
         }
 
-        $hasReplay ??= false;
+        $hasReplay = $score->has_replay;
 
         return [
+            ...$extraAttributes,
             ...$score->data->jsonSerialize(),
-            ...($multiplayerAttributes ?? []),
-            'best_id' => $bestId ?? null,
+            'beatmap_id' => $score->beatmap_id,
+            'best_id' => $score->best_id,
+            'id' => $score->getKey(),
+            'rank' => $score->rank,
+            'type' => $score->getMorphClass(),
+            'user_id' => $score->user_id,
+            'accuracy' => $score->accuracy,
+            'build_id' => $score->build_id,
+            'ended_at' => $score->ended_at_json,
             'has_replay' => $hasReplay,
-            'id' => $score->getKey(),
-            'legacy_perfect' => $legacyPerfect ?? null,
-            'pp' => $pp ?? null,
+            'legacy_perfect' => $score->legacy_perfect,
+            'legacy_score_id' => $score->legacy_score_id,
+            'legacy_total_score' => $score->legacy_total_score,
+            'max_combo' => $score->max_combo,
+            'passed' => $score->passed,
+            'pp' => $score->pp,
+            'ruleset_id' => $score->ruleset_id,
+            'started_at' => $score->started_at_json,
+            'total_score' => $score->total_score,
             // TODO: remove this redundant field sometime after 2024-02
             'replay' => $hasReplay,
-            'type' => $score->getMorphClass(),
         ];
+
+        return $ret;
     }
 
     public function transformLegacy(LegacyMatch\Score|ScoreModel|SoloScore $score)
···
             $soloScore = $score;
             $score = $soloScore->makeLegacyEntry();
             $score->score_id = $soloScore->getKey();
-            $createdAt = $soloScore->created_at_json;
+            $createdAt = $soloScore->ended_at_json;
             $type = $soloScore->getMorphClass();
             $pp = $soloScore->pp;
         } else {
···
 
     public function includeRankCountry(ScoreBest|SoloScore $score)
     {
-        return $this->primitive($score->userRank(['type' => 'country']));
+        return $this->primitive($score->userRank([
+            'type' => 'country',
+            'is_legacy' => ScoreSearchParams::showLegacyForUser(\Auth::user()),
+        ]));
     }
 
     public function includeRankGlobal(ScoreBest|SoloScore $score)
     {
-        return $this->primitive($score->userRank([]));
+        return $this->primitive($score->userRank([
+            'is_legacy' => ScoreSearchParams::showLegacyForUser(\Auth::user()),
+        ]));
     }
 
     public function includeUser(LegacyMatch\Score|MultiplayerScoreLink|ScoreModel|SoloScore $score)

app/Transformers/UserCompactTransformer.php

···
 namespace App\Transformers;
 
 use App\Libraries\MorphMap;
+use App\Libraries\Search\ScoreSearchParams;
 use App\Models\Beatmap;
 use App\Models\User;
 use App\Models\UserProfileCustomization;
···
         'scores_first_count',
         'scores_pinned_count',
         'scores_recent_count',
+        'session_verified',
         'statistics',
         'statistics_rulesets',
         'support_level',
···
 
     public function includeScoresBestCount(User $user)
     {
-        return $this->primitive(count($user->beatmapBestScoreIds($this->mode)));
+        return $this->primitive(count($user->beatmapBestScoreIds(
+            $this->mode,
+            ScoreSearchParams::showLegacyForUser(\Auth::user()),
+        )));
     }
 
     public function includeScoresFirstCount(User $user)
···
 
     public function includeScoresRecentCount(User $user)
     {
-        return $this->primitive($user->scores($this->mode, true)->includeFails(false)->count());
+        return $this->primitive($user->soloScores()->recent($this->mode, false)->count());
+    }
+
+    public function includeSessionVerified(User $user)
+    {
+        return $this->primitive($user->token()?->isVerified() ?? false);
     }
 
     public function includeStatistics(User $user)

app/helpers.php

···
 
 function oauth_token(): ?App\Models\OAuth\Token
 {
-    return request()->attributes->get(App\Http\Middleware\AuthApi::REQUEST_OAUTH_TOKEN_KEY);
+    return Request::instance()->attributes->get(App\Http\Middleware\AuthApi::REQUEST_OAUTH_TOKEN_KEY);
 }
 
 function osu_trans($key = null, $replace = [], $locale = null)

config/app.php

···
         App\Providers\EventServiceProvider::class,
         // Override default migrate:fresh
         App\Providers\MigrationServiceProvider::class,
+        App\Providers\PassportServiceProvider::class,
         App\Providers\RouteServiceProvider::class,
         // Override the session id naming (for redis key namespacing)
         App\Providers\SessionServiceProvider::class,

config/octane.php

···
         'composer.lock*',
         'config',
         'database',
-        'public/**/*.php',
         'public/assets/manifest.json*',
-        'resources/**/*.php',
+        'resources/lang',
+        'resources/views',
         'routes',
     ],
 

config/osu.php

···
     $profileScoresNotice = markdown_plain($profileScoresNotice);
 }
 
+$clientTokenKeys = [];
+foreach (explode(',', env('CLIENT_TOKEN_KEYS') ?? '') as $entry) {
+    if ($entry !== '') {
+        [$platform, $encodedKey] = explode('=', $entry, 2);
+        $clientTokenKeys[$platform] = hex2bin($encodedKey);
+    }
+}
+
 // osu config~
 return [
     'achievement' => [
···
     'client' => [
         'check_version' => get_bool(env('CLIENT_CHECK_VERSION')) ?? true,
         'default_build_id' => get_int(env('DEFAULT_BUILD_ID')) ?? 0,
+        'token_keys' => $clientTokenKeys,
+        'token_queue' => env('CLIENT_TOKEN_QUEUE') ?? 'token-queue',
         'user_agent' => env('CLIENT_USER_AGENT', 'osu!'),
     ],
     'elasticsearch' => [
···
         'experimental_rank_as_default' => get_bool(env('SCORES_EXPERIMENTAL_RANK_AS_DEFAULT')) ?? false,
         'experimental_rank_as_extra' => get_bool(env('SCORES_EXPERIMENTAL_RANK_AS_EXTRA')) ?? false,
         'processing_queue' => presence(env('SCORES_PROCESSING_QUEUE')) ?? 'osu-queue:score-statistics',
+        'submission_enabled' => get_bool(env('SCORES_SUBMISSION_ENABLED')) ?? true,
+
         'rank_cache' => [
             'local_server' => get_bool(env('SCORES_RANK_CACHE_LOCAL_SERVER')) ?? false,
             'min_users' => get_int(env('SCORES_RANK_CACHE_MIN_USERS')) ?? 35000,
···
             'key_length' => 8,
             'tries' => 8,
         ],
-        'registration_mode' => presence(env('REGISTRATION_MODE')) ?? 'client',
         'super_friendly' => array_map('intval', explode(' ', env('SUPER_FRIENDLY', '3'))),
         'ban_persist_days' => get_int(env('BAN_PERSIST_DAYS')) ?? 28,
 
         'country_change' => [
             'max_mixed_months' => get_int(env('USER_COUNTRY_CHANGE_MAX_MIXED_MONTHS')) ?? 2,
             'min_months' => get_int(env('USER_COUNTRY_CHANGE_MIN_MONTHS')) ?? 6,
+        ],
+
+        'registration_mode' => [
+            'client' => get_bool(env('REGISTRATION_MODE_CLIENT')) ?? true,
+            'web' => get_bool(env('REGISTRATION_MODE_WEB')) ?? false,
         ],
     ],
     'user_report_notification' => [

database/factories/BuildFactory.php

···
     {
         return [
             'date' => fn () => $this->faker->dateTimeBetween('-5 years'),
-            'hash' => fn () => md5($this->faker->word(), true),
+            'hash' => fn () => md5(rand(), true),
             'stream_id' => fn () => array_rand_val($GLOBALS['cfg']['osu']['changelog']['update_streams']),
             'users' => rand(100, 10000),
 

database/factories/OAuth/TokenFactory.php

···
             'expires_at' => fn () => now()->addDays(),
             'id' => str_random(40),
             'revoked' => false,
-            'scopes' => ['public'],
+            'scopes' => ['identify', 'public'],
             'user_id' => User::factory(),
+            'verified' => true,
         ];
     }
 }

database/factories/Solo/ScoreFactory.php

···
 
 namespace Database\Factories\Solo;
 
+use App\Enums\ScoreRank;
 use App\Models\Beatmap;
 use App\Models\Solo\Score;
 use App\Models\User;
···
     public function definition(): array
     {
         return [
+            'accuracy' => fn (): float => $this->faker->randomFloat(1, 0, 1),
             'beatmap_id' => Beatmap::factory()->ranked(),
+            'ended_at' => new \DateTime(),
+            'pp' => fn (): float => $this->faker->randomFloat(4, 0, 1000),
+            'rank' => fn () => array_rand_val(ScoreRank::cases())->value,
+            'total_score' => fn (): int => $this->faker->randomNumber(7),
             'user_id' => User::factory(),
 
             // depends on beatmap_id
···
 
             // depends on all other attributes
             'data' => fn (array $attr): array => $this->makeData()($attr),
+
+            'legacy_total_score' => fn (array $attr): int => isset($attr['legacy_score_id']) ? $attr['total_score'] : 0,
         ];
     }
 
···
     {
         return fn (array $attr): array => array_map(
             fn ($value) => is_callable($value) ? $value($attr) : $value,
-            array_merge([
-                'accuracy' => fn (): float => $this->faker->randomFloat(1, 0, 1),
-                'beatmap_id' => $attr['beatmap_id'],
-                'ended_at' => fn (): string => json_time(now()),
-                'max_combo' => fn (): int => rand(1, Beatmap::find($attr['beatmap_id'])->countNormal),
+            [
+                'statistics' => ['great' => 1],
                 'mods' => [],
-                'passed' => true,
-                'rank' => fn (): string => array_rand_val(['A', 'S', 'B', 'SH', 'XH', 'X']),
-                'ruleset_id' => $attr['ruleset_id'],
-                'started_at' => fn (): string => json_time(now()->subSeconds(600)),
-                'total_score' => fn (): int => $this->faker->randomNumber(7),
-                'user_id' => $attr['user_id'],
-            ], $overrides ?? []),
+                ...($overrides ?? []),
+            ],
         );
     }
 }

database/migrations/2023_12_18_104437_add_verified_column_to_oauth_access_tokens.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('oauth_access_tokens', function (Blueprint $table) {
+            $table->boolean('verified')->default(true);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('oauth_access_tokens', function (Blueprint $table) {
+            $table->dropColumn('verified');
+        });
+    }
+};

database/migrations/2024_01_12_115738_update_scores_table_final.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\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    private static function resetView(): void
+    {
+        DB::statement('DROP VIEW scores');
+        DB::statement('CREATE VIEW scores AS SELECT * FROM solo_scores');
+    }
+
+    public function up(): void
+    {
+        Schema::drop('solo_scores');
+        DB::statement("CREATE TABLE `solo_scores` (
+            `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+            `user_id` int unsigned NOT NULL,
+            `ruleset_id` smallint unsigned NOT NULL,
+            `beatmap_id` mediumint unsigned NOT NULL,
+            `has_replay` tinyint NOT NULL DEFAULT '0',
+            `preserve` tinyint NOT NULL DEFAULT '0',
+            `ranked` tinyint NOT NULL DEFAULT '1',
+            `rank` char(2) NOT NULL DEFAULT '',
+            `passed` tinyint NOT NULL DEFAULT '0',
+            `accuracy` float NOT NULL DEFAULT '0',
+            `max_combo` int unsigned NOT NULL DEFAULT '0',
+            `total_score` int unsigned NOT NULL DEFAULT '0',
+            `data` json NOT NULL,
+            `pp` float DEFAULT NULL,
+            `legacy_score_id` bigint unsigned DEFAULT NULL,
+            `legacy_total_score` int unsigned NOT NULL DEFAULT '0',
+            `started_at` timestamp NULL DEFAULT NULL,
+            `ended_at` timestamp NOT NULL,
+            `unix_updated_at` int unsigned NOT NULL DEFAULT (unix_timestamp()),
+            `build_id` smallint unsigned DEFAULT NULL,
+            PRIMARY KEY (`id`,`preserve`,`unix_updated_at`),
+            KEY `user_ruleset_index` (`user_id`,`ruleset_id`),
+            KEY `beatmap_user_index` (`beatmap_id`,`user_id`),
+            KEY `legacy_score_lookup` (`ruleset_id`,`legacy_score_id`)
+        )");
+
+        DB::statement('DROP VIEW score_legacy_id_map');
+        Schema::drop('solo_scores_legacy_id_map');
+
+        DB::statement('DROP VIEW score_performance');
+        Schema::drop('solo_scores_performance');
+
+        static::resetView();
+    }
+
+    public function down(): void
+    {
+        Schema::drop('solo_scores');
+        DB::statement("CREATE TABLE `solo_scores` (
+            `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+            `user_id` int unsigned NOT NULL,
+            `beatmap_id` mediumint unsigned NOT NULL,
+            `ruleset_id` smallint unsigned NOT NULL,
+            `data` json NOT NULL,
+            `has_replay` tinyint DEFAULT '0',
+            `preserve` tinyint NOT NULL DEFAULT '0',
+            `ranked` tinyint NOT NULL DEFAULT '1',
+            `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            `unix_updated_at` int unsigned NOT NULL DEFAULT (unix_timestamp()),
+            PRIMARY KEY (`id`,`preserve`,`unix_updated_at`),
+            KEY `user_ruleset_index` (`user_id`,`ruleset_id`),
+            KEY `beatmap_user_index` (`beatmap_id`,`user_id`)
+        )");
+
+        DB::statement('CREATE TABLE `solo_scores_legacy_id_map` (
+            `ruleset_id` smallint unsigned NOT NULL,
+            `old_score_id` bigint unsigned NOT NULL,
+            `score_id` bigint unsigned NOT NULL,
+            PRIMARY KEY (`ruleset_id`,`old_score_id`)
+        )');
+        DB::statement('CREATE VIEW score_legacy_id_map AS SELECT * FROM solo_scores_legacy_id_map');
+
+        DB::statement('CREATE TABLE `solo_scores_performance` (
+            `score_id` bigint unsigned NOT NULL,
+            `pp` float DEFAULT NULL,
+            PRIMARY KEY (`score_id`)
+        )');
+        DB::statement('CREATE VIEW score_performance AS SELECT * FROM solo_scores_performance');
+
+        static::resetView();
+    }
+};

docker-compose.yml

···
       - "${NGINX_PORT:-8080}:80"
 
   score-indexer:
-    image: pppy/osu-elastic-indexer:99cd549c5c5c959ff6b2728b76af603dda4c85cb
+    image: pppy/osu-elastic-indexer:master
     command: ["queue", "watch"]
     depends_on:
       redis:
···
       SCHEMA: "${SCHEMA:-1}"
 
   score-indexer-test:
-    image: pppy/osu-elastic-indexer:99cd549c5c5c959ff6b2728b76af603dda4c85cb
+    image: pppy/osu-elastic-indexer:master
     command: ["queue", "watch"]
     depends_on:
       redis:

phpunit.xml

···
         <env name="CHAT_PRIVATE_LIMIT" value="2"/>
 
         <env name="ADMIN_FORUM_ID" value="0"/>
+        <env name="CLIENT_CHECK_VERSION" value="0"/>
         <env name="DOUBLE_POST_ALLOWED_FORUM_IDS" value="0"/>
         <env name="FEATURE_FORUM_ID" value="0"/>
         <env name="HELP_FORUM_ID" value="0"/>

public/images/layout/osu-lazer-logo-triangles.svg

···
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="1000"
+   height="1000"
+   viewBox="0 0 1000 1000"
+   fill="none"
+   version="1.1"
+   id="svg204"
+   sodipodi:docname="osu-lazer-logo-full.svg"
+   inkscape:version="1.2.2 (732a01da63, 2022-12-09)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview206"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="0.837"
+     inkscape:cx="473.71565"
+     inkscape:cy="499.40263"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg204" />
+  <circle
+     cx="500"
+     cy="500"
+     r="450"
+     fill="#FF66AB"
+     id="circle105" />
+  <circle
+     cx="500"
+     cy="500"
+     r="450"
+     fill="url(#paint0_linear_34_23)"
+     fill-opacity="0.2"
+     id="circle107" />
+  <mask
+     id="mask0_34_23"
+     style="mask-type:alpha"
+     maskUnits="userSpaceOnUse"
+     x="50"
+     y="50"
+     width="900"
+     height="900">
+    <circle
+       cx="500"
+       cy="500"
+       r="450"
+       fill="#FF66AB"
+       id="circle109" />
+    <circle
+       cx="500"
+       cy="500"
+       r="450"
+       fill="url(#paint1_linear_34_23)"
+       fill-opacity="0.2"
+       id="circle111" />
+  </mask>
+  <g
+     mask="url(#mask0_34_23)"
+     id="g116">
+    <path
+       fill-rule="evenodd"
+       clip-rule="evenodd"
+       d="M394.438 139.1L273.829 348.001L220.638 255.872L37.1974 573.6H121.472L-0.821655 785.418H332.083L289.75 858.74H656.631L564.127 698.518H744.632L724.25 733.822H1091.13L1047.23 657.784H1235.06L1051.62 340.056L957.704 502.72L907.69 416.094L872.586 476.896L723.028 217.853L562.888 495.222L540.721 456.828H577.878L394.438 139.1ZM749.828 698.518L732.044 729.322H1083.34L1042.03 657.784H868.178L955.106 507.22L907.69 425.094L875.184 481.396L906.468 535.581H843.9L803.707 605.197L857.587 698.518H749.828ZM801.109 609.697L849.792 694.018H752.426L801.109 609.697ZM798.511 605.197L747.23 694.018H561.529L530.014 639.434L530.395 638.775H645.768L588.082 538.859L589.974 535.581H758.319L798.511 605.197ZM801.109 600.697L838.704 535.581H763.515L801.109 600.697ZM760.917 531.081H841.302L869.988 481.396L723.028 226.853L565.486 499.722L583.591 531.081H587.376L674.146 380.791L760.917 531.081ZM592.572 531.081H755.721L674.146 389.791L592.572 531.081ZM582.886 538.859L580.993 535.581H539.587L560.29 499.722L535.525 456.828H389.131L362.895 502.269L404.078 573.6H321.713L286.682 634.275H419.346L473.191 541.012L527.036 634.275H527.797L582.886 538.859ZM532.993 634.275H637.974L585.484 543.359L532.993 634.275ZM524.818 639.434L524.437 638.775H421.944L351.669 760.494L366.059 785.418H337.279L297.544 854.24H648.837L558.931 698.518H490.706L524.818 639.434ZM556.333 694.018L527.416 643.934L498.5 694.018H556.333ZM578.395 531.081L562.888 504.222L547.382 531.081H578.395ZM846.498 531.081L872.586 485.896L898.674 531.081H846.498ZM220.638 264.872L271.23 352.501L210.997 456.828H331.464L357.699 502.269L319.114 569.1H241.167L182.619 467.69L124.07 569.1H44.9916L220.638 264.872ZM273.829 357.001L218.791 452.328H328.866L273.829 357.001ZM276.427 352.501L334.062 452.328H386.533L462.328 321.047L538.123 452.328H570.084L394.438 148.1L276.427 352.501ZM360.297 497.769L336.66 456.828H383.935L360.297 497.769ZM462.328 330.047L532.927 452.328H391.729L462.328 330.047ZM126.668 573.6L6.97257 780.918H334.681L346.473 760.494L238.569 573.6H126.668ZM235.971 569.1H129.266L182.619 476.69L235.971 569.1ZM243.765 573.6L280.141 636.604L316.516 573.6H243.765ZM360.297 506.769L324.311 569.1H396.284L360.297 506.769ZM349.071 755.994L281.394 638.775H416.747L349.071 755.994ZM349.071 764.994L339.877 780.918H358.265L349.071 764.994ZM424.542 634.275L473.191 550.012L521.839 634.275H424.542ZM957.704 511.72L875.972 653.284H1039.44L957.704 511.72ZM1044.63 653.284L960.302 507.22L1051.62 349.056L1227.26 653.284H1044.63Z"
+       fill="url(#paint2_linear_34_23)"
+       id="path114" />
+  </g>
+  <defs
+     id="defs202">
+    <filter
+       id="filter0_d_34_23"
+       x="170.75"
+       y="354.714"
+       width="658.571"
+       height="283.661"
+       filterUnits="userSpaceOnUse"
+       color-interpolation-filters="sRGB">
+      <feFlood
+         flood-opacity="0"
+         result="BackgroundImageFix"
+         id="feFlood136" />
+      <feColorMatrix
+         in="SourceAlpha"
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"
+         result="hardAlpha"
+         id="feColorMatrix138" />
+      <feOffset
+         dy="10.7249"
+         id="feOffset140" />
+      <feGaussianBlur
+         stdDeviation="10.7249"
+         id="feGaussianBlur142" />
+      <feComposite
+         in2="hardAlpha"
+         operator="out"
+         id="feComposite144" />
+      <feColorMatrix
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"
+         id="feColorMatrix146" />
+      <feBlend
+         mode="normal"
+         in2="BackgroundImageFix"
+         result="effect1_dropShadow_34_23"
+         id="feBlend148" />
+      <feBlend
+         mode="normal"
+         in="SourceGraphic"
+         in2="effect1_dropShadow_34_23"
+         result="shape"
+         id="feBlend150" />
+    </filter>
+    <filter
+       id="filter1_d_34_23"
+       x="32"
+       y="41"
+       width="936"
+       height="936"
+       filterUnits="userSpaceOnUse"
+       color-interpolation-filters="sRGB">
+      <feFlood
+         flood-opacity="0"
+         result="BackgroundImageFix"
+         id="feFlood153" />
+      <feColorMatrix
+         in="SourceAlpha"
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"
+         result="hardAlpha"
+         id="feColorMatrix155" />
+      <feOffset
+         dy="9"
+         id="feOffset157" />
+      <feGaussianBlur
+         stdDeviation="9"
+         id="feGaussianBlur159" />
+      <feComposite
+         in2="hardAlpha"
+         operator="out"
+         id="feComposite161" />
+      <feColorMatrix
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"
+         id="feColorMatrix163" />
+      <feBlend
+         mode="normal"
+         in2="BackgroundImageFix"
+         result="effect1_dropShadow_34_23"
+         id="feBlend165" />
+      <feBlend
+         mode="normal"
+         in="SourceGraphic"
+         in2="effect1_dropShadow_34_23"
+         result="shape"
+         id="feBlend167" />
+    </filter>
+    <filter
+       id="filter2_d_34_23"
+       x="236.45"
+       y="475.775"
+       width="98.3216"
+       height="97.9616"
+       filterUnits="userSpaceOnUse"
+       color-interpolation-filters="sRGB">
+      <feFlood
+         flood-opacity="0"
+         result="BackgroundImageFix"
+         id="feFlood170" />
+      <feColorMatrix
+         in="SourceAlpha"
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"
+         result="hardAlpha"
+         id="feColorMatrix172" />
+      <feOffset
+         dy="10.7249"
+         id="feOffset174" />
+      <feGaussianBlur
+         stdDeviation="10.7249"
+         id="feGaussianBlur176" />
+      <feComposite
+         in2="hardAlpha"
+         operator="out"
+         id="feComposite178" />
+      <feColorMatrix
+         type="matrix"
+         values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"
+         id="feColorMatrix180" />
+      <feBlend
+         mode="normal"
+         in2="BackgroundImageFix"
+         result="effect1_dropShadow_34_23"
+         id="feBlend182" />
+      <feBlend
+         mode="normal"
+         in="SourceGraphic"
+         in2="effect1_dropShadow_34_23"
+         result="shape"
+         id="feBlend184" />
+    </filter>
+    <linearGradient
+       id="paint0_linear_34_23"
+       x1="500"
+       y1="50"
+       x2="500"
+       y2="950"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         stop-opacity="0"
+         id="stop187" />
+      <stop
+         offset="1"
+         id="stop189" />
+    </linearGradient>
+    <linearGradient
+       id="paint1_linear_34_23"
+       x1="500"
+       y1="50"
+       x2="500"
+       y2="950"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         stop-opacity="0"
+         id="stop192" />
+      <stop
+         offset="1"
+         id="stop194" />
+    </linearGradient>
+    <linearGradient
+       id="paint2_linear_34_23"
+       x1="617.118"
+       y1="139.1"
+       x2="617.118"
+       y2="858.74"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         stop-color="#F964A7"
+         id="stop197" />
+      <stop
+         offset="1"
+         stop-color="#B6346F"
+         id="stop199" />
+    </linearGradient>
+  </defs>
+</svg>

public/images/layout/osu-lazer-logo-white.svg

···
+<svg width="1000" height="1000" viewBox="0 0 1000 1000" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g filter="url(#filter0_d_34_81)">
+<path d="M780.16 365.439C792.756 365.439 801.393 374.796 801.393 387.751V507.592C801.393 520.548 792.756 529.905 780.16 529.905C767.204 529.905 758.927 520.548 758.927 507.592V387.751C758.927 374.796 767.204 365.439 780.16 365.439ZM780.16 606.2C764.685 606.2 752.449 593.964 752.449 578.489C752.449 563.374 764.685 551.138 780.16 551.138C795.635 551.138 807.871 563.374 807.871 578.489C807.871 593.964 795.635 606.2 780.16 606.2Z" fill="white"/>
+<path d="M702.605 423.379C715.561 423.379 723.838 432.736 723.838 445.332V524.866C723.838 583.527 687.672 606.199 643.766 606.199C599.501 606.199 563.334 583.527 563.334 524.866V445.332C563.334 432.736 571.611 423.379 584.567 423.379C597.163 423.379 605.8 432.736 605.8 445.332V521.987C605.8 554.017 619.294 566.612 643.766 566.612C667.878 566.612 681.372 554.017 681.372 521.987V445.332C681.372 432.736 690.01 423.379 702.605 423.379Z" fill="white"/>
+<path d="M442.923 471.964C442.923 483.84 455.159 488.159 478.551 493.557C510.941 501.474 541.891 509.752 541.891 549.699C541.891 588.566 513.1 606.2 471.714 606.2C437.525 606.2 412.693 594.324 401.177 580.648C392.18 569.852 393.259 560.495 401.896 552.218C412.693 541.781 422.05 546.1 428.168 551.498C437.885 560.495 449.761 569.852 472.793 569.852C490.067 569.852 500.864 564.094 500.864 552.578C500.864 541.061 489.348 537.103 459.118 528.825C429.247 520.548 402.616 512.631 402.616 477.002C402.616 437.055 435.006 420.501 470.994 420.501C491.507 420.501 514.899 425.899 529.295 441.374C535.413 447.492 540.091 456.129 529.295 468.005C518.498 479.162 510.581 475.923 503.023 470.165C496.185 465.126 484.309 456.489 466.315 456.489C454.079 456.489 442.923 460.448 442.923 471.964Z" fill="white"/>
+<path d="M286.129 606.2C231.427 606.2 192.2 566.613 192.2 513.35C192.2 459.728 231.427 420.501 286.129 420.501C340.831 420.501 380.058 459.728 380.058 513.35C380.058 566.613 340.831 606.2 286.129 606.2ZM286.129 566.613C317.799 566.613 337.592 543.581 337.592 513.35C337.592 483.12 317.799 459.728 286.129 459.728C254.46 459.728 234.666 483.12 234.666 513.35C234.666 543.581 254.46 566.613 286.129 566.613Z" fill="white"/>
+</g>
+<g filter="url(#filter1_d_34_81)">
+<path d="M950 500C950 748.528 748.528 950 500 950C251.472 950 50 748.528 50 500C50 251.472 251.472 50 500 50C748.528 50 950 251.472 950 500ZM95 500C95 723.675 276.325 905 500 905C723.675 905 905 723.675 905 500C905 276.325 723.675 95 500 95C276.325 95 95 276.325 95 500Z" fill="white"/>
+</g>
+<g filter="url(#filter2_d_34_81)">
+<path d="M257.9 513.851C257.9 529.326 270.136 541.562 285.611 541.562C301.086 541.562 313.322 529.326 313.322 513.851C313.322 498.736 301.086 486.5 285.611 486.5C270.136 486.5 257.9 498.736 257.9 513.851Z" fill="white"/>
+</g>
+<defs>
+<filter id="filter0_d_34_81" x="170.75" y="354.714" width="658.571" height="283.661" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset dy="10.7249"/>
+<feGaussianBlur stdDeviation="10.7249"/>
+<feComposite in2="hardAlpha" operator="out"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_34_81"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow_34_81" result="shape"/>
+</filter>
+<filter id="filter1_d_34_81" x="32" y="41" width="936" height="936" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset dy="9"/>
+<feGaussianBlur stdDeviation="9"/>
+<feComposite in2="hardAlpha" operator="out"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_34_81"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow_34_81" result="shape"/>
+</filter>
+<filter id="filter2_d_34_81" x="236.45" y="475.775" width="98.3216" height="97.9616" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset dy="10.7249"/>
+<feGaussianBlur stdDeviation="10.7249"/>
+<feComposite in2="hardAlpha" operator="out"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_34_81"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow_34_81" result="shape"/>
+</filter>
+</defs>
+</svg>

resources/css/bem/nav2.less

···
     transition: all 100ms ease-in-out;
     will-change: opacity, transform;
 
-    background-image: url('~@images/layout/osu-logo-white.svg');
+    background-image: var(--nav-logo);
 
     .@{_top}__logo-link:hover & {
       // be careful of weird snapping at the end of animation on Firefox (with 1.1, ~60px).
···
     }
 
     &--bg {
-      background-image: url('~@images/layout/osu-logo-triangles.svg');
+      background-image: var(--nav-logo-bg);
       opacity: 0;
 
       .@{_top}__logo-link:hover & {

resources/css/bem/navbar-mobile.less

···
   &__logo {
     flex: none;
     display: block;
-    background-image: url('~@images/layout/osu-logo-white.svg');
+    background-image: var(--nav-logo);
     background-size: contain;
     background-repeat: no-repeat;
     background-position: center;

resources/css/bem/osu-layout.less

···
   transition: filter 200ms ease-in-out, opacity 200ms ease-in-out; // for fading in after &--masked is removed
 
   &--body {
+    --nav-logo: url('~@images/layout/osu-logo-white.svg');
+    --nav-logo-bg: url('~@images/layout/osu-logo-triangles.svg');
+
     background-color: @osu-colour-b6;
   }
 
···
       content: " ";
       z-index: @z-index--body-background;
     }
+  }
+
+  &--body-lazer {
+    --nav-logo: url('~@images/layout/osu-lazer-logo-white.svg');
+    --nav-logo-bg: url('~@images/layout/osu-lazer-logo-triangles.svg');
   }
 
   &--full {

resources/css/bem/simple-menu.less

···
     }
   }
 
+  &__extra {
+    background-color: hsl(var(--hsl-b5));
+    padding: @_padding-vertical @_gutter;
+    margin: -@_padding-vertical -@_gutter @_padding-vertical;
+  }
+
   &__form {
     margin: -@_padding-vertical -@_gutter;
   }

resources/js/beatmap-discussions-history/main.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 { BeatmapsContext } from 'beatmap-discussions/beatmaps-context';
-import { BeatmapsetsContext } from 'beatmap-discussions/beatmapsets-context';
 import { Discussion } from 'beatmap-discussions/discussion';
-import { DiscussionsContext } from 'beatmap-discussions/discussions-context';
 import BeatmapsetCover from 'components/beatmapset-cover';
 import BeatmapsetDiscussionsBundleJson from 'interfaces/beatmapset-discussions-bundle-json';
-import { keyBy } from 'lodash';
-import { computed, makeObservable } from 'mobx';
-import { observer } from 'mobx-react';
-import { deletedUserJson } from 'models/user';
 import * as React from 'react';
+import BeatmapsetDiscussionsBundleStore from 'stores/beatmapset-discussions-bundle-store';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { trans } from 'utils/lang';
 
-interface Props {
-  bundle: BeatmapsetDiscussionsBundleJson;
-}
-
-@observer
-export default class Main extends React.Component<Props> {
-  @computed
-  private get beatmaps() {
-    return keyBy(this.props.bundle.beatmaps, 'id');
-  }
-
-  @computed
-  private get beatmapsets() {
-    return keyBy(this.props.bundle.beatmapsets, 'id');
-  }
-
-  @computed
-  private get discussions() {
-    return keyBy(this.props.bundle.included_discussions, 'id');
-  }
-
-  @computed
-  private get users() {
-    const values = keyBy(this.props.bundle.users, 'id');
-    // eslint-disable-next-line id-blacklist
-    values.null = values.undefined = deletedUserJson;
-
-    return values;
-  }
-
-  constructor(props: Props) {
-    super(props);
-
-    makeObservable(this);
-  }
+export default class Main extends React.Component<BeatmapsetDiscussionsBundleJson> {
+  private readonly store = new BeatmapsetDiscussionsBundleStore(this.props);
 
   render() {
     return (
-      <DiscussionsContext.Provider value={this.discussions}>
-        <BeatmapsetsContext.Provider value={this.beatmapsets}>
-          <BeatmapsContext.Provider value={this.beatmaps}>
-            <div className='modding-profile-list modding-profile-list--index'>
-              {this.props.bundle.discussions.length === 0 ? (
-                <div className='modding-profile-list__empty'>
-                  {trans('beatmap_discussions.index.none_found')}
-                </div>
-              ) : (this.props.bundle.discussions.map((discussion) => {
-                // TODO: handle in child component? Refactored state might not have beatmapset here (and uses Map)
-                const beatmapset = this.beatmapsets[discussion.beatmapset_id];
+      <div className='modding-profile-list modding-profile-list--index'>
+        {this.props.discussions.length === 0 ? (
+          <div className='modding-profile-list__empty'>
+            {trans('beatmap_discussions.index.none_found')}
+          </div>
+        ) : (this.props.discussions.map((discussion) => {
+          // TODO: handle in child component? Refactored state might not have beatmapset here (and uses Map)
+          const beatmapset = this.store.beatmapsets.get(discussion.beatmapset_id);
 
-                return beatmapset != null && (
-                  <div key={discussion.id} className='modding-profile-list__row'>
-                    <a
-                      className='modding-profile-list__thumbnail'
-                      href={makeUrl({ discussion })}
-                    >
-                      <BeatmapsetCover
-                        beatmapset={beatmapset}
-                        size='list'
-                      />
-                    </a>
-                    <Discussion
-                      beatmapset={beatmapset}
-                      currentBeatmap={discussion.beatmap_id != null ? this.beatmaps[discussion.beatmap_id] : null}
-                      discussion={discussion}
-                      isTimelineVisible={false}
-                      preview
-                      readonly
-                      showDeleted
-                      users={this.users}
-                    />
-                  </div>
-                );
-              }))}
+          return beatmapset != null && (
+            <div key={discussion.id} className='modding-profile-list__row'>
+              <a
+                className='modding-profile-list__thumbnail'
+                href={makeUrl({ discussion })}
+              >
+                <BeatmapsetCover
+                  beatmapset={beatmapset}
+                  size='list'
+                />
+              </a>
+              <Discussion
+                discussion={discussion}
+                discussionsState={null}
+                isTimelineVisible={false}
+                store={this.store}
+              />
             </div>
-          </BeatmapsContext.Provider>
-        </BeatmapsetsContext.Provider>
-      </DiscussionsContext.Provider>
+          );
+        }))}
+      </div>
     );
   }
 }

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

···
 
 import BeatmapListItem from 'components/beatmap-list-item';
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
 import UserJson from 'interfaces/user-json';
-import { deletedUser } from 'models/user';
+import { action, computed, makeObservable, observable } from 'mobx';
+import { observer } from 'mobx-react';
+import { deletedUserJson } from 'models/user';
 import * as React from 'react';
+import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { blackoutToggle } from 'utils/blackout';
 import { classWithModifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
 import { nextVal } from 'utils/seq';
+import DiscussionsState from './discussions-state';
 
 interface Props {
-  beatmaps: BeatmapExtendedJson[];
-  beatmapset: BeatmapsetJson;
-  createLink: (beatmap: BeatmapExtendedJson) => string;
-  currentBeatmap: BeatmapExtendedJson;
-  getCount: (beatmap: BeatmapExtendedJson) => number | undefined;
-  onSelectBeatmap: (beatmapId: number) => void;
-  users: Partial<Record<number, UserJson>>;
+  discussionsState: DiscussionsState;
+  users: Map<number | null | undefined, UserJson>;
 }
 
-interface State {
-  showingSelector: boolean;
-}
+@observer
+export default class BeatmapList extends React.Component<Props> {
+  private readonly eventId = `beatmapset-discussions-show-beatmap-list-${nextVal()}`;
+  @observable private showingSelector = false;
 
-export default class BeatmapList extends React.PureComponent<Props, State> {
-  private readonly eventId = `beatmapset-discussions-show-beatmap-list-${nextVal()}`;
+  @computed
+  private get beatmaps() {
+    return this.props.discussionsState.groupedBeatmaps.get(this.props.discussionsState.currentBeatmap.mode) ?? [];
+  }
 
   constructor(props: Props) {
     super(props);
 
-    this.state = {
-      showingSelector: false,
-    };
+    makeObservable(this);
   }
 
   componentDidMount() {
     $(document).on(`click.${this.eventId}`, this.onDocumentClick);
-    $(document).on(`turbolinks:before-cache.${this.eventId}`, this.hideSelector);
-    this.syncBlackout();
+    $(document).on(`turbolinks:before-cache.${this.eventId}`, this.handleBeforeCache);
+    blackoutToggle(this.showingSelector, 0.5);
   }
 
   componentWillUnmount() {
···
 
   render() {
     return (
-      <div className={classWithModifiers('beatmap-list', { selecting: this.state.showingSelector })}>
+      <div className={classWithModifiers('beatmap-list', { selecting: this.showingSelector })}>
         <div className='beatmap-list__body'>
           <a
             className='beatmap-list__item beatmap-list__item--selected beatmap-list__item--large js-beatmap-list-selector'
-            href={this.props.createLink(this.props.currentBeatmap)}
+            href={makeUrl({ beatmap: this.props.discussionsState.currentBeatmap })}
             onClick={this.toggleSelector}
           >
-            <BeatmapListItem beatmap={this.props.currentBeatmap} mapper={null} modifiers='large' />
+            <BeatmapListItem beatmap={this.props.discussionsState.currentBeatmap} mapper={null} modifiers='large' />
             <div className='beatmap-list__item-selector-button'>
               <span className='fas fa-chevron-down' />
             </div>
···
 
           <div className='beatmap-list__selector-container'>
             <div className='beatmap-list__selector'>
-              {this.props.beatmaps.map(this.beatmapListItem)}
+              {this.beatmaps.map(this.beatmapListItem)}
             </div>
           </div>
         </div>
···
   }
 
   private readonly beatmapListItem = (beatmap: BeatmapExtendedJson) => {
-    const count = this.props.getCount(beatmap);
+    const count = this.props.discussionsState.unresolvedDiscussionCounts.byBeatmap[beatmap.id];
 
     return (
       <div
         key={beatmap.id}
-        className={classWithModifiers('beatmap-list__item', { current: beatmap.id === this.props.currentBeatmap.id })}
+        className={classWithModifiers('beatmap-list__item', { current: beatmap.id === this.props.discussionsState.currentBeatmap.id })}
         data-id={beatmap.id}
         onClick={this.selectBeatmap}
       >
         <BeatmapListItem
           beatmap={beatmap}
-          beatmapUrl={this.props.createLink(beatmap)}
-          beatmapset={this.props.beatmapset}
-          mapper={this.props.users[beatmap.user_id] ?? deletedUser}
+          beatmapUrl={makeUrl({ beatmap })}
+          beatmapset={this.props.discussionsState.beatmapset}
+          mapper={this.props.users.get(beatmap.user_id) ?? deletedUserJson}
           showNonGuestMapper={false}
         />
         {count != null &&
···
     );
   };
 
-  private readonly hideSelector = () => {
-    if (this.state.showingSelector) {
-      this.setSelector(false);
-    }
+  @action
+  private readonly handleBeforeCache = () => {
+    this.setShowingSelector(false);
   };
 
+  @action
   private readonly onDocumentClick = (e: JQuery.ClickEvent) => {
     if (e.button !== 0) return;
 
···
       return;
     }
 
-    this.hideSelector();
+    this.setShowingSelector(false);
   };
 
+  @action
   private readonly selectBeatmap = (e: React.MouseEvent<HTMLElement>) => {
     if (e.button !== 0) return;
     e.preventDefault();
 
     const beatmapId = parseInt(e.currentTarget.dataset.id ?? '', 10);
-    this.props.onSelectBeatmap(beatmapId);
-  };
 
-  private readonly setSelector = (state: boolean) => {
-    if (this.state.showingSelector !== state) {
-      this.setState({ showingSelector: state }, this.syncBlackout);
-    }
+    this.props.discussionsState.currentBeatmapId = beatmapId;
+    this.props.discussionsState.changeDiscussionPage('timeline');
   };
 
-  private readonly syncBlackout = () => {
-    blackoutToggle(this.state.showingSelector, 0.5);
-  };
+  @action
+  private setShowingSelector(state: boolean) {
+    this.showingSelector = state;
+    blackoutToggle(state, 0.5);
+  }
 
+  @action
   private readonly toggleSelector = (e: React.MouseEvent<HTMLElement>) => {
     if (e.button !== 0) return;
     e.preventDefault();
 
-    this.setSelector(!this.state.showingSelector);
+    this.setShowingSelector(!this.showingSelector);
   };
 }

resources/js/beatmap-discussions/beatmap-owner-editor.tsx

···
 import UserAvatar from 'components/user-avatar';
 import UserLink from 'components/user-link';
 import BeatmapJson from 'interfaces/beatmap-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { action, computed, makeObservable, observable, runInAction } from 'mobx';
···
 import { classWithModifiers } from 'utils/css';
 import { transparentGif } from 'utils/html';
 import { trans } from 'utils/lang';
-
-type BeatmapsetWithDiscussionJson = BeatmapsetExtendedJson;
+import DiscussionsState from './discussions-state';
 
 interface XhrCollection {
-  updateOwner: JQuery.jqXHR<BeatmapsetWithDiscussionJson>;
+  updateOwner: JQuery.jqXHR<BeatmapsetWithDiscussionsJson>;
   userLookup: JQuery.jqXHR<UserJson>;
 }
 
 interface Props {
   beatmap: BeatmapJson;
   beatmapsetUser: UserJson;
+  discussionsState: DiscussionsState;
   user: UserJson;
   userByName: Map<string, UserJson>;
 }
···
       data: { beatmap: { user_id: userId } },
       method: 'PUT',
     });
-    this.xhr.updateOwner.done((data) => runInAction(() => {
-      $.publish('beatmapsetDiscussions:update', { beatmapset: data });
+    this.xhr.updateOwner.done((beatmapset) => runInAction(() => {
+      this.props.discussionsState.update({ beatmapset });
       this.editing = false;
     })).fail(onErrorWithCallback(() => {
       this.updateOwner(userId);

resources/js/beatmap-discussions/beatmaps-context.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 BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import * as React from 'react';
-
-const defaultValue: Partial<Record<number, BeatmapExtendedJson>> = {};
-
-export const BeatmapsContext = React.createContext(defaultValue);

resources/js/beatmap-discussions/beatmaps-owner-editor.tsx

···
 import { group as groupBeatmaps } from 'utils/beatmap-helper';
 import { trans } from 'utils/lang';
 import BeatmapOwnerEditor from './beatmap-owner-editor';
+import DiscussionsState from './discussions-state';
 
 interface Props {
   beatmapset: BeatmapsetExtendedJson;
+  discussionsState: DiscussionsState;
   onClose: () => void;
-  users: Partial<Record<number, UserJson>>;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 @observer
···
 
     // this will be outdated on new props but it's fine
     // as there's separate process handling unknown users
-    for (const user of Object.values(props.users)) {
+    for (const user of this.props.users.values()) {
       if (user != null) {
         this.userByName.set(normaliseUsername(user.username), user);
       }
···
                 key={beatmap.id}
                 beatmap={beatmap}
                 beatmapsetUser={beatmapsetUser}
+                discussionsState={this.props.discussionsState}
                 user={this.getUser(beatmap.user_id)}
                 userByName={this.userByName}
               />
···
   }
 
   private getUser(userId: number) {
-    return this.props.users[userId] ?? deletedUserJson;
+    return this.props.users.get(userId) ?? deletedUserJson;
   }
 }

resources/js/beatmap-discussions/beatmapsets-context.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 BeatmapetExtendedJson from 'interfaces/beatmapset-extended-json';
-import * as React from 'react';
-
-const defaultValue: Partial<Record<number, BeatmapetExtendedJson>> = {};
-
-export const BeatmapsetsContext = React.createContext(defaultValue);

resources/js/beatmap-discussions/chart.tsx

···
 import { classWithModifiers } from 'utils/css';
 
 interface Props {
-  discussions: Partial<Record<string, BeatmapsetDiscussionJson>>;
+  discussions: BeatmapsetDiscussionJson[];
   duration: number;
 }
 
···
   const items: React.ReactNode[] = [];
 
   if (props.duration !== 0) {
-    Object.values(props.discussions).forEach((discussion) => {
+    props.discussions.forEach((discussion) => {
       if (discussion == null || discussion.timestamp == null) return;
 
       let className = classWithModifiers('beatmapset-discussions-chart__item', [

resources/js/beatmap-discussions/discussion-mode.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.
 
-// In display order on discussion page tabs
-export const discussionPages = ['reviews', 'generalAll', 'general', 'timeline', 'events'] as const;
-export type DiscussionPage = (typeof discussionPages)[number];
+import DiscussionPage from './discussion-page';
 
 type DiscussionMode = Exclude<DiscussionPage, 'events'>;
+export const discussionModes: Readonly<DiscussionMode[]> = ['reviews', 'generalAll', 'general', 'timeline'] as const;
 
 export default DiscussionMode;

resources/js/beatmap-discussions/discussion-page.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.
+
+// In display order on discussion page tabs
+export const discussionPages = ['reviews', 'generalAll', 'general', 'timeline', 'events'] as const;
+type DiscussionPage = (typeof discussionPages)[number];
+
+const discussionPageSet = new Set<unknown>(discussionPages);
+
+export function isDiscussionPage(value: unknown): value is DiscussionPage {
+  return discussionPageSet.has(value);
+}
+
+export default DiscussionPage;

resources/js/beatmap-discussions/discussion-vote-buttons.tsx

···
 
 import UserListPopup, { createTooltip } from 'components/user-list-popup';
 import { BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { action, computed, makeObservable, observable } from 'mobx';
···
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
 import { hideLoadingOverlay, showLoadingOverlay } from 'utils/loading-overlay';
+import DiscussionsState from './discussions-state';
 
 const voteTypes = ['up', 'down'] as const;
 type VoteType = typeof voteTypes[number];
···
 interface Props {
   cannotVote: boolean;
   discussion: BeatmapsetDiscussionJsonForShow;
-  users: Partial<Record<number | string, UserJson>>;
+  discussionsState: DiscussionsState;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 @observer
 export default class DiscussionVoteButtons extends React.Component<Props> {
   private readonly tooltips: Partial<Record<VoteType, JQuery>> = {};
-  @observable private voteXhr: JQuery.jqXHR<BeatmapsetDiscussionJsonForShow> | null = null;
+  @observable private voteXhr: JQuery.jqXHR<BeatmapsetWithDiscussionsJson> | null = null;
 
   @computed
   private get canDownvote() {
···
       ? trans(`beatmaps.discussions.votes.none.${type}`)
       : `${trans(`beatmaps.discussions.votes.latest.${type}`)}:`;
 
-    const users = this.props.discussion.votes.voters[type].map((id) => this.props.users[id] ?? { id });
+    const users = this.props.discussion.votes.voters[type].map((id) => this.props.users.get(id) ?? { id });
 
     return renderToStaticMarkup(<UserListPopup count={count} title={title} users={users} />);
   }
···
     });
 
     this.voteXhr
-      .done((beatmapset) => $.publish('beatmapsetDiscussions:update', { beatmapset }))
+      .done((beatmapset) => this.props.discussionsState.update({ beatmapset }))
       .fail(onError)
       .always(action(() => {
         hideLoadingOverlay();

resources/js/beatmap-discussions/discussion.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 BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapsetDiscussionJson, { BeatmapsetDiscussionJsonForBundle, BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
 import BeatmapsetDiscussionPostJson from 'interfaces/beatmapset-discussion-post-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
-import UserJson from 'interfaces/user-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import { findLast } from 'lodash';
 import { action, computed, makeObservable } from 'mobx';
 import { observer } from 'mobx-react';
···
 import { trans } from 'utils/lang';
 import { DiscussionType, discussionTypeIcons } from './discussion-type';
 import DiscussionVoteButtons from './discussion-vote-buttons';
-import DiscussionsStateContext from './discussions-state-context';
+import DiscussionsState from './discussions-state';
 import { NewReply } from './new-reply';
 import Post from './post';
 import SystemPost from './system-post';
···
 
 const bn = 'beatmap-discussion';
 
-interface PropsBase {
-  beatmapset: BeatmapsetExtendedJson;
-  currentBeatmap: BeatmapExtendedJson | null;
+interface BaseProps {
   isTimelineVisible: boolean;
   parentDiscussion?: BeatmapsetDiscussionJson | null;
-  readonly: boolean;
-  readPostIds?: Set<number>;
-  showDeleted: boolean;
-  users: Partial<Record<number | string, UserJson>>;
+  store: BeatmapsetDiscussionsStore;
 }
 
-// preview version is used on pages other than the main discussions page.
-type Props = PropsBase & ({
-  // BeatmapsetDiscussionJsonForShow is because editing still returns
-  // BeatmapsetDiscussionJsonForShow which gets merged into the parent discussions blob.
-  discussion: BeatmapsetDiscussionJsonForBundle | BeatmapsetDiscussionJsonForShow;
-  preview: true;
+type Props = BaseProps & ({
+  discussion: BeatmapsetDiscussionJsonForBundle;
+  discussionsState: null; // TODO: make optional?
 } | {
   discussion: BeatmapsetDiscussionJsonForShow;
-  preview: false;
+  discussionsState: DiscussionsState;
 });
 
 function DiscussionTypeIcon({ type }: { type: DiscussionType | 'resolved' }) {
···
 
 @observer
 export class Discussion extends React.Component<Props> {
-  static contextType = DiscussionsStateContext;
-  static defaultProps = {
-    preview: false,
-    readonly: false,
-  };
-
-  declare context: React.ContextType<typeof DiscussionsStateContext>;
   private lastResolvedState = false;
 
-  constructor(props: Props) {
-    super(props);
-    makeObservable(this);
+  private get beatmapset() {
+    return this.props.discussionsState?.beatmapset;
+  }
+
+  private get currentBeatmap() {
+    return this.props.discussionsState?.currentBeatmap;
   }
 
   @computed
   private get canBeRepliedTo() {
-    return !downloadLimited(this.props.beatmapset)
-      && (!this.props.beatmapset.discussion_locked || canModeratePosts())
-      && (this.props.discussion.beatmap_id == null || this.props.currentBeatmap?.deleted_at == null);
+    return this.beatmapset != null
+      && !downloadLimited(this.beatmapset)
+      && (!this.beatmapset.discussion_locked || canModeratePosts())
+      && (this.props.discussion.beatmap_id == null || this.currentBeatmap?.deleted_at == null);
   }
 
   @computed
   private get collapsed() {
-    return this.context.discussionCollapsed.get(this.props.discussion.id) ?? this.context.discussionDefaultCollapsed;
+    return this.props.discussionsState?.discussionCollapsed.get(this.props.discussion.id) ?? this.props.discussionsState?.discussionDefaultCollapsed ?? false;
   }
 
   @computed
   private get highlighted() {
-    return this.context.highlightedDiscussionId === this.props.discussion.id;
+    return this.props.discussionsState?.highlightedDiscussionId === this.props.discussion.id;
+  }
+
+  private get readonly() {
+    return this.props.discussionsState == null;
+  }
+
+  private get readPostIds() {
+    return this.props.discussionsState?.readPostIds;
   }
 
   @computed
-  private get resolvedSystemPostId() {
+  private get resolvedStateChangedPostId() {
     // TODO: handling resolved status in bundles....?
-    if (this.props.preview) return -1;
+    if (this.props.discussionsState == null) return -1;
 
-    const systemPost = findLast(this.props.discussion.posts, (post) => post != null && post.system && post.message.type === 'resolved');
+    const systemPost = findLast(this.props.discussion.posts, (post) => post.system && post.message.type === 'resolved');
     return systemPost?.id ?? -1;
+  }
+
+  private get showDeleted() {
+    return this.props.discussionsState?.showDeleted ?? true;
+  }
+
+  private get users() {
+    return this.props.store.users;
+  }
+
+  constructor(props: Props) {
+    super(props);
+    makeObservable(this);
   }
 
   render() {
     if (!this.isVisible(this.props.discussion)) return null;
     const firstPost = startingPost(this.props.discussion);
-    // TODO: check if possible to have null post...
+    // firstPost shouldn't be null anymore;
+    // just simpler to allow startingPost to return undefined and adding a null check in render.
     if (firstPost == null) return null;
 
     const lineClasses = classWithModifiers(`${bn}__line`, { resolved: this.props.discussion.resolved });
 
     this.lastResolvedState = false;
 
-    const user = this.props.users[this.props.discussion.user_id] ?? deletedUserJson;
+    const user = this.users.get(this.props.discussion.user_id) ?? deletedUserJson;
     const group = badgeGroup({
-      beatmapset: this.props.beatmapset,
-      currentBeatmap: this.props.currentBeatmap,
+      beatmapset: this.beatmapset,
+      currentBeatmap: this.currentBeatmap,
       discussion: this.props.discussion,
       user,
     });
···
       deleted: this.props.discussion.deleted_at != null,
       highlighted: this.highlighted,
       'horizontal-desktop': this.props.discussion.message_type !== 'review',
-      preview: this.props.preview,
+      preview: this.readonly,
       review: this.props.discussion.message_type === 'review',
       timeline: this.props.discussion.timestamp != null,
       unread: !this.isRead(firstPost),
···
 
   @action
   private readonly handleCollapseClick = () => {
-    this.context.discussionCollapsed.set(this.props.discussion.id, !this.collapsed);
+    this.props.discussionsState?.discussionCollapsed.set(this.props.discussion.id, !this.collapsed);
   };
 
   @action
   private readonly handleSetHighlight = (e: React.MouseEvent<HTMLDivElement>) => {
-    if (e.defaultPrevented) return;
-    this.context.highlightedDiscussionId = this.props.discussion.id;
+    if (e.defaultPrevented || this.props.discussionsState == null) return;
+    this.props.discussionsState.highlightedDiscussionId = this.props.discussion.id;
   };
 
   private isOwner(object: { user_id: number }) {
···
   }
 
   private isRead(post: BeatmapsetDiscussionPostJson) {
-    return this.props.readPostIds?.has(post.id) || this.isOwner(post) || this.props.preview;
+    return this.readPostIds?.has(post.id) || this.isOwner(post) || this.readonly;
   }
 
   private isVisible(object: BeatmapsetDiscussionJson | BeatmapsetDiscussionPostJson) {
-    return object != null && (this.props.showDeleted || object.deleted_at == null);
+    return object != null && (this.showDeleted || object.deleted_at == null);
   }
 
   private postFooter() {
-    if (this.props.preview) return null;
+    if (this.props.discussionsState == null) return null;
 
     let cssClasses = `${bn}__expanded`;
     if (this.collapsed) {
···
         <div className={`${bn}__replies`}>
           {this.props.discussion.posts.slice(1).map(this.renderReply)}
         </div>
-        {this.canBeRepliedTo && (
+        {this.props.discussionsState != null && this.canBeRepliedTo && (
           <NewReply
-            beatmapset={this.props.beatmapset}
-            currentBeatmap={this.props.currentBeatmap}
             discussion={this.props.discussion}
+            discussionsState={this.props.discussionsState}
           />
         )}
       </div>
···
   }
 
   private renderPost(post: BeatmapsetDiscussionPostJson, type: 'discussion' | 'reply') {
-    const user = this.props.users[post.user_id] ?? deletedUserJson;
+    const user = this.users.get(post.user_id) ?? deletedUserJson;
 
     if (post.system) {
       return (
···
     return (
       <Post
         key={post.id}
-        beatmap={this.props.currentBeatmap}
-        beatmapset={this.props.beatmapset}
         discussion={this.props.discussion}
+        discussionsState={this.props.discussionsState}
         post={post}
         read={this.isRead(post)}
-        readonly={this.props.readonly}
-        resolvedSystemPostId={this.resolvedSystemPostId}
+        readonly={this.readonly}
+        resolvedStateChangedPostId={this.resolvedStateChangedPostId}
+        store={this.props.store}
         type={type}
         user={user}
-        users={this.props.users}
       />
     );
   }
 
   private renderPostButtons() {
-    if (this.props.preview) return null;
+    if (this.props.discussionsState == null) {
+      return null;
+    }
 
-    const user = this.props.users[this.props.discussion.user_id];
+    const user = this.props.store.users.get(this.props.discussion.user_id);
 
     return (
       <div className={`${bn}__top-actions`}>
···
           <DiscussionVoteButtons
             cannotVote={this.isOwner(this.props.discussion) || (user?.is_bot ?? false) || !this.canBeRepliedTo}
             discussion={this.props.discussion}
-            users={this.props.users}
+            discussionsState={this.props.discussionsState}
+            users={this.users}
           />
           <button
             className={`${bn}__action ${bn}__action--with-line`}

resources/js/beatmap-discussions/discussions-context.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 { BeatmapsetDiscussionJsonForBundle, BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
-import { createContext } from 'react';
-
-// TODO: needs discussions need flattening / normalization
-export const DiscussionsContext = createContext({} as Partial<Record<number, BeatmapsetDiscussionJsonForBundle | BeatmapsetDiscussionJsonForShow>>);

resources/js/beatmap-discussions/discussions-state-context.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 { createContext } from 'react';
-import DiscussionsState from './discussions-state';
-
-// TODO: combine with DiscussionsContext, BeatmapsetContext, etc into a store with properties.
-const DiscussionsStateContext = createContext(new DiscussionsState());
-
-export default DiscussionsStateContext;

resources/js/beatmap-discussions/discussions-state.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 { makeObservable, observable } from 'mobx';
+import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
+import GameMode from 'interfaces/game-mode';
+import { maxBy } from 'lodash';
+import { action, computed, makeObservable, observable, reaction } from 'mobx';
+import moment from 'moment';
+import core from 'osu-core-singleton';
+import BeatmapsetDiscussionsShowStore from 'stores/beatmapset-discussions-show-store';
+import { findDefault, group, sortWithMode } from 'utils/beatmap-helper';
+import { canModeratePosts, makeUrl, parseUrl } from 'utils/beatmapset-discussion-helper';
+import { parseJsonNullable, storeJson } from 'utils/json';
+import { Filter, filters } from './current-discussions';
+import DiscussionMode, { discussionModes } from './discussion-mode';
+import DiscussionPage, { isDiscussionPage } from './discussion-page';
+
+const jsonId = 'json-discussions-state';
+
+export interface UpdateOptions {
+  beatmap_discussion_post_ids: number[];
+  beatmapset: BeatmapsetWithDiscussionsJson;
+  watching: boolean;
+}
+
+function reviver(key: string, value: unknown) {
+  if (Array.isArray(value)) {
+    if (key === 'discussionCollapsed') {
+      return new Map(value);
+    }
+
+    if (key === 'readPostIds') {
+      return new Set(value);
+    }
+  }
+
+  return value;
+}
+
+function isFilter(value: unknown): value is Filter {
+  return (filters as readonly unknown[]).includes(value);
+}
 
 export default class DiscussionsState {
+  @observable currentBeatmapId: number;
+  @observable currentFilter: Filter = 'total'; // TODO: filter should always be total when page is events (also no highlight)
+  @observable currentPage: DiscussionPage = 'general';
   @observable discussionCollapsed = new Map<number, boolean>();
   @observable discussionDefaultCollapsed = false;
   @observable highlightedDiscussionId: number | null = null;
+  @observable jumpToDiscussion = false;
+  @observable pinnedNewDiscussion = false;
+
+  @observable readPostIds = new Set<number>();
+  @observable selectedUserId: number | null = null;
+  @observable showDeleted = true; // this toggle only affects All and deleted discussion filters, other filters don't show deleted
+
+  private previousFilter: Filter = 'total';
+  private previousPage: DiscussionPage = 'general';
+  private readonly urlStateDisposer;
+
+  get beatmapset() {
+    return this.store.beatmapset;
+  }
+
+  @computed
+  get currentBeatmap() {
+    const beatmap = this.store.beatmaps.get(this.currentBeatmapId);
+    if (beatmap == null) {
+      throw new Error('missing beatmap');
+    }
+
+    return beatmap;
+  }
+
+  /**
+   * Discussions for the current beatmap grouped by filters
+   */
+  @computed
+  get discussionsByFilter() {
+    const groups: Record<Filter, BeatmapsetDiscussionJson[]> = {
+      deleted: [],
+      hype: [],
+      mapperNotes: [],
+      mine: [],
+      pending: [],
+      praises: [],
+      resolved: [],
+      total: this.discussionForSelectedBeatmap,
+    };
+
+    const currentUser = core.currentUser;
+    const reviewsWithPending = new Set<BeatmapsetDiscussionJson>();
+
+    for (const discussion of this.discussionForSelectedBeatmap) {
+      if (discussion.deleted_at != null) {
+        groups.deleted.push(discussion);
+        continue;
+      }
+
+      if (currentUser != null && discussion.user_id === currentUser.id) {
+        groups.mine.push(discussion);
+      }
+
+      if (discussion.message_type === 'hype') {
+        groups.hype.push(discussion);
+        groups.praises.push(discussion);
+      } else if (discussion.message_type === 'mapper_note') {
+        groups.mapperNotes.push(discussion);
+      } else if (discussion.message_type === 'praise') {
+        groups.praises.push(discussion);
+      }
 
-  constructor() {
+      if (discussion.can_be_resolved) {
+        if (discussion.resolved) {
+          groups.resolved.push(discussion);
+        } else {
+          groups.pending.push(discussion);
+          // only reviews with unresolved discussions get added.
+          if (discussion.parent_id != null) {
+            const parentDiscussion = this.store.discussions.get(discussion.parent_id);
+            if (parentDiscussion != null && parentDiscussion.message_type === 'review') {
+              reviewsWithPending.add(parentDiscussion);
+            }
+          }
+        }
+      }
+    }
+
+    groups.pending.push(...reviewsWithPending);
+
+    return groups;
+  }
+
+  /**
+   * Discussions for the currently selected beatmap and filter grouped by mode.
+   */
+  @computed
+  get discussionsByMode() {
+    const discussions = this.discussionsByFilter[this.currentFilter];
+
+    const value: Record<DiscussionMode, BeatmapsetDiscussionJson[]> = {
+      general: [],
+      generalAll: [],
+      reviews: [],
+      timeline: [],
+    };
+
+    for (const discussion of discussions) {
+      if (discussion.message_type === 'review') {
+        value.reviews.push(discussion);
+      } else if (discussion.beatmap_id == null) {
+        value.generalAll.push(discussion);
+      } else if (discussion.beatmap_id === this.currentBeatmapId) {
+        if (discussion.timestamp != null) {
+          value.timeline.push(discussion);
+        } else {
+          value.general.push(discussion);
+        }
+      }
+    }
+
+    return value;
+  }
+
+  @computed
+  get discussionForSelectedBeatmap() {
+    const discussions = canModeratePosts()
+      ? this.discussionsArray
+      : this.nonDeletedDiscussions;
+
+    return discussions.filter((discussion) => (discussion.beatmap_id == null || discussion.beatmap_id === this.currentBeatmapId));
+  }
+
+  @computed
+  get discussionsArray() {
+    return [...this.store.discussions.values()];
+  }
+
+  @computed
+  get discussionsForSelectedUserByMode() {
+    if (this.selectedUser == null) {
+      return this.discussionsByMode;
+    }
+
+    const value: Record<DiscussionMode, BeatmapsetDiscussionJson[]> = {
+      general: [],
+      generalAll: [],
+      reviews: [],
+      timeline: [],
+    };
+
+    for (const mode of discussionModes) {
+      value[mode] = this.discussionsByMode[mode].filter((discussion) => discussion.user_id === this.selectedUserId);
+    }
+
+    return value;
+  }
+
+  @computed
+  get firstBeatmap() {
+    return [...this.store.beatmaps.values()][0];
+  }
+
+  @computed
+  get groupedBeatmaps() {
+    return group([...this.store.beatmaps.values()]);
+  }
+
+  @computed
+  get hasCurrentUserHyped() {
+    const currentUser = core.currentUser;
+    return currentUser != null
+      && this.discussionsByFilter.hype.some((discussion) => (
+        discussion.beatmap_id == null && discussion.user_id === currentUser.id
+      ));
+  }
+
+  @computed
+  get lastUpdate() {
+    const maxDiscussions = maxBy(this.beatmapset.discussions, 'updated_at')?.updated_at;
+    const maxEvents = maxBy(this.beatmapset.events, 'created_at')?.created_at;
+
+    const maxLastUpdate = Math.max(
+      Date.parse(this.beatmapset.last_updated),
+      maxDiscussions != null ? Date.parse(maxDiscussions) : 0,
+      maxEvents != null ? Date.parse(maxEvents) : 0,
+    );
+
+    return moment(maxLastUpdate).unix();
+  }
+
+  @computed
+  get nonDeletedDiscussions() {
+    return this.discussionsArray.filter((discussion) => discussion.deleted_at == null);
+  }
+
+  @computed
+  get selectedUser() {
+    return this.store.users.get(this.selectedUserId);
+  }
+
+  @computed
+  get sortedBeatmaps() {
+    return sortWithMode([...this.store.beatmaps.values()]);
+  }
+
+  @computed
+  get totalHypeCount() {
+    return this.nonDeletedDiscussions
+      .reduce((sum, discussion) => +(discussion.message_type === 'hype') + sum, 0);
+  }
+
+  @computed
+  get unresolvedDiscussionTotalCount() {
+    return this.nonDeletedDiscussions
+      .reduce((sum, discussion) => {
+        if (discussion.can_be_resolved && !discussion.resolved) {
+          if (discussion.beatmap_id == null) return sum + 1;
+
+          const beatmap = this.store.beatmaps.get(discussion.beatmap_id);
+          if (beatmap != null && beatmap.deleted_at == null) return sum + 1;
+        }
+
+        return sum;
+      }, 0);
+  }
+
+  @computed
+  get unresolvedDiscussionCounts() {
+    const byBeatmap: Partial<Record<number, number>> = {};
+    const byMode: Record<GameMode, number> = {
+      fruits: 0,
+      mania: 0,
+      osu: 0,
+      taiko: 0,
+    };
+
+    for (const discussion of this.nonDeletedDiscussions) {
+      if (discussion.beatmap_id != null && discussion.can_be_resolved && !discussion.resolved) {
+        byBeatmap[discussion.beatmap_id] = (byBeatmap[discussion.beatmap_id] ?? 0) + 1;
+
+        const mode = this.store.beatmaps.get(discussion.beatmap_id)?.mode;
+        if (mode != null) {
+          byMode[mode]++;
+        }
+      }
+    }
+
+    return {
+      byBeatmap,
+      byMode,
+    };
+  }
+
+  @computed
+  get url() {
+    return makeUrl({
+      beatmap: this.currentBeatmap,
+      filter: this.currentFilter,
+      mode: this.currentPage,
+      user: this.selectedUserId ?? undefined,
+    });
+  }
+
+  constructor(private readonly store: BeatmapsetDiscussionsShowStore) {
+    const existingState = parseJsonNullable(jsonId, false, reviver);
+
+    if (existingState != null) {
+      Object.assign(this, existingState);
+    } else {
+      this.jumpToDiscussion = true;
+      for (const discussion of store.beatmapset.discussions) {
+        if (discussion.posts != null) {
+          for (const post of discussion.posts) {
+            this.readPostIds.add(post.id);
+          }
+        }
+      }
+    }
+
+    this.currentBeatmapId = (findDefault({ group: this.groupedBeatmaps }) ?? this.firstBeatmap).id;
+
+    // Current url takes priority over saved state.
+    const query = parseUrl(null, store.beatmapset.discussions);
+    if (query != null) {
+      // TODO: maybe die instead?
+      this.currentPage = query.mode;
+      this.currentFilter = query.filter;
+      if (query.beatmapId != null) {
+        this.currentBeatmapId = query.beatmapId;
+      }
+      this.selectedUserId = query.user ?? null;
+    }
+
     makeObservable(this);
+
+    this.urlStateDisposer = reaction(() => this.url, (current, prev) => {
+      if (current !== prev) {
+        Turbolinks.controller.advanceHistory(this.url);
+      }
+    });
+  }
+
+  @action
+  changeDiscussionPage(page?: string) {
+    if (!isDiscussionPage(page)) return;
+
+    if (page === 'events') {
+      // record page and filter when switching to events
+      this.previousPage = this.currentPage;
+      this.previousFilter = this.currentFilter;
+    } else if (this.currentFilter !== this.previousFilter) {
+      // restore previous filter when switching away from events
+      this.currentFilter = this.previousFilter;
+    }
+
+    this.currentPage = page;
+  }
+
+  @action
+  changeFilter(filter: unknown) {
+    if (!isFilter(filter)) return;
+
+    // restore previous page when selecting a filter.
+    if (this.currentPage === 'events') {
+      this.currentPage = this.previousPage;
+    }
+
+    this.currentFilter = filter;
+  }
+
+  @action
+  changeGameMode(mode: GameMode) {
+    const beatmap = findDefault({ items: this.groupedBeatmaps.get(mode) });
+    if (beatmap != null) {
+      this.currentBeatmapId = beatmap.id;
+    }
+  }
+
+  destroy() {
+    this.urlStateDisposer();
+  }
+
+  @action
+  markAsRead(ids: number | number[]) {
+    if (Array.isArray(ids)) {
+      ids.forEach((id) => this.readPostIds.add(id));
+    } else {
+      this.readPostIds.add(ids);
+    }
+  }
+
+  saveState() {
+    storeJson(jsonId, this.toJson());
+  }
+
+  toJson() {
+    // Convert serialized properties into primitives supported by JSON.stringify.
+    // Values that need conversion should have the appropriate reviver to restore
+    // the original type when deserializing.
+    return {
+      currentBeatmapId: this.currentBeatmapId,
+      currentFilter: this.currentFilter,
+      currentPage: this.currentPage,
+      discussionCollapsed: [...this.discussionCollapsed],
+      discussionDefaultCollapsed: this.discussionDefaultCollapsed,
+      highlightedDiscussionId: this.highlightedDiscussionId,
+      jumpToDiscussion: this.jumpToDiscussion,
+      pinnedNewDiscussion: this.pinnedNewDiscussion,
+      readPostIds: [...this.readPostIds],
+      selectedUserId: this.selectedUserId,
+      showDeleted: this.showDeleted,
+    };
+  }
+
+  @action
+  update(options: Partial<UpdateOptions>) {
+    if (options.beatmap_discussion_post_ids != null) {
+      this.markAsRead(options.beatmap_discussion_post_ids);
+    }
+
+    if (options.beatmapset != null) {
+      this.store.beatmapset = options.beatmapset;
+    }
+
+    if (options.watching != null) {
+      this.beatmapset.current_user_attributes.is_watching = options.watching;
+    }
   }
 }

resources/js/beatmap-discussions/discussions.tsx

···
 // See the LICENCE file in the repository root for full licence text.
 
 import IconExpand from 'components/icon-expand';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapsetDiscussionJson, { BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
-import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
-import UserJson from 'interfaces/user-json';
-import { size } from 'lodash';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import { action, computed, makeObservable, observable } from 'mobx';
 import { observer } from 'mobx-react';
 import * as React from 'react';
 import { canModeratePosts } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
-import CurrentDiscussions, { Filter } from './current-discussions';
 import { Discussion } from './discussion';
 import DiscussionMode from './discussion-mode';
 import DiscussionsState from './discussions-state';
-import DiscussionsStateContext from './discussions-state-context';
 
 const bn = 'beatmap-discussions';
 
···
 type Sort = 'created_at' | 'updated_at' | 'timeline';
 
 interface Props {
-  // TODO: most of these can move to context/store after main is converted to typescript.
-  beatmapset: BeatmapsetExtendedJson & BeatmapsetWithDiscussionsJson;
-  currentBeatmap: BeatmapExtendedJson;
-  currentDiscussions: CurrentDiscussions;
-  currentFilter: Filter;
-  mode: DiscussionMode;
-  readPostIds: Set<number>;
-  showDeleted: boolean;
-  users: Record<number, UserJson>;
+  discussionsState: DiscussionsState;
+  store: BeatmapsetDiscussionsStore;
 }
 
 @observer
 export class Discussions extends React.Component<Props> {
-  @observable private readonly discussionsState = new DiscussionsState();
   @observable private sort: Record<DiscussionMode, Sort> = {
     general: 'updated_at',
     generalAll: 'updated_at',
···
 
   @computed
   private get currentSort() {
-    return this.sort[this.props.mode];
+    return this.discussionsState.currentPage === 'events'
+      ? 'timeline' // returning any valid mode is fine.
+      : this.sort[this.discussionsState.currentPage];
+  }
+
+  private get discussionsState() {
+    return this.props.discussionsState;
   }
 
   @computed
   private get isTimelineVisible() {
-    return this.props.mode === 'timeline' && this.currentSort === 'timeline';
+    return this.discussionsState.currentPage === 'timeline' && this.currentSort === 'timeline';
+  }
+
+  private get store() {
+    return this.props.store;
   }
 
   @computed
   private get sortedDiscussions() {
-    return this.props.currentDiscussions[this.props.mode].slice().sort((a: BeatmapsetDiscussionJson, b: BeatmapsetDiscussionJson) => {
+    if (this.discussionsState.currentPage === 'events') return [];
+
+    const discussions = this.discussionsState.discussionsForSelectedUserByMode[this.discussionsState.currentPage];
+
+    return discussions.slice().sort((a: BeatmapsetDiscussionJson, b: BeatmapsetDiscussionJson) => {
       const mapperNoteCompare =
         // no sticky for timeline sort
         this.currentSort !== 'timeline'
···
   constructor(props: Props) {
     super(props);
     makeObservable(this);
-  }
-
-  componentDidMount() {
-    $.subscribe('beatmapset-discussions:highlight', this.handleSetHighlight);
-  }
-
-  componentWillUnmount() {
-    $.unsubscribe('beatmapset-discussions:highlight', this.handleSetHighlight);
   }
 
   render() {
···
 
   @action
   private readonly handleChangeSort = (e: React.SyntheticEvent<HTMLButtonElement>) => {
-    this.sort[this.props.mode] = e.currentTarget.dataset.sortPreset as Sort;
+    if (this.discussionsState.currentPage === 'events') return;
+    this.sort[this.discussionsState.currentPage] = e.currentTarget.dataset.sortPreset as Sort;
   };
 
   @action
   private readonly handleExpandClick = (e: React.SyntheticEvent<HTMLButtonElement>) => {
     this.discussionsState.discussionDefaultCollapsed = e.currentTarget.dataset.type === 'collapse';
     this.discussionsState.discussionCollapsed.clear();
-  };
-
-  @action
-  private readonly handleSetHighlight = (_event: unknown, { discussionId }: { discussionId: number }) => {
-    // TODO: update main to use context instead of publishing event.
-    this.discussionsState.highlightedDiscussionId = discussionId;
   };
 
   private readonly renderDiscussionPage = (discussion: BeatmapsetDiscussionJsonForShow) => {
-    const visible = this.props.currentDiscussions.byFilter[this.props.currentFilter][this.props.mode][discussion.id] != null;
-
-    if (!visible) return null;
-
-    const parentDiscussion = discussion.parent_id != null ? this.props.currentDiscussions.byFilter.total.reviews[discussion.parent_id] : null;
+    const parentDiscussion = this.store.discussions.get(discussion.parent_id);
 
     return (
       <Discussion
         key={discussion.id}
-        beatmapset={this.props.beatmapset}
-        currentBeatmap={this.props.currentBeatmap}
         discussion={discussion}
+        discussionsState={this.discussionsState}
         isTimelineVisible={this.isTimelineVisible}
-        parentDiscussion={parentDiscussion}
-        readPostIds={this.props.readPostIds}
-        showDeleted={this.props.showDeleted}
-        users={this.props.users}
+        parentDiscussion={parentDiscussion?.message_type === 'review' ? parentDiscussion : null}
+        store={this.store}
       />
     );
   };
 
   private renderDiscussions() {
-    const discussions = this.props.currentDiscussions[this.props.mode];
-
-    if (discussions.length === 0) {
-      return (
-        <div className={`${bn}__discussions ${bn}__discussions--empty`}>
-          {trans('beatmaps.discussions.empty.empty')}
-        </div>
-      );
-    }
+    const count = this.sortedDiscussions.length;
 
-    if (size(this.props.currentDiscussions.byFilter[this.props.currentFilter][this.props.mode]) === 0) {
+    if (count === 0) {
       return (
         <div className={`${bn}__discussions ${bn}__discussions--empty`}>
-          {trans('beatmaps.discussions.empty.hidden')}
+          {this.discussionsState.discussionsByFilter.total.length > count
+            ? trans('beatmaps.discussions.empty.hidden')
+            : trans('beatmaps.discussions.empty.empty')
+          }
         </div>
       );
     }
···
 
         {this.isTimelineVisible && <div className={`${bn}__timeline-line hidden-xs`} />}
 
-        <DiscussionsStateContext.Provider value={this.discussionsState}>
-          {this.sortedDiscussions.map(this.renderDiscussionPage)}
-        </DiscussionsStateContext.Provider>
+        {this.sortedDiscussions.map(this.renderDiscussionPage)}
 
         {this.renderTimelineCircle()}
       </div>
···
         type='button'
       >
         <span className={`${bn}__toolbar-link-content`}>
-          <span className={this.props.showDeleted ? 'fas fa-check-square' : 'far fa-square'} />
+          <span className={this.discussionsState.showDeleted ? 'fas fa-check-square' : 'far fa-square'} />
         </span>
         <span className={`${bn}__toolbar-link-content`}>
           {trans('beatmaps.discussions.show_deleted')}
···
   }
 
   private renderSortOptions() {
-    const presets: Sort[] = this.props.mode === 'timeline'
+    const presets: Sort[] = this.discussionsState.currentPage === 'timeline'
       ? ['timeline', 'updated_at']
       : ['created_at', 'updated_at'];
 
···
     );
   }
 
+  @action
   private readonly toggleShowDeleted = () => {
-    $.publish('beatmapDiscussionPost:toggleShowDeleted');
+    this.discussionsState.showDeleted = !this.discussionsState.showDeleted;
   };
 }

resources/js/beatmap-discussions/editor-discussion-component.tsx

···
 // See the LICENCE file in the repository root for full licence text.
 
 import { EmbedElement } from 'editor';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
-import { filter } from 'lodash';
-import { Observer } from 'mobx-react';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
+import { Observer, observer } from 'mobx-react';
 import * as React from 'react';
 import { Transforms } from 'slate';
 import { RenderElementProps } from 'slate-react';
···
 import { classWithModifiers } from 'utils/css';
 import { trans, transArray } from 'utils/lang';
 import { linkHtml } from 'utils/url';
+import DiscussionsState from './discussions-state';
 import { DraftsContext } from './drafts-context';
 import EditorBeatmapSelector from './editor-beatmap-selector';
 import EditorIssueTypeSelector from './editor-issue-type-selector';
···
 }
 
 interface Props extends RenderElementProps {
-  beatmaps: BeatmapExtendedJson[];
-  beatmapset: BeatmapsetJson;
-  discussions: Partial<Record<number, BeatmapsetDiscussionJson>>;
+  discussionsState: DiscussionsState;
   editMode?: boolean;
   element: EmbedElement;
   readOnly?: boolean;
+  store: BeatmapsetDiscussionsStore;
 }
 
+@observer
 export default class EditorDiscussionComponent extends React.Component<Props> {
   static contextType = SlateContext;
 
···
   tooltipContent = React.createRef<HTMLScriptElement>();
   tooltipEl?: HTMLElement;
 
+  get discussions() {
+    return this.props.store.discussions;
+  }
+
   componentDidMount = () => {
     // reset timestamp to null on clone
     if (this.editable()) {
···
     if (this.cache.nearbyDiscussions == null
       || this.cache.nearbyDiscussions.timestamp !== timestamp
       || this.cache.nearbyDiscussions.beatmap_id !== beatmapId) {
-      const relevantDiscussions = filter(this.props.discussions, this.isRelevantDiscussion);
+      const relevantDiscussions = [...this.discussions.values()].filter(this.isRelevantDiscussion);
       this.cache.nearbyDiscussions = {
         beatmap_id: beatmapId,
         discussions: nearbyDiscussions(relevantDiscussions, timestamp),
···
 
     const disabled = this.props.readOnly || !canEdit;
 
-    const discussion = this.props.element.discussionId != null ? this.props.discussions[this.props.element.discussionId] : null;
+    const discussion = this.discussions.get(this.props.element.discussionId);
     const embedMofidiers = discussion != null
       ? postEmbedModifiers(discussion)
       : this.discussionType() === 'praise' ? 'praise' : null;
···
               className={`${bn}__selectors`}
               contentEditable={false} // workaround for slatejs 'Cannot resolve a Slate point from DOM point' nonsense
             >
-              <EditorBeatmapSelector {...this.props} disabled={disabled} element={this.props.element} />
-              <EditorIssueTypeSelector {...this.props} disabled={disabled} element={this.props.element} />
+              <EditorBeatmapSelector beatmaps={this.props.discussionsState.sortedBeatmaps} disabled={disabled} element={this.props.element} />
+              <EditorIssueTypeSelector beatmaps={this.props.discussionsState.sortedBeatmaps} disabled={disabled} element={this.props.element} />
               <div
                 className={`${bn}__timestamp`}
                 contentEditable={false} // workaround for slatejs 'Cannot resolve a Slate point from DOM point' nonsense

resources/js/beatmap-discussions/editor.tsx

···
 import { Spinner } from 'components/spinner';
 import { EmbedElement } from 'editor';
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import BeatmapsetDiscussionJson, { BeatmapsetDiscussionJsonForBundle, BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
+import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import isHotkey from 'is-hotkey';
 import { route } from 'laroute';
-import { filter } from 'lodash';
+import { observer } from 'mobx-react';
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { createEditor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, NodeEntry, Range, Text, Transforms } from 'slate';
···
 import { Editable, ReactEditor, RenderElementProps, RenderLeafProps, Slate, withReact } from 'slate-react';
 import { DOMRange } from 'slate-react/dist/utils/dom';
 import { onError } from 'utils/ajax';
-import { sortWithMode } from 'utils/beatmap-helper';
 import { timestampRegex } from 'utils/beatmapset-discussion-helper';
 import { nominationsCount } from 'utils/beatmapset-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
+import DiscussionsState from './discussions-state';
 import { DraftsContext } from './drafts-context';
 import EditorDiscussionComponent from './editor-discussion-component';
 import {
···
 }
 
 interface Props {
-  beatmaps: Partial<Record<number, BeatmapExtendedJson>>;
-  beatmapset: BeatmapsetJson;
-  currentBeatmap: BeatmapExtendedJson | null;
   discussion?: BeatmapsetDiscussionJson;
-  discussions: Partial<Record<number, BeatmapsetDiscussionJsonForBundle | BeatmapsetDiscussionJsonForShow>>; // passed in via context at parent
+  discussionsState: DiscussionsState;
   document?: string;
   editing: boolean;
   onChange?: () => void;
   onFocus?: () => void;
+  store: BeatmapsetDiscussionsStore;
 }
 
 interface State {
···
   return block.type === 'embed' && block.discussionId == null;
 }
 
+@observer
 export default class Editor extends React.Component<Props, State> {
   static contextType = ReviewEditorConfigContext;
   static defaultProps = {
···
   slateEditor: SlateEditor;
   toolbarRef: React.RefObject<EditorToolbar>;
   private readonly initialValue: SlateElement[] = emptyDocTemplate;
-  private xhr?: JQueryXHR | null;
+  private xhr: JQuery.jqXHR<BeatmapsetWithDiscussionsJson> | null = null;
+
+  private get beatmaps() {
+    return this.props.store.beatmaps;
+  }
+
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
+  private get discussions() {
+    return this.props.store.discussions;
+  }
 
   private get editMode() {
     return this.props.document != null;
···
     this.scrollContainerRef = React.createRef();
     this.toolbarRef = React.createRef();
     this.insertMenuRef = React.createRef();
-    this.localStorageKey = `newDiscussion-${this.props.beatmapset.id}`;
+    this.localStorageKey = `newDiscussion-${this.beatmapset.id}`;
 
     if (this.editMode) {
       this.initialValue = this.valueFromProps();
···
 
     return ranges;
   };
-
-  /**
-   * Type guard for checking if the beatmap is part of currently selected beatmapset
-   *
-   * @param beatmap
-   * @returns boolean
-   */
-  isCurrentBeatmap = (beatmap?: BeatmapExtendedJson): beatmap is BeatmapExtendedJson => (
-    beatmap != null && beatmap.beatmapset_id === this.props.beatmapset.id
-  );
 
   onChange = (value: SlateElement[]) => {
     // Anything that triggers this needs to be fixed!
···
 
     if (this.showConfirmationIfRequired()) {
       this.setState({ posting: true }, () => {
-        this.xhr = $.ajax(route('beatmapsets.discussion.review', { beatmapset: this.props.beatmapset.id }), {
+        this.xhr = $.ajax(route('beatmapsets.discussion.review', { beatmapset: this.beatmapset.id }), {
           data: { document: this.serialize() },
           method: 'POST',
-        })
-          .done((data) => {
-            $.publish('beatmapsetDiscussions:update', { beatmapset: data });
+        });
+
+        this.xhr
+          .done((beatmapset) => {
+            this.props.discussionsState.update({ beatmapset });
             this.resetInput();
           })
           .fail(onError)
···
             >
               <div ref={this.scrollContainerRef} className={`${editorClass}__input-area`}>
                 <EditorToolbar ref={this.toolbarRef} />
-                <EditorInsertionMenu ref={this.insertMenuRef} currentBeatmap={this.props.currentBeatmap} />
+                <EditorInsertionMenu ref={this.insertMenuRef} currentBeatmap={this.props.discussionsState.currentBeatmap} />
                 <DraftsContext.Provider value={this.cache.draftEmbeds || []}>
                   <Editable
                     decorate={this.decorateTimestamps}
···
         const { element, ...otherProps } = props; // spreading ..props doesn't use the narrower type.
         el = (
           <EditorDiscussionComponent
-            beatmaps={this.sortedBeatmaps()}
-            beatmapset={this.props.beatmapset}
-            discussions={this.props.discussions}
+            discussionsState={this.props.discussionsState}
             editMode={this.editMode}
             element={element}
             readOnly={this.state.posting}
+            store={this.props.store}
             {...otherProps}
           />
         );
···
   showConfirmationIfRequired = () => {
     const docContainsProblem = slateDocumentContainsNewProblem(this.state.value);
     const canDisqualify = core.currentUser != null && (core.currentUser.is_admin || core.currentUser.is_moderator || core.currentUser.is_full_bn);
-    const willDisqualify = this.props.beatmapset.status === 'qualified' && docContainsProblem;
+    const willDisqualify = this.beatmapset.status === 'qualified' && docContainsProblem;
     const canReset = core.currentUser != null && (core.currentUser.is_admin || core.currentUser.is_nat || core.currentUser.is_bng);
     const willReset =
-      this.props.beatmapset.status === 'pending' &&
-      this.props.beatmapset.nominations && nominationsCount(this.props.beatmapset.nominations, 'current') > 0 &&
-      docContainsProblem;
+      this.beatmapset.status === 'pending'
+        && nominationsCount(this.beatmapset.nominations, 'current') > 0
+        && docContainsProblem;
 
     if (canDisqualify && willDisqualify) {
       return confirm(trans('beatmaps.nominations.reset_confirm.disqualify'));
···
     return true;
   };
 
-  sortedBeatmaps = () => {
-    if (this.cache.sortedBeatmaps == null) {
-      // filter to only include beatmaps from the current discussion's beatmapset (for the modding profile page)
-      const beatmaps = filter(this.props.beatmaps, this.isCurrentBeatmap);
-      this.cache.sortedBeatmaps = sortWithMode(beatmaps);
-    }
-
-    return this.cache.sortedBeatmaps;
-  };
-
   updateDrafts = () => {
     this.cache.draftEmbeds = this.state.value.filter(isDraftEmbed);
   };
···
           }
 
           if (node.beatmapId != null) {
-            const beatmap = this.props.beatmaps[node.beatmapId];
+            const beatmap = this.beatmaps.get(node.beatmapId);
             if (beatmap == null || beatmap.deleted_at != null) {
               Transforms.setNodes(editor, { beatmapId: undefined }, { at: path });
             }
···
   }
 
   private valueFromProps() {
-    if (!this.props.editing || this.props.document == null || this.props.discussions == null) {
+    if (!this.props.editing || this.props.document == null) {
       return [];
     }
 
-    return parseFromJson(this.props.document, this.props.discussions);
+    return parseFromJson(this.props.document, this.discussions);
   }
 }

resources/js/beatmap-discussions/events.tsx

···
 import { trans } from 'utils/lang';
 
 interface Props {
-  discussions: Partial<Record<string, BeatmapsetDiscussionJson>>;
+  discussions: Map<number | null | undefined, BeatmapsetDiscussionJson>;
   events: BeatmapsetEventJson[];
-  users: Partial<Record<string, UserJson>>;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 export class Events extends React.PureComponent<Props> {

resources/js/beatmap-discussions/header.tsx

···
 import PlaymodeTabs from 'components/playmode-tabs';
 import StringWithComponent from 'components/string-with-component';
 import UserLink from 'components/user-link';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import BeatmapJson from 'interfaces/beatmap-json';
-import { BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
-import BeatmapsetEventJson from 'interfaces/beatmapset-event-json';
-import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import GameMode, { gameModes } from 'interfaces/game-mode';
-import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
-import { kebabCase, size, snakeCase } from 'lodash';
-import { deletedUser } from 'models/user';
-import core from 'osu-core-singleton';
+import { action, computed, makeObservable } from 'mobx';
+import { observer } from 'mobx-react';
+import { deletedUserJson } from 'models/user';
 import * as React from 'react';
-import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { getArtist, getTitle } from 'utils/beatmapset-helper';
-import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
 import BeatmapList from './beatmap-list';
 import Chart from './chart';
-import CurrentDiscussions, { Filter } from './current-discussions';
-import { DiscussionPage } from './discussion-mode';
+import DiscussionsState from './discussions-state';
 import { Nominations } from './nominations';
 import { Subscribe } from './subscribe';
+import TypeFilters from './type-filters';
 import { UserFilter } from './user-filter';
 
 interface Props {
-  beatmaps: Map<GameMode, BeatmapExtendedJson[]>;
-  beatmapset: BeatmapsetWithDiscussionsJson;
-  currentBeatmap: BeatmapExtendedJson;
-  currentDiscussions: CurrentDiscussions;
-  currentFilter: Filter;
-  discussions: Partial<Record<number, BeatmapsetDiscussionJsonForShow>>;
-  discussionStarters: UserJson[];
-  events: BeatmapsetEventJson[];
-  mode: DiscussionPage;
-  selectedUserId: number | null;
-  users: Partial<Record<number, UserJson>>;
+  discussionsState: DiscussionsState;
+  store: BeatmapsetDiscussionsStore;
 }
 
-const statTypes: Filter[] = ['mine', 'mapperNotes', 'resolved', 'pending', 'praises', 'deleted', 'total'];
+@observer
+export class Header extends React.Component<Props> {
+  private get beatmapset() {
+    return this.discussionsState.beatmapset;
+  }
+
+  private get currentBeatmap() {
+    return this.discussionsState.currentBeatmap;
+  }
+
+  private get discussionsState() {
+    return this.props.discussionsState;
+  }
 
-export class Header extends React.PureComponent<Props> {
+  @computed
+  private get timelineDiscussions() {
+    return this.discussionsState.discussionsForSelectedUserByMode.timeline;
+  }
+
+  private get users() {
+    return this.props.store.users;
+  }
+
+  constructor(props: Props) {
+    super(props);
+    makeObservable(this);
+  }
+
   render() {
     return (
       <>
         <HeaderV4
-          links={headerLinks('discussions', this.props.beatmapset)}
+          links={headerLinks('discussions', this.beatmapset)}
           linksAppend={(
             <PlaymodeTabs
-              currentMode={this.props.currentBeatmap.mode}
+              currentMode={this.currentBeatmap.mode}
               entries={gameModes.map((mode) => ({
-                count: this.props.currentDiscussions.countsByPlaymode[mode],
-                disabled: (this.props.beatmaps.get(mode)?.length ?? 0) === 0,
+                count: this.discussionsState.unresolvedDiscussionCounts.byMode[mode],
+                disabled: (this.discussionsState.groupedBeatmaps.get(mode)?.length ?? 0) === 0,
                 mode,
               }))}
               modifiers='beatmapset'
···
     );
   }
 
-  private readonly createLink = (beatmap: BeatmapJson) => makeUrl({ beatmap });
-
-  private readonly getCount = (beatmap: BeatmapExtendedJson) =>
-    beatmap.deleted_at == null
-      ? this.props.currentDiscussions.countsByBeatmap[beatmap.id]
-      : undefined;
-
+  @action
   private readonly onClickMode = (event: React.MouseEvent<HTMLAnchorElement>, mode: GameMode) => {
     event.preventDefault();
-    $.publish('playmode:set', [{ mode }]);
-  };
-
-  private readonly onSelectBeatmap = (beatmapId: number) => {
-    $.publish('beatmapsetDiscussions:update', {
-      beatmapId,
-      mode: 'timeline',
-    });
+    this.discussionsState.changeGameMode(mode);
   };
 
   private renderHeaderBottom() {
···
         <div className={`${bn}__content ${bn}__content--details`}>
           <div className={`${bn}__details ${bn}__details--full`}>
             <BeatmapsetMapping
-              beatmapset={this.props.beatmapset}
-              user={this.props.users[this.props.beatmapset.user_id]}
+              beatmapset={this.beatmapset}
+              user={this.users.get(this.beatmapset.user_id)}
             />
           </div>
           <div className={`${bn}__details`}>
-            <Subscribe beatmapset={this.props.beatmapset} />
+            <Subscribe beatmapset={this.beatmapset} discussionsState={this.discussionsState} />
           </div>
           <div className={`${bn}__details`}>
             <BigButton
-              href={route('beatmapsets.show', { beatmapset: this.props.beatmapset.id })}
+              href={route('beatmapsets.show', { beatmapset: this.beatmapset.id })}
               icon='fas fa-info'
               modifiers='full'
               text={trans('beatmaps.discussions.beatmap_information')}
···
         </div>
         <div className={`${bn}__content ${bn}__content--nomination`}>
           <Nominations
-            beatmapset={this.props.beatmapset}
-            currentDiscussions={this.props.currentDiscussions}
-            discussions={this.props.discussions}
-            events={this.props.events}
-            users={this.props.users}
+            discussionsState={this.discussionsState}
+            store={this.props.store}
           />
         </div>
       </div>
···
         <div className={`${bn}__content`}>
           <div className={`${bn}__cover`}>
             <BeatmapsetCover
-              beatmapset={this.props.beatmapset}
+              beatmapset={this.beatmapset}
               modifiers='full'
               size='cover'
             />
···
             <h1 className={`${bn}__title`}>
               <a
                 className='link link--white link--no-underline'
-                href={route('beatmapsets.show', { beatmapset: this.props.beatmapset.id })}
+                href={route('beatmapsets.show', { beatmapset: this.beatmapset.id })}
               >
-                {getTitle(this.props.beatmapset)}
+                {getTitle(this.beatmapset)}
               </a>
-              <BeatmapsetBadge beatmapset={this.props.beatmapset} type='nsfw' />
-              <BeatmapsetBadge beatmapset={this.props.beatmapset} type='spotlight' />
+              <BeatmapsetBadge beatmapset={this.beatmapset} type='nsfw' />
+              <BeatmapsetBadge beatmapset={this.beatmapset} type='spotlight' />
             </h1>
             <h2 className={`${bn}__title ${bn}__title--artist`}>
-              {getArtist(this.props.beatmapset)}
-              <BeatmapsetBadge beatmapset={this.props.beatmapset} type='featured_artist' />
+              {getArtist(this.beatmapset)}
+              <BeatmapsetBadge beatmapset={this.beatmapset} type='featured_artist' />
             </h2>
           </div>
           <div className={`${bn}__filters`}>
             <div className={`${bn}__filter-group`}>
               <BeatmapList
-                beatmaps={this.props.beatmaps.get(this.props.currentBeatmap.mode) ?? []}
-                beatmapset={this.props.beatmapset}
-                createLink={this.createLink}
-                currentBeatmap={this.props.currentBeatmap}
-                getCount={this.getCount}
-                onSelectBeatmap={this.onSelectBeatmap}
-                users={this.props.users}
+                discussionsState={this.discussionsState}
+                users={this.users}
               />
             </div>
             <div className={`${bn}__filter-group ${bn}__filter-group--stats`}>
               <UserFilter
-                ownerId={this.props.beatmapset.user_id}
-                selectedUser={this.props.selectedUserId != null ? this.props.users[this.props.selectedUserId] : null}
-                users={this.props.discussionStarters}
+                discussionsState={this.discussionsState}
+                store={this.props.store}
               />
               <div className={`${bn}__stats`}>
-                {statTypes.map(this.renderType)}
+                <TypeFilters discussionsState={this.discussionsState} />
               </div>
             </div>
           </div>
           <div className='u-relative'>
             <Chart
-              discussions={this.props.currentDiscussions.byFilter[this.props.currentFilter].timeline}
-              duration={this.props.currentBeatmap.total_length * 1000}
+              discussions={this.timelineDiscussions}
+              duration={this.currentBeatmap.total_length * 1000}
             />
             <div className={`${bn}__beatmap-stats`}>
               <div className={`${bn}__guest`}>
-                {this.props.currentBeatmap.user_id !== this.props.beatmapset.user_id && (
+                {this.currentBeatmap.user_id !== this.beatmapset.user_id && (
                   <span>
                     <StringWithComponent
                       mappings={{
-                        user: <UserLink user={this.props.users[this.props.currentBeatmap.user_id] ?? deletedUser} />,
+                        user: <UserLink user={this.users.get(this.currentBeatmap.user_id) ?? deletedUserJson} />,
                       }}
                       pattern={trans('beatmaps.discussions.guest')}
                     />
                   </span>
                 )}
               </div>
-              <BeatmapBasicStats beatmap={this.props.currentBeatmap} beatmapset={this.props.beatmapset} />
+              <BeatmapBasicStats beatmap={this.currentBeatmap} beatmapset={this.beatmapset} />
             </div>
           </div>
         </div>
       </div>
     );
   }
-
-  private readonly renderType = (type: Filter) => {
-    if ((type === 'deleted') && !core.currentUser?.is_admin) {
-      return null;
-    }
-
-    const bn = 'counter-box';
-
-    let topClasses = classWithModifiers(bn, 'beatmap-discussions', kebabCase(type));
-    if (this.props.mode !== 'events' && this.props.currentFilter === type) {
-      topClasses += ' js-active';
-    }
-
-    const discussionsByFilter = this.props.currentDiscussions.byFilter[type];
-    const total = Object.values(discussionsByFilter).reduce((acc, discussions) => acc + size(discussions), 0);
-
-    return (
-      <a
-        key={type}
-        className={topClasses}
-        data-type={type}
-        href={makeUrl({
-          beatmapId: this.props.currentBeatmap.id,
-          beatmapsetId: this.props.beatmapset.id,
-          filter: type,
-          mode: this.props.mode,
-        })}
-        onClick={this.setFilter}
-      >
-        <div className={`${bn}__content`}>
-          <div className={`${bn}__title`}>
-            {trans(`beatmaps.discussions.stats.${snakeCase(type)}`)}
-          </div>
-          <div className={`${bn}__count`}>
-            {total}
-          </div>
-        </div>
-        <div className={`${bn}__line`} />
-      </a>
-    );
-  };
-
-  private readonly setFilter = (event: React.SyntheticEvent<HTMLElement>) => {
-    event.preventDefault();
-    $.publish('beatmapsetDiscussions:update', { filter: event.currentTarget.dataset.type });
-  };
 }

resources/js/beatmap-discussions/love-beatmap-dialog.tsx

···
 import { group as groupBeatmaps } from 'utils/beatmap-helper';
 import { trans } from 'utils/lang';
 import { hideLoadingOverlay, showImmediateLoadingOverlay } from 'utils/loading-overlay';
+import DiscussionsState from './discussions-state';
 
 interface Props {
   beatmapset: BeatmapsetExtendedJson & Required<Pick<BeatmapsetExtendedJson, 'beatmaps'>>;
+  discussionsState: DiscussionsState;
   onClose: () => void;
 }
 
···
 
     this.xhr = $.ajax(url, params);
     this.xhr.done((beatmapset) => {
-      $.publish('beatmapsetDiscussions:update', { beatmapset });
+      this.props.discussionsState.update({ beatmapset });
       this.props.onClose();
     }).fail(onError)
       .always(action(() => {

resources/js/beatmap-discussions/main.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 { DiscussionsContext } from 'beatmap-discussions/discussions-context'
-import { BeatmapsContext } from 'beatmap-discussions/beatmaps-context'
-import NewReview from 'beatmap-discussions/new-review'
-import { ReviewEditorConfigContext } from 'beatmap-discussions/review-editor-config-context'
-import BackToTop from 'components/back-to-top'
-import { route } from 'laroute'
-import { deletedUserJson } from 'models/user'
-import core from 'osu-core-singleton'
-import * as React from 'react'
-import { div } from 'react-dom-factories'
-import * as BeatmapHelper from 'utils/beatmap-helper'
-import { defaultFilter, defaultMode, makeUrl, parseUrl, stateFromDiscussion } from 'utils/beatmapset-discussion-helper'
-import { nextVal } from 'utils/seq'
-import { currentUrl } from 'utils/turbolinks'
-import { Discussions } from './discussions'
-import { Events } from './events'
-import { Header } from './header'
-import { ModeSwitcher } from './mode-switcher'
-import { NewDiscussion } from './new-discussion'
-
-el = React.createElement
-
-export class Main extends React.PureComponent
-  constructor: (props) ->
-    super props
-
-    @eventId = "beatmap-discussions-#{nextVal()}"
-    @modeSwitcherRef = React.createRef()
-    @newDiscussionRef = React.createRef()
-
-    @checkNewTimeoutDefault = 10000
-    @checkNewTimeoutMax = 60000
-    @cache = {}
-    @disposers = new Set
-    @timeouts = {}
-    @xhr = {}
-    @state = JSON.parse(props.container.dataset.beatmapsetDiscussionState ? null)
-    @restoredState = @state?
-
-    if @restoredState
-      @state.readPostIds = new Set(@state.readPostIdsArray)
-    else
-      beatmapset = props.initial.beatmapset
-      reviewsConfig = props.initial.reviews_config
-      showDeleted = true
-      readPostIds = new Set
-
-      for discussion in beatmapset.discussions
-        for post in discussion?.posts ? []
-          readPostIds.add(post.id) if post?
-
-      @state = {beatmapset, currentUser, readPostIds, reviewsConfig, showDeleted}
-
-    @state.pinnedNewDiscussion ?= false
-
-    # Current url takes priority over saved state.
-    query = @queryFromLocation(@state.beatmapset.discussions)
-    @state.currentMode = query.mode
-    @state.currentFilter = query.filter
-    @state.currentBeatmapId = query.beatmapId if query.beatmapId?
-    @state.selectedUserId = query.user
-    # FIXME: update url handler to recognize this instead
-    @focusNewDiscussion = currentUrl().hash == '#new'
-
-
-  componentDidMount: =>
-    @focusNewDiscussion = false
-    $.subscribe "playmode:set.#{@eventId}", @setCurrentPlaymode
-
-    $.subscribe "beatmapsetDiscussions:update.#{@eventId}", @update
-    $.subscribe "beatmapDiscussion:jump.#{@eventId}", @jumpTo
-    $.subscribe "beatmapDiscussionPost:markRead.#{@eventId}", @markPostRead
-    $.subscribe "beatmapDiscussionPost:toggleShowDeleted.#{@eventId}", @toggleShowDeleted
-
-    $(document).on "ajax:success.#{@eventId}", '.js-beatmapset-discussion-update', @ujsDiscussionUpdate
-    $(document).on "click.#{@eventId}", '.js-beatmap-discussion--jump', @jumpToClick
-    $(document).on "turbolinks:before-cache.#{@eventId}", @saveStateToContainer
-
-    if !@restoredState
-      @disposers.add core.reactTurbolinks.runAfterPageLoad(@jumpToDiscussionByHash)
-
-    @timeouts.checkNew = Timeout.set @checkNewTimeoutDefault, @checkNew
-
-
-  componentDidUpdate: (_prevProps, prevState) =>
-    return if prevState.currentBeatmapId == @state.currentBeatmapId &&
-      prevState.currentFilter == @state.currentFilter &&
-      prevState.currentMode == @state.currentMode &&
-      prevState.selectedUserId == @state.selectedUserId &&
-      prevState.showDeleted == @state.showDeleted
-
-    Turbolinks.controller.advanceHistory @urlFromState()
-
-
-  componentWillUnmount: =>
-    $.unsubscribe ".#{@eventId}"
-    $(document).off ".#{@eventId}"
-
-    document.documentElement.style.removeProperty '--scroll-padding-top-extra'
-
-    Timeout.clear(timeout) for _name, timeout of @timeouts
-    xhr?.abort() for _name, xhr of @xhr
-    @disposers.forEach (disposer) => disposer?()
-
-
-  render: =>
-    @cache = {}
-
-    el React.Fragment, null,
-      el Header,
-        beatmaps: @groupedBeatmaps()
-        beatmapset: @state.beatmapset
-        currentBeatmap: @currentBeatmap()
-        currentDiscussions: @currentDiscussions()
-        currentFilter: @state.currentFilter
-        currentUser: @state.currentUser
-        discussions: @discussions()
-        discussionStarters: @discussionStarters()
-        events: @state.beatmapset.events
-        mode: @state.currentMode
-        selectedUserId: @state.selectedUserId
-        users: @users()
-
-      el ModeSwitcher,
-        innerRef: @modeSwitcherRef
-        mode: @state.currentMode
-        beatmapset: @state.beatmapset
-        currentBeatmap: @currentBeatmap()
-        currentDiscussions: @currentDiscussions()
-        currentFilter: @state.currentFilter
-
-      if @state.currentMode == 'events'
-        el Events,
-          events: @state.beatmapset.events
-          users: @users()
-          discussions: @discussions()
-
-      else
-        el DiscussionsContext.Provider,
-          value: @discussions()
-          el BeatmapsContext.Provider,
-            value: @beatmaps()
-            el ReviewEditorConfigContext.Provider,
-              value: @state.reviewsConfig
-
-              if @state.currentMode == 'reviews'
-                el NewReview,
-                  beatmapset: @state.beatmapset
-                  beatmaps: @beatmaps()
-                  currentBeatmap: @currentBeatmap()
-                  currentUser: @state.currentUser
-                  innerRef: @newDiscussionRef
-                  onFocus: @handleNewDiscussionFocus
-                  pinned: @state.pinnedNewDiscussion
-                  setPinned: @setPinnedNewDiscussion
-                  stickTo: @modeSwitcherRef
-              else
-                el NewDiscussion,
-                  beatmapset: @state.beatmapset
-                  currentUser: @state.currentUser
-                  currentBeatmap: @currentBeatmap()
-                  currentDiscussions: @currentDiscussions()
-                  innerRef: @newDiscussionRef
-                  mode: @state.currentMode
-                  onFocus: @handleNewDiscussionFocus
-                  pinned: @state.pinnedNewDiscussion
-                  setPinned: @setPinnedNewDiscussion
-                  stickTo: @modeSwitcherRef
-                  autoFocus: @focusNewDiscussion
-
-              el Discussions,
-                beatmapset: @state.beatmapset
-                currentBeatmap: @currentBeatmap()
-                currentDiscussions: @currentDiscussions()
-                currentFilter: @state.currentFilter
-                currentUser: @state.currentUser
-                mode: @state.currentMode
-                readPostIds: @state.readPostIds
-                showDeleted: @state.showDeleted
-                users: @users()
-
-      el BackToTop
-
-
-  beatmaps: =>
-    return @cache.beatmaps if @cache.beatmaps?
-
-    hasDiscussion = {}
-    for discussion in @state.beatmapset.discussions
-      hasDiscussion[discussion.beatmap_id] = true if discussion?
-
-    @cache.beatmaps ?=
-      _(@state.beatmapset.beatmaps)
-      .filter (beatmap) ->
-        !_.isEmpty(beatmap) && (!beatmap.deleted_at? || hasDiscussion[beatmap.id]?)
-      .keyBy 'id'
-      .value()
-
-
-  checkNew: =>
-    @nextTimeout ?= @checkNewTimeoutDefault
-
-    Timeout.clear @timeouts.checkNew
-    @xhr.checkNew?.abort()
-
-    @xhr.checkNew = $.get route('beatmapsets.discussion', beatmapset: @state.beatmapset.id),
-      format: 'json'
-      last_updated: @lastUpdate()?.unix()
-    .done (data, _textStatus, xhr) =>
-      if xhr.status == 304
-        @nextTimeout *= 2
-        return
-
-      @nextTimeout = @checkNewTimeoutDefault
-
-      @update null, beatmapset: data.beatmapset
-
-    .always =>
-      @nextTimeout = Math.min @nextTimeout, @checkNewTimeoutMax
-
-      @timeouts.checkNew = Timeout.set @nextTimeout, @checkNew
-
-
-  currentBeatmap: =>
-    @beatmaps()[@state.currentBeatmapId] ? BeatmapHelper.findDefault(group: @groupedBeatmaps())
-
-
-  currentDiscussions: =>
-    return @cache.currentDiscussions if @cache.currentDiscussions?
-
-    countsByBeatmap = {}
-    countsByPlaymode = {}
-    totalHype = 0
-    unresolvedIssues = 0
-    byMode =
-      timeline: []
-      general: []
-      generalAll: []
-      reviews: []
-    byFilter =
-      deleted: {}
-      hype: {}
-      mapperNotes: {}
-      mine: {}
-      pending: {}
-      praises: {}
-      resolved: {}
-      total: {}
-    timelineAllUsers = []
-
-    for own mode, _items of byMode
-      for own _filter, modes of byFilter
-        modes[mode] = {}
-
-    for own _id, d of @discussions()
-      if !d.deleted_at?
-        totalHype++ if d.message_type == 'hype'
-
-        if d.can_be_resolved && !d.resolved
-          beatmap = @beatmaps()[d.beatmap_id]
-
-          if !d.beatmap_id? || (beatmap? && !beatmap.deleted_at?)
-            unresolvedIssues++
-
-          if beatmap?
-            countsByBeatmap[beatmap.id] ?= 0
-            countsByBeatmap[beatmap.id]++
-
-            if !beatmap.deleted_at?
-              countsByPlaymode[beatmap.mode] ?= 0
-              countsByPlaymode[beatmap.mode]++
-
-      if d.message_type == 'review'
-        mode = 'reviews'
-      else
-        if d.beatmap_id?
-          if d.beatmap_id == @currentBeatmap().id
-            if d.timestamp?
-              mode = 'timeline'
-              timelineAllUsers.push d
-            else
-              mode = 'general'
-          else
-            mode = null
-        else
-          mode = 'generalAll'
-
-      # belongs to different beatmap, excluded
-      continue unless mode?
-
-      # skip if filtering users
-      continue if @state.selectedUserId? && d.user_id != @state.selectedUserId
-
-      filters = total: true
-
-      if d.deleted_at?
-        filters.deleted = true
-      else if d.message_type == 'hype'
-        filters.hype = true
-        filters.praises = true
-      else if d.message_type == 'praise'
-        filters.praises = true
-      else if d.can_be_resolved
-        if d.resolved
-          filters.resolved = true
-        else
-          filters.pending = true
-
-      if d.user_id == @state.currentUser.id
-        filters.mine = true
-
-      if d.message_type == 'mapper_note'
-        filters.mapperNotes = true
-
-      # the value should always be true
-      for own filter, _isSet of filters
-        byFilter[filter][mode][d.id] = d
-
-      if filters.pending && d.parent_id?
-        parentDiscussion = @discussions()[d.parent_id]
-
-        if parentDiscussion? && parentDiscussion.message_type == 'review'
-          byFilter.pending.reviews[parentDiscussion.id] = parentDiscussion
-
-      byMode[mode].push d
-
-    timeline = byMode.timeline
-    general = byMode.general
-    generalAll = byMode.generalAll
-    reviews = byMode.reviews
-
-    @cache.currentDiscussions = {general, generalAll, timeline, reviews, timelineAllUsers, byFilter, countsByBeatmap, countsByPlaymode, totalHype, unresolvedIssues}
-
-
-  discussions: =>
-    # skipped discussions
-    # - not privileged (deleted discussion)
-    # - deleted beatmap
-    @cache.discussions ?= _ @state.beatmapset.discussions
-                            .filter (d) -> !_.isEmpty(d)
-                            .keyBy 'id'
-                            .value()
-
-
-  discussionStarters: =>
-    _ @discussions()
-      .filter (discussion) -> discussion.message_type != 'hype'
-      .map 'user_id'
-      .uniq()
-      .map (user_id) => @users()[user_id]
-      .orderBy (user) -> user.username.toLocaleLowerCase()
-      .value()
-
-
-  groupedBeatmaps: (discussionSet) =>
-    @cache.groupedBeatmaps ?= BeatmapHelper.group _.values(@beatmaps())
-
-
-  handleNewDiscussionFocus: =>
-    # Bug with position: sticky and scroll-padding: https://bugs.chromium.org/p/chromium/issues/detail?id=1466472
-    document.documentElement.style.removeProperty '--scroll-padding-top-extra'
-
-
-  jumpToDiscussionByHash: =>
-    target = parseUrl(null, @state.beatmapset.discussions)
-
-    @jumpTo(null, id: target.discussionId, postId: target.postId) if target.discussionId?
-
-
-  jumpTo: (_e, {id, postId}) =>
-    discussion = @discussions()[id]
-
-    return if !discussion?
-
-    newState = stateFromDiscussion(discussion)
-
-    newState.filter =
-      if @currentDiscussions().byFilter[@state.currentFilter][newState.mode][id]?
-        @state.currentFilter
-      else
-        defaultFilter
-
-    if @state.selectedUserId? && @state.selectedUserId != discussion.user_id
-      newState.selectedUserId = null
-
-    newState.callback = =>
-      $.publish 'beatmapset-discussions:highlight', discussionId: discussion.id
-
-      attribute = if postId? then "data-post-id='#{postId}'" else "data-id='#{id}'"
-      target = document.querySelector(".js-beatmap-discussion-jump[#{attribute}]")
-
-      return unless target? && @modeSwitcherRef.current? && @newDiscussionRef.current?
-
-      margin = @modeSwitcherRef.current.getBoundingClientRect().height
-      margin += @newDiscussionRef.current.getBoundingClientRect().height if @state.pinnedNewDiscussion
-
-      # Update scroll-padding instead of adding scroll-margin, otherwise it doesn't anchor in the right place.
-      document.documentElement.style.setProperty '--scroll-padding-top-extra', "#{Math.floor(margin)}px"
-
-      # avoid smooth scrolling to avoid triggering lazy loaded images.
-      # FIXME: Safari still has the issue where images just out of view get loaded and push the page down
-      # because it doesn't anchor the scroll position.
-      target.scrollIntoView behavior: 'instant', block: 'start', inline: 'nearest'
-
-    @update null, newState
-
-
-  jumpToClick: (e) =>
-    url = e.currentTarget.getAttribute('href')
-    { discussionId, postId } = parseUrl(url, @state.beatmapset.discussions)
-
-    return if !discussionId?
-
-    e.preventDefault()
-    @jumpTo null, { id: discussionId, postId }
-
-
-  lastUpdate: =>
-    lastUpdate = _.max [
-      @state.beatmapset.last_updated
-      _.maxBy(@state.beatmapset.discussions, 'updated_at')?.updated_at
-      _.maxBy(@state.beatmapset.events, 'created_at')?.created_at
-    ]
-
-    moment(lastUpdate) if lastUpdate?
-
-
-  markPostRead: (_e, {id}) =>
-    return if @state.readPostIds.has(id)
-
-    newSet = new Set(@state.readPostIds)
-    if Array.isArray(id)
-      newSet.add(i) for i in id
-    else
-      newSet.add(id)
-
-    @setState readPostIds: newSet
-
-
-  queryFromLocation: (discussions = @state.beatmapsetDiscussion.beatmap_discussions) =>
-    parseUrl(null, discussions)
-
-
-  saveStateToContainer: =>
-    # This is only so it can be stored with JSON.stringify.
-    @state.readPostIdsArray = Array.from(@state.readPostIds)
-    @props.container.dataset.beatmapsetDiscussionState = JSON.stringify(@state)
-
-
-  setCurrentPlaymode: (e, {mode}) =>
-    @update e, playmode: mode
-
-
-  setPinnedNewDiscussion: (pinned) =>
-    @setState pinnedNewDiscussion: pinned
-
-
-  toggleShowDeleted: =>
-    @setState showDeleted: !@state.showDeleted
-
-
-  update: (_e, options) =>
-    {
-      callback
-      mode
-      modeIf
-      beatmapId
-      playmode
-      beatmapset
-      watching
-      filter
-      selectedUserId
-    } = options
-    newState = {}
-
-    if beatmapset?
-      newState.beatmapset = beatmapset
-
-    if watching?
-      newState.beatmapset ?= _.assign {}, @state.beatmapset
-      newState.beatmapset.current_user_attributes.is_watching = watching
-
-    if playmode?
-      beatmap = BeatmapHelper.findDefault items: @groupedBeatmaps().get(playmode)
-      beatmapId = beatmap?.id
-
-    if beatmapId? && beatmapId != @currentBeatmap().id
-      newState.currentBeatmapId = beatmapId
-
-    if filter?
-      if @state.currentMode == 'events'
-        newState.currentMode = @lastMode ? defaultMode(newState.currentBeatmapId)
-
-      if filter != @state.currentFilter
-        newState.currentFilter = filter
-
-    if mode? && mode != @state.currentMode
-      if !modeIf? || modeIf == @state.currentMode
-        newState.currentMode = mode
-
-      # switching to events:
-      # - record last filter, to be restored when setMode is called
-      # - record last mode, to be restored when setFilter is called
-      # - set filter to total
-      if mode == 'events'
-        @lastMode = @state.currentMode
-        @lastFilter = @state.currentFilter
-        newState.currentFilter = 'total'
-      # switching from events:
-      # - restore whatever last filter set or default to total
-      else if @state.currentMode == 'events'
-        newState.currentFilter = @lastFilter ? 'total'
-
-    newState.selectedUserId = selectedUserId if selectedUserId != undefined # need to setState if null
-
-    @setState newState, callback
-
-
-  urlFromState: =>
-    makeUrl
-      beatmap: @currentBeatmap()
-      mode: @state.currentMode
-      filter: @state.currentFilter
-      user: @state.selectedUserId
-
-
-  users: =>
-    if !@cache.users?
-      @cache.users = _.keyBy @state.beatmapset.related_users, 'id'
-      @cache.users[null] = @cache.users[undefined] = deletedUserJson
-
-    @cache.users
-
-
-  ujsDiscussionUpdate: (_e, data) =>
-    # to allow ajax:complete to be run
-    Timeout.set 0, => @update(null, beatmapset: data)

resources/js/beatmap-discussions/main.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 NewReview from 'beatmap-discussions/new-review';
+import { ReviewEditorConfigContext } from 'beatmap-discussions/review-editor-config-context';
+import BackToTop from 'components/back-to-top';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
+import { route } from 'laroute';
+import { action, makeObservable, observable, toJS } from 'mobx';
+import { observer } from 'mobx-react';
+import core from 'osu-core-singleton';
+import * as React from 'react';
+import BeatmapsetDiscussionsShowStore from 'stores/beatmapset-discussions-show-store';
+import { defaultFilter, parseUrl, stateFromDiscussion } from 'utils/beatmapset-discussion-helper';
+import { parseJson, storeJson } from 'utils/json';
+import { nextVal } from 'utils/seq';
+import { currentUrl } from 'utils/turbolinks';
+import { Discussions } from './discussions';
+import DiscussionsState from './discussions-state';
+import { Events } from './events';
+import { Header } from './header';
+import { ModeSwitcher } from './mode-switcher';
+import { NewDiscussion } from './new-discussion';
+
+const checkNewTimeoutDefault = 10000;
+const checkNewTimeoutMax = 60000;
+const beatmapsetJsonId = 'json-beatmapset';
+
+interface Props {
+  reviewsConfig: {
+    max_blocks: number;
+  };
+}
+
+interface UpdateResponseJson {
+  beatmapset: BeatmapsetWithDiscussionsJson;
+}
+
+@observer
+export default class Main extends React.Component<Props> {
+  @observable private readonly discussionsState: DiscussionsState;
+  private readonly disposers = new Set<((() => void) | undefined)>();
+  private readonly eventId = `beatmap-discussions-${nextVal()}`;
+  // FIXME: update url handler to recognize this instead
+  private readonly focusNewDiscussion = currentUrl().hash === '#new';
+  private readonly modeSwitcherRef = React.createRef<HTMLDivElement>();
+  private readonly newDiscussionRef = React.createRef<HTMLDivElement>();
+  private nextTimeout = checkNewTimeoutDefault;
+  @observable private readonly store;
+  private timeoutCheckNew?: number;
+  private xhrCheckNew?: JQuery.jqXHR<UpdateResponseJson>;
+
+  constructor(props: Props) {
+    super(props);
+
+    // TODO: avoid reparsing/loading everything on browser navigation for better performance.
+    const beatmapset = parseJson<BeatmapsetWithDiscussionsJson>(beatmapsetJsonId);
+
+    this.store = new BeatmapsetDiscussionsShowStore(beatmapset);
+    this.discussionsState = new DiscussionsState(this.store);
+
+    makeObservable(this);
+  }
+
+  componentDidMount() {
+    $(document).on(`ajax:success.${this.eventId}`, '.js-beatmapset-discussion-update', this.ujsDiscussionUpdate);
+    $(document).on(`click.${this.eventId}`, '.js-beatmap-discussion--jump', this.jumpToClick);
+    document.addEventListener('turbolinks:before-cache', this.destroy);
+
+    if (this.discussionsState.jumpToDiscussion) {
+      this.disposers.add(core.reactTurbolinks.runAfterPageLoad(this.jumpToDiscussionByHash));
+    }
+
+    this.timeoutCheckNew = window.setTimeout(this.checkNew, checkNewTimeoutDefault);
+  }
+
+  componentWillUnmount() {
+    $.unsubscribe(`.${this.eventId}`);
+    $(document).off(`.${this.eventId}`);
+  }
+
+  render() {
+    return (
+      <>
+        <Header
+          discussionsState={this.discussionsState}
+          store={this.store}
+        />
+        <ModeSwitcher
+          discussionsState={this.discussionsState}
+          innerRef={this.modeSwitcherRef}
+        />
+        {this.discussionsState.currentPage === 'events' ? (
+          <Events
+            discussions={this.store.discussions}
+            events={this.discussionsState.beatmapset.events}
+            users={this.store.users}
+          />
+        ) : (
+          <ReviewEditorConfigContext.Provider value={this.props.reviewsConfig}>
+            {this.discussionsState.currentPage === 'reviews' ? (
+              <NewReview
+                discussionsState={this.discussionsState}
+                innerRef={this.newDiscussionRef}
+                onFocus={this.handleNewDiscussionFocus}
+                stickTo={this.modeSwitcherRef}
+                store={this.store}
+              />
+            ) : (
+              <NewDiscussion
+                autoFocus={this.focusNewDiscussion}
+                discussionsState={this.discussionsState}
+                innerRef={this.newDiscussionRef}
+                onFocus={this.handleNewDiscussionFocus}
+                stickTo={this.modeSwitcherRef}
+
+              />
+            )}
+            <Discussions
+              discussionsState={this.discussionsState}
+              store={this.store}
+            />
+          </ReviewEditorConfigContext.Provider>
+        )}
+        <BackToTop />
+      </>
+    );
+  }
+
+  @action
+  private readonly checkNew = () => {
+    if (this.xhrCheckNew != null) return;
+
+    window.clearTimeout(this.timeoutCheckNew);
+
+    this.xhrCheckNew = $.get(route('beatmapsets.discussion', { beatmapset: this.discussionsState.beatmapset.id }), {
+      format: 'json',
+      last_updated: this.discussionsState.lastUpdate,
+    });
+
+    this.xhrCheckNew.done((data, _textStatus, xhr) => {
+      if (xhr.status === 304) {
+        this.nextTimeout *= 2;
+        return;
+      }
+
+      this.nextTimeout = checkNewTimeoutDefault;
+      this.discussionsState.update({ beatmapset: data.beatmapset });
+    }).always(() => {
+      this.nextTimeout = Math.min(this.nextTimeout, checkNewTimeoutMax);
+
+      this.timeoutCheckNew = window.setTimeout(this.checkNew, this.nextTimeout);
+      this.xhrCheckNew = undefined;
+    });
+  };
+
+  private readonly destroy = () => {
+    document.removeEventListener('turbolinks:before-cache', this.destroy);
+
+    document.documentElement.style.removeProperty('--scroll-padding-top-extra');
+    window.clearTimeout(this.timeoutCheckNew);
+    this.xhrCheckNew?.abort();
+
+    storeJson(beatmapsetJsonId, toJS(this.store.beatmapset));
+    this.discussionsState.saveState();
+
+    this.disposers.forEach((disposer) => disposer?.());
+    this.discussionsState.destroy();
+  };
+
+  private readonly handleNewDiscussionFocus = () => {
+    // Bug with position: sticky and scroll-padding: https://bugs.chromium.org/p/chromium/issues/detail?id=1466472
+    document.documentElement.style.removeProperty('--scroll-padding-top-extra');
+  };
+
+  @action
+  private jumpTo(id: number, postId?: number) {
+    const discussion = this.store.discussions.get(id);
+
+    if (discussion == null) return;
+
+    const {
+      beatmapId,
+      mode,
+    } = stateFromDiscussion(discussion);
+
+    // unset filter
+    const currentDiscussionsByMode = this.discussionsState.discussionsByMode[mode];
+    if (currentDiscussionsByMode.find((d) => d.id === discussion.id) == null) {
+      this.discussionsState.currentFilter = defaultFilter;
+    }
+
+    // unset user filter if new discussion would have been filtered out.
+    if (this.discussionsState.selectedUserId != null && this.discussionsState.selectedUserId !== discussion.user_id) {
+      this.discussionsState.selectedUserId = null;
+    }
+
+    if (beatmapId != null) {
+      this.discussionsState.currentBeatmapId = beatmapId;
+    }
+
+    this.discussionsState.currentPage = mode;
+    this.discussionsState.highlightedDiscussionId = discussion.id;
+
+    window.setTimeout(() => this.jumpToAfterRender(id, postId), 0);
+  }
+
+  private jumpToAfterRender(discussionId: number, postId?: number) {
+    const attribute = postId != null ? `data-post-id='${postId}'` : `data-id='${discussionId}'`;
+    const target = document.querySelector(`.js-beatmap-discussion-jump[${attribute}]`);
+
+    if (target == null || this.modeSwitcherRef.current == null || this.newDiscussionRef.current == null) return;
+
+    let margin = this.modeSwitcherRef.current.getBoundingClientRect().height;
+    if (this.discussionsState.pinnedNewDiscussion) {
+      margin += this.newDiscussionRef.current.getBoundingClientRect().height;
+    }
+
+    // Update scroll-padding instead of adding scroll-margin, otherwise it doesn't anchor in the right place.
+    document.documentElement.style.setProperty('--scroll-padding-top-extra', `${Math.floor(margin)}px`);
+
+    // avoid smooth scrolling to avoid triggering lazy loaded images.
+    // FIXME: Safari still has the issue where images just out of view get loaded and push the page down
+    // because it doesn't anchor the scroll position.
+    target.scrollIntoView({ behavior: 'instant', block: 'start', inline: 'nearest' });
+  }
+
+  private readonly jumpToClick = (e: JQuery.TriggeredEvent<Document, unknown, HTMLElement, HTMLElement>) => {
+    if (!(e.currentTarget instanceof HTMLAnchorElement)) return;
+
+    const url = e.currentTarget.href;
+    const parsedUrl = parseUrl(url, this.discussionsState.discussionsArray);
+
+    if (parsedUrl == null) return;
+
+    const { discussionId, postId } = parsedUrl;
+
+    if (discussionId == null) return;
+
+    e.preventDefault();
+    this.jumpTo(discussionId, postId);
+  };
+
+  private readonly jumpToDiscussionByHash = () => {
+    const target = parseUrl(null, this.discussionsState.discussionsArray);
+
+    if (target?.discussionId != null) {
+      this.jumpTo(target.discussionId, target.postId);
+    }
+  };
+
+  private readonly ujsDiscussionUpdate = (_event: unknown, beatmapset: BeatmapsetWithDiscussionsJson) => {
+    // to allow ajax:complete to be run
+    window.setTimeout(() => this.discussionsState.update({ beatmapset }), 0);
+  };
+}

resources/js/beatmap-discussions/mode-switcher.tsx

···
 // See the LICENCE file in the repository root for full licence text.
 
 import StringWithComponent from 'components/string-with-component';
-import BeatmapJson from 'interfaces/beatmap-json';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
-import { snakeCase, size } from 'lodash';
+import { snakeCase } from 'lodash';
+import { action } from 'mobx';
+import { observer } from 'mobx-react';
 import * as React from 'react';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
-import CurrentDiscussions, { Filter } from './current-discussions';
-import { DiscussionPage, discussionPages } from './discussion-mode';
+import DiscussionPage, { discussionPages } from './discussion-page';
+import DiscussionsState from './discussions-state';
 
 interface Props {
-  beatmapset: BeatmapsetJson;
-  currentBeatmap: BeatmapJson;
-  currentDiscussions: CurrentDiscussions;
-  currentFilter: Filter;
+  discussionsState: DiscussionsState;
   innerRef: React.RefObject<HTMLDivElement>;
-  mode: DiscussionPage;
 }
 
 const selectedClassName = 'page-mode-link--is-active';
 
-export class ModeSwitcher extends React.PureComponent<Props> {
+@observer
+export class ModeSwitcher extends React.Component<Props> {
   private readonly scrollerRef = React.createRef<HTMLUListElement>();
 
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
+  private get currentBeatmap() {
+    return this.props.discussionsState.currentBeatmap;
+  }
+
+  private get currentMode() {
+    return this.props.discussionsState.currentPage;
+  }
+
   componentDidMount() {
     this.scrollModeSwitcher();
   }
···
   private readonly renderMode = (mode: DiscussionPage) => (
     <li key={mode} className='page-mode__item'>
       <a
-        className={classWithModifiers('page-mode-link', { 'is-active': this.props.mode === mode })}
+        className={classWithModifiers('page-mode-link', { 'is-active': this.currentMode === mode })}
         data-mode={mode}
         href={makeUrl({
-          beatmapId: this.props.currentBeatmap.id,
-          beatmapsetId: this.props.beatmapset.id,
+          beatmapId: this.currentBeatmap.id,
+          beatmapsetId: this.beatmapset.id,
           mode,
         })}
         onClick={this.switch}
···
           {this.renderModeText(mode)}
           {mode !== 'events' && (
             <span className='page-mode-link__badge'>
-              {size(this.props.currentDiscussions.byFilter[this.props.currentFilter][mode])}
+              {this.props.discussionsState.discussionsForSelectedUserByMode[mode].length}
             </span>
           )}
           <span className='page-mode-link__stripe' />
···
   private renderModeText(mode: DiscussionPage) {
     if (mode === 'general' || mode === 'generalAll') {
       const text = mode === 'general'
-        ? this.props.currentBeatmap.version
+        ? this.currentBeatmap.version
         : trans('beatmaps.discussions.mode.scopes.generalAll');
 
       return (
···
     $(this.scrollerRef.current).scrollTo(`.${selectedClassName}`, 0, { over: { left: -1 } });
   }
 
+  @action
   private readonly switch = (e: React.SyntheticEvent<HTMLAnchorElement>) => {
     e.preventDefault();
 
-    $.publish('beatmapsetDiscussions:update', { mode: e.currentTarget.dataset.mode });
+    this.props.discussionsState.changeDiscussionPage(e.currentTarget.dataset.mode);
   };
 }

resources/js/beatmap-discussions/new-discussion.tsx

···
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import { BeatmapsetDiscussionPostStoreResponseJson } from 'interfaces/beatmapset-discussion-post-responses';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
-import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import { route } from 'laroute';
-import { action, computed, makeObservable, observable, runInAction } from 'mobx';
-import { observer } from 'mobx-react';
+import { action, computed, makeObservable, observable, reaction, runInAction } from 'mobx';
+import { disposeOnUnmount, observer } from 'mobx-react';
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { onError } from 'utils/ajax';
···
 import { joinComponents, trans } from 'utils/lang';
 import { hideLoadingOverlay, showLoadingOverlay } from 'utils/loading-overlay';
 import { present } from 'utils/string';
-import CurrentDiscussions from './current-discussions';
 import DiscussionMessageLengthCounter from './discussion-message-length-counter';
-import DiscussionMode from './discussion-mode';
+import DiscussionsState from './discussions-state';
 import { hypeExplanationClass } from './nominations';
 
 const bn = 'beatmap-discussion-new';
···
 
 interface Props {
   autoFocus: boolean;
-  beatmapset: BeatmapsetExtendedJson & BeatmapsetWithDiscussionsJson;
-  currentBeatmap: BeatmapExtendedJson;
-  currentDiscussions: CurrentDiscussions;
+  discussionsState: DiscussionsState;
   innerRef: React.RefObject<HTMLDivElement>;
-  mode: DiscussionMode;
   onFocus?: () => void;
-  pinned: boolean;
-  setPinned: (flag: boolean) => void;
   stickTo: React.RefObject<HTMLElement>;
 }
 
···
   @observable private stickToHeight: number | undefined;
   @observable private timestampConfirmed = false;
 
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
+  private get currentBeatmap() {
+    return this.props.discussionsState.currentBeatmap;
+  }
+
+  private get currentMode() {
+    return this.props.discussionsState.currentPage;
+  }
+
   private get canPost() {
     if (core.currentUser == null) return false;
-    if (downloadLimited(this.props.beatmapset)) return false;
+    if (downloadLimited(this.beatmapset)) return false;
 
     return !core.currentUser.is_silenced
-      && (!this.props.beatmapset.discussion_locked || canModeratePosts())
-      && (this.props.currentBeatmap.deleted_at == null || this.props.mode === 'generalAll');
+      && (!this.beatmapset.discussion_locked || canModeratePosts())
+      && (this.currentBeatmap.deleted_at == null || this.currentMode === 'generalAll');
   }
 
   @computed
   private get cssTop() {
-    if (this.mounted && this.props.pinned && this.stickToHeight != null) {
+    if (this.mounted && this.pinned && this.stickToHeight != null) {
       return core.stickyHeader.headerHeight + this.stickToHeight;
     }
   }
 
   private get isTimeline() {
-    return this.props.mode === 'timeline';
+    return this.currentMode === 'timeline';
   }
 
   private get nearbyDiscussions() {
     const timestamp = this.timestamp;
     if (timestamp == null) return [];
 
-    if (this.nearbyDiscussionsCache == null || (this.nearbyDiscussionsCache.beatmap !== this.props.currentBeatmap || this.nearbyDiscussionsCache.timestamp !== this.timestamp)) {
+    if (this.nearbyDiscussionsCache == null || (this.nearbyDiscussionsCache.beatmap !== this.currentBeatmap || this.nearbyDiscussionsCache.timestamp !== this.timestamp)) {
       this.nearbyDiscussionsCache = {
-        beatmap: this.props.currentBeatmap,
-        discussions: nearbyDiscussions(this.props.currentDiscussions.timelineAllUsers, timestamp),
+        beatmap: this.currentBeatmap,
+        discussions: nearbyDiscussions(this.props.discussionsState.discussionForSelectedBeatmap, timestamp),
         timestamp: this.timestamp,
       };
     }
···
     return this.nearbyDiscussionsCache.discussions;
   }
 
+  private get pinned() {
+    return this.props.discussionsState.pinnedNewDiscussion;
+  }
+
   private get storageKey() {
-    return `beatmapset-discussion:store:${this.props.beatmapset.id}:message`;
+    return `beatmapset-discussion:store:${this.beatmapset.id}:message`;
   }
 
   private get storedMessage() {
···
     if (core.currentUser == null) return;
 
     if (this.canPost) {
-      return trans(`beatmaps.discussions.message_placeholder.${this.props.mode}`, { version: this.props.currentBeatmap.version });
+      return trans(`beatmaps.discussions.message_placeholder.${this.currentMode}`, { version: this.currentBeatmap.version });
     }
 
     if (core.currentUser.is_silenced) {
       return trans('beatmaps.discussions.message_placeholder_silenced');
-    } else if (this.props.beatmapset.discussion_locked || downloadLimited(this.props.beatmapset)) {
+    } else if (this.beatmapset.discussion_locked || downloadLimited(this.beatmapset)) {
       return trans('beatmaps.discussions.message_placeholder_locked');
     } else {
       return trans('beatmaps.discussions.message_placeholder_deleted_beatmap');
···
 
   @computed
   private get timestamp() {
-    return this.props.mode === 'timeline'
+    return this.currentMode === 'timeline'
       ? parseTimestamp(this.message)
       : null;
   }
···
     super(props);
     makeObservable(this);
     this.handleKeyDown = makeTextAreaHandler(this.handleKeyDownCallback);
+
+    disposeOnUnmount(this, reaction(() => this.message, (current, prev) => {
+      if (prev !== current) {
+        this.storeMessage();
+      }
+    }));
+
+    disposeOnUnmount(this, reaction(() => this.props.discussionsState.beatmapset, (current, prev) => {
+      // TODO: check if this is still needed.
+      if (prev.id !== current.id) {
+        runInAction(() => {
+          this.message = this.storedMessage;
+        });
+      }
+    }));
   }
 
   componentDidMount() {
···
     }
   }
 
-  componentDidUpdate(prevProps: Readonly<Props>) {
-    if (prevProps.beatmapset.id !== this.props.beatmapset.id) {
-      this.message = this.storedMessage;
-      return;
-    }
-    this.storeMessage();
-  }
-
   componentWillUnmount() {
     $(window).off('resize', this.updateStickToHeight);
     this.postXhr?.abort();
···
   }
 
   render() {
-    const cssClasses = classWithModifiers('beatmap-discussion-new-float', { pinned: this.props.pinned });
+    const cssClasses = classWithModifiers('beatmap-discussion-new-float', { pinned: this.pinned });
 
     return (
       <div
···
     }
 
     if (type === 'hype') {
-      if (!confirm(trans('beatmaps.hype.confirm', { n: this.props.beatmapset.current_user_attributes.remaining_hype }))) return;
+      if (!confirm(trans('beatmaps.hype.confirm', { n: this.beatmapset.current_user_attributes.remaining_hype }))) return;
     }
 
     showLoadingOverlay();
···
 
     const data = {
       beatmap_discussion: {
-        beatmap_id: this.props.mode === 'generalAll' ? undefined : this.props.currentBeatmap.id,
+        beatmap_id: this.currentMode === 'generalAll' ? undefined : this.currentBeatmap.id,
         message_type: type,
         timestamp: this.timestamp,
       },
       beatmap_discussion_post: {
         message: this.message,
       },
-      beatmapset_id: this.props.currentBeatmap.beatmapset_id,
+      beatmapset_id: this.currentBeatmap.beatmapset_id,
     };
 
     this.postXhr = $.ajax(route('beatmapsets.discussions.posts.store'), {
···
       .done((json) => runInAction(() => {
         this.message = '';
         this.timestampConfirmed = false;
-        $.publish('beatmapDiscussionPost:markRead', { id: json.beatmap_discussion_post_ids });
-        $.publish('beatmapsetDiscussions:update', { beatmapset: json.beatmapset });
+        for (const postId of json.beatmap_discussion_post_ids) {
+          this.props.discussionsState.readPostIds.add(postId);
+        }
+        this.props.discussionsState.update({ beatmapset: json.beatmapset });
       }))
       .fail(onError)
       .always(action(() => {
···
 
   private problemType() {
     const canDisqualify = core.currentUser?.is_admin || core.currentUser?.is_moderator || core.currentUser?.is_full_bn;
-    const willDisqualify = this.props.beatmapset.status === 'qualified';
+    const willDisqualify = this.beatmapset.status === 'qualified';
 
     if (canDisqualify && willDisqualify) return 'disqualify';
 
     const canReset = core.currentUser?.is_admin || core.currentUser?.is_nat || core.currentUser?.is_bng;
-    const currentNominations = nominationsCount(this.props.beatmapset.nominations, 'current');
-    const willReset = this.props.beatmapset.status === 'pending' && currentNominations > 0;
+    const currentNominations = nominationsCount(this.beatmapset.nominations, 'current');
+    const willReset = this.beatmapset.status === 'pending' && currentNominations > 0;
 
     if (canReset && willReset) return 'nomination_reset';
     if (willDisqualify) return 'problem_warning';
···
   }
 
   private renderBox() {
-    const canHype = this.props.beatmapset.current_user_attributes?.can_hype
-      && this.props.beatmapset.can_be_hyped
-      && this.props.mode === 'generalAll';
+    const canHype = this.beatmapset.current_user_attributes?.can_hype
+      && this.beatmapset.can_be_hyped
+      && this.currentMode === 'generalAll';
 
     const canPostNote = core.currentUser != null
-        && (core.currentUser.id === this.props.beatmapset.user_id
-          || (core.currentUser.id === this.props.currentBeatmap.user_id && ['general', 'timeline'].includes(this.props.mode))
+        && (core.currentUser.id === this.beatmapset.user_id
+          || (core.currentUser.id === this.currentBeatmap.user_id && ['general', 'timeline'].includes(this.currentMode))
           || core.currentUser.is_bng
           || canModeratePosts());
 
-    const buttonCssClasses = classWithModifiers('btn-circle', { activated: this.props.pinned });
+    const buttonCssClasses = classWithModifiers('btn-circle', { activated: this.pinned });
 
     return (
       <div className='osu-page osu-page--small'>
···
               <span
                 className={buttonCssClasses}
                 onClick={this.toggleSticky}
-                title={trans(`beatmaps.discussions.new.${this.props.pinned ? 'unpin' : 'pin'}`)}
+                title={trans(`beatmaps.discussions.new.${this.pinned ? 'unpin' : 'pin'}`)}
               >
                 <span className='btn-circle__content'>
                   <i className='fas fa-thumbtack' />
···
   }
 
   private renderHype() {
-    if (!(this.props.mode === 'generalAll' && this.props.beatmapset.can_be_hyped)) return null;
+    if (!(this.currentMode === 'generalAll' && this.beatmapset.can_be_hyped)) return null;
 
     return (
       <div className={`${bn}__footer-content ${hypeExplanationClass} js-flash-border`}>
···
         <div className={`${bn}__footer-message`}>
           {core.currentUser != null ? (
             <span>
-              {this.props.beatmapset.current_user_attributes.can_hype ? trans('beatmaps.hype.explanation') : this.props.beatmapset.current_user_attributes.can_hype_reason}
-              {(this.props.beatmapset.current_user_attributes.can_hype || this.props.beatmapset.current_user_attributes.remaining_hype <= 0) && (
+              {this.beatmapset.current_user_attributes.can_hype ? trans('beatmaps.hype.explanation') : this.beatmapset.current_user_attributes.can_hype_reason}
+              {(this.beatmapset.current_user_attributes.can_hype || this.beatmapset.current_user_attributes.remaining_hype <= 0) && (
                 <>
                   <StringWithComponent
-                    mappings={{ remaining: this.props.beatmapset.current_user_attributes.remaining_hype }}
+                    mappings={{ remaining: this.beatmapset.current_user_attributes.remaining_hype }}
                     pattern={` ${trans('beatmaps.hype.remaining')}`}
                   />
-                  {this.props.beatmapset.current_user_attributes.new_hype_time != null && (
+                  {this.beatmapset.current_user_attributes.new_hype_time != null && (
                     <StringWithComponent
                       mappings={{
-                        new_time: <TimeWithTooltip dateTime={this.props.beatmapset.current_user_attributes.new_hype_time} relative />,
+                        new_time: <TimeWithTooltip dateTime={this.beatmapset.current_user_attributes.new_hype_time} relative />,
                       }}
                       pattern={` ${trans('beatmaps.hype.new_time')}`}
                     />
···
   }
 
   private renderTimestamp() {
-    if (this.props.mode !== 'timeline') return null;
+    if (this.currentMode !== 'timeline') return null;
 
     const timestamp = this.timestamp != null ? formatTimestamp(this.timestamp) : trans('beatmaps.discussions.new.timestamp_missing');
 
···
 
   @action
   private readonly setSticky = (sticky: boolean) => {
-    this.props.setPinned(sticky);
+    this.props.discussionsState.pinnedNewDiscussion = sticky;
     this.updateStickToHeight();
   };
 
···
   }
 
   private readonly toggleSticky = () => {
-    this.setSticky(!this.props.pinned);
+    this.setSticky(!this.pinned);
   };
 
   @action

resources/js/beatmap-discussions/new-reply.tsx

···
 import BigButton from 'components/big-button';
 import TextareaAutosize from 'components/textarea-autosize';
 import UserAvatar from 'components/user-avatar';
-import BeatmapJson from 'interfaces/beatmap-json';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import { BeatmapsetDiscussionPostStoreResponseJson } from 'interfaces/beatmapset-discussion-post-responses';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
 import { route } from 'laroute';
 import { action, makeObservable, observable, runInAction } from 'mobx';
 import { observer } from 'mobx-react';
···
 import { hideLoadingOverlay, showLoadingOverlay } from 'utils/loading-overlay';
 import { present } from 'utils/string';
 import DiscussionMessageLengthCounter from './discussion-message-length-counter';
+import DiscussionsState from './discussions-state';
 
 const bn = 'beatmap-discussion-post';
 
 interface Props {
-  beatmapset: BeatmapsetJson;
-  currentBeatmap: BeatmapJson | null;
   discussion: BeatmapsetDiscussionJson;
+  discussionsState: DiscussionsState;
 }
 
 const actionIcons = {
···
       .done((json) => runInAction(() => {
         this.editing = false;
         this.setMessage('');
-        $.publish('beatmapDiscussionPost:markRead', { id: json.beatmap_discussion_post_ids });
-        $.publish('beatmapsetDiscussions:update', { beatmapset: json.beatmapset });
+        this.props.discussionsState.update(json);
       }))
       .fail(onError)
       .always(action(() => {

resources/js/beatmap-discussions/new-review.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 { DiscussionsContext } from 'beatmap-discussions/discussions-context';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import { action, computed, makeObservable, observable } from 'mobx';
 import { observer } from 'mobx-react';
 import core from 'osu-core-singleton';
···
 import { downloadLimited } from 'utils/beatmapset-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
+import DiscussionsState from './discussions-state';
 import Editor from './editor';
 
 interface Props {
-  beatmaps: BeatmapExtendedJson[];
-  beatmapset: BeatmapsetExtendedJson;
-  currentBeatmap: BeatmapExtendedJson;
+  discussionsState: DiscussionsState;
   innerRef: React.RefObject<HTMLDivElement>;
   onFocus?: () => void;
-  pinned?: boolean;
-  setPinned?: (sticky: boolean) => void;
   stickTo?: React.RefObject<HTMLDivElement>;
+  store: BeatmapsetDiscussionsStore;
 }
 
 @observer
···
   @observable private mounted = false;
   @observable private stickToHeight: number | undefined;
 
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
   @computed
   private get cssTop() {
-    if (this.mounted && this.props.pinned && this.stickToHeight != null) {
+    if (this.mounted && this.pinned && this.stickToHeight != null) {
       return core.stickyHeader.headerHeight + this.stickToHeight;
     }
   }
 
+  private get pinned() {
+    return this.props.discussionsState.pinnedNewDiscussion;
+  }
+
   private get noPermissionText() {
-    if (downloadLimited(this.props.beatmapset)) {
+    if (downloadLimited(this.beatmapset)) {
       return trans('beatmaps.discussions.message_placeholder_locked');
     }
 
···
     const placeholder = this.noPermissionText;
 
     return (
-      <div className={classWithModifiers(floatClass, { pinned: this.props.pinned })} style={{ top: this.cssTop }}>
+      <div className={classWithModifiers(floatClass, { pinned: this.pinned })} style={{ top: this.cssTop }}>
         <div className={`${floatClass}__floatable`}>
           <div ref={this.props.innerRef} className={`${floatClass}__content`}>
             <div className='osu-page osu-page--small'>
···
                   {trans('beatmaps.discussions.review.new')}
                   <span className='page-title__button'>
                     <span
-                      className={classWithModifiers('btn-circle', { activated: this.props.pinned })}
+                      className={classWithModifiers('btn-circle', { activated: this.pinned })}
                       onClick={this.toggleSticky}
-                      title={trans(`beatmaps.discussions.new.${this.props.pinned ? 'unpin' : 'pin'}`)}
+                      title={trans(`beatmaps.discussions.new.${this.pinned ? 'unpin' : 'pin'}`)}
                     >
                       <span className='btn-circle__content'><i className='fas fa-thumbtack' /></span>
                     </span>
                   </span>
                 </div>
                 {placeholder == null ? (
-                  <DiscussionsContext.Consumer>
-                    {
-                      (discussions) => (<Editor
-                        beatmaps={this.props.beatmaps}
-                        beatmapset={this.props.beatmapset}
-                        currentBeatmap={this.props.currentBeatmap}
-                        discussions={discussions}
-                        onFocus={this.handleFocus}
-                      />)
-                    }
-                  </DiscussionsContext.Consumer>
+                  <Editor
+                    discussionsState={this.props.discussionsState}
+                    onFocus={this.handleFocus}
+                    store={this.props.store}
+                  />
                 ) : <div className='beatmap-discussion-new__login-required'>{placeholder}</div>}
               </div>
             </div>
···
 
   @action
   private setSticky(sticky: boolean) {
-    this.props.setPinned?.(sticky);
+    this.props.discussionsState.pinnedNewDiscussion = sticky;
     this.updateStickToHeight();
   }
 
   private readonly toggleSticky = () => {
-    this.setSticky(!this.props.pinned);
+    this.setSticky(!this.pinned);
   };
 
   @action

resources/js/beatmap-discussions/nominations.tsx

···
 import StringWithComponent from 'components/string-with-component';
 import TimeWithTooltip from 'components/time-with-tooltip';
 import UserLink from 'components/user-link';
-import { BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import BeatmapsetEventJson from 'interfaces/beatmapset-event-json';
 import { BeatmapsetNominationsInterface } from 'interfaces/beatmapset-json';
 import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import GameMode from 'interfaces/game-mode';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
-import { action, makeObservable, observable } from 'mobx';
+import { action, makeObservable, observable, runInAction } from 'mobx';
 import { observer } from 'mobx-react';
-import { deletedUser } from 'models/user';
+import { deletedUser, deletedUserJson } from 'models/user';
 import moment from 'moment';
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { onError } from 'utils/ajax';
-import { canModeratePosts, makeUrl } from 'utils/beatmapset-discussion-helper';
+import { canModeratePosts, makeUrl, startingPost } from 'utils/beatmapset-discussion-helper';
 import { nominationsCount } from 'utils/beatmapset-helper';
 import { classWithModifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
 import { joinComponents, trans, transExists } from 'utils/lang';
 import { presence } from 'utils/string';
 import { wikiUrl } from 'utils/url';
-import CurrentDiscussions from './current-discussions';
+import DiscussionsState from './discussions-state';
 
 const bn = 'beatmap-discussion-nomination';
 const flashClass = 'js-flash-border--on';
···
 const nominatorsVisibleBeatmapStatuses = Object.freeze(new Set(['wip', 'pending', 'ranked', 'qualified']));
 
 interface Props {
-  beatmapset: BeatmapsetWithDiscussionsJson;
-  currentDiscussions: CurrentDiscussions;
-  discussions: Partial<Record<number, BeatmapsetDiscussionJsonForShow>>;
-  events: BeatmapsetEventJson[];
-  users: Partial<Record<number, UserJson>>;
+  discussionsState: DiscussionsState;
+  store: BeatmapsetDiscussionsStore;
 }
 
 type XhrType = 'delete' | 'discussionLock' | 'removeFromLoved';
···
 }
 
 @observer
-export class Nominations extends React.PureComponent<Props> {
+export class Nominations extends React.Component<Props> {
   private hypeFocusTimeout: number | undefined;
   @observable private showBeatmapsOwnerEditor = false;
   @observable private showLoveBeatmapDialog = false;
   @observable private readonly xhr: Partial<Record<XhrType, JQuery.jqXHR<BeatmapsetWithDiscussionsJson>>> = {};
 
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
+  private get discussions() {
+    return this.props.store.discussions;
+  }
+
+  private get events() {
+    return this.beatmapset.events;
+  }
+
   private get isQualified() {
-    return this.props.beatmapset.status === 'qualified';
+    return this.beatmapset.status === 'qualified';
   }
 
   private get userCanDisqualify() {
···
   }
 
   private get userIsOwner() {
-    return core.currentUser != null && (core.currentUser.id === this.props.beatmapset.user_id);
+    return core.currentUser != null && (core.currentUser.id === this.beatmapset.user_id);
+  }
+
+  private get users() {
+    return this.props.store.users;
   }
 
   constructor(props: Props) {
···
             <div className={`${bn}__item`}>{this.renderDisqualifyButton()}</div>
             <div className={`${bn}__item`}>
               <Nominator
-                beatmapset={this.props.beatmapset}
-                currentHype={this.props.currentDiscussions.totalHype}
-                unresolvedIssues={this.props.currentDiscussions.unresolvedIssues}
-                users={this.props.users}
+                discussionsState={this.props.discussionsState}
+                store={this.props.store}
               />
             </div>
           </div>
···
     if (!confirm(message)) return;
 
     this.xhr.delete = $.ajax(
-      route('beatmapsets.destroy', { beatmapset: this.props.beatmapset.id }),
+      route('beatmapsets.destroy', { beatmapset: this.beatmapset.id }),
       { method: 'DELETE' },
     )
-      .done(() => Turbolinks.visit(route('users.show', { user: this.props.beatmapset.user_id })))
+      .done(() => Turbolinks.visit(route('users.show', { user: this.beatmapset.user_id })))
       .fail(onError)
       .always(action(() => {
         this.xhr.delete = undefined;
···
     if (reason == null) return;
 
     this.xhr.discussionLock = $.ajax(
-      route('beatmapsets.discussion-lock', { beatmapset: this.props.beatmapset.id }),
+      route('beatmapsets.discussion-lock', { beatmapset: this.beatmapset.id }),
       { data: { reason }, method: 'POST' },
     );
 
     this.xhr.discussionLock
-      .done((beatmapset) => {
-        $.publish('beatmapsetDiscussions:update', { beatmapset });
-      })
+      .done((beatmapset) => runInAction(() => {
+        this.props.discussionsState.update({ beatmapset });
+      }))
       .fail(onError)
       .always(action(() => {
         this.xhr.discussionLock = undefined;
···
     if (!confirm(trans('beatmaps.discussions.lock.prompt.unlock'))) return;
 
     this.xhr.discussionLock = $.ajax(
-      route('beatmapsets.discussion-unlock', { beatmapset: this.props.beatmapset.id }),
+      route('beatmapsets.discussion-unlock', { beatmapset: this.beatmapset.id }),
       { method: 'POST' },
     );
 
     this.xhr.discussionLock
-      .done((beatmapset) => {
-        $.publish('beatmapsetDiscussions:update', { beatmapset });
-      })
+      .done((beatmapset) => runInAction(() => {
+        this.props.discussionsState.update({ beatmapset });
+      }))
       .fail(onError)
       .always(action(() => {
         this.xhr.discussionLock = undefined;
       }));
   };
 
+  @action
   private readonly focusHypeInput = () => {
     // switch to generalAll tab, set current filter to praises
-    $.publish('beatmapsetDiscussions:update', {
-      filter: 'praises',
-      mode: 'generalAll',
-    });
+    this.props.discussionsState.changeFilter('praises');
+    this.props.discussionsState.changeDiscussionPage('generalAll');
 
     this.hypeFocusTimeout = window.setTimeout(() => {
       this.focusNewDiscussion(() => {
···
     }, 0);
   };
 
-  private focusNewDiscussion(this: void, callback: () => void) {
+  private focusNewDiscussion(this: void, callback?: () => void) {
     const inputBox = $('.js-hype--input');
     inputBox.trigger('focus');
 
···
     });
   }
 
+  @action
   private readonly focusNewDiscussionWithModeSwitch = () => {
     // Switch to generalAll tab just in case currently in event tab
     // and thus new discussion box isn't visible.
-    $.publish('beatmapsetDiscussions:update', {
-      callback: this.focusNewDiscussion,
-      mode: 'generalAll',
-      modeIf: 'events',
-    });
+    if (this.props.discussionsState.currentPage === 'events') {
+      this.props.discussionsState.changeDiscussionPage('generalAll');
+      this.focusNewDiscussion();
+    }
   };
 
   @action
···
   };
 
   private parseEventData(event: BeatmapsetEventJson) {
-    const user = event.user_id != null ? this.props.users[event.user_id] : null;
+    const user = this.users.get(event.user_id) ?? deletedUserJson;
     const discussionId = discussionIdFromEvent(event);
-    const discussion = discussionId != null ? this.props.discussions[discussionId] : null;
-    const post = discussion?.posts[0];
+    const discussion = this.discussions.get(discussionId);
+    const post = discussion != null ? startingPost(discussion) : null;
 
     let link: React.ReactNode;
     let message: React.ReactNode;
···
     if (reason == null) return;
 
     this.xhr.removeFromLoved = $.ajax(
-      route('beatmapsets.remove-from-loved', { beatmapset: this.props.beatmapset.id }),
+      route('beatmapsets.remove-from-loved', { beatmapset: this.beatmapset.id }),
       { data: { reason }, method: 'DELETE' },
     );
 
     this.xhr.removeFromLoved
-      .done((beatmapset) =>
-        $.publish('beatmapsetDiscussions:update', { beatmapset }),
-      )
+      .done((beatmapset) => runInAction(() => {
+        this.props.discussionsState.update({ beatmapset });
+      }))
       .fail(onError)
       .always(action(() => {
         this.xhr.removeFromLoved = undefined;
···
     return (
       <Modal>
         <BeatmapsOwnerEditor
-          beatmapset={this.props.beatmapset}
+          beatmapset={this.beatmapset}
+          discussionsState={this.props.discussionsState}
           onClose={this.handleToggleBeatmapsOwnerEditor}
-          users={this.props.users}
+          users={this.props.store.users}
         />
       </Modal>
     );
   }
 
   private renderBeatmapsOwnerEditorButton() {
-    if (!this.props.beatmapset.current_user_attributes.can_beatmap_update_owner) return;
+    if (!this.beatmapset.current_user_attributes.can_beatmap_update_owner) return;
 
     return (
       <BigButton
···
   }
 
   private renderDeleteButton() {
-    if (!this.props.beatmapset.current_user_attributes.can_delete) return;
+    if (!this.beatmapset.current_user_attributes.can_delete) return;
 
     return (
       <BigButton
···
   private renderDiscussionLockButton() {
     if (!canModeratePosts()) return;
 
-    const { buttonProps, lockAction } = this.props.beatmapset.discussion_locked
+    const { buttonProps, lockAction } = this.beatmapset.discussion_locked
       ? {
         buttonProps: {
           icon: 'fas fa-unlock',
···
   }
 
   private renderDiscussionLockMessage() {
-    if (!this.props.beatmapset.discussion_locked) return;
+    if (!this.beatmapset.discussion_locked) return;
 
-    for (let i = this.props.events.length - 1; i >= 0; i--) {
-      const event = this.props.events[i];
+    for (let i = this.events.length - 1; i >= 0; i--) {
+      const event = this.events[i];
       if (event.type === 'discussion_lock') {
         return trans('beatmapset_events.event.discussion_lock', { text: event.comment.reason });
       }
···
   }
 
   private renderDisqualificationMessage() {
-    const showHype = this.props.beatmapset.can_be_hyped;
-    const disqualification = this.props.beatmapset.nominations.disqualification;
+    const showHype = this.beatmapset.can_be_hyped;
+    const disqualification = this.beatmapset.nominations.disqualification;
 
     if (!showHype || this.isQualified || disqualification == null) return;
 
···
   }
 
   private renderFeedbackButton() {
-    if (core.currentUser == null || this.userIsOwner || this.props.beatmapset.can_be_hyped || this.props.beatmapset.discussion_locked) {
+    if (core.currentUser == null || this.userIsOwner || this.beatmapset.can_be_hyped || this.beatmapset.discussion_locked) {
       return null;
     }
 
···
   }
 
   private renderHypeBar() {
-    if (!this.props.beatmapset.can_be_hyped || this.props.beatmapset.hype == null) return;
+    if (!this.beatmapset.can_be_hyped || this.beatmapset.hype == null) return;
 
-    const requiredHype = this.props.beatmapset.hype.required;
-    const hype = this.props.currentDiscussions.totalHype;
+    const requiredHype = this.beatmapset.hype.required;
+    const hype = this.props.discussionsState.totalHypeCount;
 
     return (
       <div>
···
   }
 
   private renderHypeButton() {
-    if (!this.props.beatmapset.can_be_hyped || core.currentUser == null || this.userIsOwner) return;
-
-    const currentUser = core.currentUser; // core.currentUser check below doesn't make the inferrence that it's not nullable after the check.
-    const discussions = Object.values(this.props.currentDiscussions.byFilter.hype.generalAll);
-    const userAlreadyHyped = currentUser != null && discussions.some((discussion) => discussion?.user_id === currentUser.id);
+    if (!this.beatmapset.can_be_hyped || core.currentUser == null || this.userIsOwner) return;
 
     return (
       <BigButton
-        disabled={!this.props.beatmapset.current_user_attributes.can_hype}
+        disabled={!this.beatmapset.current_user_attributes.can_hype}
         icon='fas fa-bullhorn'
         props={{
           onClick: this.focusHypeInput,
-          title: this.props.beatmapset.current_user_attributes.can_hype_reason,
+          title: this.beatmapset.current_user_attributes.can_hype_reason,
         }}
-        text={userAlreadyHyped ? trans('beatmaps.hype.button_done') : trans('beatmaps.hype.button')}
+        text={this.props.discussionsState.hasCurrentUserHyped ? trans('beatmaps.hype.button_done') : trans('beatmaps.hype.button')}
       />
     );
   }
···
   private renderLightsForNominations(nominations?: BeatmapsetNominationsInterface) {
     if (nominations == null) return;
 
-    const hybrid = Object.keys(this.props.beatmapset.nominations.required).length > 1;
+    const hybrid = Object.keys(this.beatmapset.nominations.required).length > 1;
 
     return (
       <div className={classWithModifiers(`${bn}__discrete-bar-group`, { hybrid })}>
···
     return (
       <Modal>
         <LoveBeatmapDialog
-          beatmapset={this.props.beatmapset}
+          beatmapset={this.beatmapset}
+          discussionsState={this.props.discussionsState}
           onClose={this.handleToggleLoveBeatmapDialog}
         />
       </Modal>
···
   }
 
   private renderLoveButton() {
-    if (!this.props.beatmapset.current_user_attributes.can_love) return;
+    if (!this.beatmapset.current_user_attributes.can_love) return;
 
     return (
       <BigButton
···
   }
 
   private renderNominationBar() {
-    const requiredHype = this.props.beatmapset.hype?.required ?? 0; // TODO: skip if null?
-    const hypeRaw = this.props.currentDiscussions.totalHype;
-    const mapCanBeNominated = this.props.beatmapset.status === 'pending' && hypeRaw >= requiredHype;
+    const requiredHype = this.beatmapset.hype?.required ?? 0; // TODO: skip if null?
+    const hypeRaw = this.props.discussionsState.totalHypeCount;
+    const mapCanBeNominated = this.beatmapset.status === 'pending' && hypeRaw >= requiredHype;
 
     if (!(mapCanBeNominated || this.isQualified)) return;
 
-    const nominations = this.props.beatmapset.nominations;
+    const nominations = this.beatmapset.nominations;
 
     return (
       <div>
···
   }
 
   private renderNominationResetMessage() {
-    const nominationReset = this.props.beatmapset.nominations.nomination_reset;
+    const nominationReset = this.beatmapset.nominations.nomination_reset;
 
-    if (!this.props.beatmapset.can_be_hyped || this.isQualified || nominationReset == null) return;
+    if (!this.beatmapset.can_be_hyped || this.isQualified || nominationReset == null) return;
 
     return <div>{this.renderResetReason(nominationReset)}</div>;
   }
 
   private renderNominatorsList() {
-    if (!nominatorsVisibleBeatmapStatuses.has(this.props.beatmapset.status)) return;
+    if (!nominatorsVisibleBeatmapStatuses.has(this.beatmapset.status)) return;
 
     const nominators: UserJson[] = [];
-    for (let i = this.props.events.length - 1; i >= 0; i--) {
-      const event = this.props.events[i];
+    for (let i = this.events.length - 1; i >= 0; i--) {
+      const event = this.events[i];
       if (event.type === 'disqualify' || event.type === 'nomination_reset') {
         break;
       }
 
       if (event.type === 'nominate' && event.user_id != null) {
-        const user = this.props.users[event.user_id]; // for typing
+        const user = this.users.get(event.user_id);
         if (user != null) {
           nominators.unshift(user);
         }
···
   }
 
   private renderRemoveFromLovedButton() {
-    if (!this.props.beatmapset.current_user_attributes.can_remove_from_loved) return;
+    if (!this.beatmapset.current_user_attributes.can_remove_from_loved) return;
 
     return (
       <BigButton
···
   }
 
   private renderStatusMessage() {
-    switch (this.props.beatmapset.status) {
+    switch (this.beatmapset.status) {
       case 'approved':
       case 'loved':
       case 'ranked':
-        return trans(`beatmaps.discussions.status-messages.${this.props.beatmapset.status}`, { date: formatDate(this.props.beatmapset.ranked_date) });
+        return trans(`beatmaps.discussions.status-messages.${this.beatmapset.status}`, { date: formatDate(this.beatmapset.ranked_date) });
       case 'graveyard':
-        return trans('beatmaps.discussions.status-messages.graveyard', { date: formatDate(this.props.beatmapset.last_updated) });
+        return trans('beatmaps.discussions.status-messages.graveyard', { date: formatDate(this.beatmapset.last_updated) });
       case 'wip':
         return trans('beatmaps.discussions.status-messages.wip');
       case 'qualified': {
-        const rankingEta = this.props.beatmapset.nominations.ranking_eta;
+        const rankingEta = this.beatmapset.nominations.ranking_eta;
         const date = rankingEta != null
           // TODO: remove after translations are updated
           ? transExists('beatmaps.nominations.rank_estimate.on')
···
             mappings={{
               date,
               // TODO: ranking_queue_position should not be nullable when status is qualified.
-              position: formatNumber(this.props.beatmapset.nominations.ranking_queue_position ?? 0),
+              position: formatNumber(this.beatmapset.nominations.ranking_queue_position ?? 0),
               queue: (
                 <a
                   href={wikiUrl('Beatmap_ranking_procedure/Ranking_queue')}

resources/js/beatmap-discussions/nominator.tsx

···
 
 import BigButton from 'components/big-button';
 import Modal from 'components/modal';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import BeatmapsetEventJson from 'interfaces/beatmapset-event-json';
 import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import GameMode from 'interfaces/game-mode';
-import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { forEachRight, map, uniq } from 'lodash';
-import { action, computed, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable, runInAction } from 'mobx';
 import { observer } from 'mobx-react';
 import core from 'osu-core-singleton';
 import * as React from 'react';
···
 import { isUserFullNominator } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
+import DiscussionsState from './discussions-state';
 
 interface Props {
-  beatmapset: BeatmapsetWithDiscussionsJson;
-  currentHype: number;
-  unresolvedIssues: number;
-  users: Partial<Record<number, UserJson>>;
+  discussionsState: DiscussionsState;
+  store: BeatmapsetDiscussionsStore;
 }
 
 const bn = 'nomination-dialog';
···
   @observable private visible = false;
   private xhr?: JQuery.jqXHR<BeatmapsetWithDiscussionsJson>;
 
+  private get beatmapset() {
+    return this.props.discussionsState.beatmapset;
+  }
+
+  private get currentHype() {
+    return this.props.discussionsState.totalHypeCount;
+  }
+
   private get mapCanBeNominated() {
-    if (this.props.beatmapset.hype == null) {
+    if (this.beatmapset.hype == null) {
       return false;
     }
 
-    return this.props.beatmapset.status === 'pending' && this.props.currentHype >= this.props.beatmapset.hype.required;
+    return this.beatmapset.status === 'pending' && this.currentHype >= this.beatmapset.hype.required;
   }
 
   private get nominationEvents() {
     const nominations: BeatmapsetEventJson[] = [];
 
-    forEachRight(this.props.beatmapset.events, (event) => {
+    forEachRight(this.beatmapset.events, (event) => {
       if (event.type === 'nomination_reset' || event.type === 'disqualify') {
         return false;
       }
···
 
   @computed
   private get playmodes() {
-    return this.props.beatmapset.nominations.legacy_mode
+    return this.beatmapset.nominations.legacy_mode
       ? null
-      : Object.keys(this.props.beatmapset.nominations.required) as GameMode[];
+      : Object.keys(this.beatmapset.nominations.required) as GameMode[];
+  }
+
+  private get users() {
+    return this.props.store.users;
   }
 
   private get userCanNominate() {
···
       return false;
     }
 
-    const nominationModes = this.playmodes ?? uniq(this.props.beatmapset.beatmaps.map((bm) => bm.mode));
+    const nominationModes = this.playmodes ?? uniq(this.beatmapset.beatmaps.map((bm) => bm.mode));
 
     return nominationModes.some((mode) => this.userCanNominateMode(mode));
   }
···
   private get userIsOwner() {
     const userId = core.currentUserOrFail.id;
 
-    return userId === this.props.beatmapset.user_id
-      || this.props.beatmapset.beatmaps.some((beatmap) => beatmap.deleted_at == null && userId === beatmap.user_id);
+    return userId === this.beatmapset.user_id
+      || this.beatmapset.beatmaps.some((beatmap) => beatmap.deleted_at == null && userId === beatmap.user_id);
   }
 
   private get userNominatableModes() {
···
       return {};
     }
 
-    return this.props.beatmapset.current_user_attributes.nomination_modes ?? {};
+    return this.beatmapset.current_user_attributes.nomination_modes ?? {};
   }
 
   constructor(props: Props) {
···
 
   private hasFullNomination(mode: GameMode) {
     return this.nominationEvents.some((event) => {
-      const user = event.user_id != null ? this.props.users[event.user_id] : null;
+      const user = this.users.get(event.user_id);
 
       return event.type === 'nominate' && event.comment != null
         ? event.comment.modes.includes(mode) && isUserFullNominator(user, mode)
···
 
     this.loading = true;
 
-    const url = route('beatmapsets.nominate', { beatmapset: this.props.beatmapset.id });
+    const url = route('beatmapsets.nominate', { beatmapset: this.beatmapset.id });
     const params = {
       data: {
         playmodes: this.playmodes != null && this.playmodes.length === 1 ? this.playmodes : this.selectedModes,
···
     };
 
     this.xhr = $.ajax(url, params);
-    this.xhr.done((response) => {
-      $.publish('beatmapsetDiscussions:update', { beatmapset: response });
+    this.xhr.done((beatmapset) => runInAction(() => {
+      this.props.discussionsState.update({ beatmapset });
       this.hideNominationModal();
-    })
+    }))
       .fail(onError)
       .always(action(() => this.loading = false));
   };
 
   private nominationCountMet(mode: GameMode) {
-    if (this.props.beatmapset.nominations.legacy_mode || this.props.beatmapset.nominations.required[mode] === 0) {
+    if (this.beatmapset.nominations.legacy_mode || this.beatmapset.nominations.required[mode] === 0) {
       return false;
     }
 
-    const req = this.props.beatmapset.nominations.required[mode];
-    const curr = this.props.beatmapset.nominations.current[mode] ?? 0;
+    const req = this.beatmapset.nominations.required[mode];
+    const curr = this.beatmapset.nominations.current[mode] ?? 0;
 
     if (req == null) {
       return false;
···
     }
 
     let tooltipText: string | undefined;
-    if (this.props.unresolvedIssues > 0) {
+    if (this.props.discussionsState.unresolvedDiscussionTotalCount > 0) {
       tooltipText = trans('beatmaps.nominations.unresolved_issues');
-    } else if (this.props.beatmapset.nominations.nominated) {
+    } else if (this.beatmapset.nominations.nominated) {
       tooltipText = trans('beatmaps.nominations.already_nominated');
     } else if (!this.userCanNominate) {
       tooltipText = trans('beatmaps.nominations.cannot_nominate');
···
     let req: number;
     let curr: number;
 
-    if (this.props.beatmapset.nominations.legacy_mode) {
-      req = this.props.beatmapset.nominations.required;
-      curr = this.props.beatmapset.nominations.current;
+    if (this.beatmapset.nominations.legacy_mode) {
+      req = this.beatmapset.nominations.required;
+      curr = this.beatmapset.nominations.current;
     } else {
-      req = this.props.beatmapset.nominations.required[mode] ?? 0;
-      curr = this.props.beatmapset.nominations.current[mode] ?? 0;
+      req = this.beatmapset.nominations.required[mode] ?? 0;
+      curr = this.beatmapset.nominations.current[mode] ?? 0;
     }
 
     return (curr === req - 1) && !this.hasFullNomination(mode);

resources/js/beatmap-discussions/post.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 { BeatmapsContext } from 'beatmap-discussions/beatmaps-context';
-import { DiscussionsContext } from 'beatmap-discussions/discussions-context';
 import Editor from 'beatmap-discussions/editor';
 import { ReviewPost } from 'beatmap-discussions/review-post';
 import BigButton from 'components/big-button';
···
 import TextareaAutosize from 'components/textarea-autosize';
 import TimeWithTooltip from 'components/time-with-tooltip';
 import UserLink from 'components/user-link';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import { BeatmapsetDiscussionMessagePostJson } from 'interfaces/beatmapset-discussion-post-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
-import BeatmapsetJson from 'interfaces/beatmapset-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { isEqual } from 'lodash';
 import { action, autorun, computed, makeObservable, observable, runInAction } from 'mobx';
 import { disposeOnUnmount, observer } from 'mobx-react';
-import { deletedUser, deletedUserJson } from 'models/user';
+import { deletedUserJson } from 'models/user';
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { onError } from 'utils/ajax';
···
 import { trans } from 'utils/lang';
 import DiscussionMessage from './discussion-message';
 import DiscussionMessageLengthCounter from './discussion-message-length-counter';
+import DiscussionsState from './discussions-state';
 import { UserCard } from './user-card';
 
 const bn = 'beatmap-discussion-post';
 
 interface Props {
-  beatmap: BeatmapExtendedJson | null;
-  beatmapset: BeatmapsetJson | BeatmapsetExtendedJson;
   discussion: BeatmapsetDiscussionJson;
+  discussionsState: DiscussionsState | null; // TODO: make optional
   post: BeatmapsetDiscussionMessagePostJson;
   read: boolean;
   readonly: boolean;
-  resolvedSystemPostId: number;
+  resolvedStateChangedPostId: number;
+  store: BeatmapsetDiscussionsStore;
   type: string;
   user: UserJson;
-  users: Partial<Record<number, UserJson>>;
 }
 
 @observer
 export default class Post extends React.Component<Props> {
+  static defaultProps = {
+    resolvedStateChangedPostId: -1,
+  };
+
   @observable private canSave = true; // this isn't computed because Editor's onChange doesn't provide anything to react to.
   @observable private editing = false;
   private readonly handleTextareaKeyDown;
···
   private readonly textareaRef = React.createRef<HTMLTextAreaElement>();
   @observable private xhr: JQuery.jqXHR<BeatmapsetWithDiscussionsJson> | null = null;
 
+  private get beatmap() {
+    return this.props.discussionsState?.currentBeatmap;
+  }
+
+  private get beatmapset() {
+    return this.props.discussionsState?.beatmapset;
+  }
+
+  private get users() {
+    return this.props.store.users;
+  }
+
   @computed
   private get canEdit() {
     // no information available (non-discussion pages), return false.
-    if (!('discussion_locked' in this.props.beatmapset)) {
+    if (this.beatmapset == null) {
       return false;
     }
 
     return this.isAdmin
-      || (!downloadLimited(this.props.beatmapset)
+      || (!downloadLimited(this.beatmapset)
         && this.isOwn
-        && this.props.post.id > this.props.resolvedSystemPostId
-        && !this.props.beatmapset.discussion_locked
+        && this.props.post.id > this.props.resolvedStateChangedPostId
+        && !this.beatmapset.discussion_locked
       );
   }
 
···
           {this.props.type === 'reply' && (
             <UserCard
               group={badgeGroup({
-                beatmapset: this.props.beatmapset,
-                currentBeatmap: this.props.beatmap,
+                beatmapset: this.beatmapset,
+                currentBeatmap: this.beatmap,
                 discussion: this.props.discussion,
                 user: this.props.user,
               })}
···
   };
 
   private readonly handleMarkRead = () => {
-    $.publish('beatmapDiscussionPost:markRead', { id: this.props.post.id });
+    this.props.discussionsState?.markAsRead(this.props.post.id);
   };
 
   @action
···
 
   private renderDeletedBy() {
     if (this.deleteModel.deleted_at == null) return null;
-    const user = (
-      this.deleteModel.deleted_by_id != null
-        ? this.props.users[this.deleteModel.deleted_by_id]
-        : null
-    ) ?? deletedUser;
+    const user = this.users.get(this.deleteModel.deleted_by_id) ?? deletedUserJson;
 
     return (
       <span className={`${bn}__info`}>
···
       return null;
     }
 
-    const lastEditor = this.props.users[this.props.post.last_editor_id] ?? deletedUserJson;
+    const lastEditor = this.users.get(this.props.post.last_editor_id) ?? deletedUserJson;
 
     return (
       <span className={`${bn}__info`}>
···
   }
 
   private renderMessageEditor() {
-    if (!this.canEdit) return;
+    if (this.props.discussionsState == null || !this.canEdit) return;
     const canPost = !this.isPosting && this.canSave;
 
     const document = this.props.post.message;
···
     return (
       <div className={`${bn}__message-container`}>
         {this.isReview ? (
-          <DiscussionsContext.Consumer>
-            {(discussions) => (
-              <BeatmapsContext.Consumer>
-                {(beatmaps) => (
-                  <Editor
-                    ref={this.reviewEditorRef}
-                    beatmaps={beatmaps}
-                    beatmapset={this.props.beatmapset}
-                    currentBeatmap={this.props.beatmap}
-                    discussion={this.props.discussion}
-                    discussions={discussions}
-                    document={document}
-                    editing={this.editing}
-                    onChange={this.handleEditorChange}
-                  />
-                )}
-              </BeatmapsContext.Consumer>
-            )}
-          </DiscussionsContext.Consumer>
+          <Editor
+            ref={this.reviewEditorRef}
+            discussion={this.props.discussion}
+            discussionsState={this.props.discussionsState}
+            document={document}
+            editing={this.editing}
+            onChange={this.handleEditorChange}
+            store={this.props.store}
+          />
         ) : (
           <>
             <TextareaAutosize
···
       <div className={`${bn}__message-container`}>
         {this.isReview ? (
           <div className={`${bn}__message`}>
-            <ReviewPost post={this.props.post} />
+            <ReviewPost post={this.props.post} store={this.props.store} />
           </div>
         ) : (
           <div ref={this.messageBodyRef} className={`${bn}__message`}>
···
     );
   }
 
-
   private renderMessageViewerActions() {
     return (
       <div className={`${bn}__actions`}>
···
             />
           </span>
 
-          {!this.props.readonly && (
-            <>
-              {this.canEdit && (
-                <button
-                  className={`${bn}__action ${bn}__action--button`}
-                  onClick={this.editStart}
-                >
-                  {trans('beatmaps.discussions.edit')}
-                </button>
-              )}
-
-              {this.deleteModel.deleted_at == null && this.canDelete && (
-                <a
-                  className={`js-beatmapset-discussion-update ${bn}__action ${bn}__action--button`}
-                  data-confirm={trans('common.confirmation')}
-                  data-method='DELETE'
-                  data-remote
-                  href={this.deleteHref('destroy')}
-                >
-                  {trans('beatmaps.discussions.delete')}
-                </a>
-              )}
-
-              {this.deleteModel.deleted_at != null && this.canModerate && (
-                <a
-                  className={`js-beatmapset-discussion-update ${bn}__action ${bn}__action--button`}
-                  data-confirm={trans('common.confirmation')}
-                  data-method='POST'
-                  data-remote
-                  href={this.deleteHref('restore')}
-                >
-                  {trans('beatmaps.discussions.restore')}
-                </a>
-              )}
-
-              {this.props.type === 'discussion' && this.props.discussion.current_user_attributes?.can_moderate_kudosu && (
-                this.props.discussion.can_grant_kudosu
-                  ? this.renderKudosuAction('deny')
-                  : this.props.discussion.kudosu_denied && this.renderKudosuAction('allow')
-              )}
-            </>
-          )}
+          {this.renderMessageViewerEditingActions()}
 
           {this.canReport && (
             <ReportReportable
···
     );
   }
 
+  private renderMessageViewerEditingActions() {
+    if (this.props.readonly || this.props.discussionsState == null) return;
+
+    return (
+      <>
+        {this.canEdit && (
+          <button
+            className={`${bn}__action ${bn}__action--button`}
+            onClick={this.editStart}
+          >
+            {trans('beatmaps.discussions.edit')}
+          </button>
+        )}
+
+        {this.deleteModel.deleted_at == null && this.canDelete && (
+          <a
+            className={`js-beatmapset-discussion-update ${bn}__action ${bn}__action--button`}
+            data-confirm={trans('common.confirmation')}
+            data-method='DELETE'
+            data-remote
+            href={this.deleteHref('destroy')}
+          >
+            {trans('beatmaps.discussions.delete')}
+          </a>
+        )}
+
+        {this.deleteModel.deleted_at != null && this.canModerate && (
+          <a
+            className={`js-beatmapset-discussion-update ${bn}__action ${bn}__action--button`}
+            data-confirm={trans('common.confirmation')}
+            data-method='POST'
+            data-remote
+            href={this.deleteHref('restore')}
+          >
+            {trans('beatmaps.discussions.restore')}
+          </a>
+        )}
+
+        {this.props.type === 'discussion' && this.props.discussion.current_user_attributes?.can_moderate_kudosu && (
+          this.props.discussion.can_grant_kudosu
+            ? this.renderKudosuAction('deny')
+            : this.props.discussion.kudosu_denied && this.renderKudosuAction('allow')
+        )}
+      </>
+    );
+  }
 
   @action
   private readonly updatePost = () => {
···
 
     this.xhr.done((beatmapset) => runInAction(() => {
       this.editing = false;
-      $.publish('beatmapsetDiscussions:update', { beatmapset });
+      this.props.discussionsState?.update({ beatmapset });
     }))
       .fail(onError)
       .always(action(() => this.xhr = null));

resources/js/beatmap-discussions/review-document.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 { BeatmapsetDiscussionJsonForBundle, BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import remarkParse from 'remark-parse';
 import disableConstructs from 'remark-plugins/disable-constructs';
 import { Element, Text } from 'slate';
···
   return node.type === 'text';
 }
 
-export function parseFromJson(json: string, discussions: Partial<Record<number, BeatmapsetDiscussionJsonForBundle | BeatmapsetDiscussionJsonForShow>>) {
+export function parseFromJson(json: string, discussions: Map<number | null | undefined, BeatmapsetDiscussionJson>) {
   let srcDoc: BeatmapDiscussionReview;
 
   try {
···
       case 'embed': {
         // embed
         const existingEmbedBlock = block as PersistedDocumentIssueEmbed;
-        const discussion = discussions[existingEmbedBlock.discussion_id];
+        const discussion = discussions.get(existingEmbedBlock.discussion_id);
         if (discussion == null) {
           console.error('unknown/external discussion referenced', existingEmbedBlock.discussion_id);
           break;
···
         }
 
         const post = startingPost(discussion);
-        if (post.system) {
-          console.error('embed should not have system starting post', existingEmbedBlock.discussion_id);
+        if (post == null || post.system) {
+          console.error('embed starting post is missing or is system post', existingEmbedBlock.discussion_id);
           break;
         }
 

resources/js/beatmap-discussions/review-post-embed.tsx

···
 import { discussionTypeIcons } from 'beatmap-discussions/discussion-type';
 import { BeatmapIcon } from 'components/beatmap-icon';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import * as React from 'react';
 import { formatTimestamp, makeUrl, startingPost } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
-import { BeatmapsContext } from './beatmaps-context';
 import DiscussionMessage from './discussion-message';
-import { DiscussionsContext } from './discussions-context';
 
 interface Props {
   data: {
     discussion_id: number;
   };
+  store: BeatmapsetDiscussionsStore;
 }
 
 export function postEmbedModifiers(discussion: BeatmapsetDiscussionJson) {
···
   };
 }
 
-export const ReviewPostEmbed = ({ data }: Props) => {
-  const bn = 'beatmap-discussion-review-post-embed-preview';
-  const discussions = React.useContext(DiscussionsContext);
-  const beatmaps = React.useContext(BeatmapsContext);
-  const discussion = discussions[data.discussion_id];
+const bn = 'beatmap-discussion-review-post-embed-preview';
 
-  if (!discussion) {
+export const ReviewPostEmbed = ({ data, store }: Props) => {
+  const beatmaps = store.beatmaps;
+  const discussion = store.discussions.get(data.discussion_id);
+
+  if (discussion == null) {
     // if a discussion has been deleted or is otherwise missing
     return (
       <div className={classWithModifiers(bn, ['deleted', 'lighter'])}>
···
   }
 
   const post = startingPost(discussion);
-  if (post.system) {
-    console.error('embed should not have system starting post', discussion.id);
+  if (post == null || post.system) {
+    console.error('embed starting post is missing or is system post', discussion.id);
     return null;
   }
 
-  const beatmap = discussion.beatmap_id == null ? undefined : beatmaps[discussion.beatmap_id];
+  const beatmap = discussion.beatmap_id == null ? undefined : beatmaps.get(discussion.beatmap_id);
 
   const messageTypeIcon = () => {
     const type = discussion.message_type;

resources/js/beatmap-discussions/review-post.tsx

···
 
 import { PersistedBeatmapDiscussionReview } from 'interfaces/beatmap-discussion-review';
 import { BeatmapsetDiscussionMessagePostJson } from 'interfaces/beatmapset-discussion-post-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import * as React from 'react';
 import DiscussionMessage from './discussion-message';
 import { ReviewPostEmbed } from './review-post-embed';
 
 interface Props {
   post: BeatmapsetDiscussionMessagePostJson;
+  store: BeatmapsetDiscussionsStore;
 }
 
 export class ReviewPost extends React.Component<Props> {
···
           }
           case 'embed':
             if (block.discussion_id) {
-              docBlocks.push(<ReviewPostEmbed key={index} data={{ discussion_id: block.discussion_id }} />);
+              docBlocks.push(<ReviewPostEmbed key={index} data={{ discussion_id: block.discussion_id }} store={this.props.store} />);
             }
             break;
         }

resources/js/beatmap-discussions/subscribe.tsx

···
 import * as React from 'react';
 import { onError } from 'utils/ajax';
 import { trans } from 'utils/lang';
+import DiscussionsState from './discussions-state';
 
 interface Props {
   beatmapset: BeatmapsetJson;
+  discussionsState: DiscussionsState;
 }
 
 @observer
···
     });
 
     this.xhr.done(() => {
-      $.publish('beatmapsetDiscussions:update', { watching: !this.isWatching });
+      this.props.discussionsState.update({ watching: !this.isWatching });
     })
       .fail(onError)
       .always(action(() => this.xhr = null));

resources/js/beatmap-discussions/type-filters.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 { kebabCase, snakeCase } from 'lodash';
+import { computed } from 'mobx';
+import { observer } from 'mobx-react';
+import core from 'osu-core-singleton';
+import * as React from 'react';
+import { makeUrl } from 'utils/beatmapset-discussion-helper';
+import { classWithModifiers } from 'utils/css';
+import { trans } from 'utils/lang';
+import { Filter } from './current-discussions';
+import DiscussionsState from './discussions-state';
+
+interface Props {
+  discussionsState: DiscussionsState;
+}
+
+const bn = 'counter-box';
+const statTypes: Filter[] = ['mine', 'mapperNotes', 'resolved', 'pending', 'praises', 'deleted', 'total'];
+
+@observer
+export default class TypeFilters extends React.Component<Props> {
+  @computed
+  private get discussionCounts() {
+    const counts: Partial<Record<Filter, number>> = {};
+    const selectedUserId = this.props.discussionsState.selectedUserId;
+
+    for (const type of statTypes) {
+      let discussions = this.props.discussionsState.discussionsByFilter[type];
+      if (selectedUserId != null) {
+        discussions = discussions.filter((discussion) => discussion.user_id === selectedUserId);
+      }
+
+      counts[type] = discussions.length;
+    }
+
+    return counts;
+  }
+
+  render() {
+    return statTypes.map(this.renderType);
+  }
+
+  private readonly renderType = (type: Filter) => {
+    if ((type === 'deleted') && !core.currentUser?.is_admin) {
+      return null;
+    }
+
+    let topClasses = classWithModifiers(bn, 'beatmap-discussions', kebabCase(type));
+    if (this.props.discussionsState.currentPage !== 'events' && this.props.discussionsState.currentFilter === type) {
+      topClasses += ' js-active';
+    }
+
+    return (
+      <a
+        key={type}
+        className={topClasses}
+        data-type={type}
+        href={makeUrl({
+          beatmapId: this.props.discussionsState.currentBeatmap.id,
+          beatmapsetId: this.props.discussionsState.beatmapset.id,
+          filter: type,
+          mode: this.props.discussionsState.currentPage,
+        })}
+        onClick={this.setFilter}
+      >
+        <div className={`${bn}__content`}>
+          <div className={`${bn}__title`}>
+            {trans(`beatmaps.discussions.stats.${snakeCase(type)}`)}
+          </div>
+          <div className={`${bn}__count`}>
+            {this.discussionCounts[type]}
+          </div>
+        </div>
+        <div className={`${bn}__line`} />
+      </a>
+    );
+  };
+
+  private readonly setFilter = (event: React.SyntheticEvent<HTMLElement>) => {
+    event.preventDefault();
+    this.props.discussionsState.changeFilter(event.currentTarget.dataset.type);
+  };
+}
+

resources/js/beatmap-discussions/user-filter.tsx

···
 
 import mapperGroup from 'beatmap-discussions/mapper-group';
 import SelectOptions, { OptionRenderProps } from 'components/select-options';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import UserJson from 'interfaces/user-json';
+import { action, computed, makeObservable } from 'mobx';
+import { observer } from 'mobx-react';
+import { usernameSortAscending } from 'models/user';
 import * as React from 'react';
+import { mobxArrayGet } from 'utils/array';
 import { makeUrl, parseUrl } from 'utils/beatmapset-discussion-helper';
 import { groupColour } from 'utils/css';
 import { trans } from 'utils/lang';
+import DiscussionsState from './discussions-state';
 
 const allUsers = Object.freeze({
   id: null,
···
 
 interface Option {
   groups: UserJson['groups'];
-  id: UserJson['id'];
+  id: UserJson['id'] | null;
   text: UserJson['username'];
 }
 
 interface Props {
-  ownerId: number;
-  selectedUser?: UserJson | null;
-  users: UserJson[];
+  discussionsState: DiscussionsState;
+  store: BeatmapsetDiscussionsStore;
 }
 
 function mapUserProperties(user: UserJson): Option {
···
   };
 }
 
+@observer
 export class UserFilter extends React.Component<Props> {
+  private get ownerId() {
+    return this.props.discussionsState.beatmapset.user_id;
+  }
+
+  @computed
   private get selected() {
-    return this.props.selectedUser != null
-      ? mapUserProperties(this.props.selectedUser)
+    return this.props.discussionsState.selectedUser != null
+      ? mapUserProperties(this.props.discussionsState.selectedUser)
       : noSelection;
   }
 
+  @computed
   private get options() {
-    return [allUsers, ...this.props.users.map(mapUserProperties)];
+    const usersWithDicussions = new Map<number, UserJson>();
+    for (const [, discussion] of this.props.store.discussions) {
+      if (discussion.message_type === 'hype') continue;
+
+      const user = this.props.store.users.get(discussion.user_id);
+      if (user != null && !usersWithDicussions.has(user.id)) {
+        usersWithDicussions.set(user.id, user);
+      }
+    }
+
+    return [
+      allUsers,
+      ...[...usersWithDicussions.values()]
+        .sort(usernameSortAscending)
+        .map(mapUserProperties),
+    ];
+  }
+
+  constructor(props: Props) {
+    super(props);
+    makeObservable(this);
   }
 
   render() {
···
     );
   }
 
+  private getGroup(option: Option) {
+    if (this.isOwner(option)) return mapperGroup;
+
+    return mobxArrayGet(option.groups, 0);
+  }
+
+  @action
   private readonly handleChange = (option: Option) => {
-    $.publish('beatmapsetDiscussions:update', { selectedUserId: option.id });
+    this.props.discussionsState.selectedUserId = option.id;
   };
 
   private isOwner(user?: Option) {
-    return user != null && user.id === this.props.ownerId;
+    return user != null && user.id === this.ownerId;
   }
 
   private readonly renderOption = ({ cssClasses, children, onClick, option }: OptionRenderProps<Option>) => {
-    const group = this.isOwner(option) ? mapperGroup : option.groups?.[0];
+    const group = this.getGroup(option);
     const style = groupColour(group);
 
     const urlOptions = parseUrl();
     // means it doesn't work on non-beatmapset discussion paths
     if (urlOptions == null) return null;
 
-    urlOptions.user = option?.id;
+    urlOptions.user = option.id ?? undefined;
 
     return (
       <a
-        key={option?.id}
+        key={option.id}
         className={cssClasses}
         href={makeUrl(urlOptions)}
         onClick={onClick}

resources/js/beatmapsets-show/scoreboard/table-row.tsx

···
 import { classWithModifiers, Modifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
 import { trans } from 'utils/lang';
-import { hasMenu, isPerfectCombo, modeAttributesMap, scoreUrl, totalScore } from 'utils/score-helper';
+import { filterMods, hasMenu, isPerfectCombo, modeAttributesMap, scoreUrl, totalScore } from 'utils/score-helper';
 
 const bn = 'beatmap-scoreboard-table';
 
···
 
         <TdLink href={this.scoreUrl} modifiers='mods'>
           <div className={`${bn}__mods`}>
-            {score.mods.map((mod) => <Mod key={mod.acronym} mod={mod} />)}
+            {filterMods(score).map((mod) => <Mod key={mod.acronym} mod={mod} />)}
           </div>
         </TdLink>
 

resources/js/beatmapsets-show/scoreboard/top-card.tsx

···
 import { classWithModifiers, Modifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
 import { trans } from 'utils/lang';
-import { isPerfectCombo, modeAttributesMap, scoreUrl, totalScore } from 'utils/score-helper';
+import { filterMods, isPerfectCombo, modeAttributesMap, scoreUrl, totalScore } from 'utils/score-helper';
 
 interface Props {
   beatmap: BeatmapJson;
···
                   {trans('beatmapsets.show.scoreboard.headers.mods')}
                 </div>
                 <div className='beatmap-score-top__stat-value beatmap-score-top__stat-value--mods u-hover'>
-                  {this.props.score.mods.map((mod) => <Mod key={mod.acronym} mod={mod} />)}
+                  {filterMods(this.props.score).map((mod) => <Mod key={mod.acronym} mod={mod} />)}
                 </div>
               </div>
             </div>

resources/js/components/beatmapset-event.tsx

···
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { kebabCase } from 'lodash';
-import { deletedUser } from 'models/user';
+import { deletedUser, deletedUserJson } from 'models/user';
 import * as React from 'react';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
···
 export type EventViewMode = 'discussions' | 'profile' | 'list';
 
 interface Props {
-  discussions?: Partial<Record<string, BeatmapsetDiscussionJson>>;
+  discussions?: Map<number | null | undefined, BeatmapsetDiscussionJson>;
   event: BeatmapsetEventJson;
   mode: EventViewMode;
   time?: string;
-  users: Partial<Record<string, UserJson>>;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 export default class BeatmapsetEvent extends React.PureComponent<Props> {
···
 
   // discussion page doesn't include the discussion as part of the event.
   private get discussion() {
-    return this.props.event.discussion ?? this.props.discussions?.[this.discussionId ?? ''];
+    return this.props.event.discussion ?? this.props.discussions?.get(this.discussionId);
   }
 
   private get firstPost() {
···
         url = makeUrl({ discussion: this.discussion });
         text = firstPostMessage != null ? <PlainTextPreview markdown={firstPostMessage} /> : '[no preview]';
 
-        const discussionUser = this.props.users[this.discussion.user_id];
+        const discussionUser = this.props.users.get(this.discussion.user_id) ?? deletedUserJson;
 
-        if (discussionUser != null) {
-          discussionUserLink = <UserLink user={discussionUser} />;
-        }
+        // TODO: remove link for deleted user?
+        discussionUserLink = <UserLink user={discussionUser} />;
       }
 
       discussionLink = <a className='js-beatmap-discussion--jump' href={url}>{`#${this.discussionId}`}</a>;
···
     }
 
     if (this.props.event.user_id != null) {
-      const userData = this.props.users[this.props.event.user_id];
+      const userData = this.props.users.get(this.props.event.user_id);
       user = userData != null ? <UserLink user={userData} /> : deletedUser.username;
     }
 

resources/js/components/beatmapset-events.tsx

···
 export interface Props {
   events: BeatmapsetEventJson[];
   mode: EventViewMode;
-  users: Partial<Record<string, UserJson>>;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 export default class BeatmapsetEvents extends React.PureComponent<Props> {

resources/js/entrypoints/beatmap-discussions-history.tsx

···
 import { parseJson } from 'utils/json';
 
 core.reactTurbolinks.register('beatmap-discussions-history', () => (
-  <Main bundle={parseJson<BeatmapsetDiscussionsBundleJson>('json-index')} />
+  <Main {...parseJson<BeatmapsetDiscussionsBundleJson>('json-index')} />
 ));

resources/js/entrypoints/beatmap-discussions.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 core from 'osu-core-singleton'
-import { createElement } from 'react'
-import { parseJson } from 'utils/json'
-import { Main } from 'beatmap-discussions/main'
-
-core.reactTurbolinks.register 'beatmap-discussions', (container) ->
-  createElement Main,
-    initial: parseJson 'json-beatmapset-discussion'
-    container: container

resources/js/entrypoints/beatmap-discussions.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 Main from 'beatmap-discussions/main';
+import core from 'osu-core-singleton';
+import React from 'react';
+import { parseJson } from 'utils/json';
+
+
+core.reactTurbolinks.register('beatmap-discussions', () => (
+  <Main reviewsConfig={parseJson('json-reviews_config')} />
+));

resources/js/entrypoints/modding-profile.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 { BeatmapsetDiscussionsBundleJsonForModdingProfile } from 'interfaces/beatmapset-discussions-bundle-json';
 import Main from 'modding-profile/main';
 import core from 'osu-core-singleton';
 import React from 'react';
 import { parseJson } from 'utils/json';
 
 core.reactTurbolinks.register('modding-profile', () => (
-  <Main
-    beatmaps={parseJson('json-beatmaps')}
-    beatmapsets={parseJson('json-beatmapsets')}
-    discussions={parseJson('json-discussions')}
-    events={parseJson('json-events')}
-    extras={parseJson('json-extras')}
-    perPage={parseJson('json-perPage')}
-    posts={parseJson('json-posts')}
-    user={parseJson('json-user')}
-    users={parseJson('json-users')}
-    votes={parseJson('json-votes')}
-  />
+  <Main {...parseJson<BeatmapsetDiscussionsBundleJsonForModdingProfile>('json-bundle')} />
 ));

resources/js/interfaces/beatmapset-discussions-bundle-json.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 { Direction, VoteSummary } from 'modding-profile/votes';
 import BeatmapExtendedJson from './beatmap-extended-json';
 import { BeatmapsetDiscussionJsonForBundle } from './beatmapset-discussion-json';
+import { BeatmapsetDiscussionMessagePostJson } from './beatmapset-discussion-post-json';
+import BeatmapsetEventJson from './beatmapset-event-json';
 import BeatmapsetExtendedJson from './beatmapset-extended-json';
+import KudosuHistoryJson from './kudosu-history-json';
 import UserJson from './user-json';
+import UserModdingProfileJson from './user-modding-profile-json';
 
 export default interface BeatmapsetDiscussionsBundleJson {
   beatmaps: BeatmapExtendedJson[];
···
   included_discussions: BeatmapsetDiscussionJsonForBundle[];
   users: UserJson[];
 }
+
+export interface BeatmapsetDiscussionsBundleJsonForModdingProfile {
+  beatmaps: BeatmapExtendedJson[];
+  beatmapsets: BeatmapsetExtendedJson[];
+  discussions: BeatmapsetDiscussionJsonForBundle[];
+  events: BeatmapsetEventJson[];
+  extras: {
+    recentlyReceivedKudosu: KudosuHistoryJson[];
+  };
+  perPage: {
+    recentlyReceivedKudosu: number;
+  };
+  posts: BeatmapsetDiscussionMessagePostJson[];
+  user: UserModdingProfileJson;
+  users: UserJson[];
+  votes: Record<Direction, VoteSummary[]>;
+}

resources/js/interfaces/beatmapset-discussions-store.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 BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
+import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import UserJson from 'interfaces/user-json';
+
+export default interface BeatmapsetDiscussionsStore {
+  beatmaps: Map<number, BeatmapExtendedJson>;
+  beatmapsets: Map<number, BeatmapsetExtendedJson>;
+  discussions: Map<number | null | undefined, BeatmapsetDiscussionJson>;
+  users: Map<number | null | undefined, UserJson>;
+}

resources/js/interfaces/beatmapset-with-discussions-json.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 { BeatmapsetDiscussionJsonForShow } from './beatmapset-discussion-json';
 import BeatmapsetExtendedJson from './beatmapset-extended-json';
 
-type DiscussionsRequiredAttributes = 'beatmaps' | 'current_user_attributes' | 'discussions' | 'events' | 'nominations' | 'related_users';
-type BeatmapsetWithDiscussionsJson = BeatmapsetExtendedJson & Required<Pick<BeatmapsetExtendedJson, DiscussionsRequiredAttributes>>;
+type DiscussionsRequiredAttributes = 'beatmaps' | 'current_user_attributes' | 'events' | 'nominations' | 'related_users';
+type BeatmapsetWithDiscussionsJson =
+  Omit<BeatmapsetExtendedJson, keyof OverrideIncludes>
+  & OverrideIncludes
+  & Required<Pick<BeatmapsetExtendedJson, DiscussionsRequiredAttributes>>;
+
+interface OverrideIncludes {
+  discussions: BeatmapsetDiscussionJsonForShow[];
+}
 
 export default BeatmapsetWithDiscussionsJson;

resources/js/interfaces/solo-score-json.ts

···
   has_replay: boolean;
   id: number;
   legacy_score_id: number | null;
-  legacy_total_score: number | null;
+  legacy_total_score: number;
   max_combo: number;
   mods: ScoreModJson[];
   passed: boolean;
   pp: number | null;
   rank: Rank;
+  ranked?: boolean;
   ruleset_id: number;
   started_at: string | null;
   statistics: Partial<Record<SoloScoreStatisticsAttribute, number>>;

resources/js/interfaces/user-preferences-json.ts

···
   comments_show_deleted: false,
   comments_sort: 'new',
   forum_posts_show_deleted: true,
+  legacy_score_only: true,
   profile_cover_expanded: true,
   user_list_filter: 'all',
   user_list_sort: 'last_visit',
···
   comments_show_deleted: boolean;
   comments_sort: string;
   forum_posts_show_deleted: boolean;
+  legacy_score_only: boolean;
   profile_cover_expanded: boolean;
   user_list_filter: Filter;
   user_list_sort: SortMode;

resources/js/modding-profile/discussions.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 { BeatmapsContext } from 'beatmap-discussions/beatmaps-context';
-import { BeatmapsetsContext } from 'beatmap-discussions/beatmapsets-context';
 import { Discussion } from 'beatmap-discussions/discussion';
 import BeatmapsetCover from 'components/beatmapset-cover';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import { BeatmapsetDiscussionJsonForBundle } from 'interfaces/beatmapset-discussion-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
+import { observer } from 'mobx-react';
 import React from 'react';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { trans } from 'utils/lang';
 
 interface Props {
   discussions: BeatmapsetDiscussionJsonForBundle[];
+  store: BeatmapsetDiscussionsStore;
   user: UserJson;
-  users: Partial<Record<number, UserJson>>;
 }
 
+@observer
 export default class Discussions extends React.Component<Props> {
   render() {
     return (
···
           {this.props.discussions.length === 0 ? (
             <div className='modding-profile-list__empty'>{trans('users.show.extra.none')}</div>
           ) : (
-            <BeatmapsetsContext.Consumer>
-              {(beatmapsets) => (
-                <BeatmapsContext.Consumer>
-                  {(beatmaps) => (
-                    <>
-                      {this.props.discussions.map((discussion) => this.renderDiscussion(discussion, beatmapsets, beatmaps))}
-                      <a className='modding-profile-list__show-more' href={route('beatmapsets.discussions.index', { user: `@${this.props.user.username}` })}>
-                        {trans('users.show.extra.discussions.show_more')}
-                      </a>
-                    </>
-                  )}
-                </BeatmapsContext.Consumer>
-              )}
-            </BeatmapsetsContext.Consumer>
+            <>
+              {this.props.discussions.map((discussion) => this.renderDiscussion(discussion))}
+              <a className='modding-profile-list__show-more' href={route('beatmapsets.discussions.index', { user: `@${this.props.user.username}` })}>
+                {trans('users.show.extra.discussions.show_more')}
+              </a>
+            </>
           )}
         </div>
       </div>
     );
   }
 
-  private renderDiscussion(discussion: BeatmapsetDiscussionJsonForBundle, beatmapsets: Partial<Record<number, BeatmapsetExtendedJson>>, beatmaps: Partial<Record<number, BeatmapExtendedJson>>) {
-    const beatmapset = beatmapsets[discussion.beatmapset_id];
-    const currentBeatmap = discussion.beatmap_id != null ? beatmaps[discussion.beatmap_id] : null;
-
+  private renderDiscussion(discussion: BeatmapsetDiscussionJsonForBundle) {
+    const beatmapset = this.props.store.beatmapsets.get(discussion.beatmapset_id);
     if (beatmapset == null) return null;
 
     return (
       <div key={discussion.id} className='modding-profile-list__row'>
         <a className='modding-profile-list__thumbnail' href={makeUrl({ discussion })}>
-          <BeatmapsetCover beatmapset={beatmapsets[discussion.beatmapset_id]} size='list' />
+          <BeatmapsetCover beatmapset={beatmapset} size='list' />
         </a>
         <Discussion
-          beatmapset={beatmapset}
-          currentBeatmap={currentBeatmap ?? null}
           discussion={discussion}
+          discussionsState={null}
           isTimelineVisible={false}
-          preview
-          readonly
-          showDeleted
-          users={this.props.users}
+          store={this.props.store}
         />
       </div>
     );

resources/js/modding-profile/events.tsx

···
 interface Props {
   events: BeatmapsetEventJson[];
   user: UserJson;
-  users: Partial<Record<string, UserJson>>;
+  users: Map<number | null | undefined, UserJson>;
 }
 
 export default class Events extends React.Component<Props> {

resources/js/modding-profile/main.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 { BeatmapsContext } from 'beatmap-discussions/beatmaps-context';
-import { BeatmapsetsContext } from 'beatmap-discussions/beatmapsets-context';
-import { DiscussionsContext } from 'beatmap-discussions/discussions-context';
 import HeaderV4 from 'components/header-v4';
 import ProfilePageExtraTab from 'components/profile-page-extra-tab';
 import ProfileTournamentBanner from 'components/profile-tournament-banner';
 import UserProfileContainer from 'components/user-profile-container';
-import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import { BeatmapsetDiscussionJsonForBundle } from 'interfaces/beatmapset-discussion-json';
-import { BeatmapsetDiscussionMessagePostJson } from 'interfaces/beatmapset-discussion-post-json';
-import BeatmapsetEventJson from 'interfaces/beatmapset-event-json';
-import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
-import KudosuHistoryJson from 'interfaces/kudosu-history-json';
-import UserJson from 'interfaces/user-json';
-import UserModdingProfileJson from 'interfaces/user-modding-profile-json';
-import { first, isEmpty, keyBy, last, throttle } from 'lodash';
+import { BeatmapsetDiscussionsBundleJsonForModdingProfile } from 'interfaces/beatmapset-discussions-bundle-json';
+import { first, last, throttle } from 'lodash';
 import { action, computed, makeObservable, observable } from 'mobx';
 import { observer } from 'mobx-react';
 import Kudosu from 'modding-profile/kudosu';
-import { deletedUserJson } from 'models/user';
 import core from 'osu-core-singleton';
 import Badges from 'profile-page/badges';
 import Cover from 'profile-page/cover';
 import DetailBar from 'profile-page/detail-bar';
 import headerLinks from 'profile-page/header-links';
 import * as React from 'react';
+import BeatmapsetDiscussionsBundleForModdingProfileStore from 'stores/beatmapset-discussions-for-modding-profile-store';
 import { bottomPage } from 'utils/html';
 import { nextVal } from 'utils/seq';
 import { switchNever } from 'utils/switch-never';
 import { currentUrl } from 'utils/turbolinks';
 import Discussions from './discussions';
 import Events from './events';
-import { Posts } from './posts';
+import Posts from './posts';
 import Stats from './stats';
-import Votes, { Direction, VoteSummary } from './votes';
+import Votes from './votes';
 
 // in display order.
 const moddingExtraPages = ['events', 'discussions', 'posts', 'votes', 'kudosu'] as const;
 type ModdingExtraPage = (typeof moddingExtraPages)[number];
-
-interface Props {
-  beatmaps: BeatmapExtendedJson[];
-  beatmapsets: BeatmapsetExtendedJson[];
-  discussions: BeatmapsetDiscussionJsonForBundle[];
-  events: BeatmapsetEventJson[];
-  extras: {
-    recentlyReceivedKudosu: KudosuHistoryJson[];
-  };
-  perPage: {
-    recentlyReceivedKudosu: number;
-  };
-  posts: BeatmapsetDiscussionMessagePostJson[];
-  user: UserModdingProfileJson;
-  users: UserJson[];
-  votes: Record<Direction, VoteSummary[]>;
-}
-
 type Page = ModdingExtraPage | 'main';
 
 function validPage(page: unknown) {
···
 }
 
 @observer
-export default class Main extends React.Component<Props> {
+export default class Main extends React.Component<BeatmapsetDiscussionsBundleJsonForModdingProfile> {
   @observable private currentPage: Page = 'main';
   private readonly disposers = new Set<(() => void) | undefined>();
   private readonly eventId = `users-modding-history-index-${nextVal()}`;
···
   };
   private readonly pages = React.createRef<HTMLDivElement>();
   private readonly pagesOffsetRef = React.createRef<HTMLDivElement>();
+  @observable private readonly store = new BeatmapsetDiscussionsBundleForModdingProfileStore(this.props);
   private readonly tabs = React.createRef<HTMLDivElement>();
 
-  @computed
-  private get beatmaps() {
-    return keyBy(this.props.beatmaps, 'id');
-  }
-
-  @computed
-  private get beatmapsets() {
-    return keyBy(this.props.beatmapsets, 'id');
-  }
-
-  @computed
-  private get discussions() {
-    // skipped discussions
-    // - not privileged (deleted discussion)
-    // - deleted beatmap
-    return keyBy(this.props.discussions.filter((d) => !isEmpty(d)), 'id');
-  }
-
   private get pagesOffset() {
     return this.pagesOffsetRef.current;
   }
···
     return core.stickyHeader.headerHeight + (this.pagesOffset?.getBoundingClientRect().height ?? 0);
   }
 
-  @computed
-  private get userDiscussions() {
-    return this.props.discussions.filter((d) => d.user_id === this.props.user.id);
+  private get user() {
+    return this.props.user;
   }
 
   @computed
-  private get users() {
-    const values = keyBy(this.props.users, 'id');
-    // eslint-disable-next-line id-blacklist
-    values.null = values.undefined = deletedUserJson;
-
-    return values;
+  private get userDiscussions() {
+    return [...this.store.discussions.values()].filter((d) => d.user_id === this.props.user.id);
   }
 
-  constructor(props: Props) {
+  constructor(props: BeatmapsetDiscussionsBundleJsonForModdingProfile) {
     super(props);
 
     makeObservable(this);
···
 
   render() {
     return (
-      <DiscussionsContext.Provider value={this.discussions}>
-        <BeatmapsetsContext.Provider value={this.beatmapsets}>
-          <BeatmapsContext.Provider value={this.beatmaps}>
-            <UserProfileContainer user={this.props.user}>
-              <HeaderV4
-                backgroundImage={this.props.user.cover.url}
-                links={headerLinks(this.props.user, 'modding')}
-                theme='users'
-              />
-              <div className='osu-page osu-page--generic-compact'>
-                <div ref={this.pageRefs.main} data-page-id='main'>
-                  <Cover
-                    coverUrl={this.props.user.cover.url}
-                    currentMode={this.props.user.playmode}
-                    user={this.props.user}
-                  />
-                  <Badges badges={this.props.user.badges} />
-                  {!this.props.user.is_bot && (
-                    <>
-                      {this.props.user.active_tournament_banners.map((banner) => (
-                        <ProfileTournamentBanner key={banner.id} banner={banner} />
-                      ))}
-                      <div className='profile-detail'>
-                        <Stats user={this.props.user} />
-                      </div>
-                    </>
-                  )}
-                  <DetailBar user={this.props.user} />
+      <UserProfileContainer user={this.user}>
+        <HeaderV4
+          backgroundImage={this.user.cover.url}
+          links={headerLinks(this.user, 'modding')}
+          theme='users'
+        />
+        <div className='osu-page osu-page--generic-compact'>
+          <div ref={this.pageRefs.main} data-page-id='main'>
+            <Cover
+              coverUrl={this.user.cover.url}
+              currentMode={this.user.playmode}
+              user={this.user}
+            />
+            <Badges badges={this.user.badges} />
+            {!this.user.is_bot && (
+              <>
+                {this.user.active_tournament_banners.map((banner) => (
+                  <ProfileTournamentBanner key={banner.id} banner={banner} />
+                ))}
+                <div className='profile-detail'>
+                  <Stats user={this.props.user} />
                 </div>
-                <div
-                  ref={this.pagesOffsetRef}
-                  className='page-extra-tabs page-extra-tabs--profile-page'
+              </>
+            )}
+            <DetailBar user={this.user} />
+          </div>
+          <div
+            ref={this.pagesOffsetRef}
+            className='page-extra-tabs page-extra-tabs--profile-page'
+          >
+            <div
+              ref={this.tabs}
+              className='page-mode page-mode--profile-page-extra'
+            >
+              {moddingExtraPages.map((page) => (
+                <a
+                  key={page}
+                  className='page-mode__item'
+                  data-page-id={page}
+                  href={`#${page}`}
+                  onClick={this.tabClick}
                 >
-                  <div
-                    ref={this.tabs}
-                    className='page-mode page-mode--profile-page-extra'
-                  >
-                    {moddingExtraPages.map((page) => (
-                      <a
-                        key={page}
-                        className='page-mode__item'
-                        data-page-id={page}
-                        href={`#${page}`}
-                        onClick={this.tabClick}
-                      >
-                        <ProfilePageExtraTab
-                          currentPage={this.currentPage}
-                          page={page}
-                        />
-                      </a>
-                    ))}
-                  </div>
-                </div>
-                <div ref={this.pages} className='user-profile-pages'>
-                  {moddingExtraPages.map((name) => (
-                    <div
-                      key={name}
-                      ref={this.pageRefs[name]}
-                      data-page-id={name}
-                    >
-                      {this.extraPage(name)}
-                    </div>
-                  ))}
-                </div>
+                  <ProfilePageExtraTab
+                    currentPage={this.currentPage}
+                    page={page}
+                  />
+                </a>
+              ))}
+            </div>
+          </div>
+          <div ref={this.pages} className='user-profile-pages'>
+            {moddingExtraPages.map((name) => (
+              <div
+                key={name}
+                ref={this.pageRefs[name]}
+                data-page-id={name}
+              >
+                {this.extraPage(name)}
               </div>
-            </UserProfileContainer>
-          </BeatmapsContext.Provider>
-        </BeatmapsetsContext.Provider>
-      </DiscussionsContext.Provider>
+            ))}
+          </div>
+        </div>
+      </UserProfileContainer>
     );
   }
 
   private readonly extraPage = (name: ModdingExtraPage) => {
     switch (name) {
       case 'discussions':
-        return <Discussions discussions={this.userDiscussions} user={this.props.user} users={this.users} />;
+        return <Discussions discussions={this.userDiscussions} store={this.store} user={this.user} />;
       case 'events':
-        return <Events events={this.props.events} user={this.props.user} users={this.users} />;
+        return <Events events={this.props.events} user={this.user} users={this.store.users} />;
       case 'kudosu':
         return (
           <Kudosu
             expectedInitialCount={this.props.perPage.recentlyReceivedKudosu}
             initialKudosu={this.props.extras.recentlyReceivedKudosu}
             name={name}
-            total={this.props.user.kudosu.total}
-            userId={this.props.user.id}
+            total={this.user.kudosu.total}
+            userId={this.user.id}
           />
         );
       case 'posts':
-        return <Posts posts={this.props.posts} user={this.props.user} users={this.users} />;
+        return <Posts posts={this.props.posts} store={this.store} user={this.user} />;
       case 'votes':
-        return <Votes users={this.users} votes={this.props.votes} />;
+        return <Votes users={this.props.users} votes={this.props.votes} />;
       default:
         switchNever(name);
         throw new Error('unsupported extra page');

resources/js/modding-profile/posts.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 { BeatmapsContext } from 'beatmap-discussions/beatmaps-context';
 import BeatmapsetCover from 'components/beatmapset-cover';
 import { BeatmapsetDiscussionMessagePostJson } from 'interfaces/beatmapset-discussion-post-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import UserJson from 'interfaces/user-json';
 import { route } from 'laroute';
 import { deletedUserJson } from 'models/user';
···
 
 interface Props {
   posts: BeatmapsetDiscussionMessagePostJson[];
+  store: BeatmapsetDiscussionsStore;
   user: UserJson;
-  users: Partial<Record<number, UserJson>>;
 }
 
-export class Posts extends React.Component<Props> {
-  static contextType = BeatmapsContext;
-  declare context: React.ContextType<typeof BeatmapsContext>;
-
+export default class Posts extends React.Component<Props> {
   render() {
     return (
       <div className='page-extra'>
···
     const discussion = post.beatmap_discussion;
     if (discussion == null || discussion.beatmapset == null) return;
 
-    const beatmap = (discussion.beatmap_id != null ? this.context[discussion.beatmap_id] : null) ?? null;
-
     const discussionClasses = classWithModifiers(
       'beatmap-discussion',
       ['preview', 'modding-profile'],
···
         <div className={discussionClasses}>
           <div className='beatmap-discussion__discussion'>
             <Post
-              beatmap={beatmap}
-              beatmapset={discussion.beatmapset}
               discussion={discussion}
+              discussionsState={null}
               post={post}
               read
               readonly
-              resolvedSystemPostId={-1} // TODO: Can probably move to context after refactoring state?
+              store={this.props.store}
               type='reply'
-              user={this.props.users[post.user_id] ?? deletedUserJson}
-              users={this.props.users}
+              user={this.props.store.users.get(post.user_id) ?? deletedUserJson}
             />
           </div>
         </div>

resources/js/mp-history/game-header.coffee

···
 import { div, a, span, h1, h2 } from 'react-dom-factories'
 import { getArtist, getTitle } from 'utils/beatmapset-helper'
 import { trans } from 'utils/lang'
+import { filterMods } from 'utils/score-helper'
 
 el = React.createElement
 

resources/js/profile-page/play-detail.tsx

···
 import { classWithModifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
 import { trans } from 'utils/lang';
-import { hasMenu } from 'utils/score-helper';
+import { accuracy, filterMods, hasMenu, rank } from 'utils/score-helper';
 import { beatmapUrl } from 'utils/url';
 
 const bn = 'play-detail';
···
     }
 
     const scoreWeight = this.props.showPpWeight ? score.weight : null;
+    const scoreRank = rank(score);
 
     return (
       <div className={blockClass} {...additionalAttributes}>
         {this.renderPinSortableHandle()}
         <div className={`${bn}__group ${bn}__group--top`}>
           <div className={`${bn}__icon ${bn}__icon--main`}>
-            <div className={`score-rank score-rank--full score-rank--${score.rank}`} />
+            <div className={`score-rank score-rank--full score-rank--${scoreRank}`} />
           </div>
 
           <div className={`${bn}__detail`}>
···
         <div className={`${bn}__group ${bn}__group--bottom`}>
           <div className={`${bn}__score-detail ${bn}__score-detail--score`}>
             <div className={`${bn}__icon ${bn}__icon--extra`}>
-              <div className={`score-rank score-rank--full score-rank--${score.rank}`} />
+              <div className={`score-rank score-rank--full score-rank--${scoreRank}`} />
             </div>
             <div className={`${bn}__score-detail-top-right`}>
               <div className={`${bn}__accuracy-and-weighted-pp`}>
                 <span className={`${bn}__accuracy`}>
-                  {formatNumber(score.accuracy * 100, 2)}%
+                  {formatNumber(accuracy(score) * 100, 2)}%
                 </span>
                 {scoreWeight != null && (
                   <span className={`${bn}__weighted-pp`}>
···
           </div>
 
           <div className={`${bn}__score-detail ${bn}__score-detail--mods`}>
-            {score.mods.map((mod) => <Mod key={mod.acronym} mod={mod} />)}
+            {filterMods(score).map((mod) => <Mod key={mod.acronym} mod={mod} />)}
           </div>
 
           <div className={`${bn}__pp`}>

resources/js/register-components.tsx

···
 import { startListening, UserCardTooltip } from 'components/user-card-tooltip';
 import { UserCards } from 'components/user-cards';
 import { WikiSearch } from 'components/wiki-search';
-import { keyBy } from 'lodash';
 import { observable } from 'mobx';
-import { deletedUserJson } from 'models/user';
 import NotificationWidget from 'notification-widget/main';
 import core from 'osu-core-singleton';
 import QuickSearch from 'quick-search/main';
 import QuickSearchWorker from 'quick-search/worker';
 import * as React from 'react';
 import { parseJson } from 'utils/json';
+import { mapBy } from 'utils/map';
 
 function reqJson<T>(input: string|undefined): T {
   // This will throw when input is missing and thus parsing empty string.
···
   const props: BeatmapsetEventsProps = {
     events: parseJson('json-events'),
     mode: 'list',
-    users: keyBy(parseJson('json-users'), 'id'),
+    users: mapBy(parseJson('json-users'), 'id'),
   };
-
-  // TODO: move to store?
-  // eslint-disable-next-line id-blacklist
-  props.users.null = props.users.undefined = deletedUserJson;
 
   return <BeatmapsetEvents {...props} />;
 });

resources/js/scores-show/info.tsx

···
 import { SoloScoreJsonForShow } from 'interfaces/solo-score-json';
 import * as React from 'react';
 import { rulesetName } from 'utils/beatmap-helper';
+import { accuracy, rank } from 'utils/score-helper';
 import Buttons from './buttons';
 import Dial from './dial';
 import Player from './player';
···
       </div>
 
       <div className='score-info__item'>
-        <Tower rank={score.rank} />
+        <Tower rank={rank(score)} />
       </div>
 
       <div className='score-info__item score-info__item--dial'>
-        <Dial accuracy={score.accuracy} mode={rulesetName(score.ruleset_id)} rank={score.rank} />
+        <Dial accuracy={accuracy(score)} mode={rulesetName(score.ruleset_id)} rank={rank(score)} />
       </div>
 
       <div className='score-info__item score-info__item--player'>

resources/js/scores-show/player.tsx

···
 import * as React from 'react';
 import { formatNumber } from 'utils/html';
 import { trans } from 'utils/lang';
-import { totalScore } from 'utils/score-helper';
+import { filterMods, totalScore } from 'utils/score-helper';
 
 interface Props {
   score: SoloScoreJsonForShow;
···
         </div>
 
         <div className='score-player__mods'>
-          {props.score.mods.map((mod) => (
+          {filterMods(props.score).map((mod) => (
             <div key={mod.acronym} className='score-player__mod'>
               <Mod mod={mod} />
             </div>

resources/js/scores/pp-value.tsx

···
   if (!isBest && !isSolo) {
     title = trans('scores.status.non_best');
     content = '-';
+  } else if (props.score.ranked === false) {
+    title = trans('scores.status.no_pp');
+    content = '-';
   } else if (props.score.pp == null) {
     if (isSolo && !props.score.passed) {
       title = trans('scores.status.non_passing');
       content = '-';
     } else {
       title = trans('scores.status.processing');
-      content = <span className='fas fa-exclamation-triangle' />;
+      content = <span className='fas fa-sync' />;
     }
   } else {
     title = formatNumber(props.score.pp);

resources/js/stores/beatmapset-discussions-bundle-store.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 BeatmapsetDiscussionsBundleJson from 'interfaces/beatmapset-discussions-bundle-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
+import { computed, makeObservable, observable } from 'mobx';
+import { mapBy, mapByWithNulls } from 'utils/map';
+
+export default class BeatmapsetDiscussionsBundleStore implements BeatmapsetDiscussionsStore {
+  /** TODO: accessor; readonly */
+  @observable bundle;
+
+  @computed
+  get beatmaps() {
+    return mapBy(this.bundle.beatmaps, 'id');
+  }
+
+  @computed
+  get beatmapsets() {
+    return mapBy(this.bundle.beatmapsets, 'id');
+  }
+
+  @computed
+  get discussions() {
+    // TODO: add bundle.discussions?
+    return mapByWithNulls(this.bundle.included_discussions, 'id');
+  }
+
+  @computed
+  get users() {
+    return mapByWithNulls(this.bundle.users, 'id');
+  }
+
+  constructor(bundle: BeatmapsetDiscussionsBundleJson) {
+    this.bundle = bundle;
+    makeObservable(this);
+  }
+}

resources/js/stores/beatmapset-discussions-for-modding-profile-store.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 { BeatmapsetDiscussionsBundleJsonForModdingProfile } from 'interfaces/beatmapset-discussions-bundle-json';
+import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
+import { computed, makeObservable, observable } from 'mobx';
+import { mapBy, mapByWithNulls } from 'utils/map';
+
+export default class BeatmapsetDiscussionsBundleForModdingProfileStore implements BeatmapsetDiscussionsStore {
+  /** TODO: accessor; readonly */
+  @observable bundle;
+
+  @computed
+  get beatmaps() {
+    return mapBy(this.bundle.beatmaps, 'id');
+  }
+
+  @computed
+  get beatmapsets() {
+    return mapBy(this.bundle.beatmapsets, 'id');
+  }
+
+  @computed
+  get discussions() {
+    return mapByWithNulls(this.bundle.discussions, 'id');
+  }
+
+  @computed
+  get users() {
+    return mapByWithNulls(this.bundle.users, 'id');
+  }
+
+  constructor(bundle: BeatmapsetDiscussionsBundleJsonForModdingProfile) {
+    this.bundle = bundle;
+    makeObservable(this);
+  }
+}

resources/js/stores/beatmapset-discussions-show-store.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 BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
+import BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
+import { computed, makeObservable, observable } from 'mobx';
+import { mapBy, mapByWithNulls } from 'utils/map';
+
+export default class BeatmapsetDiscussionsShowStore implements BeatmapsetDiscussionsStore {
+  @observable beatmapset: BeatmapsetWithDiscussionsJson;
+
+  @computed
+  get beatmaps() {
+    const hasDiscussion = new Set<number>();
+    for (const discussion of this.beatmapset.discussions) {
+      if (discussion?.beatmap_id != null) {
+        hasDiscussion.add(discussion.beatmap_id);
+      }
+    }
+
+    return mapBy(
+      this.beatmapset.beatmaps.filter((beatmap) => beatmap.deleted_at == null || hasDiscussion.has(beatmap.id)),
+      'id',
+    );
+  }
+
+  @computed
+  get beatmapsets() {
+    return new Map<number, BeatmapsetExtendedJson>([[this.beatmapset.id, this.beatmapset]]);
+  }
+
+  @computed
+  get discussions() {
+    // skipped discussions
+    // - not privileged (deleted discussion)
+    // - deleted beatmap
+
+    // allow null for the key so we can use .get(null)
+    return mapByWithNulls(this.beatmapset.discussions, 'id');
+  }
+
+  @computed
+  get users() {
+    return mapByWithNulls(this.beatmapset.related_users, 'id');
+  }
+
+  constructor(beatmapset: BeatmapsetWithDiscussionsJson) {
+    this.beatmapset = beatmapset;
+    makeObservable(this);
+  }
+}

resources/js/utils/array.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.
+
+export function mobxArrayGet<T>(array: T[] | null | undefined, index: number): T | undefined {
+  return array != null && array.length > index ? array[index] : undefined;
+}

resources/js/utils/beatmapset-discussion-helper.ts

···
 // See the LICENCE file in the repository root for full licence text.
 
 import { Filter, filters } from 'beatmap-discussions/current-discussions';
-import DiscussionMode, { DiscussionPage, discussionPages } from 'beatmap-discussions/discussion-mode';
+import DiscussionMode from 'beatmap-discussions/discussion-mode';
+import DiscussionPage, { isDiscussionPage } from 'beatmap-discussions/discussion-page';
 import guestGroup from 'beatmap-discussions/guest-group';
 import mapperGroup from 'beatmap-discussions/mapper-group';
 import BeatmapJson from 'interfaces/beatmap-json';
-import BeatmapsetDiscussionJson, { BeatmapsetDiscussionJsonForBundle, BeatmapsetDiscussionJsonForShow } from 'interfaces/beatmapset-discussion-json';
+import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import BeatmapsetDiscussionPostJson from 'interfaces/beatmapset-discussion-post-json';
 import BeatmapsetJson from 'interfaces/beatmapset-json';
 import GameMode, { gameModes } from 'interfaces/game-mode';
···
 import { getInt } from './math';
 
 interface BadgeGroupParams {
-  beatmapset: BeatmapsetJson;
-  currentBeatmap: BeatmapJson | null;
+  beatmapset?: BeatmapsetJson;
+  currentBeatmap?: BeatmapJson | null;
   discussion: BeatmapsetDiscussionJson;
   user?: UserJson;
 }
···
 // parseUrl and makeUrl lookups
 const filterLookup = new Set<unknown>(filters);
 const generalPages = new Set<unknown>(['events', 'generalAll', 'reviews']);
-const pageLookup = new Set<unknown>(discussionPages);
 
 const defaultBeatmapId = '-';
 
···
     return null;
   }
 
-  if (user.id === beatmapset.user_id) {
+  if (user.id === beatmapset?.user_id) {
     return mapperGroup;
   }
 
···
     return guestGroup;
   }
 
-  return user.groups?.[0];
+  if (user.groups == null || user.groups.length === 0) {
+    return null;
+  }
+
+  return user.groups[0];
 }
 
 export function canModeratePosts() {
···
   const m = Math.floor(value / 1000 / 60);
 
   return `${padStart(m.toString(), 2, '0')}:${padStart(s.toString(), 2, '0')}:${padStart(ms.toString(), 3, '0')}`;
-}
-
-
-function isDiscussionPage(value: string): value is DiscussionPage {
-  return pageLookup.has(value);
 }
 
 function isFilter(value: string): value is Filter {
···
 }
 
 // Workaround for the discussion starting_post typing mess until the response gets refactored and normalized.
-export function startingPost(discussion: BeatmapsetDiscussionJsonForBundle | BeatmapsetDiscussionJsonForShow): BeatmapsetDiscussionPostJson {
-  if (!('posts' in discussion)) {
-    return discussion.starting_post;
+export function startingPost(discussion: BeatmapsetDiscussionJson) {
+  if ('posts' in discussion && discussion.posts != null) {
+    return discussion.posts[0];
   }
 
-  return discussion.posts[0];
+  return discussion.starting_post;
 }
 
 export function stateFromDiscussion(discussion: BeatmapsetDiscussionJson) {

resources/js/utils/json.ts

···
  *
  * @param id id of the HTMLScriptElement.
  */
-export function parseJson<T>(id: string): T {
-  const json = parseJsonNullable<T>(id);
+export function parseJson<T>(id: string, remove = false): T {
+  const json = parseJsonNullable<T>(id, remove);
   if (json == null) {
     throw new Error(`script element ${id} is missing or contains nullish value.`);
   }
···
  * @param id id of the HTMLScriptElement.
  * @param remove true to remove the element after parsing; false, otherwise.
  */
-export function parseJsonNullable<T>(id: string, remove = false): T | undefined {
+export function parseJsonNullable<T>(id: string, remove = false, reviver?: (key: string, value: any) => any): T | undefined {
   const element = (window.newBody ?? document.body).querySelector(`#${id}`);
   if (!(element instanceof HTMLScriptElement)) return undefined;
-  const json = JSON.parse(element.text) as T;
+  const json = JSON.parse(element.text, reviver) as T;
 
   if (remove) {
     element.remove();

resources/js/utils/legacy-score-helper.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 Rank from 'interfaces/rank';
+import SoloScoreJson from 'interfaces/solo-score-json';
+
+interface CacheEntry {
+  accuracy: number;
+  rank: Rank;
+}
+let cache: Partial<Record<string, CacheEntry>> = {};
+
+// reset cache on navigation
+document.addEventListener('turbolinks:load', () => {
+  cache = {};
+});
+
+function shouldHaveHiddenRank(score: SoloScoreJson) {
+  return score.mods.some((mod) => mod.acronym === 'FL' || mod.acronym === 'HD');
+}
+
+export function legacyAccuracyAndRank(score: SoloScoreJson) {
+  const key = `${score.type}:${score.id}`;
+  let cached = cache[key];
+
+  if (cached == null) {
+    const countMiss = score.statistics.miss ?? 0;
+    const countGreat = score.statistics.great ?? 0;
+
+    let accuracy: number;
+    let rank: Rank;
+
+    // Reference: https://github.com/ppy/osu/blob/e3ffea1b127cbd3171010972588a8b07cf049ba0/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs#L170-L274
+    switch (score.ruleset_id) {
+      // osu
+      case 0: {
+        const countMeh = score.statistics.meh ?? 0;
+        const countOk = score.statistics.ok ?? 0;
+
+        const totalHits = countMeh + countOk + countGreat + countMiss;
+        accuracy = totalHits > 0
+          ? (countMeh * 50 + countOk * 100 + countGreat * 300) / (totalHits * 300)
+          : 1;
+
+        const ratioGreat = totalHits > 0 ? countGreat / totalHits : 1;
+        const ratioMeh = totalHits > 0 ? countMeh / totalHits : 1;
+
+        if (score.rank === 'F') {
+          rank = 'F';
+        } else if (ratioGreat === 1) {
+          rank = shouldHaveHiddenRank(score) ? 'XH' : 'X';
+        } else if (ratioGreat > 0.9 && ratioMeh <= 0.01 && countMiss === 0) {
+          rank = shouldHaveHiddenRank(score) ? 'SH' : 'S';
+        } else if ((ratioGreat > 0.8 && countMiss === 0) || ratioGreat > 0.9) {
+          rank = 'A';
+        } else if ((ratioGreat > 0.7 && countMiss === 0) || ratioGreat > 0.8) {
+          rank = 'B';
+        } else if (ratioGreat > 0.6) {
+          rank = 'C';
+        } else {
+          rank = 'D';
+        }
+        break;
+      }
+      // taiko
+      case 1: {
+        const countOk = score.statistics.ok ?? 0;
+
+        const totalHits = countOk + countGreat + countMiss;
+        accuracy = totalHits > 0
+          ? (countOk * 150 + countGreat * 300) / (totalHits * 300)
+          : 1;
+
+        const ratioGreat = totalHits > 0 ? countGreat / totalHits : 1;
+
+        if (score.rank === 'F') {
+          rank = 'F';
+        } else if (ratioGreat === 1) {
+          rank = shouldHaveHiddenRank(score) ? 'XH' : 'X';
+        } else if (ratioGreat > 0.9 && countMiss === 0) {
+          rank = shouldHaveHiddenRank(score) ? 'SH' : 'S';
+        } else if ((ratioGreat > 0.8 && countMiss === 0) || ratioGreat > 0.9) {
+          rank = 'A';
+        } else if ((ratioGreat > 0.7 && countMiss === 0) || ratioGreat > 0.8) {
+          rank = 'B';
+        } else if (ratioGreat > 0.6) {
+          rank = 'C';
+        } else {
+          rank = 'D';
+        }
+        break;
+      }
+      // catch
+      case 2: {
+        const countLargeTickHit = score.statistics.large_tick_hit ?? 0;
+        const countSmallTickHit = score.statistics.small_tick_hit ?? 0;
+        const countSmallTickMiss = score.statistics.small_tick_miss ?? 0;
+
+        const totalHits = countSmallTickHit + countLargeTickHit + countGreat + countMiss + countSmallTickMiss;
+        accuracy = totalHits > 0
+          ? (countSmallTickHit + countLargeTickHit + countGreat) / totalHits
+          : 1;
+
+        if (score.rank === 'F') {
+          rank = 'F';
+        } else if (accuracy === 1) {
+          rank = shouldHaveHiddenRank(score) ? 'XH' : 'X';
+        } else if (accuracy > 0.98) {
+          rank = shouldHaveHiddenRank(score) ? 'SH' : 'S';
+        } else if (accuracy > 0.94) {
+          rank = 'A';
+        } else if (accuracy > 0.9) {
+          rank = 'B';
+        } else if (accuracy > 0.85) {
+          rank = 'C';
+        } else {
+          rank = 'D';
+        }
+        break;
+      }
+      // mania
+      case 3: {
+        const countPerfect = score.statistics.perfect ?? 0;
+        const countGood = score.statistics.good ?? 0;
+        const countOk = score.statistics.ok ?? 0;
+        const countMeh = score.statistics.meh ?? 0;
+
+        const totalHits = countPerfect + countGood + countOk + countMeh + countGreat + countMiss;
+        accuracy = totalHits > 0
+          ? ((countGreat + countPerfect) * 300 + countGood * 200 + countOk * 100 + countMeh * 50) / (totalHits * 300)
+          : 1;
+
+        if (score.rank === 'F') {
+          rank = 'F';
+        } else if (accuracy === 1) {
+          rank = shouldHaveHiddenRank(score) ? 'XH' : 'X';
+        } else if (accuracy > 0.95) {
+          rank = shouldHaveHiddenRank(score) ? 'SH' : 'S';
+        } else if (accuracy > 0.9) {
+          rank = 'A';
+        } else if (accuracy > 0.8) {
+          rank = 'B';
+        } else if (accuracy > 0.7) {
+          rank = 'C';
+        } else {
+          rank = 'D';
+        }
+        break;
+      }
+      default:
+        throw new Error('unknown score ruleset');
+    }
+
+    cached = cache[key] = { accuracy, rank };
+  }
+
+  return cached;
+}

resources/js/utils/map.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.
+
+export function mapBy<T, K extends keyof T>(array: T[], key: K) {
+  const map = new Map<T[K], T>();
+
+  for (const value of array) {
+    map.set(value[key], value);
+  }
+
+  return map;
+}
+
+export function mapByWithNulls<T, K extends keyof T>(array: T[], key: K) {
+  const map = new Map<T[K] | null | undefined, T>();
+
+  for (const value of array) {
+    map.set(value[key], value);
+  }
+
+  return map;
+}

resources/js/utils/score-helper.ts

···
 import core from 'osu-core-singleton';
 import { rulesetName } from './beatmap-helper';
 import { trans } from './lang';
+import { legacyAccuracyAndRank } from './legacy-score-helper';
+
+export function accuracy(score: SoloScoreJson) {
+  if (score.legacy_score_id == null || !core.userPreferences.get('legacy_score_only')) {
+    return score.accuracy;
+  }
+
+  return legacyAccuracyAndRank(score).accuracy;
+}
 
 export function canBeReported(score: SoloScoreJson) {
   return (score.best_id != null || score.type === 'solo_score')
     && core.currentUser != null
     && score.user_id !== core.currentUser.id;
+}
+
+// Removes CL mod on legacy score if user has lazer mode disabled
+export function filterMods(score: SoloScoreJson) {
+  if (score.legacy_score_id == null || !core.userPreferences.get('legacy_score_only')) {
+    return score.mods;
+  }
+
+  return score.mods.filter((mod) => mod.acronym !== 'CL');
 }
 
 // TODO: move to application state repository thingy later
···
   ],
 };
 
+export function rank(score: SoloScoreJson) {
+  if (score.legacy_score_id == null || !core.userPreferences.get('legacy_score_only')) {
+    return score.rank;
+  }
+
+  return legacyAccuracyAndRank(score).rank;
+}
+
 export function scoreDownloadUrl(score: SoloScoreJson) {
   if (score.type === 'solo_score') {
     return route('scores.download', { score: score.id });
···
 }
 
 export function totalScore(score: SoloScoreJson) {
-  return score.legacy_total_score ?? score.total_score;
+  if (score.legacy_score_id == null || !core.userPreferences.get('legacy_score_only')) {
+    return score.total_score;
+  }
+
+  return score.legacy_total_score;
 }

resources/lang/ar/password_reset.php

···
     'starting' => [
         'username' => 'أدخل اسم المستخدم أو عنوان البريد الإلكتروني',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'تحتاج دعم في المستقبل؟ تواصل معنا على :button.',
             'button' => 'نظام الدعم',

resources/lang/be/password_reset.php

···
     'starting' => [
         'username' => 'Увядзіце эл. пошту або імя карыстальніка',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Патрэбна дадатковая дапамога? Звяжыцеся з намі :button.',
             'button' => 'сістэма падтрымкі',

resources/lang/bg/password_reset.php

···
     'starting' => [
         'username' => 'Въведете имейл или потребителско име',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Нуждаете се от допълнителна помощ? Свържете се с нашата :button.',
             'button' => 'поддръжка',

resources/lang/ca/password_reset.php

···
     'starting' => [
         'username' => 'Adreça electrònica o  nom d\'usuari',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Necessites més assistència? Contacta\'ns a través del nostre :button.',
             'button' => 'sistema de suport',

resources/lang/cs/password_reset.php

···
     'starting' => [
         'username' => 'Zadejte Vaši e-mailovou adresu nebo uživatelské jméno',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Potřebujete další pomoc? Kontaktujte nás prostřednictvím :button.',
             'button' => 'systém podpory',

resources/lang/da/password_reset.php

···
     'starting' => [
         'username' => 'Indtast email-adresse eller brugernavn',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Har du brug for yderligere assistance? Kontakt os via vores :button.',
             'button' => 'support system',

resources/lang/de/password_reset.php

···
     'starting' => [
         'username' => 'Benutzername oder E-Mail eingeben',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Benötigst du weitere Hilfe? Kontaktiere uns über unser :button.',
             'button' => 'Supportsystem',

resources/lang/el/password_reset.php

···
     'starting' => [
         'username' => 'Εισάγετε τη διεύθυνση ηλεκτρονικού ταχυδρομείου ή το όνομα χρήστη',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Χρειάζεστε περαιτέρω βοήθεια? Επικοινωνήστε μαζί μας μέσω :button.',
             'button' => 'σύστημα υποστήριξης',

resources/lang/en/layout.php

···
             'account-edit' => 'Settings',
             'follows' => 'Watchlists',
             'friends' => 'Friends',
+            'legacy_score_only_toggle' => 'Lazer mode',
+            'legacy_score_only_toggle_tooltip' => 'Lazer mode shows scores set from lazer with a new scoring algorithm',
             'logout' => 'Sign Out',
             'profile' => 'My Profile',
         ],

resources/lang/en/scores.php

···
     'status' => [
         'non_best' => 'Only personal best scores award pp',
         'non_passing' => 'Only passing scores award pp',
+        'no_pp' => 'pp is not awarded for this score',
         'processing' => 'This score is still being calculated and will be displayed soon',
     ],
 ];

resources/lang/es/password_reset.php

···
     'starting' => [
         'username' => 'Ingrese correo o nombre de usuario',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '¿Necesita asistencia? Contáctenos a través de nuestro :button.',
             'button' => 'sistema de soporte',

resources/lang/fa-IR/password_reset.php

···
     'starting' => [
         'username' => 'ایمیل یا نام کاربری را وارد کتید',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'نیاز به کمک بیشتر دارید؟ با ما توسط :button تماس بگیرید.',
             'button' => 'سیستم پشتیبانی',

resources/lang/fi/beatmaps.php

···
         'pending' => 'Vireillä',
         'wip' => 'Työn alla',
         'qualified' => 'Kelpuutettu',
-        'ranked' => 'Pisteytetty',
+        'ranked' => 'Rankattu',
     ],
     'genre' => [
         'any' => 'Kaikki',

resources/lang/fi/beatmapsets.php

···
                 'friend' => 'Kukaan kavereistasi ei vielä ole saanut tulosta tässä mapissa!',
                 'global' => 'Tuloksia ei ole. Voisit hankkia niitä.',
                 'loading' => 'Ladataan tuloksia...',
-                'unranked' => 'Pisteyttämätön rytmikartta.',
+                'unranked' => 'Rankkaamaton rytmikartta.',
             ],
             'score' => [
                 'first' => 'Johdossa',

resources/lang/fi/community.php

···
                 'description' => 'Lahjoituksesi auttavat pitämään pelin itsenäisenä ja täysin vapaana mainoksista ja ulkopuolisista sponsoreista.',
             ],
             'tournaments' => [
-                'title' => 'Virallisiin turnauksiin',
-                'description' => 'Auta osu! maailmancup -turnausten ylläpidon (sekä palkintojen) rahoituksessa.',
+                'title' => 'Viralliset turnaukset',
+                'description' => 'Auta osu!-maailmancup -turnausten ylläpidon (sekä palkintojen) rahoituksessa.',
                 'link_text' => 'Selaa turnauksia »',
             ],
             'bounty-program' => [
-                'title' => 'Avoimen lähdekoodin palkkio -ohjelmaan',
+                'title' => 'Avoimen lähdekoodin palkkio -ohjelma',
                 'description' => 'Tue yhteisön osallistujia, jotka ovat käyttäneet aikaansa ja vaivaansa tekemään osu!sta paremman.',
                 'link_text' => 'Lue lisää »',
             ],

resources/lang/fi/layout.php

···
         ],
         'help' => [
             '_' => 'apua',
-            'getAbuse' => 'ilmoita häirinnästä',
+            'getAbuse' => 'ilmoita väärinkäytöstä',
             'getFaq' => 'usein kysytyt',
             'getRules' => 'säännöt',
             'getSupport' => 'tarvitsen siis oikeasti apua!',

resources/lang/fi/password_reset.php

···
     'starting' => [
         'username' => 'Anna sähköposti tai käyttäjänimi',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Tarvitsetko lisäapua? Ota yhteyttä meihin: :button.',
             'button' => 'tukijärjestelmä',

resources/lang/fi/users.php

···
         ],
 
         'options' => [
-            'cheating' => 'Väärin pelaaminen / Huijaaminen',
+            'cheating' => 'Huijaaminen',
             'multiple_accounts' => 'Käyttää useita tilejä',
             'insults' => 'Loukkaa minua / muita',
             'spam' => 'Spämmii',

resources/lang/fil/legacy_api_key.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
-    'new' => '',
-    'none' => '',
+    'new' => 'Bagong Legacy API Key',
+    'none' => 'Walang key.',
 
     'docs' => [
         '_' => '',

resources/lang/fil/legacy_irc_key.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
-    'confirm_new' => '',
-    'new' => '',
-    'none' => '',
+    'confirm_new' => 'Gumawa ng bagong IRC password?',
+    'new' => 'Bagong Legacy IRC Password',
+    'none' => 'Hindi na-set ang IRC Password.',
 
     'form' => [
-        'server_host' => '',
-        'server_port' => '',
-        'token' => '',
-        'username' => '',
+        'server_host' => 'server',
+        'server_port' => 'port',
+        'token' => 'server password',
+        'username' => 'username',
     ],
 
     'view' => [
-        'hide' => '',
-        'show' => '',
-        'delete' => '',
+        'hide' => 'Itago ang password',
+        'show' => 'Ipakita ang password',
+        'delete' => 'Burahin',
     ],
 ];

resources/lang/fil/password_reset.php

···
     'starting' => [
         'username' => 'Itala ang email address o username',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Kailangan pa ng tulong? Makipag-usap sa amin sa :button.',
             'button' => 'support system',

resources/lang/fil/store.php

···
 return [
     'cart' => [
         'checkout' => 'Checkout',
-        'empty_cart' => '',
+        'empty_cart' => 'Tanggalin lahat ng items sa cart',
         'info' => ':count_delimited pirasong item sa kariton ($:subtotal)|:count_delimited pirasong mga item sa kariton ($:subtotal)',
         'more_goodies' => 'Gusto kong tingnan ang higit pang mga goodies bago makumpleto ang order',
         'shipping_fees' => 'mga bayarin sa pagpapadala',
···
     ],
 
     'discount' => 'makatipid ng :percent%',
-    'free' => '',
+    'free' => 'free!',
 
     'invoice' => [
         'contact' => '',

resources/lang/fr/chat.php

···
             'title' => [
                 'ANNOUNCE' => 'Annonces',
                 'GROUP' => 'Groupes',
-                'PM' => 'Messages directs',
+                'PM' => 'Messages privés',
                 'PUBLIC' => 'Canaux',
             ],
         ],
···
 
     'input' => [
         'create' => 'Créer',
-        'disabled' => 'impossible d\'envoyer un message...',
+        'disabled' => 'impossible d’envoyer le message...',
         'disconnected' => 'Déconnecté',
         'placeholder' => 'saisissez votre message...',
         'send' => 'Envoyer',

resources/lang/fr/password_reset.php

···
     'starting' => [
         'username' => 'Entrez une adresse e-mail ou un nom d\'utilisateur',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Vous avez besoin d\'aide supplémentaire ? Contactez-nous via notre :button.',
             'button' => 'système de support',

resources/lang/he/password_reset.php

···
     'starting' => [
         'username' => 'הכנס אימייל או שם משתמש',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'צריך עזרה נוספת? צור איתנו קשר דרך ה:button שלנו.',
             'button' => 'מערכת תמיכה',

resources/lang/hr-HR/password_reset.php

···
     'starting' => [
         'username' => 'Unesi svoju adresu e-pošte ili korisničko ime',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Trebaš dodatnu pomoć? Kontaktiraj nas putem naše :button.',
             'button' => 'sistema za podršku',

resources/lang/hu/password_reset.php

···
     'starting' => [
         'username' => 'Add meg az e-mail címed vagy felhasználóneved',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Segítség kéne? Lépj kapcsolatba velünk itt :botton.',
             'button' => 'támogatói rendszer',

resources/lang/id/artist.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
-    'page_description' => 'Featured artist di osu!',
+    'page_description' => 'Featured Artist di osu!',
     'title' => 'Featured Artist',
 
     'admin' => [

resources/lang/id/authorization.php

···
         'edit' => [
             'not_owner' => 'Hanya pemilik topik yang diperbolehkan untuk menyunting kiriman.',
             'resolved' => 'Kamu tidak dapat menyunting postingan pada topik diskusi yang telah terjawab.',
-            'system_generated' => 'Post yang dihasilkan secara otomatis tidak dapat disunting.',
+            'system_generated' => 'Postingan yang dihasilkan secara otomatis tidak dapat disunting.',
         ],
     ],
 

resources/lang/id/beatmap_discussions.php

···
     ],
 
     'events' => [
-        'empty' => 'Belum ada hal apapun yang terjadi... hingga saat ini.',
+        'empty' => 'Belum ada hal apa pun yang terjadi... hingga saat ini.',
     ],
 
     'index' => [

resources/lang/id/follows.php

···
     ],
 
     'mapping' => [
-        'empty' => 'Kamu tidak sedang mengikuti siapapun.',
+        'empty' => 'Kamu tidak sedang mengikuti siapa pun.',
         'followers' => 'pengikut mapping',
         'page_title' => 'mapper yang diikuti',
         'title' => 'mapper',

resources/lang/id/forum.php

···
         ],
 
         'topics' => [
-            'empty' => 'Tidak ada topik!',
+            'empty' => 'Tidak ada topik apa pun di sini!',
         ],
     ],
 

resources/lang/id/home.php

···
     'landing' => [
         'download' => 'Unduh sekarang',
         'online' => 'dengan <strong>:players</strong> pemain yang saat ini terhubung dalam <strong>:games</strong> ruang permainan',
-        'peak' => 'Jumlah pengguna online terbanyak: :count',
+        'peak' => 'Puncak aktivitas: :count pengguna online',
         'players' => '<strong>:count</strong> pengguna terdaftar',
         'title' => 'selamat datang',
         'see_more_news' => 'lihat lebih banyak berita',

resources/lang/id/legacy_api_key.php

···
     ],
 
     'warning' => [
-        'line1' => 'Jangan berikan informasi ini pada siapapun.',
+        'line1' => 'Jangan berikan informasi ini kepada siapa pun.',
         'line2' => "Ini sama halnya membagikan akunmu pada yang lain.",
         'line3' => 'Harap untuk tidak membagikan informasi ini.',
     ],

resources/lang/id/notifications.php

···
 
             'beatmapset_discussion' => [
                 '_' => 'Laman diskusi beatmap',
-                'beatmapset_discussion_lock' => 'Diskusi untuk beatmap ":title" telah ditutup.',
+                'beatmapset_discussion_lock' => 'Diskusi pada beatmap ":title" telah dikunci',
                 'beatmapset_discussion_lock_compact' => 'Diskusi beatmap telah dikunci',
                 'beatmapset_discussion_post_new' => 'Postingan baru pada ":title" oleh :username: ":content"',
                 'beatmapset_discussion_post_new_empty' => 'Postingan baru pada ":title" oleh :username',
                 'beatmapset_discussion_post_new_compact' => 'Postingan baru oleh :username: ":content"',
                 'beatmapset_discussion_post_new_compact_empty' => 'Postingan baru oleh :username',
-                'beatmapset_discussion_review_new' => 'Terdapat ulasan baru pada ":title" oleh :username yang menyinggung seputar masalah: :problems, saran: :suggestions, dan pujian berupa: :praises',
-                'beatmapset_discussion_review_new_compact' => 'Terdapat ulasan baru oleh :username yang menyinggung seputar masalah: :problems, saran: :suggestions, dan pujian berupa: :praises',
-                'beatmapset_discussion_unlock' => 'Diskusi untuk beatmap ":title" telah dibuka kembali.',
+                'beatmapset_discussion_review_new' => 'Kajian baru pada ":title" oleh :username yang mengandung :review_counts',
+                'beatmapset_discussion_review_new_compact' => 'Kajian baru oleh :username yang mengandung :review_counts',
+                'beatmapset_discussion_unlock' => 'Diskusi pada beatmap ":title" telah kembali dibuka',
                 'beatmapset_discussion_unlock_compact' => 'Diskusi beatmap telah dibuka',
 
                 'review_count' => [
···
                 'beatmapset_nominate' => '":title" telah dinominasikan',
                 'beatmapset_nominate_compact' => 'Beatmap telah dinominasikan',
                 'beatmapset_qualify' => '":title" telah memperoleh jumlah nominasi yang dibutuhkan untuk dapat memasuki antrian ranking',
-                'beatmapset_qualify_compact' => 'Beatmap telah memasuki antrian ranking',
+                'beatmapset_qualify_compact' => 'Beatmap memasuki antrian ranking',
                 'beatmapset_rank' => '":title" telah berstatus Ranked',
                 'beatmapset_rank_compact' => 'Beatmap telah berstatus Ranked',
                 'beatmapset_remove_from_loved' => '":title" telah dilepas dari Loved',
                 'beatmapset_remove_from_loved_compact' => 'Beatmap telah dilepas dari Loved',
-                'beatmapset_reset_nominations' => 'Masalah yang dikemukakan oleh :username menganulir nominasi sebelumnya pada beatmap ":title" ',
+                'beatmapset_reset_nominations' => 'Nominasi pada beatmap ":title" telah dianulir',
                 'beatmapset_reset_nominations_compact' => 'Nominasi beatmap dianulir',
             ],
 
···
                 'beatmapset_qualify' => '":title" telah memperoleh jumlah nominasi yang dibutuhkan untuk dapat memasuki antrian ranking',
                 'beatmapset_rank' => '":title" telah berstatus Ranked',
                 'beatmapset_remove_from_loved' => ':title telah dilepas dari Loved',
-                'beatmapset_reset_nominations' => 'Status nominasi pada ":title" telah dianulir',
+                'beatmapset_reset_nominations' => 'Nominasi pada beatmap ":title" telah dianulir',
             ],
 
             'comment' => [

resources/lang/id/password_reset.php

···
     'starting' => [
         'username' => 'Masukkan alamat email atau nama pengguna',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Butuh bantuan lebih lanjut? Hubungi :button kami.',
             'button' => 'layanan dukungan',

resources/lang/id/store.php

···
 
         'errors_no_checkout' => [
             'line_1' => 'Uh-oh, terdapat masalah dengan keranjangmu yang menghalangi proses checkout!',
-            'line_2' => 'Hapus atau perbarui item-item di atas untuk melanjutkan.',
+            'line_2' => 'Hapus atau perbarui rangkaian item di atas untuk melanjutkan.',
         ],
 
         'empty' => [
···
         ],
 
         'pending_checkout' => [
-            'line_1' => 'Transaksi sebelumnya belum dituntaskan.',
+            'line_1' => 'Terdapat transaksi terdahulu yang belum dituntaskan.',
             'line_2' => 'Lanjutkan pembayaranmu dengan memilih metode pembayaran.',
         ],
     ],
···
                 ],
             ],
             'prepared' => [
-                'title' => 'Pesananmu sedang disiapkan!',
+                'title' => 'Pesananmu sedang dipersiapkan!',
                 'line_1' => 'Harap tunggu sedikit lebih lama untuk pengiriman. Informasi pelacakan akan muncul di sini setelah pesanan telah diolah dan dikirim. Ini bisa perlu sampai 5 hari (tetapi biasanya lebih cepat!) tergantung kesibukan kami.',
                 'line_2' => 'Kami mengirim seluruh pesanan dari Jepang dengan berbagai macam layanan pengiriman tergantung berat dan nilai. Bagian ini akan diperbarui dengan perincian setelah kami mengirimkan pesanan.',
             ],

resources/lang/id/wiki.php

···
         ],
 
         'translation' => [
-            'legal' => 'Terjemahan ini diberikan semata-mata hanya untuk memudahkan. :default dari artikel ini merupakan satu-satunya versi artikel yang mengikat secara hukum.',
+            'legal' => 'Terjemahan ini diberikan semata-mata untuk memudahkan. :default dari artikel ini merupakan satu-satunya versi artikel yang mengikat secara hukum.',
             'outdated' => 'Laman ini mengandung terjemahan yang telah kedaluwarsa dari artikel aslinya. Mohon periksa :default dari artikel ini untuk mendapatkan informasi yang paling akurat (dan apabila kamu berkenan, mohon bantu kami untuk memperbarui terjemahan ini)!',
 
             'default' => 'Versi Bahasa Inggris',

resources/lang/it/password_reset.php

···
     'starting' => [
         'username' => 'Inserisci l\'indirizzo email o il nome utente',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Hai bisogno di ulteriore assistenza? Contattaci col nostro :button.',
             'button' => 'sistema di supporto',

resources/lang/it/store.php

···
                 'title' => 'Il tuo ordine è stato spedito!',
                 'tracking_details' => '',
                 'no_tracking_details' => [
-                    '_' => "Non disponiamo dei dettagli di tracciabilità poiché abbiamo inviato il tuo pacco tramite posta aerea, ma puoi aspettarti di riceverlo entro 1-3 settimane. Per l'Europa, a volte la dogana può ritardare l'ordine senza il nostro controllo. Se hai qualche dubbio, rispondi all'e-mail di conferma dell'ordine che hai ricevuto :link.",
+                    '_' => "Non disponiamo dei dettagli di tracciabilità poiché abbiamo inviato il tuo pacco tramite posta aerea, ma puoi aspettarti di riceverlo entro 1-3 settimane. Per l'Europa, a volte la dogana può ritardare l'ordine senza il nostro controllo. Se hai qualche dubbio, rispondi all'e-mail di conferma dell'ordine che hai ricevuto (o :link).",
                     'link_text' => 'inviaci un\'email',
                 ],
             ],

resources/lang/ja/password_reset.php

···
     'starting' => [
         'username' => 'メールアドレスまたはユーザー名を入力してください',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'さらにサポートが必要ですか？ :buttonからお問い合わせください。',
             'button' => 'サポートシステム',

resources/lang/kk-KZ/password_reset.php

···
     'starting' => [
         'username' => '',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '',
             'button' => '',

resources/lang/ko/password_reset.php

···
     'starting' => [
         'username' => '아이디나 이메일 주소를 입력하세요.',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '도움이 필요하신가요? :button을 통해 문의해보세요.',
             'button' => '지원 시스템',

resources/lang/lt/password_reset.php

···
     'starting' => [
         'username' => 'Įrašykite el. pašto adresą arba naudotojo vardą',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Reikia tolimesnės pagalbos? Susisiekite su mumis per :button.',
             'button' => 'pagalbos sistemą',

resources/lang/lv-LV/password_reset.php

···
     'starting' => [
         'username' => 'Ievadiet e-pasta adresi vai lietotājvārdu',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Nepieciešams tālāks atbalsts? Sazinieties ar mums caur :button.',
             'button' => 'atbalsta sistēma',

resources/lang/ms-MY/password_reset.php

···
     'starting' => [
         'username' => 'Masukkan alamat e-mel atau nama pengguna',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Perlukan bantuan lebih lanjut? Hubungi :button kami.',
             'button' => 'layanan dukungan',

resources/lang/nl/password_reset.php

···
     'starting' => [
         'username' => 'Vul e-mail adres of gebruikersnaam in',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Meer hulp nodig? Neem contact met ons op via onze :button.',
             'button' => 'ondersteuningssysteem',

resources/lang/no/password_reset.php

···
     'starting' => [
         'username' => 'Skriv inn e-postadresse eller brukernavn',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Trenger du mer hjelp? Kontakt oss via vårt :button.',
             'button' => 'støttesystem',

resources/lang/pl/password_reset.php

···
     'starting' => [
         'username' => 'Wprowadź e-mail lub nazwę użytkownika',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Potrzebujesz pomocy? Skontaktuj się z :button.',
             'button' => 'pomocą techniczną',

resources/lang/pt-br/password_reset.php

···
     'starting' => [
         'username' => 'Insira endereço de email ou nome de usuário',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Precisa de mais assistência? Entre em contato conosco através do nosso :button.',
             'button' => 'sistema de suporte',

resources/lang/pt/password_reset.php

···
     'starting' => [
         'username' => 'Introduz um endereço de email ou um nome de utilizador',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Precisas de mais assistência? Contacta-nos a partir do nosso :button.',
             'button' => 'sistema de suporte',

resources/lang/ro/beatmapset_events.php

···
         'nomination_reset' => 'O problemă nouă :discussion (:text) a declanșat reluarea unei nominalizări.',
         'nomination_reset_received' => 'Nominalizarea de :user a fost resetată de către :source_user (:text)',
         'nomination_reset_received_profile' => 'Nominalizarea a fost resetată de :user (:text)',
-        'offset_edit' => 'Offset-ul online schimbat din :old la :new.',
+        'offset_edit' => 'Decalaj online schimbat din :old la :new.',
         'qualify' => 'Acest beatmap a atins numărul limită de nominalizări și s-a calificat.',
         'rank' => 'Clasat.',
         'remove_from_loved' => 'Eliminat din Iubit de :user. (:text)',
···
         'nomination_reset' => 'Resetarea nominalizărilor',
         'nomination_reset_received' => 'Resetare a nominalizării primită',
         'nsfw_toggle' => 'Marcaj obscen',
-        'offset_edit' => 'Editare offset',
+        'offset_edit' => 'Editare decalaj',
         'qualify' => 'Calificare',
         'rank' => 'Clasament',
         'remove_from_loved' => 'Scoaterea din Iubit',

resources/lang/ro/beatmapsets.php

···
             'no_scores' => 'Încă se calculează datele...',
             'nominators' => 'Nominalizatori',
             'nsfw' => 'Conținut obscen',
-            'offset' => 'Offset online',
+            'offset' => 'Decalaj online',
             'points-of-failure' => 'Puncte de eșec',
             'source' => 'Sursă',
             'storyboard' => 'Acest beatmap conține un storyboard',
···
             'bpm' => 'BPM',
             'count_circles' => 'Număr Cercuri',
             'count_sliders' => 'Număr Slidere',
-            'offset' => 'Offset online: :offset',
+            'offset' => 'Decalaj online: :offset',
             'user-rating' => 'Rating Utilizatori',
             'rating-spread' => 'Grafic Rating-uri',
             'nominations' => 'Nominalizări',

resources/lang/ro/password_reset.php

···
     'starting' => [
         'username' => 'Introduceți adresa de e-mail sau numele de utilizator',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Aveți nevoie de asistență suplimentară? Contactați-ne prin intermediul :button.',
             'button' => 'sistem de ajutor',

resources/lang/ru/password_reset.php

···
     'starting' => [
         'username' => 'Введите почту или ник',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Нужна дополнительная помощь? Свяжитесь с нами через :button.',
             'button' => 'систему поддержки',

resources/lang/ru/store.php

···
                 'title' => 'Ваш заказ отправлен!',
                 'tracking_details' => 'Подробности отслеживания:',
                 'no_tracking_details' => [
-                    '_' => "У нас нет данных отслеживания, поскольку мы отправили ваш заказ авиапочтой, однако вы можете рассчитывать на их получение в течение 1-3 недель. Иногда таможня в Европе может задержать заказ вне нашего контроля. Если у вас остались вопросы, ответьте на полученное вами письмо с подтверждением заказа :link.",
+                    '_' => "У нас нет данных отслеживания, поскольку мы отправили ваш заказ авиапочтой, однако вы можете рассчитывать на их получение в течение 1-3 недель. Иногда таможня в Европе может задержать заказ вне нашего контроля. Если у вас остались вопросы, ответьте на полученное вами письмо с подтверждением заказа (или :link).",
                     'link_text' => 'отправьте нам письмо',
                 ],
             ],

resources/lang/si-LK/password_reset.php

···
     'starting' => [
         'username' => '',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '',
             'button' => '',

resources/lang/sk/password_reset.php

···
     'starting' => [
         'username' => 'Zadajte e-mailovú adresu alebo užívateľské meno',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '',
             'button' => '',

resources/lang/sl/password_reset.php

···
     'starting' => [
         'username' => 'Vnesi e-poštni naslov ali uporabniško ime',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Potrebuješ nadaljno pomoč? Kontaktiraj nas preko našega :button.',
             'button' => 'sistema podpore',

resources/lang/sr/password_reset.php

···
     'starting' => [
         'username' => 'Унесите адресу е-поште или корисничко име',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Треба Вам додатна помоћ? Ступите у контакт преко нашег :button.',
             'button' => 'систем за подршку',

resources/lang/sv/password_reset.php

···
     'starting' => [
         'username' => 'Fyll i din e-postadress eller ditt användarnamn',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Behöver du mer hjälp? Kontakta oss via vår :button.',
             'button' => 'supportsystem',

resources/lang/tg-TJ/password_reset.php

···
     'starting' => [
         'username' => '',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '',
             'button' => '',

resources/lang/tg-TJ/scores.php

···
         'title' => '',
 
         'beatmap' => [
-            'by' => '',
+            'by' => 'аз ҷониби :artist',
         ],
 
         'player' => [

resources/lang/tg-TJ/store.php

···
         'checkout' => '',
         'empty_cart' => '',
         'info' => '',
-        'more_goodies' => '',
-        'shipping_fees' => '',
-        'title' => '',
-        'total' => '',
+        'more_goodies' => 'Ман мехоҳам пеш аз ба итмом расонидани фармоиш чизҳои бештарро тафтиш кунам',
+        'shipping_fees' => 'ҳаққи интиқол',
+        'title' => 'Сабади харид',
+        'total' => 'умумии',
 
         'errors_no_checkout' => [
             'line_1' => '',
-            'line_2' => '',
+            'line_2' => 'Барои идома додани ҷузъҳои боло хориҷ ё навсозӣ кунед.',
         ],
 
         'empty' => [
-            'text' => '',
+            'text' => 'Аробаи шумо холист.',
             'return_link' => [
-                '_' => '',
+                '_' => 'Ба :link баргардед, то чизҳои хубро пайдо кунед!',
                 'link_text' => '',
             ],
         ],

resources/lang/tg-TJ/supporter_tag.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
-    'months' => '',
+    'months' => 'моҳҳо',
 
     'user_search' => [
-        'searching' => '',
-        'not_found' => "",
+        'searching' => 'чустучуй...',
+        'not_found' => "Ин корбар вуҷуд надорад",
     ],
 ];

resources/lang/th/password_reset.php

···
     'starting' => [
         'username' => 'กรอกอีเมล หรือชื่อผู้ใช้',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '
 ต้องการความช่วยเหลือเพิ่มเติมหรือไม่? ติดต่อเราผ่านทาง :button',

resources/lang/tr/accounts.php

···
     ],
 
     'github_user' => [
-        'info' => "",
+        'info' => "Eğer osu!'nun açık kaynaklı repository'lerinde katkılıysanız, GitHub hesabınızı bağlamanız sizin değişim günlüğü girişleriniz, osu! profilinizle ilişkilendirilecektir. osu! repository'lerinde katkı geçmişi olmayan GitHub hesapları bağlanamaz.",
         'link' => 'GitHub Hesabını Bağla',
         'title' => 'GitHub',
         'unlink' => 'GitHub Hesabının bağlantısını Kaldır',
 
         'error' => [
-            'already_linked' => '',
-            'no_contribution' => '',
-            'unverified_email' => '',
+            'already_linked' => 'Bu GitHub hesabı zaten başka bir kullanıcıya bağlı.',
+            'no_contribution' => 'osu! repository\'lerinde katkı geçmişi olmayan GitHub hesabı bağlanamaz.',
+            'unverified_email' => 'Lütfen GitHub\'daki ana e-postanızı doğrulayın, sonra hesabınızı tekrar bağlamayı deneyin.',
         ],
     ],
 

resources/lang/tr/notifications.php

···
                 'beatmapset_discussion_unlock_compact' => 'Tartışmanın kilidi kaldırılmış',
 
                 'review_count' => [
-                    'praises' => '',
-                    'problems' => '',
-                    'suggestions' => '',
+                    'praises' => ':count_delimited övgü|:count_delimited övgü',
+                    'problems' => ':count_delimited sorun|:count_delimited sorun',
+                    'suggestions' => ':count_delimited öneri|:count_delimited öneri',
                 ],
             ],
 

resources/lang/tr/password_reset.php

···
     'starting' => [
         'username' => 'E-posta adresi veya kullanıcı adı girin',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Yardıma mı ihtiyacınız var? :button üzerinden bizimle iletişime geçin.',
             'button' => 'Destek sistemimiz',

resources/lang/tr/store.php

···
             'cancelled' => [
                 'title' => 'Siparişiniz iptal edildi',
                 'line_1' => [
-                    '_' => "",
+                    '_' => "Eğer iptal edilmesini talep etmediyseniz lütfen :link yoluyla sipariş numaranızı bahsederek ulaşınız. (#:order_number).",
                     'link_text' => 'osu!store destek',
                 ],
             ],
···
             ],
             'prepared' => [
                 'title' => 'Siparişiniz hazılrlanıyor!',
-                'line_1' => '',
-                'line_2' => '',
+                'line_1' => 'Lütfen kargolanması için az daha bekleyiniz. Takip bilgisi, siparişiniz işlenip gönderildiğinde burada belirecektir. Meşgullük durumumuza göre 5 güne kadar sürebilir (ama genellikle daha az!).',
+                'line_2' => 'Siparişleri, ağırlığı ve değerine bağlı olarak çeşitli kargo şirketleri kullanarak gönderiyoruz. Bu alan, siparişi gönderdiğimizde detaylarla güncellenecektir.',
             ],
             'processing' => [
                 'title' => 'Ödemeniz henüz onaylanmadı!',
···
                 'title' => 'Siparişiniz kargoya verildi!',
                 'tracking_details' => 'Kargo takip detayları aşağıdadır:',
                 'no_tracking_details' => [
-                    '_' => "",
+                    '_' => "Paketinizi uçak kargosu yoluyla gönderdiğimiz için takip ayrıntılarına sahip değiliz, ancak paketinizi 1-3 hafta içinde almayı bekleyebilirsiniz. Avrupa'da bazen gümrükler bizim kontrolümüz dışında siparişi geciktirebilir. Herhangi bir endişeniz varsa lütfen sana gelen sipariş onay e-postasını yanıtlayınız (ya da :link).",
                     'link_text' => 'bize bir e-mail yollayın',
                 ],
             ],
···
         'thanks' => [
             'title' => 'Siparişiniz için teşekkür ederiz!',
             'line_1' => [
-                '_' => '',
+                '_' => 'Yakında bir onay e-postası alacaksınız. Sorunuz varsa, lütfen :link!',
                 'link_text' => 'bizimle iletişime geçin',
             ],
         ],

resources/lang/uk/password_reset.php

···
     'starting' => [
         'username' => 'Введіть пошту або нікнейм',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Потрібна додаткова допомога? Зв\'яжіться з нами через :button.',
             'button' => 'система підтримки',

resources/lang/vi/password_reset.php

···
     'starting' => [
         'username' => 'Nhập địa chỉ email hoặc tên tài khoản',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => 'Cần nhiều sự giúp đỡ hơn? Liên hệ với chúng tôi bằng :button.',
             'button' => 'hệ thống hỗ trợ',

resources/lang/zh-tw/password_reset.php

···
     'starting' => [
         'username' => '輸入郵件地址或使用者名稱',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '需要進一步的幫助？通過我們的 :button 聯繫我們。',
             'button' => '支持系統',

resources/lang/zh/password_reset.php

···
     'starting' => [
         'username' => '输入邮箱或用户名',
 
+        'reason' => [
+            'inactive_different_country' => "",
+        ],
         'support' => [
             '_' => '需要进一步的帮助？通过我们的 :button 联系我们。',
             'button' => '支持系统',

resources/views/beatmapsets/discussion.blade.php

···
 @section ("script")
     @parent
 
-    <script id="json-beatmapset-discussion" type="application/json">
-        {!! json_encode($initialData) !!}
-    </script>
+    @foreach ($initialData as $name => $data)
+        <script id="json-{{ $name }}" type="application/json">
+            {!! json_encode($data) !!}
+        </script>
+    @endforeach
+
 
     @include('beatmapsets._recommended_star_difficulty_all')
     @include('layout._react_js', ['src' => 'js/beatmap-discussions.js'])

resources/views/docs/_structures/user.md

···
 scores_best_count          | integer | |
 scores_first_count         | integer | |
 scores_recent_count        | integer | |
+session_verified           | boolean | |
 statistics                 | | |
 statistics_rulesets        | UserStatisticsRulesets | |
 support_level              | | |

resources/views/layout/_popup_user.blade.php

···
         <div class="u-relative">{{ Auth::user()->username }}</div>
     </a>
 
+    <div class="simple-menu__extra">
+        @include('layout._score_mode_toggle', ['class' => 'simple-menu__item'])
+    </div>
+
     <a
         class="simple-menu__item"
         href="{{ route('users.show', Auth::user()) }}"

resources/views/layout/_score_mode_toggle.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.
+--}}
+@php
+    $legacyScoreMode ??= App\Libraries\Search\ScoreSearchParams::showLegacyForUser(Auth::user()) === true;
+    $icon = $legacyScoreMode
+        ? 'far fa-square'
+        : 'fas fa-check-square';
+@endphp
+<button
+    class="{{ $class }}"
+    type="button"
+    data-url="{{ route('account.options', ['user_profile_customization[legacy_score_only]' => !$legacyScoreMode]) }}"
+    data-method="PUT"
+    data-remote="1"
+    data-reload-on-success="1"
+    title="{{ osu_trans("layout.popup_user.links.legacy_score_only_toggle_tooltip") }}"
+>
+    <span>
+        <span class="{{ $icon }}"></span>
+        {{ osu_trans("layout.popup_user.links.legacy_score_only_toggle") }}
+    </span>
+</button>

resources/views/layout/header_mobile/user.blade.php

···
             data-is-current-user="1"
         ></div>
 
+        @include('layout._score_mode_toggle', ['class' => 'navbar-mobile-item__main'])
+
         <a
             class="navbar-mobile-item__main"
             href="{{ route('users.show', Auth::user()) }}"

resources/views/master.blade.php

···
 
     $currentUser = Auth::user();
 
+    $legacyScoreMode = App\Libraries\Search\ScoreSearchParams::showLegacyForUser($currentUser) === true;
+
     $titleTree = [];
 
     if (isset($titleOverride)) {
···
 
     <body
         class="
-            osu-layout
-            osu-layout--body
             t-section
+            {{ class_with_modifiers('osu-layout', 'body', ['body-lazer' => !$legacyScoreMode]) }}
             {{ $bodyAdditionalClasses ?? '' }}
         "
     >

resources/views/users/beatmapset_activities.blade.php

···
 @section ("script")
     @parent
 
-    @foreach ($jsonChunks as $name => $data)
-        <script id="json-{{$name}}" type="application/json">
-            {!! json_encode($data) !!}
-        </script>
-    @endforeach
+    <script id="json-bundle" type="application/json">
+        {!! json_encode($jsonChunks) !!}
+    </script>
 
     @include('layout._react_js', ['src' => 'js/modding-profile.js'])
 @endsection

routes/web.php

···
 // There's also a different group which skips throttle middleware.
 Route::group(['as' => 'api.', 'prefix' => 'api', 'middleware' => ['api', ThrottleRequests::getApiThrottle(), 'require-scopes']], function () {
     Route::group(['prefix' => 'v2'], function () {
+        Route::group(['middleware' => ['require-scopes:any']], function () {
+            Route::post('session/verify', 'AccountController@verify')->name('verify');
+            Route::post('session/verify/reissue', 'AccountController@reissueCode')->name('verify.reissue');
+        });
+
         Route::group(['as' => 'beatmaps.', 'prefix' => 'beatmaps'], function () {
             Route::get('lookup', 'BeatmapsController@lookup')->name('lookup');
 
             Route::apiResource('packs', 'BeatmapPacksController', ['only' => ['index', 'show']]);
 
             Route::group(['prefix' => '{beatmap}'], function () {
-                Route::get('scores/users/{user}', 'BeatmapsController@userScore');
-                Route::get('scores/users/{user}/all', 'BeatmapsController@userScoreAll');
+                Route::get('scores/users/{user}', 'BeatmapsController@userScore')->name('user.score');
+                Route::get('scores/users/{user}/all', 'BeatmapsController@userScoreAll')->name('user.scores');
                 Route::get('scores', 'BeatmapsController@scores')->name('scores');
                 Route::get('solo-scores', 'BeatmapsController@soloScores')->name('solo-scores');
 

tests/Browser/BeatmapDiscussionPostsTest.php

···
 
 class BeatmapDiscussionPostsTest extends DuskTestCase
 {
-    private $new_reply_widget_selector = '.beatmap-discussion-post--new-reply';
+    private const NEW_REPLY_SELECTOR = '.beatmap-discussion-post--new-reply';
+    private const RESOLVE_BUTTON_SELECTOR = '.btn-osu-big[data-action=reply_resolve]';
+
+    private Beatmap $beatmap;
+    private BeatmapDiscussion $beatmapDiscussion;
+    private Beatmapset $beatmapset;
+    private User $mapper;
+    private User $user;
 
     public function testConcurrentPostAfterResolve()
     {
···
 
     protected function writeReply(Browser $browser, $reply)
     {
-        $browser->with($this->new_reply_widget_selector, function ($new_reply) use ($reply) {
-            $new_reply->press('Respond')
+        $browser->with(static::NEW_REPLY_SELECTOR, function (Browser $newReply) use ($reply) {
+            $newReply->press(trans('beatmap_discussions.reply.open.user'))
                 ->waitFor('textarea')
                 ->type('textarea', $reply);
         });
···
 
     protected function postReply(Browser $browser, $action)
     {
-        $browser->with($this->new_reply_widget_selector, function ($new_reply) use ($action) {
+        $browser->with(static::NEW_REPLY_SELECTOR, function (Browser $newReply) use ($action) {
             switch ($action) {
                 case 'resolve':
-                    $new_reply->press('Reply and Resolve');
+                    // button may be covered by dev banner;
+                    // ->element->($selector)->getLocationOnScreenOnceScrolledIntoView() uses { block: 'end', inline: 'nearest' } which isn't enough.
+                    $newReply->scrollIntoView(static::RESOLVE_BUTTON_SELECTOR);
+                    $newReply->element(static::RESOLVE_BUTTON_SELECTOR)->click();
                     break;
                 default:
-                    $new_reply->keys('textarea', '{enter}');
+                    $newReply->keys('textarea', '{enter}');
                     break;
             }
         });
···
         $post = BeatmapDiscussionPost::factory()->timeline()->make([
             'user_id' => $this->user,
         ]);
-        $this->beatmapDiscussionPost = $this->beatmapDiscussion->beatmapDiscussionPosts()->save($post);
+        $this->beatmapDiscussion->beatmapDiscussionPosts()->save($post);
 
         $this->beforeApplicationDestroyed(function () {
             // Similar case to SanityTest, cleanup the models we created during the test.

tests/Browser/SanityTest.php

···
             } elseif ($line['message'] === "security - Error with Permissions-Policy header: Unrecognized feature: 'ch-ua-form-factor'.") {
                 // we don't use ch-ua-* crap and this error is thrown by youtube.com as of 2023-05-16
                 continue;
+            } elseif (str_ends_with($line['message'], ' Third-party cookie will be blocked. Learn more in the Issues tab.')) {
+                // thanks, youtube
+                continue;
             }
 
             $return[] = $line;

tests/Controllers/BeatmapsControllerSoloScoresTest.php

···
 use App\Models\Genre;
 use App\Models\Group;
 use App\Models\Language;
+use App\Models\OAuth;
 use App\Models\Solo\Score as SoloScore;
 use App\Models\User;
 use App\Models\UserGroup;
···
 
             $countryAcronym = static::$user->country_acronym;
 
+            $otherUser2 = User::factory()->create(['country_acronym' => Country::factory()]);
+            $otherUser3SameCountry = User::factory()->create(['country_acronym' => $countryAcronym]);
+
             static::$scores = [];
-            $scoreFactory = SoloScore::factory();
-            foreach (['solo' => 0, 'legacy' => null] as $type => $buildId) {
-                $defaultData = ['build_id' => $buildId];
+            $scoreFactory = SoloScore::factory()->state(['build_id' => 0]);
+            foreach (['solo' => false, 'legacy' => true] as $type => $isLegacy) {
+                $scoreFactory = $scoreFactory->state([
+                    'legacy_score_id' => $isLegacy ? 1 : null,
+                ]);
+                $makeMods = fn (array $modNames): array => array_map(
+                    fn (string $modName): array => [
+                        'acronym' => $modName,
+                        'settings' => [],
+                    ],
+                    [...$modNames, ...($isLegacy ? ['CL'] : [])],
+                );
+
+                $makeTotalScores = fn (int $totalScore): array => [
+                    'legacy_total_score' => $totalScore * ($isLegacy ? 1 : 0),
+                    'total_score' => $totalScore + ($isLegacy ? -1 : 0),
+                ];
 
-                static::$scores = array_merge(static::$scores, [
-                    "{$type}:user" => $scoreFactory->withData($defaultData, ['total_score' => 1100])->create([
+                static::$scores = [
+                    ...static::$scores,
+                    "{$type}:userModsLowerScore" => $scoreFactory->withData([
+                        'mods' => $makeMods(['DT', 'HD']),
+                    ])->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$user,
                     ]),
-                    "{$type}:userMods" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1050,
-                        'mods' => static::defaultMods(['DT', 'HD']),
+                    "{$type}:otherUserModsNCPFHigherScore" => $scoreFactory->withData([
+                        'mods' => $makeMods(['NC', 'PF']),
                     ])->create([
+                        ...$makeTotalScores(1010),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
-                        'user_id' => static::$user,
+                        'user_id' => static::$otherUser,
                     ]),
-                    "{$type}:userModsNC" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1050,
-                        'mods' => static::defaultMods(['NC']),
+                    "{$type}:userMods" => $scoreFactory->withData([
+                        'mods' => $makeMods(['DT', 'HD']),
                     ])->create([
+                        ...$makeTotalScores(1050),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$user,
                     ]),
-                    "{$type}:otherUserModsNCPFHigherScore" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1010,
-                        'mods' => static::defaultMods(['NC', 'PF']),
+                    "{$type}:userModsNC" => $scoreFactory->withData([
+                        'mods' => $makeMods(['NC']),
                     ])->create([
+                        ...$makeTotalScores(1050),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
-                        'user_id' => static::$otherUser,
+                        'user_id' => static::$user,
                     ]),
-                    "{$type}:userModsLowerScore" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1000,
-                        'mods' => static::defaultMods(['DT', 'HD']),
-                    ])->create([
+                    "{$type}:user" => $scoreFactory->create([
+                        ...$makeTotalScores(1100),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$user,
                     ]),
-                    "{$type}:friend" => $scoreFactory->withData($defaultData, ['total_score' => 1000])->create([
+                    "{$type}:friend" => $scoreFactory->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => $friend,
                     ]),
                     // With preference mods
-                    "{$type}:otherUser" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1000,
-                        'mods' => static::defaultMods(['PF']),
+                    "{$type}:otherUser" => $scoreFactory->withData([
+                        'mods' => $makeMods(['PF']),
                     ])->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$otherUser,
                     ]),
-                    "{$type}:otherUserMods" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1000,
-                        'mods' => static::defaultMods(['HD', 'PF', 'NC']),
+                    "{$type}:otherUserMods" => $scoreFactory->withData([
+                        'mods' => $makeMods(['HD', 'PF', 'NC']),
                     ])->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$otherUser,
                     ]),
-                    "{$type}:otherUserModsExtraNonPreferences" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1000,
-                        'mods' => static::defaultMods(['DT', 'HD', 'HR']),
+                    "{$type}:otherUserModsExtraNonPreferences" => $scoreFactory->withData([
+                        'mods' => $makeMods(['DT', 'HD', 'HR']),
                     ])->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$otherUser,
                     ]),
-                    "{$type}:otherUserModsUnrelated" => $scoreFactory->withData($defaultData, [
-                        'total_score' => 1000,
-                        'mods' => static::defaultMods(['FL']),
+                    "{$type}:otherUserModsUnrelated" => $scoreFactory->withData([
+                        'mods' => $makeMods(['FL']),
                     ])->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
                         'user_id' => static::$otherUser,
                     ]),
                     // Same total score but achieved later so it should come up after earlier score
-                    "{$type}:otherUser2Later" => $scoreFactory->withData($defaultData, ['total_score' => 1000])->create([
+                    "{$type}:otherUser2Later" => $scoreFactory->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
-                        'user_id' => User::factory()->state(['country_acronym' => Country::factory()]),
+                        'user_id' => $otherUser2,
                     ]),
-                    "{$type}:otherUser3SameCountry" => $scoreFactory->withData($defaultData, ['total_score' => 1000])->create([
+                    "{$type}:otherUser3SameCountry" => $scoreFactory->create([
+                        ...$makeTotalScores(1000),
                         'beatmap_id' => static::$beatmap,
                         'preserve' => true,
-                        'user_id' => User::factory()->state(['country_acronym' => $countryAcronym]),
+                        'user_id' => $otherUser3SameCountry,
                     ]),
                     // Non-preserved score should be filtered out
-                    "{$type}:nonPreserved" => $scoreFactory->withData($defaultData)->create([
+                    "{$type}:nonPreserved" => $scoreFactory->create([
                         'beatmap_id' => static::$beatmap,
                         'preserve' => false,
                         'user_id' => User::factory()->state(['country_acronym' => Country::factory()]),
                     ]),
                     // Unrelated score
-                    "{$type}:unrelated" => $scoreFactory->withData($defaultData)->create([
+                    "{$type}:unrelated" => $scoreFactory->create([
                         'user_id' => User::factory()->state(['country_acronym' => Country::factory()]),
                     ]),
-                ]);
+                ];
             }
 
             UserRelation::create([
···
             Country::truncate();
             Genre::truncate();
             Language::truncate();
+            OAuth\Client::truncate();
+            OAuth\Token::truncate();
             SoloScore::select()->delete(); // TODO: revert to truncate after the table is actually renamed
             User::truncate();
             UserGroup::truncate();
···
         });
     }
 
-    private static function defaultMods(array $modNames): array
-    {
-        return array_map(
-            fn ($modName) => [
-                'acronym' => $modName,
-                'settings' => [],
-            ],
-            $modNames,
-        );
-    }
-
     /**
      * @dataProvider dataProviderForTestQuery
      * @group RequiresScoreIndexer
      */
-    public function testQuery(array $scoreKeys, array $params)
+    public function testQuery(array $scoreKeys, array $params, string $route)
     {
         $resp = $this->actingAs(static::$user)
-            ->json('GET', route('beatmaps.solo-scores', static::$beatmap), $params)
+            ->json('GET', route("beatmaps.{$route}", static::$beatmap), $params)
             ->assertSuccessful();
 
         $json = json_decode($resp->getContent(), true);
···
         }
     }
 
+    /**
+     * @group RequiresScoreIndexer
+     */
+    public function testUserScore()
+    {
+        $url = route('api.beatmaps.user.score', [
+            'beatmap' => static::$beatmap->getKey(),
+            'legacy_only' => 1,
+            'mods' => ['DT', 'HD'],
+            'user' => static::$user->getKey(),
+        ]);
+        $this->actAsScopedUser(static::$user);
+        $this
+            ->json('GET', $url)
+            ->assertJsonPath('score.id', static::$scores['legacy:userMods']->getKey());
+    }
+
+    /**
+     * @group RequiresScoreIndexer
+     */
+    public function testUserScoreAll()
+    {
+        $url = route('api.beatmaps.user.scores', [
+            'beatmap' => static::$beatmap->getKey(),
+            'legacy_only' => 1,
+            'user' => static::$user->getKey(),
+        ]);
+        $this->actAsScopedUser(static::$user);
+        $this
+            ->json('GET', $url)
+            ->assertJsonCount(4, 'scores')
+            ->assertJsonPath(
+                'scores.*.id',
+                array_map(fn (string $key): int => static::$scores[$key]->getKey(), [
+                    'legacy:user',
+                    'legacy:userMods',
+                    'legacy:userModsNC',
+                    'legacy:userModsLowerScore',
+                ])
+            );
+    }
+
     public static function dataProviderForTestQuery(): array
     {
-        return [
-            'no parameters' => [[
-                'solo:user',
-                'solo:otherUserModsNCPFHigherScore',
-                'solo:friend',
-                'solo:otherUser2Later',
-                'solo:otherUser3SameCountry',
-            ], []],
-            'by country' => [[
-                'solo:user',
-                'solo:otherUser3SameCountry',
-            ], ['type' => 'country']],
-            'by friend' => [[
-                'solo:user',
-                'solo:friend',
-            ], ['type' => 'friend']],
-            'mods filter' => [[
-                'solo:userMods',
-                'solo:otherUserMods',
-            ], ['mods' => ['DT', 'HD']]],
-            'mods with implied filter' => [[
-                'solo:userModsNC',
-                'solo:otherUserModsNCPFHigherScore',
-            ], ['mods' => ['NC']]],
-            'mods with nomods' => [[
-                'solo:user',
-                'solo:otherUserModsNCPFHigherScore',
-                'solo:friend',
-                'solo:otherUser2Later',
-                'solo:otherUser3SameCountry',
-            ], ['mods' => ['NC', 'NM']]],
-            'nomods filter' => [[
-                'solo:user',
-                'solo:friend',
-                'solo:otherUser',
-                'solo:otherUser2Later',
-                'solo:otherUser3SameCountry',
-            ], ['mods' => ['NM']]],
-        ];
+        $ret = [];
+        foreach (['solo' => 'solo-scores', 'legacy' => 'scores'] as $type => $route) {
+            $ret = array_merge($ret, [
+                "{$type}: no parameters" => [[
+                    "{$type}:user",
+                    "{$type}:otherUserModsNCPFHigherScore",
+                    "{$type}:friend",
+                    "{$type}:otherUser2Later",
+                    "{$type}:otherUser3SameCountry",
+                ], [], $route],
+                "{$type}: by country" => [[
+                    "{$type}:user",
+                    "{$type}:otherUser3SameCountry",
+                ], ['type' => 'country'], $route],
+                "{$type}: by friend" => [[
+                    "{$type}:user",
+                    "{$type}:friend",
+                ], ['type' => 'friend'], $route],
+                "{$type}: mods filter" => [[
+                    "{$type}:userMods",
+                    "{$type}:otherUserMods",
+                ], ['mods' => ['DT', 'HD']], $route],
+                "{$type}: mods with implied filter" => [[
+                    "{$type}:userModsNC",
+                    "{$type}:otherUserModsNCPFHigherScore",
+                ], ['mods' => ['NC']], $route],
+                "{$type}: mods with nomods" => [[
+                    "{$type}:user",
+                    "{$type}:otherUserModsNCPFHigherScore",
+                    "{$type}:friend",
+                    "{$type}:otherUser2Later",
+                    "{$type}:otherUser3SameCountry",
+                ], ['mods' => ['NC', 'NM']], $route],
+                "{$type}: nomods filter" => [[
+                    "{$type}:user",
+                    "{$type}:friend",
+                    "{$type}:otherUser",
+                    "{$type}:otherUser2Later",
+                    "{$type}:otherUser3SameCountry",
+                ], ['mods' => ['NM']], $route],
+            ]);
+        }
+
+        return $ret;
     }
 }

tests/Controllers/BeatmapsControllerTest.php

···
 use App\Models\Beatmap;
 use App\Models\Beatmapset;
 use App\Models\BeatmapsetEvent;
-use App\Models\Country;
-use App\Models\Score\Best\Model as ScoreBest;
 use App\Models\User;
-use App\Models\UserRelation;
 use Illuminate\Testing\Fluent\AssertableJson;
-use Illuminate\Testing\TestResponse;
 use Tests\TestCase;
 
 class BeatmapsControllerTest extends TestCase
···
     {
         $this->json('GET', route('beatmaps.scores', $this->beatmap), [
             'mode' => 'nope',
-        ])->assertStatus(404);
+        ])->assertStatus(422);
     }
 
     /**
···
             ])->assertStatus(200);
     }
 
-    public function testScores()
-    {
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1100,
-                'user_id' => $this->user,
-            ]),
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1000,
-            ]),
-            // Same total score but achieved later so it should come up after earlier score
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1000,
-            ]),
-        ];
-        // Hidden score should be filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'hidden' => true,
-            'score' => 800,
-        ]);
-        // Another score from scores[0] user (should be filtered out)
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'score' => 800,
-            'user_id' => $this->user,
-        ]);
-        // Unrelated score
-        ScoreBest::getClass(array_rand(Beatmap::MODES))::factory()->create();
-
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', $this->beatmap))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresByCountry()
-    {
-        $countryAcronym = $this->user->country_acronym;
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'country_acronym' => $countryAcronym,
-                'score' => 1100,
-                'user_id' => $this->user,
-            ]),
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1000,
-                'country_acronym' => $countryAcronym,
-                'user_id' => User::factory()->state(['country_acronym' => $countryAcronym]),
-            ]),
-        ];
-        $otherCountry = Country::factory()->create();
-        $otherCountryAcronym = $otherCountry->acronym;
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'country_acronym' => $otherCountryAcronym,
-            'user_id' => User::factory()->state(['country_acronym' => $otherCountryAcronym]),
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'type' => 'country']))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresByFriend()
-    {
-        $friend = User::factory()->create();
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1100,
-                'user_id' => $friend,
-            ]),
-            // Own score is included
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1000,
-                'user_id' => $this->user,
-            ]),
-        ];
-        UserRelation::create([
-            'friend' => true,
-            'user_id' => $this->user->getKey(),
-            'zebra_id' => $friend->getKey(),
-        ]);
-        // Non-friend score is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'type' => 'friend']))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresModsFilter()
-    {
-        $modsHelper = app('mods');
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => $modsHelper->idsToBitset(['DT', 'HD']),
-                'score' => 1500,
-            ]),
-            // Score with preference mods is included
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => $modsHelper->idsToBitset(['DT', 'HD', 'NC', 'PF']),
-                'score' => 1100,
-                'user_id' => $this->user,
-            ]),
-        ];
-        // No mod is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => 0,
-        ]);
-        // Unrelated mod is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => $modsHelper->idsToBitset(['FL']),
-        ]);
-        // Extra non-preference mod is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => $modsHelper->idsToBitset(['DT', 'HD', 'HR']),
-        ]);
-        // From same user but lower score is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => $modsHelper->idsToBitset(['DT', 'HD']),
-            'score' => 1000,
-            'user_id' => $this->user,
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'mods' => ['DT', 'HD']]))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresModsWithImpliedFilter()
-    {
-        $modsHelper = app('mods');
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => $modsHelper->idsToBitset(['DT', 'NC']),
-                'score' => 1500,
-            ]),
-            // Score with preference mods is included
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => $modsHelper->idsToBitset(['DT', 'NC', 'PF']),
-                'score' => 1100,
-                'user_id' => $this->user,
-            ]),
-        ];
-        // No mod is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => 0,
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'mods' => ['NC']]))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresModsWithNomodsFilter()
-    {
-        $modsHelper = app('mods');
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => $modsHelper->idsToBitset(['DT', 'NC']),
-                'score' => 1500,
-            ]),
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'enabled_mods' => 0,
-                'score' => 1100,
-                'user_id' => $this->user,
-            ]),
-        ];
-        // With unrelated mod
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => $modsHelper->idsToBitset(['DT', 'NC', 'HD']),
-            'score' => 1500,
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'mods' => ['DT', 'NC', 'NM']]))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
-    public function testScoresNomodsFilter()
-    {
-        $modsHelper = app('mods');
-        $scoreClass = ScoreBest::getClassByRulesetId($this->beatmap->playmode);
-        $scores = [
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1500,
-                'enabled_mods' => 0,
-            ]),
-            // Preference mod is included
-            $scoreClass::factory()->create([
-                'beatmap_id' => $this->beatmap,
-                'score' => 1100,
-                'user_id' => $this->user,
-                'enabled_mods' => $modsHelper->idsToBitset(['PF']),
-            ]),
-        ];
-        // Non-preference mod is filtered out
-        $scoreClass::factory()->create([
-            'beatmap_id' => $this->beatmap,
-            'enabled_mods' => $modsHelper->idsToBitset(['DT']),
-        ]);
-
-        $this->user->update(['osu_subscriber' => true]);
-        $resp = $this->actingAs($this->user)
-            ->json('GET', route('beatmaps.scores', ['beatmap' => $this->beatmap, 'mods' => ['NM']]))
-            ->assertSuccessful();
-
-        $this->assertSameScoresFromResponse($scores, $resp);
-    }
-
     public function testShowForApi()
     {
         $beatmap = Beatmap::factory()->create();
···
 
         $this->user = User::factory()->create();
         $this->beatmap = Beatmap::factory()->qualified()->create();
-    }
-
-    private function assertSameScoresFromResponse(array $scores, TestResponse $response): void
-    {
-        $json = json_decode($response->getContent(), true);
-        $this->assertSame(count($scores), count($json['scores']));
-        foreach ($json['scores'] as $i => $jsonScore) {
-            $this->assertSame($scores[$i]->getKey(), $jsonScore['id']);
-        }
     }
 
     private function createExistingFruitsBeatmap()

tests/Controllers/Multiplayer/Rooms/Playlist/ScoresControllerTest.php

···
         $scoreLinks[] = ScoreLink
             ::factory()
             ->state(['playlist_item_id' => $playlist])
-            ->completed([], ['passed' => true, 'total_score' => 30])
+            ->completed(['passed' => true, 'total_score' => 30])
             ->create();
         $scoreLinks[] = $userScoreLink = ScoreLink
             ::factory()
             ->state([
                 'playlist_item_id' => $playlist,
                 'user_id' => $user,
-            ])->completed([], ['passed' => true, 'total_score' => 20])
+            ])->completed(['passed' => true, 'total_score' => 20])
             ->create();
         $scoreLinks[] = ScoreLink
             ::factory()
             ->state(['playlist_item_id' => $playlist])
-            ->completed([], ['passed' => true, 'total_score' => 10])
+            ->completed(['passed' => true, 'total_score' => 10])
             ->create();
 
         foreach ($scoreLinks as $scoreLink) {
···
         $scoreLinks[] = ScoreLink
             ::factory()
             ->state(['playlist_item_id' => $playlist])
-            ->completed([], ['passed' => true, 'total_score' => 30])
+            ->completed(['passed' => true, 'total_score' => 30])
             ->create();
         $scoreLinks[] = $userScoreLink = ScoreLink
             ::factory()
             ->state([
                 'playlist_item_id' => $playlist,
                 'user_id' => $user,
-            ])->completed([], ['passed' => true, 'total_score' => 20])
+            ])->completed(['passed' => true, 'total_score' => 20])
             ->create();
         $scoreLinks[] = ScoreLink
             ::factory()
             ->state(['playlist_item_id' => $playlist])
-            ->completed([], ['passed' => true, 'total_score' => 10])
+            ->completed(['passed' => true, 'total_score' => 10])
             ->create();
 
         foreach ($scoreLinks as $scoreLink) {
···
      */
     public function testStore($allowRanking, $hashParam, $status)
     {
+        $origClientCheckVersion = $GLOBALS['cfg']['osu']['client']['check_version'];
+        config_set('osu.client.check_version', true);
         $user = User::factory()->create();
         $playlistItem = PlaylistItem::factory()->create();
         $build = Build::factory()->create(['allow_ranking' => $allowRanking]);
 
         $this->actAsScopedUser($user, ['*']);
 
-        $params = [];
         if ($hashParam !== null) {
-            $params['version_hash'] = $hashParam ? bin2hex($build->hash) : md5('invalid_');
+            $this->withHeaders([
+                'x-token' => $hashParam ? static::createClientToken($build) : strtoupper(md5('invalid_')),
+            ]);
         }
 
         $countDiff = ((string) $status)[0] === '2' ? 1 : 0;
···
         $this->json('POST', route('api.rooms.playlist.scores.store', [
             'room' => $playlistItem->room_id,
             'playlist' => $playlistItem->getKey(),
-        ]), $params)->assertStatus($status);
+        ]))->assertStatus($status);
+
+        config_set('osu.client.check_version', $origClientCheckVersion);
     }
 
     /**
···
         $room = $playlistItem->room;
         $build = Build::factory()->create(['allow_ranking' => true]);
         $scoreToken = $room->startPlay($user, $playlistItem, 0);
+
+        $this->withHeaders(['x-token' => static::createClientToken($build)]);
+
+        $this->expectCountChange(
+            fn () => \LaravelRedis::llen($GLOBALS['cfg']['osu']['client']['token_queue']),
+            $status === 200 ? 1 : 0,
+        );
 
         $this->actAsScopedUser($user, ['*']);
 

tests/Controllers/OAuth/TokensControllerTest.php

···
 
 namespace Tests\Controllers\OAuth;
 
+use App\Libraries\OAuth\EncodeToken;
+use App\Mail\UserVerification as UserVerificationMail;
+use App\Models\OAuth\Client;
 use App\Models\OAuth\Token;
+use App\Models\User;
+use Database\Factories\OAuth\ClientFactory;
 use Database\Factories\OAuth\RefreshTokenFactory;
+use Database\Factories\UserFactory;
 use Tests\TestCase;
 
 class TokensControllerTest extends TestCase
 {
+    public static function dataProviderForTestIssueTokenWithRefreshTokenInheritsVerified(): array
+    {
+        return [
+            [true],
+            [false],
+        ];
+    }
+
     public function testDestroyCurrent()
     {
         $refreshToken = (new RefreshTokenFactory())->create();
···
             ->assertSuccessful();
 
         $this->assertTrue($token->fresh()->revoked);
+    }
+
+    public function testIssueTokenWithPassword(): void
+    {
+        \Mail::fake();
+
+        $user = User::factory()->create();
+        $client = (new ClientFactory())->create([
+            'password_client' => true,
+        ]);
+
+        $this->expectCountChange(fn () => $user->tokens()->count(), 1);
+
+        $tokenJson = $this->json('POST', route('oauth.passport.token'), [
+            'grant_type' => 'password',
+            'client_id' => $client->getKey(),
+            'client_secret' => $client->secret,
+            'scope' => '*',
+            'username' => $user->username,
+            'password' => UserFactory::DEFAULT_PASSWORD,
+        ])->assertSuccessful()
+        ->decodeResponseJson();
+
+        $this->json('GET', route('api.me'), [], [
+            'Authorization' => "Bearer {$tokenJson['access_token']}",
+        ])->assertSuccessful()
+        ->assertJsonPath('session_verified', false);
+
+        // unverified access to api should trigger this but not necessarily return 401
+        \Mail::assertQueued(UserVerificationMail::class);
+    }
+
+    /**
+     * @dataProvider dataProviderForTestIssueTokenWithRefreshTokenInheritsVerified
+     */
+    public function testIssueTokenWithRefreshTokenInheritsVerified(bool $verified): void
+    {
+        \Mail::fake();
+
+        $client = Client::factory()->create(['password_client' => true]);
+        $accessToken = Token::factory()->create([
+            'client_id' => $client,
+            'scopes' => ['*'],
+            'verified' => $verified,
+        ]);
+        $refreshToken = (new RefreshTokenFactory())
+            ->create(['access_token_id' => $accessToken]);
+        $refreshTokenString = EncodeToken::encodeRefreshToken($refreshToken, $accessToken);
+        $user = $accessToken->user;
+
+        $this->expectCountChange(fn () => $user->tokens()->count(), 1);
+
+        $tokenJson = $this->json('POST', route('oauth.passport.token'), [
+            'grant_type' => 'refresh_token',
+            'client_id' => $client->getKey(),
+            'client_secret' => $client->secret,
+            'refresh_token' => $refreshTokenString,
+            'scope' => implode(' ', $accessToken->scopes),
+        ])->assertSuccessful()
+        ->decodeResponseJson();
+
+        $this->json('GET', route('api.me'), [], [
+            'Authorization' => "Bearer {$tokenJson['access_token']}",
+        ])->assertSuccessful()
+        ->assertJsonPath('session_verified', $verified);
+
+        \Mail::assertQueued(UserVerificationMail::class, $verified ? 0 : 1);
     }
 }

tests/Controllers/PasswordResetControllerTest.php

···
 
 class PasswordResetControllerTest extends TestCase
 {
+    private string $origCacheDefault;
+
     private static function randomPassword(): string
     {
         return str_random(10);
···
     {
         parent::setUp();
         $this->withoutMiddleware(ThrottleRequests::class);
+        // There's no easy way to clear data cache in redis otherwise
+        $this->origCacheDefault = $GLOBALS['cfg']['cache']['default'];
+        config_set('cache.default', 'array');
+    }
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        config_set('cache.default', $this->origCacheDefault);
     }
 
     private function generateKey(User $user): string

tests/Controllers/ScoreTokensControllerTest.php

···
             'beatmap' => $beatmap->getKey(),
             'ruleset_id' => $beatmap->playmode,
         ];
-        $bodyParams = [
-            'beatmap_hash' => $beatmap->checksum,
-            'version_hash' => bin2hex($this->build->hash),
-        ];
+        $bodyParams = ['beatmap_hash' => $beatmap->checksum];
+        $this->withHeaders(['x-token' => static::createClientToken($this->build)]);
 
         $this->expectCountChange(fn () => ScoreToken::count(), $status >= 200 && $status < 300 ? 1 : 0);
 
···
      */
     public function testStoreInvalidParameter(string $paramKey, ?string $paramValue, int $status): void
     {
+        $origClientCheckVersion = $GLOBALS['cfg']['osu']['client']['check_version'];
+        config_set('osu.client.check_version', true);
         $beatmap = Beatmap::factory()->ranked()->create();
 
         $this->actAsScopedUser($this->user, ['*']);
···
         $params = [
             'beatmap' => $beatmap->getKey(),
             'ruleset_id' => $beatmap->playmode,
-            'version_hash' => bin2hex($this->build->hash),
             'beatmap_hash' => $beatmap->checksum,
         ];
-        $params[$paramKey] = $paramValue;
+        $this->withHeaders([
+            'x-token' => $paramKey === 'client_token'
+                ? $paramValue
+                : static::createClientToken($this->build),
+        ]);
+
+        if ($paramKey !== 'client_token') {
+            $params[$paramKey] = $paramValue;
+        }
 
         $routeParams = [
             'beatmap' => $params['beatmap'],
···
         ];
         $bodyParams = [
             'beatmap_hash' => $params['beatmap_hash'],
-            'version_hash' => $params['version_hash'],
         ];
 
         $this->expectCountChange(fn () => ScoreToken::count(), 0);
 
         $errorMessage = $paramValue === null ? 'missing' : 'invalid';
         $errorMessage .= ' ';
-        $errorMessage .= $paramKey === 'version_hash'
+        $errorMessage .= $paramKey === 'client_token'
             ? ($paramValue === null
-                ? 'client version'
+                ? 'token header'
                 : 'client hash'
             ) : $paramKey;
 
···
         ->assertJson([
             'error' => $errorMessage,
         ]);
+
+        config_set('osu.client.check_version', $origClientCheckVersion);
     }
 
     public static function dataProviderForTestStore(): array
···
     public static function dataProviderForTestStoreInvalidParameter(): array
     {
         return [
-            'invalid build hash' => ['version_hash', md5('invalid_'), 422],
-            'missing build hash' => ['version_hash', null, 422],
+            'invalid client token' => ['client_token', md5('invalid_'), 422],
+            'missing client token' => ['client_token', null, 422],
 
             'invalid ruleset id' => ['ruleset_id', '5', 422],
             'missing ruleset id' => ['ruleset_id', null, 422],

tests/Controllers/ScoresControllerTest.php

···
     public function testDownloadSoloScore()
     {
         $soloScore = SoloScore::factory()
-            ->withData(['legacy_score_id' => $this->score->getKey()])
             ->create([
+                'legacy_score_id' => $this->score->getKey(),
                 'ruleset_id' => Beatmap::MODES[$this->score->getMode()],
                 'has_replay' => true,
             ]);

tests/Controllers/Solo/ScoresControllerTest.php

···
 
 namespace Tests\Controllers\Solo;
 
-use App\Models\Score as LegacyScore;
+use App\Models\Build;
 use App\Models\ScoreToken;
 use App\Models\Solo\Score;
 use App\Models\User;
···
 {
     public function testStore()
     {
-        $scoreToken = ScoreToken::factory()->create();
-        $legacyScoreClass = LegacyScore\Model::getClassByRulesetId($scoreToken->beatmap->playmode);
+        $build = Build::factory()->create(['allow_ranking' => true]);
+        $scoreToken = ScoreToken::factory()->create(['build_id' => $build]);
 
         $this->expectCountChange(fn () => Score::count(), 1);
-        $this->expectCountChange(fn () => $legacyScoreClass::count(), 1);
         $this->expectCountChange(fn () => $this->processingQueueCount(), 1);
+        $this->expectCountChange(
+            fn () => \LaravelRedis::llen($GLOBALS['cfg']['osu']['client']['token_queue']),
+            1,
+        );
 
+        $this->withHeaders(['x-token' => static::createClientToken($build)]);
         $this->actAsScopedUser($scoreToken->user, ['*']);
 
         $this->json(

tests/Controllers/UsersControllerTest.php

···
         $this->assertSame($previousCount + 1, User::count());
     }
 
-    public function testStoreRegModeWeb()
+    public function testStoreRegModeWebOnly()
     {
-        config_set('osu.user.registration_mode', 'web');
+        config_set('osu.user.registration_mode.client', false);
+        config_set('osu.user.registration_mode.web', true);
         $this->expectCountChange(fn () => User::count(), 0);
 
         $this
···
         $this->assertSame($previousCount, User::count());
     }
 
-    public function testStoreWebRegModeClient()
+    public function testStoreWebRegModeClientOnly()
     {
+        config_set('osu.user.registration_mode.client', true);
+        config_set('osu.user.registration_mode.web', false);
+
         $this->expectCountChange(fn () => User::count(), 0);
 
         $this->post(route('users.store'), [
···
 
     public function testStoreWeb(): void
     {
-        config_set('osu.user.registration_mode', 'web');
+        config_set('osu.user.registration_mode.web', true);
         $this->expectCountChange(fn () => User::count(), 1);
 
         $this->post(route('users.store-web'), [
···
      */
     public function testStoreWebInvalidParams($username, $email, $emailConfirmation, $password, $passwordConfirmation): void
     {
-        config_set('osu.user.registration_mode', 'web');
+        config_set('osu.user.registration_mode.web', true);
         $this->expectCountChange(fn () => User::count(), 0);
 
         $this->post(route('users.store-web'), [
···
 
     public function testStoreWebLoggedIn(): void
     {
-        config_set('osu.user.registration_mode', 'web');
+        config_set('osu.user.registration_mode.web', true);
         $user = User::factory()->create();
 
         $this->expectCountChange(fn () => User::count(), 0);

tests/Jobs/RemoveBeatmapsetSoloScoresTest.php

···
 use App\Models\Group;
 use App\Models\Language;
 use App\Models\Solo\Score;
-use App\Models\Solo\ScorePerformance;
 use App\Models\User;
 use App\Models\UserGroup;
 use App\Models\UserGroupEvent;
···
             fn (): Score => $this->createScore($beatmapset),
             array_fill(0, 10, null),
         );
-        foreach ($scores as $i => $score) {
-            $score->performance()->create(['pp' => rand(0, 1000)]);
-        }
         $userAdditionalScores = array_map(
             fn (Score $score) => $this->createScore($beatmapset, $score->user_id, $score->ruleset_id),
             $scores,
···
 
         // These scores shouldn't be deleted
         for ($i = 0; $i < 10; $i++) {
-            $score = $this->createScore($beatmapset);
-            $score->performance()->create(['pp' => rand(0, 1000)]);
+            $this->createScore($beatmapset);
         }
 
         $this->expectCountChange(fn () => Score::count(), count($scores) * -2, 'removes scores');
-        $this->expectCountChange(fn () => ScorePerformance::count(), count($scores) * -1, 'removes score performances');
 
         static::reindexScores();
 
···
                 Genre::truncate();
                 Language::truncate();
                 Score::select()->delete(); // TODO: revert to truncate after the table is actually renamed
-                ScorePerformance::select()->delete(); // TODO: revert to truncate after the table is actually renamed
                 User::truncate();
                 UserGroup::truncate();
                 UserGroupEvent::truncate();

tests/Libraries/ClientCheckTest.php

···
 
 use App\Libraries\ClientCheck;
 use App\Models\Build;
-use App\Models\User;
 use Tests\TestCase;
 
 class ClientCheckTest extends TestCase
 {
-    public function testFindBuild()
+    public function testParseToken(): void
     {
-        $user = User::factory()->withGroup('default')->create();
         $build = Build::factory()->create(['allow_ranking' => true]);
+        $request = \Request::instance();
+        $request->headers->set('x-token', static::createClientToken($build));
 
-        $foundBuild = ClientCheck::findBuild($user, ['version_hash' => bin2hex($build->hash)]);
+        $parsed = ClientCheck::parseToken($request);
 
-        $this->assertSame($build->getKey(), $foundBuild->getKey());
+        $this->assertSame($build->getKey(), $parsed['buildId']);
+        $this->assertNotNull($parsed['token']);
     }
 
-    public function testFindBuildAsAdmin()
+    public function testParseTokenExpired()
     {
-        $user = User::factory()->withGroup('admin')->create();
         $build = Build::factory()->create(['allow_ranking' => true]);
+        $request = \Request::instance();
+        $request->headers->set('x-token', static::createClientToken($build, 0));
 
-        $foundBuild = ClientCheck::findBuild($user, ['version_hash' => bin2hex($build->hash)]);
+        $parsed = ClientCheck::parseToken($request);
 
-        $this->assertSame($build->getKey(), $foundBuild->getKey());
+        $this->assertSame($build->getKey(), $parsed['buildId']);
+        $this->assertNull($parsed['token']);
     }
 
-    public function testFindBuildDisallowedRanking()
+    public function testParseTokenNonRankedBuild(): void
     {
-        $user = User::factory()->withGroup('default')->create();
         $build = Build::factory()->create(['allow_ranking' => false]);
+        $request = \Request::instance();
+        $request->headers->set('x-token', static::createClientToken($build));
 
-        $this->expectExceptionMessage('invalid client hash');
-        ClientCheck::findBuild($user, ['version_hash' => bin2hex($build->hash)]);
-    }
+        $parsed = ClientCheck::parseToken($request);
 
-    public function testFindBuildMissingParam()
-    {
-        $user = User::factory()->withGroup('default')->create();
-
-        $this->expectExceptionMessage('missing client version');
-        ClientCheck::findBuild($user, []);
-    }
-
-    public function testFindBuildNonexistent()
-    {
-        $user = User::factory()->withGroup('default')->create();
-
-        $this->expectExceptionMessage('invalid client hash');
-        ClientCheck::findBuild($user, ['version_hash' => 'stuff']);
-    }
-
-    public function testFindBuildNonexistentAsAdmin()
-    {
-        $user = User::factory()->withGroup('admin')->create();
-
-        $foundBuild = ClientCheck::findBuild($user, ['version_hash' => 'stuff']);
-
-        $this->assertNull($foundBuild);
-    }
-
-    public function testFindBuildNonexistentWithDisabledAssertion()
-    {
-        config_set('osu.client.check_version', false);
-
-        $user = User::factory()->withGroup('default')->create();
-
-        $foundBuild = ClientCheck::findBuild($user, ['version_hash' => 'stuff']);
-
-        $this->assertNull($foundBuild);
-    }
-
-    public function testFindBuildStringHash()
-    {
-        $user = User::factory()->withGroup('default')->create();
-        $hashString = 'hello';
-        $build = Build::factory()->create(['allow_ranking' => true, 'hash' => md5($hashString, true)]);
-
-        $foundBuild = ClientCheck::findBuild($user, ['version_hash' => $hashString]);
-
-        $this->assertSame($build->getKey(), $foundBuild->getKey());
+        $this->assertSame($GLOBALS['cfg']['osu']['client']['default_build_id'], $parsed['buildId']);
+        $this->assertNull($parsed['token']);
     }
 }

tests/Libraries/SessionVerification/ControllerTest.php

···
 use App\Libraries\SessionVerification;
 use App\Mail\UserVerification as UserVerificationMail;
 use App\Models\LoginAttempt;
+use App\Models\OAuth\Client;
+use App\Models\OAuth\Token;
 use App\Models\User;
 use Tests\TestCase;
 
···
         $this->assertNotSame($state->key, SessionVerification\State::fromSession($session)->key);
     }
 
+    public function testReissueOAuthVerified(): void
+    {
+        \Mail::fake();
+        $token = Token::factory()->create(['verified' => true]);
+
+        $this
+            ->actingWithToken($token)
+            ->post(route('api.verify.reissue'))
+            ->assertStatus(422);
+
+        \Mail::assertNotQueued(UserVerificationMail::class);
+        $this->assertNull(SessionVerification\State::fromSession($token));
+    }
+
+    public function testReissueVerified(): void
+    {
+        \Mail::fake();
+        $user = User::factory()->create();
+        $session = \Session::instance();
+        $session->markVerified();
+
+        $this
+            ->be($user)
+            ->withPersistentSession($session)
+            ->post(route('account.reissue-code'))
+            ->assertStatus(422);
+
+        \Mail::assertNotQueued(UserVerificationMail::class);
+        $this->assertNull(SessionVerification\State::fromSession($session));
+    }
+
     public function testVerify(): void
     {
         $user = User::factory()->create();
···
         $this->assertFalse(SessionStore::findOrNew($sessionId)->isVerified());
     }
 
+    public function testVerifyLinkOAuth(): void
+    {
+        $token = Token::factory()->create([
+            'client_id' => Client::factory()->create(['password_client' => true]),
+            'verified' => false,
+        ]);
+
+        $this
+            ->actingWithToken($token)
+            ->get(route('api.me'))
+            ->assertSuccessful();
+
+        $linkKey = SessionVerification\State::fromSession($token)->linkKey;
+
+        \Auth::logout();
+        $this
+            ->withPersistentSession(SessionStore::findOrNew())
+            ->get(route('account.verify', ['key' => $linkKey]))
+            ->assertSuccessful();
+
+        $record = LoginAttempt::find('127.0.0.1');
+
+        $this->assertFalse($record->containsUser($token->user, 'verify-mismatch:'));
+        $this->assertTrue($token->fresh()->isVerified());
+    }
+
     public function testVerifyMismatch(): void
     {
         $user = User::factory()->create();
···
 
         $this->assertTrue($record->containsUser($user, 'verify-mismatch:'));
         $this->assertFalse($session->isVerified());
+    }
+
+    public function testVerifyOAuth(): void
+    {
+        $token = Token::factory()->create([
+            'client_id' => Client::factory()->create(['password_client' => true]),
+            'verified' => false,
+        ]);
+
+        $this
+            ->actingWithToken($token)
+            ->get(route('api.me'))
+            ->assertSuccessful();
+
+        $key = SessionVerification\State::fromSession($token)->key;
+
+        $this
+            ->actingWithToken($token)
+            ->post(route('api.verify', ['verification_key' => $key]))
+            ->assertSuccessful();
+
+        $record = LoginAttempt::find('127.0.0.1');
+
+        $this->assertFalse($record->containsUser($token->user, 'verify-mismatch:'));
+        $this->assertTrue($token->fresh()->isVerified());
+    }
+
+    public function testVerifyOAuthVerified(): void
+    {
+        \Mail::fake();
+        $token = Token::factory()->create(['verified' => true]);
+
+        $this
+            ->actingWithToken($token)
+            ->post(route('api.verify', ['verification_key' => 'invalid']))
+            ->assertSuccessful();
+
+        $this->assertNull(SessionVerification\State::fromSession($token));
+        \Mail::assertNotQueued(UserVerificationMail::class);
+    }
+
+    public function testVerifyVerified(): void
+    {
+        \Mail::fake();
+        $user = User::factory()->create();
+        $session = \Session::instance();
+        $session->markVerified();
+
+        $this
+            ->be($user)
+            ->withPersistentSession($session)
+            ->post(route('account.verify'), ['verification_key' => 'invalid'])
+            ->assertSuccessful();
+
+        $this->assertNull(SessionVerification\State::fromSession($session));
+        \Mail::assertNotQueued(UserVerificationMail::class);
     }
 }

tests/Models/BeatmapPackUserCompletionTest.php

···
 
 namespace Tests\Models;
 
+use App\Libraries\Search\ScoreSearch;
 use App\Models\Beatmap;
 use App\Models\BeatmapPack;
-use App\Models\Score\Best as ScoreBest;
+use App\Models\BeatmapPackItem;
+use App\Models\Beatmapset;
+use App\Models\Country;
+use App\Models\Genre;
+use App\Models\Group;
+use App\Models\Language;
+use App\Models\Solo\Score;
 use App\Models\User;
+use App\Models\UserGroup;
+use App\Models\UserGroupEvent;
 use Tests\TestCase;
 
+/**
+ * @group RequiresScoreIndexer
+ */
 class BeatmapPackUserCompletionTest extends TestCase
 {
+    private static array $users;
+    private static BeatmapPack $pack;
+
+    public static function setUpBeforeClass(): void
+    {
+        parent::setUpBeforeClass();
+
+        static::withDbAccess(function () {
+            $beatmap = Beatmap::factory()->ranked()->state([
+                'playmode' => Beatmap::MODES['taiko'],
+            ])->create();
+            static::$pack = BeatmapPack::factory()->create();
+            static::$pack->items()->create(['beatmapset_id' => $beatmap->beatmapset_id]);
+
+            static::$users = [
+                'convertOsu' => User::factory()->create(),
+                'default' => User::factory()->create(),
+                'null' => null,
+                'unrelated' => User::factory()->create(),
+            ];
+
+            Score::factory()->create([
+                'beatmap_id' => $beatmap,
+                'ruleset_id' => Beatmap::MODES['osu'],
+                'preserve' => true,
+                'user_id' => static::$users['convertOsu'],
+            ]);
+            Score::factory()->create([
+                'beatmap_id' => $beatmap,
+                'preserve' => true,
+                'user_id' => static::$users['default'],
+            ]);
+
+            static::reindexScores();
+        });
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        static::withDbAccess(function () {
+            Beatmap::truncate();
+            BeatmapPack::truncate();
+            BeatmapPackItem::truncate();
+            Beatmapset::truncate();
+            Country::truncate();
+            Genre::truncate();
+            Language::truncate();
+            Score::select()->delete(); // TODO: revert to truncate after the table is actually renamed
+            User::truncate();
+            UserGroup::truncate();
+            UserGroupEvent::truncate();
+            (new ScoreSearch())->deleteAll();
+        });
+
+        parent::tearDownAfterClass();
+    }
+
+    protected $connectionsToTransact = [];
+
     /**
      * @dataProvider dataProviderForTestBasic
      */
     public function testBasic(string $userType, ?string $packRuleset, bool $completed): void
     {
-        $beatmap = Beatmap::factory()->ranked()->state([
-            'playmode' => Beatmap::MODES['taiko'],
-        ])->create();
-        $pack = BeatmapPack::factory()->create();
-        $pack->items()->create(['beatmapset_id' => $beatmap->beatmapset_id]);
-
-        $scoreUser = User::factory()->create();
-        $scoreClass = ScoreBest\Taiko::class;
-        switch ($userType) {
-            case 'convertOsu':
-                $checkUser = $scoreUser;
-                $scoreClass = ScoreBest\Osu::class;
-                break;
-            case 'default':
-                $checkUser = $scoreUser;
-                break;
-            case 'null':
-                $checkUser = null;
-                break;
-            case 'unrelated':
-                $checkUser = User::factory()->create();
-                break;
-        }
-
-        $scoreClass::factory()->create([
-            'beatmap_id' => $beatmap,
-            'user_id' => $scoreUser->getKey(),
-        ]);
+        $user = static::$users[$userType];
 
         $rulesetId = $packRuleset === null ? null : Beatmap::MODES[$packRuleset];
-        $pack->update(['playmode' => $rulesetId]);
-        $pack->refresh();
+        static::$pack->update(['playmode' => $rulesetId]);
+        static::$pack->refresh();
 
-        $data = $pack->userCompletionData($checkUser);
+        $data = static::$pack->userCompletionData($user, null);
         $this->assertSame($completed ? 1 : 0, count($data['beatmapset_ids']));
         $this->assertSame($completed, $data['completed']);
     }

tests/Models/ContestTest.php

···
                 MultiplayerScoreLink::factory()->state([
                     'playlist_item_id' => $playlistItem,
                     'user_id' => $userId,
-                ])->completed([], [
+                ])->completed([
                     'ended_at' => $endedAt,
                     'passed' => $passed,
                 ])->create();

tests/Models/Multiplayer/ScoreLinkTest.php

···
 use App\Models\Multiplayer\PlaylistItem;
 use App\Models\Multiplayer\ScoreLink;
 use App\Models\ScoreToken;
-use Carbon\Carbon;
 use Tests\TestCase;
 
 class ScoreLinkTest extends TestCase
 {
+    private static array $commonScoreParams;
+
+    public static function setUpBeforeClass(): void
+    {
+        parent::setUpBeforeClass();
+        static::$commonScoreParams = [
+            'accuracy' => 0.5,
+            'ended_at' => new \DateTime(),
+            'max_combo' => 1,
+            'statistics' => [
+                'great' => 1,
+            ],
+            'total_score' => 1,
+        ];
+    }
+
     public function testRequiredModsMissing()
     {
         $playlistItem = PlaylistItem::factory()->create([
···
         $this->expectException(InvariantException::class);
         $this->expectExceptionMessage('This play does not include the mods required.');
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
             'ruleset_id' => $playlistItem->ruleset_id,
             'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
-            'mods' => [],
-            'statistics' => [
-                'great' => 1,
-            ],
         ]);
     }
 
···
 
         $this->expectNotToPerformAssertions();
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
+            'mods' => [['acronym' => 'HD']],
             'ruleset_id' => $playlistItem->ruleset_id,
             'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
-            'mods' => [['acronym' => 'HD']],
-            'statistics' => [
-                'great' => 1,
-            ],
         ]);
     }
 
···
 
         $this->expectNotToPerformAssertions();
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
-            'ruleset_id' => $playlistItem->ruleset_id,
-            'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
             'mods' => [
                 ['acronym' => 'DT'],
                 ['acronym' => 'HD'],
             ],
-            'statistics' => [
-                'great' => 1,
-            ],
+            'ruleset_id' => $playlistItem->ruleset_id,
+            'user_id' => $scoreToken->user_id,
         ]);
     }
 
···
         $this->expectException(InvariantException::class);
         $this->expectExceptionMessage('This play includes mods that are not allowed.');
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
-            'ruleset_id' => $playlistItem->ruleset_id,
-            'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
             'mods' => [
                 ['acronym' => 'DT'],
                 ['acronym' => 'HD'],
             ],
-            'statistics' => [
-                'great' => 1,
-            ],
+            'ruleset_id' => $playlistItem->ruleset_id,
+            'user_id' => $scoreToken->user_id,
         ]);
     }
 
···
         $this->expectException(InvariantException::class);
         $this->expectExceptionMessage('This play includes mods that are not allowed.');
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
+            'mods' => [['acronym' => 'HD']],
             'ruleset_id' => $playlistItem->ruleset_id,
             'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
-            'mods' => [['acronym' => 'HD']],
-            'statistics' => [
-                'great' => 1,
-            ],
         ]);
     }
 
···
 
         $this->expectNotToPerformAssertions();
         ScoreLink::complete($scoreToken, [
+            ...static::$commonScoreParams,
             'beatmap_id' => $playlistItem->beatmap_id,
+            'mods' => [['acronym' => 'TD']],
             'ruleset_id' => $playlistItem->ruleset_id,
             'user_id' => $scoreToken->user_id,
-            'ended_at' => json_date(Carbon::now()),
-            'mods' => [['acronym' => 'TD']],
-            'statistics' => [
-                'great' => 1,
-            ],
         ]);
     }
 }

tests/Models/Multiplayer/UserScoreAggregateTest.php

···
             [
                 'beatmap_id' => $playlistItem->beatmap_id,
                 'ended_at' => json_time(new \DateTime()),
+                'max_combo' => 1,
+                'statistics' => ['good' => 1],
                 'ruleset_id' => $playlistItem->ruleset_id,
-                'statistics' => ['good' => 1],
                 'user_id' => $user->getKey(),
                 ...$params,
             ],

tests/Models/Solo/ScoreEsIndexTest.php

···
             static::$beatmap = Beatmap::factory()->qualified()->create();
 
             $scoreFactory = Score::factory()->state(['preserve' => true]);
-            $defaultData = ['build_id' => 1];
 
             $mods = [
                 ['acronym' => 'DT', 'settings' => []],
···
             ];
 
             static::$scores = [
-                'otherUser' => $scoreFactory->withData($defaultData, [
-                    'total_score' => 1150,
+                'otherUser' => $scoreFactory->withData([
                     'mods' => $unrelatedMods,
                 ])->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1150,
                     'user_id' => $otherUser,
                 ]),
-                'otherUserMods' => $scoreFactory->withData($defaultData, [
-                    'total_score' => 1140,
+                'otherUserMods' => $scoreFactory->withData([
                     'mods' => $mods,
                 ])->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1140,
                     'user_id' => $otherUser,
                 ]),
-                'otherUser2' => $scoreFactory->withData($defaultData, [
-                    'total_score' => 1150,
+                'otherUser2' => $scoreFactory->withData([
                     'mods' => $mods,
                 ])->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1150,
                     'user_id' => User::factory()->state(['country_acronym' => Country::factory()]),
                 ]),
-                'otherUser3SameCountry' => $scoreFactory->withData($defaultData, [
-                    'total_score' => 1130,
+                'otherUser3SameCountry' => $scoreFactory->withData([
                     'mods' => $unrelatedMods,
                 ])->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1130,
                     'user_id' => User::factory()->state(['country_acronym' => static::$user->country_acronym]),
                 ]),
-                'user' => $scoreFactory->withData($defaultData, ['total_score' => 1100])->create([
+                'user' => $scoreFactory->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1100,
                     'user_id' => static::$user,
                 ]),
-                'userMods' => $scoreFactory->withData($defaultData, [
-                    'total_score' => 1050,
+                'userMods' => $scoreFactory->withData([
                     'mods' => $mods,
                 ])->create([
                     'beatmap_id' => static::$beatmap,
+                    'total_score' => 1050,
                     'user_id' => static::$user,
                 ]),
             ];

tests/Models/Solo/ScoreTest.php

···
             'user_id' => 1,
         ]);
 
-        $this->assertTrue($score->data->passed);
-        $this->assertSame($score->data->rank, 'S');
+        $this->assertTrue($score->passed);
+        $this->assertSame($score->rank, 'S');
 
-        $legacy = $score->createLegacyEntryOrExplode();
+        $legacy = $score->makeLegacyEntry();
 
         $this->assertTrue($legacy->perfect);
         $this->assertSame($legacy->rank, 'S');
···
             'user_id' => 1,
         ]);
 
-        $this->assertFalse($score->data->passed);
-        $this->assertSame($score->data->rank, 'F');
+        $this->assertFalse($score->passed);
+        $this->assertSame($score->rank, 'F');
 
-        $legacy = $score->createLegacyEntryOrExplode();
+        $legacy = $score->makeLegacyEntry();
 
         $this->assertFalse($legacy->perfect);
         $this->assertSame($legacy->rank, 'F');
···
             'statistics' => ['great' => 10, 'ok' => 20, 'meh' => 30, 'miss' => 40],
             'total_score' => 1000,
             'user_id' => 1,
-        ])->createLegacyEntryOrExplode();
+        ])->makeLegacyEntry();
 
         $this->assertFalse($legacy->perfect);
         $this->assertSame($legacy->count300, 10);
···
             'statistics' => ['Great' => 10, 'Ok' => 20, 'Meh' => 30, 'Miss' => 40],
             'total_score' => 1000,
             'user_id' => 1,
-        ])->createLegacyEntryOrExplode();
+        ])->makeLegacyEntry();
 
         $this->assertFalse($legacy->perfect);
         $this->assertSame($legacy->count300, 10);
···
 
     public function testModsPropertyType()
     {
-        $score = new Score(['data' => [
+        $score = new Score([
             'beatmap_id' => 0,
+            'data' => [
+                'mods' => [['acronym' => 'DT']],
+            ],
             'ended_at' => json_time(now()),
-            'mods' => [['acronym' => 'DT']],
             'ruleset_id' => 0,
             'user_id' => 0,
-        ]]);
+        ]);
 
         $this->assertTrue($score->data->mods[0] instanceof stdClass, 'mods entry should be of type stdClass');
     }
···
     {
         $pp = 10;
         $weight = 0.5;
-        $score = Score::factory()->create();
-        $score->performance()->create(['pp' => $pp]);
+        $score = Score::factory()->create(['pp' => $pp]);
         $score->weight = $weight;
 
         $this->assertSame($score->weightedPp(), $pp * $weight);
···
 
     public function testWeightedPpWithoutPerformance(): void
     {
-        $score = Score::factory()->create();
+        $score = Score::factory()->create(['pp' => null]);
         $score->weight = 0.5;
 
         $this->assertNull($score->weightedPp());
···
 
     public function testWeightedPpWithoutWeight(): void
     {
-        $score = Score::factory()->create();
-        $score->performance()->create(['pp' => 10]);
+        $score = Score::factory()->create(['pp' => 10]);
 
         $this->assertNull($score->weightedPp());
     }

tests/TestCase.php

···
 use App\Events\NewPrivateNotificationEvent;
 use App\Http\Middleware\AuthApi;
 use App\Jobs\Notifications\BroadcastNotificationBase;
+use App\Libraries\OAuth\EncodeToken;
 use App\Libraries\Search\ScoreSearch;
 use App\Libraries\Session\Store as SessionStore;
 use App\Models\Beatmapset;
+use App\Models\Build;
 use App\Models\OAuth\Client;
 use App\Models\User;
 use Artisan;
 use DMS\PHPUnitExtensions\ArraySubset\ArraySubsetAsserts;
-use Firebase\JWT\JWT;
 use Illuminate\Database\DatabaseManager;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Foundation\Testing\DatabaseTransactions;
···
         $callback();
 
         static::resetAppDb($db);
+    }
+
+    protected static function createClientToken(Build $build, ?int $clientTime = null): string
+    {
+        $data = strtoupper(bin2hex($build->hash).bin2hex(pack('V', $clientTime ?? time())));
+        $expected = hash_hmac('sha1', $data, '');
+
+        return strtoupper(bin2hex(random_bytes(40)).$data.$expected.'00');
     }
 
     protected static function fileList($path, $suffix)
···
         return $this;
     }
 
-    // FIXME: figure out how to generate the encrypted token without doing it
-    //        manually here. Or alternatively some other way to authenticate
-    //        with token.
     protected function actingWithToken($token)
     {
-        static $privateKey;
+        $this->actAsUserWithToken($token);
 
-        if ($privateKey === null) {
-            $privateKey = $GLOBALS['cfg']['passport']['private_key'] ?? file_get_contents(Passport::keyPath('oauth-private.key'));
-        }
-
-        $encryptedToken = JWT::encode([
-            'aud' => $token->client_id,
-            'exp' => $token->expires_at->timestamp,
-            'iat' => $token->created_at->timestamp, // issued at
-            'jti' => $token->getKey(),
-            'nbf' => $token->created_at->timestamp, // valid after
-            'sub' => $token->user_id,
-            'scopes' => $token->scopes,
-        ], $privateKey, 'RS256');
-
-        $this->actAsUserWithToken($token);
+        $encodedToken = EncodeToken::encodeAccessToken($token);
 
         return $this->withHeaders([
-            'Authorization' => "Bearer {$encryptedToken}",
+            'Authorization' => "Bearer {$encodedToken}",
         ]);
     }
 
···
      */
     protected function createToken(?User $user, ?array $scopes = null, ?Client $client = null)
     {
-        $client ??= Client::factory()->create();
-
-        $token = $client->tokens()->create([
+        return ($client ?? Client::factory()->create())->tokens()->create([
             'expires_at' => now()->addDays(1),
             'id' => uniqid(),
             'revoked' => false,
             'scopes' => $scopes,
-            'user_id' => optional($user)->getKey(),
+            'user_id' => $user?->getKey(),
+            'verified' => true,
         ]);
-
-        return $token;
     }
 
     protected function expectCountChange(callable $callback, int $change, string $message = '')

tests/api_routes.json

···
 [
     {
+        "uri": "api/v2/session/verify",
+        "methods": [
+            "POST"
+        ],
+        "controller": "App\\Http\\Controllers\\AccountController@verify",
+        "middlewares": [
+            "App\\Http\\Middleware\\ThrottleRequests:1200,1,api:",
+            "App\\Http\\Middleware\\RequireScopes",
+            "App\\Http\\Middleware\\RequireScopes:any",
+            "Illuminate\\Auth\\Middleware\\Authenticate",
+            "App\\Http\\Middleware\\VerifyUser",
+            "App\\Http\\Middleware\\ThrottleRequests:60,10"
+        ],
+        "scopes": [
+            "any"
+        ]
+    },
+    {
+        "uri": "api/v2/session/verify/reissue",
+        "methods": [
+            "POST"
+        ],
+        "controller": "App\\Http\\Controllers\\AccountController@reissueCode",
+        "middlewares": [
+            "App\\Http\\Middleware\\ThrottleRequests:1200,1,api:",
+            "App\\Http\\Middleware\\RequireScopes",
+            "App\\Http\\Middleware\\RequireScopes:any",
+            "Illuminate\\Auth\\Middleware\\Authenticate",
+            "App\\Http\\Middleware\\VerifyUser",
+            "App\\Http\\Middleware\\ThrottleRequests:60,10"
+        ],
+        "scopes": [
+            "any"
+        ]
+    },
+    {
         "uri": "api/v2/beatmaps/lookup",
         "methods": [
             "GET",