Merge branch 'master' into team-settings

.env.example

···
 # SEARCH_MINIMUM_LENGTH=2
 
 # BEATMAPS_DIFFICULTY_CACHE_SERVER_URL=http://localhost:5001
+# BEATMAPS_OWNERS_MAX=10
 # BEATMAPSET_DISCUSSION_KUDOSU_PER_USER=10
 # BEATMAPSET_GUEST_ADVANCED_SEARCH=0
 # BEATMAPSET_MAXIMUM_DISQUALIFIED_RANK_PENALTY_DAYS=7
···
 # SCORES_EXPERIMENTAL_RANK_AS_EXTRA=false
 # SCORES_PROCESSING_QUEUE=osu-queue:score-statistics
 # SCORES_SUBMISSION_ENABLED=1
+# SCORE_INDEX_MAX_ID_DISTANCE=10_000_000
 
 # BANCHO_BOT_USER_ID=
 

app/Console/Commands/BeatmapsMigrateOwners.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\Console\Commands;
+
+use App\Models\Beatmap;
+use Illuminate\Console\Command;
+
+class BeatmapsMigrateOwners extends Command
+{
+    protected $signature = 'beatmaps:migrate-owners';
+
+    protected $description = 'Migrates beatmap owners to new table.';
+
+    public function handle()
+    {
+        $progress = $this->output->createProgressBar();
+
+        Beatmap::chunkById(1000, function ($beatmaps) use ($progress) {
+            foreach ($beatmaps as $beatmap) {
+                $beatmap->beatmapOwners()->firstOrCreate(['user_id' => $beatmap->user_id]);
+                $progress->advance();
+            }
+        });
+
+        $progress->finish();
+        $this->line('');
+    }
+}

app/Http/Controllers/BeatmapsController.php

···
 
 use App\Enums\Ruleset;
 use App\Exceptions\InvariantException;
-use App\Jobs\Notifications\BeatmapOwnerChange;
 use App\Libraries\BeatmapDifficultyAttributes;
+use App\Libraries\Beatmapset\ChangeBeatmapOwners;
 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\User;
 use App\Transformers\BeatmapTransformer;
 use App\Transformers\ScoreTransformer;
···
     public function updateOwner($id)
     {
         $beatmap = Beatmap::findOrFail($id);
-        $currentUser = auth()->user();
-
-        priv_check('BeatmapUpdateOwner', $beatmap->beatmapset)->ensureCan();
+        $newUserIds = get_arr(request('user_ids'), 'get_int');
 
-        $newUserId = get_int(request('beatmap.user_id'));
-
-        $beatmap->getConnection()->transaction(function () use ($beatmap, $currentUser, $newUserId) {
-            $beatmap->setOwner($newUserId);
-
-            BeatmapsetEvent::log(BeatmapsetEvent::BEATMAP_OWNER_CHANGE, $currentUser, $beatmap->beatmapset, [
-                'beatmap_id' => $beatmap->getKey(),
-                'beatmap_version' => $beatmap->version,
-                'new_user_id' => $beatmap->user_id,
-                'new_user_username' => $beatmap->user->username,
-            ])->saveOrExplode();
-        });
-
-        if ($beatmap->user_id !== $currentUser->getKey()) {
-            (new BeatmapOwnerChange($beatmap, $currentUser))->dispatch();
-        }
+        (new ChangeBeatmapOwners($beatmap, $newUserIds ?? [], \Auth::user()))->handle();
 
         return $beatmap->beatmapset->defaultDiscussionJson();
     }
···
             'score' => json_item(
                 $score,
                 new ScoreTransformer(),
-                ['beatmap', ...static::DEFAULT_SCORE_INCLUDES]
+                ['beatmap.owners', ...static::DEFAULT_SCORE_INCLUDES]
             ),
         ];
     }

app/Http/Controllers/BeatmapsetsController.php

···
             "{$beatmapRelation}.baseDifficultyRatings",
             "{$beatmapRelation}.baseMaxCombo",
             "{$beatmapRelation}.failtimes",
+            "{$beatmapRelation}.beatmapOwners.user",
             'genre',
             'language',
             'user',
···
             'beatmaps',
             'beatmaps.failtimes',
             'beatmaps.max_combo',
+            'beatmaps.owners',
             'converts',
             'converts.failtimes',
+            'converts.owners',
             'current_nominations',
             'current_user_attributes',
             'description',

app/Http/Controllers/Multiplayer/RoomsController.php

···
     private function createJoinedRoomResponse($room)
     {
         return json_item(
-            $room
-                ->load('host.country')
-                ->load('playlist.beatmap.beatmapset')
-                ->load('playlist.beatmap.baseMaxCombo'),
+            $room->loadMissing([
+                'host',
+                'playlist.beatmap.beatmapset',
+                'playlist.beatmap.baseMaxCombo',
+            ]),
             'Multiplayer\Room',
             [
                 'current_user_score.playlist_item_attempts',

app/Http/Controllers/ScoresController.php

···
 namespace App\Http\Controllers;
 
 use App\Enums\Ruleset;
+use App\Models\Beatmap;
 use App\Models\Score\Best\Model as ScoreBest;
 use App\Models\ScoreReplayStats;
 use App\Models\Solo\Score as SoloScore;
···
         parent::__construct();
 
         $this->middleware('auth', ['except' => [
+            'download',
+            'index',
             'show',
-            'download',
         ]]);
 
         $this->middleware('require-scopes:public');
···
         }, $this->makeReplayFilename($score), $responseHeaders);
     }
 
+    /**
+     * Get Scores
+     *
+     * Returns submitted scores. Up to 1000 scores will be returned in order of oldest to latest.
+     * Most recent scores will be returned if `cursor_string` parameter is not specified.
+     *
+     * Obtaining new scores that arrived after the last request can be done by passing `cursor_string`
+     * parameter from the previous request.
+     *
+     * ---
+     *
+     * ### Response Format
+     *
+     * Field         | Type                          | Notes
+     * ------------- | ----------------------------- | -----
+     * scores        | [Score](#score)[]             | |
+     * cursor_string | [CursorString](#cursorstring) | Same value as the request will be returned if there's no new scores
+     *
+     * @group Scores
+     *
+     * @queryParam ruleset The [Ruleset](#ruleset) to get scores for.
+     * @queryParam cursor_string Next set of scores
+     */
+    public function index()
+    {
+        $params = \Request::all();
+        $cursor = cursor_from_params($params);
+        $isOldScores = false;
+        if (isset($cursor['id']) && ($idFromCursor = get_int($cursor['id'])) !== null) {
+            $currentMaxId = SoloScore::max('id');
+            $idDistance = $currentMaxId - $idFromCursor;
+            if ($idDistance > $GLOBALS['cfg']['osu']['scores']['index_max_id_distance']) {
+                abort(422, 'cursor is too old');
+            }
+            $isOldScores = $idDistance > 10_000;
+        }
+
+        $rulesetId = null;
+        if (isset($params['ruleset'])) {
+            $rulesetId = Beatmap::modeInt(get_string($params['ruleset']));
+
+            if ($rulesetId === null) {
+                abort(422, 'invalid ruleset parameter');
+            }
+        }
+
+        return \Cache::remember(
+            'score_index:'.($rulesetId ?? '').':'.json_encode($cursor),
+            $isOldScores ? 600 : 5,
+            function () use ($cursor, $isOldScores, $rulesetId) {
+                $cursorHelper = SoloScore::makeDbCursorHelper('old');
+                $scoresQuery = SoloScore::forListing()->limit(1_000);
+                if ($rulesetId !== null) {
+                    $scoresQuery->where('ruleset_id', $rulesetId);
+                }
+                if ($cursor === null || $cursorHelper->prepare($cursor) === null) {
+                    // fetch the latest scores when no or invalid cursor is specified
+                    // and reverse result to match the other query (latest score last)
+                    $scores = array_reverse($scoresQuery->orderByDesc('id')->get()->all());
+                } else {
+                    $scores = $scoresQuery->cursorSort($cursorHelper, $cursor)->get()->all();
+                }
+
+                if ($isOldScores) {
+                    $filteredScores = $scores;
+                } else {
+                    $filteredScores = [];
+                    foreach ($scores as $score) {
+                        // only return up to but not including the earliest unprocessed scores
+                        if ($score->isProcessed()) {
+                            $filteredScores[] = $score;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+
+                return [
+                    'scores' => json_collection($filteredScores, new ScoreTransformer(ScoreTransformer::TYPE_SOLO)),
+                    // return previous cursor if no result, assuming there's no new scores yet
+                    ...cursor_for_response($cursorHelper->next($filteredScores) ?? $cursor),
+                ];
+            },
+        );
+    }
+
     public function show($rulesetOrSoloId, $legacyId = null)
     {
         if ($legacyId === null) {
···
         $scoreJson = json_item($score, new ScoreTransformer(), array_merge([
             'beatmap.max_combo',
             'beatmap.user',
+            'beatmap.owners',
             'beatmapset',
             'rank_global',
         ], $userIncludes));

app/Libraries/Beatmapset/ChangeBeatmapOwners.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\Beatmapset;
+
+use App\Exceptions\InvariantException;
+use App\Jobs\Notifications\BeatmapOwnerChange;
+use App\Models\Beatmap;
+use App\Models\BeatmapOwner;
+use App\Models\BeatmapsetEvent;
+use App\Models\User;
+use Ds\Set;
+
+class ChangeBeatmapOwners
+{
+    private Set $userIds;
+
+    public function __construct(private Beatmap $beatmap, array $newUserIds, private User $source)
+    {
+        priv_check_user($source, 'BeatmapUpdateOwner', $beatmap->beatmapset)->ensureCan();
+
+        $this->userIds = new Set($newUserIds);
+
+        if ($this->userIds->count() > $GLOBALS['cfg']['osu']['beatmaps']['owners_max']) {
+            throw new InvariantException(osu_trans('beatmaps.change_owner.too_many'));
+        }
+
+        if ($this->userIds->isEmpty()) {
+            throw new InvariantException('user_ids must be specified');
+        }
+    }
+
+    public function handle(): void
+    {
+        $currentOwners = new Set($this->beatmap->getOwners()->pluck('user_id'));
+        if ($currentOwners->xor($this->userIds)->isEmpty()) {
+            return;
+        }
+
+        $newUserIds = $this->userIds->diff($currentOwners);
+
+        if (User::whereIn('user_id', $newUserIds->toArray())->default()->count() !== $newUserIds->count()) {
+            throw new InvariantException('invalid user_id');
+        }
+
+        $this->beatmap->getConnection()->transaction(function () {
+            $params = array_map(
+                fn ($userId) => ['beatmap_id' => $this->beatmap->getKey(), 'user_id' => $userId],
+                $this->userIds->toArray()
+            );
+
+            $this->beatmap->fill(['user_id' => $this->userIds->first()])->saveOrExplode();
+            $this->beatmap->beatmapOwners()->delete();
+            BeatmapOwner::insert($params);
+
+            $this->beatmap->refresh();
+
+            $newUsers = $this->beatmap->getOwners()->select('id', 'username')->all();
+            $beatmapset = $this->beatmap->beatmapset;
+            $firstMapper = $newUsers[0];
+
+            BeatmapsetEvent::log(BeatmapsetEvent::BEATMAP_OWNER_CHANGE, $this->source, $beatmapset, [
+                'beatmap_id' => $this->beatmap->getKey(),
+                'beatmap_version' => $this->beatmap->version,
+                // TODO: mainly for compatibility during dev when switching branches, can be removed after deployed.
+                'new_user_id' => $firstMapper['id'],
+                'new_user_username' => $firstMapper['username'],
+                'new_users' => $newUsers,
+            ])->saveOrExplode();
+
+            $beatmapset->update(['eligible_main_rulesets' => null]);
+        });
+
+        (new BeatmapOwnerChange($this->beatmap, $this->source))->dispatch();
+    }
+}

app/Models/Beatmap.php

···
 use App\Libraries\Transactions\AfterCommit;
 use DB;
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\SoftDeletes;
 
 /**
  * @property int $approved
- * @property \Illuminate\Database\Eloquent\Collection $beatmapDiscussions BeatmapDiscussion
+ * @property-read Collection<BeatmapDiscussion> $beatmapDiscussions
+ * @property-read Collection<BeatmapOwner> $beatmapOwners
  * @property int $beatmap_id
  * @property Beatmapset $beatmapset
  * @property int|null $beatmapset_id
···
  * @property float $diff_drain
  * @property float $diff_overall
  * @property float $diff_size
- * @property \Illuminate\Database\Eloquent\Collection $difficulty BeatmapDifficulty
- * @property \Illuminate\Database\Eloquent\Collection $difficultyAttribs BeatmapDifficultyAttrib
+ * @property-read Collection<BeatmapDifficulty> $difficulty
+ * @property-read Collection<BeatmapDifficultyAttrib> $difficultyAttribs
  * @property float $difficultyrating
- * @property \Illuminate\Database\Eloquent\Collection $failtimes BeatmapFailtimes
+ * @property-read Collection<BeatmapFailtimes> $failtimes
  * @property string|null $filename
  * @property int $hit_length
  * @property \Carbon\Carbon $last_update
  * @property int $max_combo
  * @property mixed $mode
+ * @property-read Collection<User> $owners
  * @property int $passcount
  * @property int $playcount
  * @property int $playmode
  * @property int $score_version
  * @property int $total_length
+ * @property User $user
  * @property int $user_id
  * @property string $version
  * @property string|null $youtube_preview
···
     public function baseMaxCombo()
     {
         return $this->difficultyAttribs()->noMods()->maxCombo();
+    }
+
+    public function beatmapOwners()
+    {
+        return $this->hasMany(BeatmapOwner::class);
     }
 
     public function beatmapset()
···
             'baseDifficultyRatings',
             'baseMaxCombo',
             'beatmapDiscussions',
+            'beatmapOwners',
             'beatmapset',
             'difficulty',
             'difficultyAttribs',
···
         };
     }
 
+    /**
+     * @return Collection<User>
+     */
+    public function getOwners(): Collection
+    {
+        $owners = $this->beatmapOwners->loadMissing('user')->map(
+            fn ($beatmapOwner) => $beatmapOwner->user ?? new DeletedUser(['user_id' => $beatmapOwner->user_id])
+        );
+
+        // TODO: remove when everything writes to beatmap_owners.
+        if (!$owners->contains(fn ($beatmapOwner) => $beatmapOwner->user_id === $this->user_id)) {
+            $owners->prepend($this->user ?? new DeletedUser(['user_id' => $this->user_id]));
+        }
+
+        return $owners;
+    }
+
+    public function isOwner(User $user): bool
+    {
+        if ($this->user_id === $user->getKey()) {
+            return true;
+        }
+
+        return $this->relationLoaded('beatmapOwners')
+            ? $this->beatmapOwners->contains('user_id', $user->getKey())
+            : $this->beatmapOwners()->where('user_id', $user->getKey())->exists();
+    }
+
     public function maxCombo()
     {
         if (!$this->convert) {
···
         }
 
         return $maxCombo?->value;
-    }
-
-    public function setOwner($newUserId)
-    {
-        if ($newUserId === null) {
-            throw new InvariantException('user_id must be specified');
-        }
-
-        if (User::find($newUserId) === null) {
-            throw new InvariantException('invalid user_id');
-        }
-
-        if ($newUserId === $this->user_id) {
-            throw new InvariantException('the specified user_id is already the owner');
-        }
-
-        $this->fill(['user_id' => $newUserId])->saveOrExplode();
-        $this->beatmapset->update(['eligible_main_rulesets' => null]);
     }
 
     public function status()

app/Models/BeatmapDiscussion.php

···
 
     public function managedBy(User $user): bool
     {
-        $id = $user->getKey();
-
-        return $this->beatmapset->user_id === $id
-            || ($this->beatmap !== null && $this->beatmap->user_id === $id);
+        return $this->beatmapset->user_id === $user->getKey()
+            || ($this->beatmap !== null && $this->beatmap->isOwner($user));
     }
 
     public function userRecentVotesCount($user, $increment = false)

app/Models/BeatmapOwner.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;
+
+/**
+ * @property Beatmap $beatmap
+ * @property int $beatmap_id
+ * @property User $user
+ * @property int $user_id
+ */
+class BeatmapOwner extends Model
+{
+    public $incrementing = false;
+    public $timestamps = false;
+
+    protected $primaryKey = ':composite';
+    protected $primaryKeys = ['beatmap_id', 'user_id'];
+
+    public function beatmap()
+    {
+        return $this->belongsTo(Beatmap::class, 'beatmap_id');
+    }
+
+    public function user()
+    {
+        return $this->belongsTo(User::class, 'user_id');
+    }
+}

app/Models/Beatmapset.php

···
 use App\Libraries\Transactions\AfterCommit;
 use App\Traits\Memoizes;
 use App\Traits\Validatable;
+use App\Transformers\BeatmapsetTransformer;
 use Cache;
 use Carbon\Carbon;
 use DB;
···
 
     public function defaultDiscussionJson()
     {
+        $this->loadMissing([
+            'allBeatmaps',
+            'allBeatmaps.beatmapOwners.user',
+            'allBeatmaps.user', // TODO: for compatibility only, should migrate user_id to BeatmapOwner.
+            'beatmapDiscussions.beatmapDiscussionPosts',
+            'beatmapDiscussions.beatmapDiscussionVotes',
+        ]);
+
+        foreach ($this->allBeatmaps as $beatmap) {
+            $beatmap->setRelation('beatmapset', $this);
+        }
+
+        $beatmapsByKey = $this->allBeatmaps->keyBy('beatmap_id');
+
+        foreach ($this->beatmapDiscussions as $discussion) {
+            // set relations for priv checks.
+            $discussion->setRelation('beatmapset', $this);
+
+            if ($discussion->beatmap_id !== null) {
+                $discussion->setRelation('beatmap', $beatmapsByKey[$discussion->beatmap_id]);
+            }
+        }
+
         return json_item(
-            static::with([
-                'allBeatmaps.beatmapset',
-                'beatmapDiscussions.beatmapDiscussionPosts',
-                'beatmapDiscussions.beatmapDiscussionVotes',
-                'beatmapDiscussions.beatmapset',
-                'beatmapDiscussions.beatmap',
-                'beatmapDiscussions.beatmapDiscussionVotes',
-            ])->find($this->getKey()),
-            'Beatmapset',
+            $this,
+            new BeatmapsetTransformer(),
             [
-                'beatmaps:with_trashed',
+                'beatmaps:with_trashed.owners',
                 'current_user_attributes',
                 'discussions',
                 'discussions.current_user_attributes',

app/Models/Multiplayer/Room.php

···
             throw new InvariantException('room must have at least one playlist item');
         }
 
+        if (mb_strlen($this->name) > 100) {
+            throw new InvariantException(osu_trans('multiplayer.room.errors.name_too_long'));
+        }
+
         PlaylistItem::assertBeatmapsExist($playlistItems);
 
         $this->getConnection()->transaction(function () use ($host, $playlistItems) {

app/Models/Solo/Score.php

···
  */
 class Score extends Model implements Traits\ReportableInterface
 {
-    use Traits\Reportable, Traits\WithWeightedPp;
+    use Traits\Reportable, Traits\WithDbCursorHelper, Traits\WithWeightedPp;
+
+    const DEFAULT_SORT = 'old';
+
+    const SORTS = [
+        'old' => [['column' => 'id', 'order' => 'ASC']],
+    ];
 
     public $timestamps = false;
 
···
         return $query->whereHas('beatmap.beatmapset');
     }
 
+    public function scopeForListing(Builder $query): Builder
+    {
+        return $query->where('ranked', true)
+            ->leftJoinRelation('processHistory')
+            ->select([$query->qualifyColumn('*'), 'processed_version']);
+    }
+
     public function scopeForRuleset(Builder $query, string $ruleset): Builder
     {
         return $query->where('ruleset_id', Beatmap::MODES[$ruleset]);
···
             throw new InvariantException('Invalid accuracy.');
         }
 
-        // unsigned int (as per the column)
-        if ($this->total_score === null || $this->total_score < 0 || $this->total_score > 4294967295) {
+        // int (as per es schema)
+        if ($this->total_score === null || $this->total_score < 0 || $this->total_score > 2147483647) {
             throw new InvariantException('Invalid total_score.');
         }
 
-        // unsigned int (no data type enforcement as this goes into the json, but just to match total_score)
+        // int (no data type enforcement as this goes into the json, but just to match total_score)
         if (
             $this->data->totalScoreWithoutMods !== null
-            && ($this->data->totalScoreWithoutMods < 0 || $this->data->totalScoreWithoutMods > 4294967295)
+            && ($this->data->totalScoreWithoutMods < 0 || $this->data->totalScoreWithoutMods > 2147483647)
         ) {
             throw new InvariantException('Invalid total_score_without_mods.');
         }
···
         }
 
         return null;
+    }
+
+    public function isProcessed(): bool
+    {
+        if ($this->legacy_score_id !== null) {
+            return true;
+        }
+
+        if (array_key_exists('processed_version', $this->attributes)) {
+            return $this->attributes['processed_version'] !== null;
+        }
+
+        return $this->processHistory !== null;
     }
 
     public function legacyScore(): ?LegacyScore\Best\Model

app/Models/Traits/Es/BeatmapsetSearch.php

···
         return static::withoutGlobalScopes()
             ->active()
             ->with('beatmaps') // note that the with query will run with the default scopes.
+            ->with('beatmaps.beatmapOwners')
             ->with('beatmaps.baseDifficultyRatings');
     }
 
···
                 $beatmapValues[$field] = $beatmap->$field;
             }
 
+            // TODO: remove adding $beatmap->user_id once everything else also populated beatmap_owners by default.
+            // Duplicate user_id in the array should be fine for now since the field isn't scored for querying.
+            $beatmapValues['user_id'] = $beatmap->beatmapOwners->pluck('user_id')->add($beatmap->user_id);
             $values[] = $beatmapValues;
 
             if ($beatmap->playmode === Beatmap::MODES['osu']) {
···
                         $convertValues[$field] = $convert->$field;
                     }
 
+                    $convertValues['user_id'] = $beatmapValues['user_id']; // just add a copy for converts too.
                     $values[] = $convertValues;
                 }
             }

app/Models/User.php

···
             'cover_preset_id',
             'custom_cover_filename',
             'group_id',
+            'laravel_through_key', // added by hasManyThrough relation in Beatmap
             'osu_featurevotes',
             'osu_kudosavailable',
             'osu_kudosdenied',
···
     {
         return Beatmapset
             ::where('user_id', '<>', $this->getKey())
-            ->whereHas('beatmaps', function (Builder $query) {
-                $query->scoreable()->where('user_id', $this->getKey());
-            })
+            ->whereHas(
+                'beatmaps',
+                fn (Builder $query) => $query->scoreable()->whereHas(
+                    'beatmapOwners',
+                    fn (Builder $ownerQuery) => $ownerQuery->where('user_id', $this->getKey())
+                )
+            )
             ->with('beatmaps');
     }
 

app/Singletons/OsuAuthorize.php

···
             return $prefix.'owner';
         }
 
+        $beatmapset->loadMissing('beatmaps.beatmapOwners');
+
         foreach ($beatmapset->beatmaps as $beatmap) {
-            if ($userId === $beatmap->user_id) {
+            if ($beatmap->isOwner($user)) {
                 return $prefix.'owner';
             }
         }

app/Transformers/BeatmapCompactTransformer.php

···
 use App\Models\Beatmap;
 use App\Models\BeatmapFailtimes;
 use App\Models\DeletedUser;
+use App\Models\User;
 
 class BeatmapCompactTransformer extends TransformerAbstract
 {
···
         'checksum',
         'failtimes',
         'max_combo',
+        'owners',
         'user',
     ];
 
···
     public function includeMaxCombo(Beatmap $beatmap)
     {
         return $this->primitive($beatmap->maxCombo());
+    }
+
+    public function includeOwners(Beatmap $beatmap)
+    {
+        return $this->collection($beatmap->getOwners(), fn (User $user) => [
+            'id' => $user->getKey(),
+            'username' => $user->username,
+        ]);
     }
 
     public function includeUser(Beatmap $beatmap)

app/Transformers/BeatmapsetCompactTransformer.php

···
         $userIds = new Set([$beatmapset->user_id]);
         switch ($this->relatedUsersType) {
             case 'discussions':
-                $userIds->add(...$beatmapset->allBeatmaps->pluck('user_id'));
+                $beatmaps = $beatmapset->allBeatmaps;
+                $userIds->add(...$beatmaps->pluck('user_id'));
+                $userIds->add(...$beatmaps->flatMap->beatmapOwners->pluck('user_id'));
 
                 foreach ($beatmapset->beatmapDiscussions as $discussion) {
                     if (!priv_check('BeatmapDiscussionShow', $discussion)->can()) {
···
                 }
                 break;
             case 'show':
-                $userIds->add(...$this->beatmaps($beatmapset)->pluck('user_id'));
+                $beatmaps = $this->beatmaps($beatmapset);
+                $userIds->add(...$beatmaps->pluck('user_id'));
+                $userIds->add(...$beatmaps->flatMap->beatmapOwners->pluck('user_id'));
                 $userIds->add(...$beatmapset->beatmapsetNominationsCurrent->pluck('user_id'));
                 break;
         }

app/Transformers/ScoreTransformer.php

···
         if ($score instanceof SoloScore) {
             $extraAttributes['classic_total_score'] = $score->getClassicTotalScore();
             $extraAttributes['preserve'] = $score->preserve;
-            $extraAttributes['processed'] = $score->legacy_score_id !== null || $score->processHistory !== null;
+            $extraAttributes['processed'] = $score->isProcessed();
             $extraAttributes['ranked'] = $score->ranked;
         }
 

app/helpers.php

···
 
     $tooltipDate = i18n_date($user->user_regdate);
 
-    $formattedDate = i18n_date($user->user_regdate, null, 'year_month');
+    $formattedDate = i18n_date($user->user_regdate, pattern: 'year_month');
 
     if ($user->user_regdate < Carbon\Carbon::createFromDate(2008, 1, 1)) {
         return '<div title="'.$tooltipDate.'">'.osu_trans('users.show.first_members').'</div>';
···
     ]);
 }
 
-function i18n_date($datetime, $format = IntlDateFormatter::LONG, $pattern = null)
+function i18n_date($datetime, int $format = IntlDateFormatter::LONG, $pattern = null)
 {
     $formatter = IntlDateFormatter::create(
         App::getLocale(),

config/osu.php

···
     'beatmaps' => [
         'max' => 50,
         'max_scores' => 100,
+        'owners_max' => get_int(env('BEATMAPS_OWNERS_MAX')) ?? 10,
 
         'difficulty_cache' => [
             'server_url' => presence(env('BEATMAPS_DIFFICULTY_CACHE_SERVER_URL')) ?? 'http://localhost:5001',
···
         'es_cache_duration' => 60 * (get_float(env('SCORES_ES_CACHE_DURATION')) ?? 0.5), // in minutes, converted to seconds
         '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,
+        'index_max_id_distance' => get_int(env('SCORE_INDEX_MAX_ID_DISTANCE')) ?? 10_000_000,
         'processing_queue' => presence(env('SCORES_PROCESSING_QUEUE')) ?? 'osu-queue:score-statistics',
         'submission_enabled' => get_bool(env('SCORES_SUBMISSION_ENABLED')) ?? true,
     ],

database/factories/BeatmapFactory.php

···
 namespace Database\Factories;
 
 use App\Models\Beatmap;
+use App\Models\BeatmapOwner;
 use App\Models\Beatmapset;
+use App\Models\User;
 use Carbon\Carbon;
 
 class BeatmapFactory extends Factory
···
         return $this->state([
             'beatmapset_id' => Beatmapset::factory()->state(['active' => false]),
         ]);
+    }
+
+    public function owner(User $user): static
+    {
+        return $this
+            ->state(['user_id' => $user])
+            ->has(BeatmapOwner::factory()->state(fn (array $attr, Beatmap $beatmap) => [
+                'user_id' => $beatmap->user_id,
+            ]));
     }
 
     public function qualified(): static

database/factories/BeatmapOwnerFactory.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 Database\Factories;
+
+use App\Models\Beatmap;
+use App\Models\BeatmapOwner;
+use App\Models\User;
+
+class BeatmapOwnerFactory extends Factory
+{
+    protected $model = BeatmapOwner::class;
+
+    public function definition(): array
+    {
+        return [
+            'beatmap_id' => Beatmap::factory(),
+            'user_id' => User::factory(),
+        ];
+    }
+}

database/factories/UserFactory.php

···
         ];
     }
 
+    // convenience for dataProviders so null checks don't have to be called when creating with named state.
+    public function default()
+    {
+        return $this;
+    }
+
     public function restricted()
     {
         return $this

database/migrations/2024_07_02_000001_create_beatmap_owners.php

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

database/migrations/2024_12_03_102822_add_synthetic_pk_to_beatmapset_version_files.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.
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('beatmapset_version_files', function (Blueprint $table) {
+            $table->dropPrimary();
+        });
+        Schema::table('beatmapset_version_files', function (Blueprint $table) {
+            $table->bigIncrements('id')->first();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('beatmapset_version_files', function (Blueprint $table) {
+            $table->dropColumn('id');
+        });
+        Schema::table('beatmapset_version_files', function (Blueprint $table) {
+            $table->primary(['file_id', 'version_id']);
+        });
+    }
+};

resources/css/bem-index.less

···
 @import "bem/beatmap-icon";
 @import "bem/beatmap-list";
 @import "bem/beatmap-list-item";
+@import "bem/beatmap-owner";
 @import "bem/beatmap-owner-editor";
+@import "bem/beatmap-owner-editor-owners";
 @import "bem/beatmap-pack";
 @import "bem/beatmap-pack-description";
 @import "bem/beatmap-pack-items";

resources/css/bem/beatmap-owner-editor-owners.less

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+.beatmap-owner-editor-owners {
+  display: flex;
+  flex-direction: row;
+  flex-wrap: wrap;
+  gap: 2px;
+  padding: var(--input-padding);
+  border-radius: @border-radius-large;
+
+  &--editing {
+    background: var(--input-bg);
+    box-shadow: inset 0 0 0 2px var(--input-border-colour);
+  }
+}

resources/css/bem/beatmap-owner-editor.less

···
   display: contents;
 
   &__avatar {
-    display: flex;
-    width: 100%;
-    height: 100%;
+    width: 20px;
+    height: $width;
   }
 
   &__col {
     display: flex;
     align-items: center;
-
-    &--avatar {
-      position: relative;
-      width: 20px;
-      font-size: $width;
-    }
+    gap: 5px;
 
     &--buttons {
       display: flex;
···
   &__button {
     .reset-input();
     .link-default();
-    margin-left: 5px;
 
     &[disabled] {
       opacity: 0.5;
     }
   }
 
-  &__input {
-    .default-border-radius();
-    .reset-input();
-    background-color: hsl(var(--hsl-b6));
-    color: inherit;
-    padding: 1px 3px;
-    width: auto;
-    border: 2px solid transparent;
-
-    &--error {
-      border-color: hsl(var(--hsl-red-2));
-    }
-
-    &--static {
-      // defined here so it doesn't trigger tooltip in addition to usercard
-      .ellipsis-overflow();
-      background-color: transparent;
-      padding-left: 0;
-      padding-right: 0;
-    }
+  &__user {
+    display: flex;
+    align-items: center;
+    gap: 5px;
   }
 }

resources/css/bem/beatmap-owner.less

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+.beatmap-owner {
+  display: flex;
+  gap: 2px;
+
+  // same colour as the modal.
+  background-color: hsla(var(--hsl-b5), 0.8);
+  border-radius: @border-radius-large;
+
+  &__avatar {
+    width: 20px;
+    height: $width;
+  }
+
+  &__remove {
+    .reset-input();
+
+    opacity: 0.7;
+    margin: 2px;
+    padding: 0 0.3em;
+    visibility: hidden;
+
+    border-radius: 50%;
+    display: flex;
+    place-items: center;
+
+    .link-hover({
+      opacity: 1;
+      background-color: hsl(var(--hsl-b1));
+    });
+
+    &--editing {
+      visibility: visible;
+    }
+  }
+
+  &__user {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+  }
+}

resources/css/bem/beatmaps-owner-editor.less

···
       grid-gap: 5px;
       font-size: @font-size--normal;
       // mode-icon version avatar username buttons
-      grid-template-columns: auto minmax(20px, auto) auto minmax(20px, 150px) 70px;
+      grid-template-columns: auto minmax(20px, auto) minmax(20px, 300px) 70px;
       align-items: center;
       overflow-y: auto;
       max-height: calc(var(--vh) * 60);

resources/css/bem/input-container.less

···
     }
   }
 
+  &--beatmap-owner-editor {
+    --input-bg: hsl(var(--hsl-b6));
+    --input-padding: 5px;
+  }
+
   &--error {
     --input-border-colour: var(--input-border-error-colour);
     --input-border-focus-colour: var(--input-border-error-focus-colour);

resources/css/bem/username-input.less

···
     color: hsl(var(--hsl-c1));
 
     flex: 1;
+    order: 1;
     // can't do much about wrapping the input itself...
     min-width: 40px;
   }
 
   &__spinner {
     display: inline-flex;
+    order: 2;
     align-items: center;
     min-width: 1em;
   }

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

···
 import UserJson from 'interfaces/user-json';
 import { action, autorun, computed, makeObservable, observable } from 'mobx';
 import { disposeOnUnmount, observer } from 'mobx-react';
-import { deletedUserJson } from 'models/user';
 import * as React from 'react';
 import { makeUrl } from 'utils/beatmapset-discussion-helper';
 import { blackoutToggle } from 'utils/blackout';
···
             href={makeUrl({ beatmap: this.props.discussionsState.currentBeatmap })}
             onClick={this.toggleSelector}
           >
-            <BeatmapListItem beatmap={this.props.discussionsState.currentBeatmap} mapper={null} modifiers='large' />
+            <BeatmapListItem beatmap={this.props.discussionsState.currentBeatmap} modifiers='large' showOwners={false} />
             <div className='beatmap-list__item-selector-button'>
               <span className='fas fa-chevron-down' />
             </div>
···
           beatmap={beatmap}
           beatmapUrl={makeUrl({ beatmap, filter: this.props.discussionsState.currentFilter })}
           beatmapset={this.props.discussionsState.beatmapset}
-          mapper={this.props.users.get(beatmap.user_id) ?? deletedUserJson}
-          showNonGuestMapper={false}
+          showNonGuestOwner={false}
+          showOwners
         />
         {count != null &&
           <div className='beatmap-list__item-count'>

resources/js/beatmap-discussions/beatmap-owner-editor.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 InputContainer from 'components/input-container';
 import { Spinner } from 'components/spinner';
-import UserAvatar from 'components/user-avatar';
-import UserLink from 'components/user-link';
+import UsernameInput from 'components/username-input';
 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 WithBeatmapOwners from 'interfaces/with-beatmap-owners';
 import { route } from 'laroute';
-import { action, computed, makeObservable, observable, runInAction } from 'mobx';
+import { xor } from 'lodash';
+import { action, makeObservable, observable, runInAction } from 'mobx';
 import { observer } from 'mobx-react';
 import { normaliseUsername } from 'models/user';
 import * as React from 'react';
-import { onErrorWithCallback } from 'utils/ajax';
+import { onError } from 'utils/ajax';
+import { hasGuestOwners } from 'utils/beatmap-helper';
 import { classWithModifiers } from 'utils/css';
-import { transparentGif } from 'utils/html';
 import { trans } from 'utils/lang';
-import { apiLookupUsers } from 'utils/user';
+import BeatmapOwner from './beatmap-owner';
 import DiscussionsState from './discussions-state';
 
-interface XhrCollection {
-  updateOwner: JQuery.jqXHR<BeatmapsetWithDiscussionsJson>;
-  userLookup: ReturnType<typeof apiLookupUsers>;
-}
-
 interface Props {
-  beatmap: BeatmapJson;
-  beatmapsetUser: UserJson;
-  discussionsState: DiscussionsState;
-  user: UserJson;
-  userByName: Map<string, UserJson>;
+  beatmap: WithBeatmapOwners<BeatmapJson>;
+  beatmapset: BeatmapsetExtendedJson;
+  discussionsState: DiscussionsState; // only for updating the state with the response.
 }
 
 @observer
 export default class BeatmapOwnerEditor extends React.Component<Props> {
-  @observable private checkingUser: string | null = null;
-  @observable private editing = false;
+  @observable editing = false;
   private readonly inputRef = React.createRef<HTMLInputElement>();
-  @observable private inputUsername: string;
+  @observable private inputUsername = '';
   private shouldFocusInputOnNextRender = false;
+  @observable private showError = false;
+  private updateOwnerXhr?: JQuery.jqXHR<BeatmapsetWithDiscussionsJson>;
   @observable private updatingOwner = false;
-  private userLookupTimeout?: number;
-  private readonly xhr: Partial<XhrCollection> = {};
+  @observable private validUsers = new Map<number, UserJson>();
 
-  @computed
-  private get inputUser() {
-    return this.props.userByName.get(normaliseUsername(this.inputUsername));
+  private get canSave() {
+    return this.validUsers.size > 0 && normaliseUsername(this.inputUsername).length === 0;
+  }
+
+  private get owners() {
+    return this.props.discussionsState.beatmapOwners(this.props.beatmap);
   }
 
   constructor(props: Props) {
     super(props);
 
-    this.inputUsername = props.user.username;
-
     makeObservable(this);
   }
 
···
   }
 
   componentWillUnmount() {
-    window.clearTimeout(this.userLookupTimeout);
-    Object.values(this.xhr).forEach((xhr) => xhr?.abort());
+    this.updateOwnerXhr?.abort();
   }
 
   render() {
-    const blockClass = classWithModifiers('beatmap-owner-editor', {
-      editing: this.editing,
-    });
-
     return (
-      <div className={blockClass}>
+      <div className='beatmap-owner-editor'>
         <div className='beatmap-owner-editor__col'>
           <span className='beatmap-owner-editor__mode'>
             <span className={`fal fa-fw fa-extra-mode-${this.props.beatmap.mode}`} />
···
           </span>
         </div>
 
-        <div className='beatmap-owner-editor__col beatmap-owner-editor__col--avatar'>
-          {this.renderAvatar()}
-        </div>
-
         <div className='beatmap-owner-editor__col'>
-          {this.renderUsername()}
+          {this.renderUsernames()}
         </div>
 
         <div className='beatmap-owner-editor__col beatmap-owner-editor__col--buttons'>
···
   @action
   private readonly handleCancelEditingClick = () => {
     this.editing = false;
+    this.showError = false;
   };
 
   @action
···
     if (!confirm(trans('beatmap_discussions.owner_editor.reset_confirm'))) return;
 
     this.editing = false;
-    this.updateOwner(this.props.beatmapsetUser.id);
+    this.updateOwners([this.props.beatmapset.user_id]);
   };
 
   private readonly handleSaveClick = () => {
-    if (this.inputUser == null) return;
+    if (!this.canSave) return;
 
-    this.updateOwner(this.inputUser.id);
+    this.updateOwners([...this.validUsers.keys()]);
   };
 
   @action
   private readonly handleStartEditingClick = () => {
     this.editing = true;
     this.shouldFocusInputOnNextRender = true;
-    this.inputUsername = this.props.user.username;
   };
 
   @action
-  private readonly handleUsernameInput = (e: React.ChangeEvent<HTMLInputElement>) => {
-    this.inputUsername = e.currentTarget.value;
-    const inputUsernameNormalised = normaliseUsername(this.inputUsername);
-
-    if (inputUsernameNormalised === this.checkingUser) return;
-
-    window.clearTimeout(this.userLookupTimeout);
-    this.xhr.userLookup?.abort();
-    this.checkingUser = this.inputUser == null && inputUsernameNormalised !== '' ? inputUsernameNormalised : null;
-
-    if (this.checkingUser != null) {
-      this.userLookupTimeout = window.setTimeout(this.userLookup, 500);
+  private readonly handleUsernameInputValueChanged = (value: string) => {
+    // field should not be flagged as error on the first lookup.
+    // reset showError if input is cleared.
+    if (value === '') {
+      this.showError = false;
     }
-  };
 
-  private readonly handleUsernameInputKeyup = (e: React.KeyboardEvent<HTMLInputElement>) => {
-    if (e.key === 'Enter') this.handleSaveClick();
+    this.inputUsername = value;
   };
 
-  private renderAvatar() {
-    if (this.checkingUser != null) {
-      return <Spinner />;
-    }
-
-    const user = this.editing
-      ? (this.inputUser ?? { avatar_url: transparentGif })
-      : this.props.user;
-
-    const avatar = <UserAvatar modifiers='full-circle' user={user} />;
-
-    return this.editing
-      ? avatar
-      : <UserLink className='beatmap-owner-editor__avatar' user={this.props.user}>{avatar}</UserLink>;
-  }
+  @action
+  private readonly handleValidUsersChanged = (value: Map<number, UserJson>) => {
+    this.validUsers = value;
+    this.showError = this.inputUsername !== '';
+  };
 
   private renderButtons() {
     if (this.updatingOwner) {
···
     const reset = (
       <button
         className='beatmap-owner-editor__button'
-        disabled={this.props.beatmap.user_id === this.props.beatmapsetUser.id}
+        disabled={!hasGuestOwners(this.props.beatmap, this.props.beatmapset)}
         onClick={this.handleResetClick}
       >
         <span className='fas fa-fw fa-undo' />
···
 
     return (
       <>
-        <button className='beatmap-owner-editor__button' disabled={this.inputUser == null} onClick={this.handleSaveClick}>
+        <button className='beatmap-owner-editor__button' disabled={!this.canSave} onClick={this.handleSaveClick}>
           <span className='fas fa-fw fa-check' />
         </button>
 
···
     );
   }
 
-  private renderUsername() {
-    if (!this.editing) {
-      return (
-        <UserLink
-          className='beatmap-owner-editor__input beatmap-owner-editor__input--static'
-          user={this.props.user}
-        />
-      );
-    }
+  private readonly renderOwner = (owner: UserJson, onRemoveClick: (user: UserJson) => void) => (
+    <BeatmapOwner key={owner.id} editing={this.editing} onRemoveUser={onRemoveClick} user={owner} />
+  );
 
+  private renderUsernames() {
     return (
-      <input
-        ref={this.inputRef}
-        className={classWithModifiers('beatmap-owner-editor__input', {
-          error: this.inputUser == null,
-        })}
-        disabled={this.updatingOwner}
-        onChange={this.handleUsernameInput}
-        onKeyUp={this.handleUsernameInputKeyup}
-        value={this.inputUsername}
-      />
+      <InputContainer
+        hasError={!this.canSave}
+        modifiers='beatmap-owner-editor'
+        showError={this.showError}
+      >
+        <div className={classWithModifiers('beatmap-owner-editor-owners', { editing: this.editing })}>
+          {this.editing ? (
+            <UsernameInput
+              initialUsers={this.owners}
+              // initialValue not set for owner editor as value is reset when cancelled.
+              modifiers='beatmap-owner-editor'
+              onEnterPressed={this.handleSaveClick}
+              onValidUsersChanged={this.handleValidUsersChanged}
+              onValueChanged={this.handleUsernameInputValueChanged}
+              renderUser={this.renderOwner}
+            />
+          ) : (
+            this.owners.map((owner) => <BeatmapOwner key={owner.id} editing={this.editing} user={owner} />)
+          )}
+        </div>
+      </InputContainer>
     );
   }
 
   @action
-  private readonly updateOwner = (userId: number) => {
-    this.xhr.updateOwner?.abort();
+  private updateOwners(userIds: number[]) {
+    this.updateOwnerXhr?.abort();
 
-    if (this.props.beatmap.user_id === userId) {
+    if (xor([...this.validUsers.keys()], this.owners.map((owner) => owner.id)).length === 0) {
       this.editing = false;
-
       return;
     }
 
     this.updatingOwner = true;
 
-    this.xhr.updateOwner = $.ajax(route('beatmaps.update-owner', { beatmap: this.props.beatmap.id }), {
-      data: { beatmap: { user_id: userId } },
-      method: 'PUT',
+    this.updateOwnerXhr = $.ajax(route('beatmaps.update-owner', { beatmap: this.props.beatmap.id }), {
+      data: { user_ids: userIds },
+      method: 'POST',
     });
-    this.xhr.updateOwner.done((beatmapset) => runInAction(() => {
-      this.props.discussionsState.update({ beatmapset });
-      this.editing = false;
-    })).fail(onErrorWithCallback(() => {
-      this.updateOwner(userId);
-    })).always(action(() => {
-      this.updatingOwner = false;
-    }));
-  };
-
-  private readonly userLookup = () => {
-    const currentCheckingUser = this.checkingUser;
-
-    if (currentCheckingUser == null) return;
-
-    this.xhr.userLookup = apiLookupUsers([currentCheckingUser]);
-    this.xhr.userLookup.done((response) => runInAction(() => {
-      if (response.users.length > 0) {
-        this.props.userByName.set(currentCheckingUser, response.users[0]);
-      }
-    })).fail(
-      onErrorWithCallback(this.userLookup),
-    ).always(action(() => {
-      this.checkingUser = null;
-    }));
-  };
+    this.updateOwnerXhr
+      .done((beatmapset) => runInAction(() => {
+        this.props.discussionsState.update({ beatmapset });
+        this.editing = false;
+      }))
+      .fail(onError)
+      .always(action(() => {
+        this.updatingOwner = false;
+      }));
+  }
 }

resources/js/beatmap-discussions/beatmap-owner.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 UserAvatar from 'components/user-avatar';
+import UserLink from 'components/user-link';
+import UserJson from 'interfaces/user-json';
+import * as React from 'react';
+import { classWithModifiers } from 'utils/css';
+
+interface Props {
+  editing: boolean;
+  onRemoveUser?: (user: UserJson) => void;
+  user: UserJson;
+}
+
+function createRemoveOwnerHandler(user: UserJson, onRemoveClick?: NonNullable<Props['onRemoveUser']>) {
+  return (event: React.MouseEvent<HTMLButtonElement>) => {
+    event.preventDefault();
+    onRemoveClick?.(user);
+  };
+}
+
+export default class BeatmapOwner extends React.PureComponent<Props> {
+  render() {
+    return (
+      <div className='beatmap-owner'>
+        <UserLink className='beatmap-owner__user' tooltipPosition='top right' user={this.props.user}>
+          <div className='beatmap-owner__avatar'>
+            <UserAvatar modifiers='full-circle' user={this.props.user} />
+          </div>
+          <div className='u-ellipsis-overflow'>
+            {this.props.user.username}
+          </div>
+        </UserLink>
+
+        <button
+          className={classWithModifiers('beatmap-owner__remove', { editing: this.props.editing })}
+          onClick={createRemoveOwnerHandler(this.props.user, this.props.onRemoveUser)}
+        >
+          <span className='fas fa-times' />
+        </button>
+
+      </div>
+    );
+  }
+}

resources/js/beatmap-discussions/beatmaps-owner-editor.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 BeatmapsetExtendedJson from 'interfaces/beatmapset-extended-json';
+import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import UserJson from 'interfaces/user-json';
-import { makeObservable, observable } from 'mobx';
+import { action, makeObservable } from 'mobx';
 import { observer } from 'mobx-react';
-import { deletedUserJson, normaliseUsername } from 'models/user';
 import * as React from 'react';
 import { group as groupBeatmaps } from 'utils/beatmap-helper';
 import { trans } from 'utils/lang';
···
 import DiscussionsState from './discussions-state';
 
 interface Props {
-  beatmapset: BeatmapsetExtendedJson;
+  beatmapset: BeatmapsetWithDiscussionsJson;
   discussionsState: DiscussionsState;
   onClose: () => void;
   users: Map<number | null | undefined, UserJson>;
···
 
 @observer
 export default class BeatmapsOwnerEditor extends React.Component<Props> {
-  @observable userByName = new Map<string, UserJson>();
+  private readonly editorRefs: Partial<Record<number, React.RefObject<BeatmapOwnerEditor>>> = {};
 
   constructor(props: Props) {
     super(props);
 
-    // this will be outdated on new props but it's fine
-    // as there's separate process handling unknown users
-    for (const user of this.props.users.values()) {
-      if (user != null) {
-        this.userByName.set(normaliseUsername(user.username), user);
+    for (const beatmap of this.props.beatmapset.beatmaps) {
+      if (beatmap.deleted_at == null) {
+        this.editorRefs[beatmap.id] = React.createRef<BeatmapOwnerEditor>();
       }
     }
 
     makeObservable(this);
   }
 
+  componentDidMount() {
+    document.addEventListener('turbo:before-visit', this.handleBeforeVisit);
+  }
+
+  componentWillUnmount() {
+    document.removeEventListener('turbo:before-visit', this.handleBeforeVisit);
+  }
+
   render() {
-    const beatmapsetUser = this.getUser(this.props.beatmapset.user_id);
     const groupedBeatmaps = [...groupBeatmaps((this.props.beatmapset.beatmaps ?? []).filter(
       (beatmap) => beatmap.deleted_at == null,
     ))];
···
           <strong>
             {trans('beatmap_discussions.owner_editor.version')}
           </strong>
-          <div />
           <strong>
             {trans('beatmap_discussions.owner_editor.user')}
           </strong>
···
             beatmaps.map((beatmap) => (
               <BeatmapOwnerEditor
                 key={beatmap.id}
+                ref={this.editorRefs[beatmap.id]}
                 beatmap={beatmap}
-                beatmapsetUser={beatmapsetUser}
+                beatmapset={this.props.beatmapset}
                 discussionsState={this.props.discussionsState}
-                user={this.getUser(beatmap.user_id)}
-                userByName={this.userByName}
               />
             ))
           ))}
···
         <div className='beatmaps-owner-editor__row beatmaps-owner-editor__row--footer'>
           <button
             className='btn-osu-big btn-osu-big--rounded-thin'
-            onClick={this.props.onClose}
+            onClick={this.handleCloseClick}
             type='button'
           >
             {trans('common.buttons.close')}
···
     );
   }
 
-  private getUser(userId: number) {
-    return this.props.users.get(userId) ?? deletedUserJson;
+  @action
+  private readonly handleBeforeVisit = (event: Event) => {
+    if (this.shouldCancelNavigation()) {
+      event.preventDefault();
+    }
+  };
+
+  private readonly handleCloseClick = () => {
+    if (this.shouldCancelNavigation()) return;
+    this.props.onClose();
+  };
+
+  private shouldCancelNavigation() {
+    return Object.values(this.editorRefs).some((ref) => ref?.current?.editing)
+      && !confirm(trans('common.confirmation_unsaved'));
   }
 }

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 BeatmapJson from 'interfaces/beatmap-json';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
 import { BeatmapsetStatus } from 'interfaces/beatmapset-json';
 import BeatmapsetWithDiscussionsJson from 'interfaces/beatmapset-with-discussions-json';
 import Ruleset from 'interfaces/ruleset';
 import UserJson from 'interfaces/user-json';
+import WithBeatmapOwners from 'interfaces/with-beatmap-owners';
 import { intersectionWith, maxBy, sum } from 'lodash';
 import { action, computed, makeObservable, observable } from 'mobx';
+import { deletedUserJson } from 'models/user';
 import core from 'osu-core-singleton';
 import BeatmapsetDiscussionsShowStore from 'stores/beatmapset-discussions-show-store';
 import { findDefault, group, sortWithMode } from 'utils/beatmap-helper';
···
 
 const defaultFilterPraise = new Set<BeatmapsetStatus>(['approved', 'ranked']);
 const jsonId = 'json-discussions-state';
+
+function deletedUser(userId: number) {
+  const user: UserJson = structuredClone(deletedUserJson) as UserJson; // structuredClone copies the Readonly type but is actually mutable.
+  user.id = userId;
+
+  return user;
+}
 
 export interface UpdateOptions {
   beatmap_discussion_post_ids: number[];
···
     }
 
     makeObservable(this);
+  }
+
+  beatmapOwners(beatmap: WithBeatmapOwners<BeatmapJson>) {
+    return beatmap.owners.map((user) => this.store.users.get(user.id) ?? deletedUser(user.id));
   }
 
   @action

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

···
       menuOptions.push({
         icon: <BeatmapIcon beatmap={beatmap} />,
         id: beatmap.id.toString(),
-        label: <BeatmapListItem beatmap={beatmap} mapper={null} modifiers={listItemModifier} />,
+        label: <BeatmapListItem beatmap={beatmap} modifiers={listItemModifier} showOwners={false} />,
         renderIcon: false,
       });
     });

resources/js/beatmap-discussions/header.tsx

···
 import HeaderV4 from 'components/header-v4';
 import PlaymodeTabs from 'components/playmode-tabs';
 import StringWithComponent from 'components/string-with-component';
-import UserLink from 'components/user-link';
 import BeatmapsetDiscussionsStore from 'interfaces/beatmapset-discussions-store';
 import Ruleset, { rulesets } from 'interfaces/ruleset';
 import { route } from 'laroute';
 import { action, computed, makeObservable } from 'mobx';
 import { observer } from 'mobx-react';
-import { deletedUserJson } from 'models/user';
 import * as React from 'react';
+import { hasGuestOwners } from 'utils/beatmap-helper';
 import { getArtist, getTitle } from 'utils/beatmapset-helper';
 import { trans, transChoice } from 'utils/lang';
 import BeatmapList from './beatmap-list';
···
 import { Subscribe } from './subscribe';
 import TypeFilters from './type-filters';
 import { UserFilter } from './user-filter';
+import UserLinkList from './user-link-list';
 
 interface Props {
   discussionsState: DiscussionsState;
···
             />
             <div className={`${bn}__beatmap-stats`}>
               <div className={`${bn}__guest`}>
-                {this.currentBeatmap.user_id !== this.beatmapset.user_id && (
+                {hasGuestOwners(this.currentBeatmap, this.beatmapset) && (
                   <span>
                     <StringWithComponent
                       mappings={{
-                        user: <UserLink user={this.users.get(this.currentBeatmap.user_id) ?? deletedUserJson} />,
+                        user: <UserLinkList users={this.currentBeatmap.owners ?? []} />,
                       }}
                       pattern={trans('beatmaps.discussions.guest')}
                     />

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

···
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { onError } from 'utils/ajax';
+import { isOwner } from 'utils/beatmap-helper';
 import { canModeratePosts, formatTimestamp, makeUrl, NearbyDiscussion, nearbyDiscussions, parseTimestamp, validMessageLength } from 'utils/beatmapset-discussion-helper';
 import { downloadLimited } from 'utils/beatmapset-helper';
 import { classWithModifiers } from 'utils/css';
···
 
     const canPostNote = core.currentUser != null
         && (core.currentUser.id === this.beatmapset.user_id
-          || (core.currentUser.id === this.currentBeatmap.user_id && ['general', 'timeline'].includes(this.currentMode))
+          || (isOwner(core.currentUser.id, this.currentBeatmap) && ['general', 'timeline'].includes(this.currentMode))
           || core.currentUser.is_bng
           || canModeratePosts());
 

resources/js/beatmap-discussions/nominator.tsx

···
 import core from 'osu-core-singleton';
 import * as React from 'react';
 import { onError } from 'utils/ajax';
+import { isOwner } from 'utils/beatmap-helper';
 import { isUserFullNominator } from 'utils/beatmapset-discussion-helper';
 import { classWithModifiers } from 'utils/css';
 import { trans } from 'utils/lang';
···
     const userId = core.currentUserOrFail.id;
 
     return userId === this.beatmapset.user_id
-      || this.beatmapset.beatmaps.some((beatmap) => beatmap.deleted_at == null && userId === beatmap.user_id);
+      || this.beatmapset.beatmaps.some((beatmap) => beatmap.deleted_at == null && isOwner(userId, beatmap));
   }
 
   private get userNominatableModes() {

resources/js/beatmap-discussions/user-link-list.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 UserLink from 'components/user-link';
+import UserJson from 'interfaces/user-json';
+import React from 'react';
+import { joinComponents } from 'utils/lang';
+
+interface Props {
+  users: Pick<UserJson, 'id' | 'username'>[];
+}
+
+export default class UserLinkList extends React.PureComponent<Props> {
+  render() {
+    return joinComponents(this.props.users.map((user) => <UserLink key={user.id} user={user} />));
+  }
+}

resources/js/beatmapset-panel/beatmaps-popup.tsx

···
     className='beatmaps-popup-item'
     href={route('beatmaps.show', { beatmap: beatmap.id })}
   >
-    <BeatmapListItem beatmap={beatmap} mapper={null} />
+    <BeatmapListItem beatmap={beatmap} showOwners={false} />
   </a>
 ));
 

resources/js/beatmapsets-show/controller.ts

···
 import UserJson from 'interfaces/user-json';
 import { keyBy } from 'lodash';
 import { action, computed, makeObservable, observable, runInAction } from 'mobx';
-import { deletedUser } from 'models/user';
+import { deletedUserJson } from 'models/user';
 import core from 'osu-core-singleton';
 import { find, findDefault, group } from 'utils/beatmap-helper';
 import { parse } from 'utils/beatmapset-page-hash';
···
     $(document).off('turbo:before-cache', this.saveState);
   }
 
-  mapper(beatmap: BeatmapJsonForBeatmapsetShow) {
-    return this.usersById[beatmap.user_id] ?? deletedUser;
+  owners(beatmap: BeatmapJsonForBeatmapsetShow) {
+    return beatmap.owners.map((mapper) => this.usersById[mapper.id] ?? deletedUserJson);
   }
 
   @action

resources/js/beatmapsets-show/header.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 UserLinkList from 'beatmap-discussions/user-link-list';
 import BeatmapsetBadge from 'components/beatmapset-badge';
 import BeatmapsetCover from 'components/beatmapset-cover';
 import BeatmapsetMapping from 'components/beatmapset-mapping';
 import BigButton from 'components/big-button';
 import StringWithComponent from 'components/string-with-component';
-import UserLink from 'components/user-link';
 import { createTooltip } from 'components/user-list-popup';
 import { route } from 'laroute';
 import { action, computed, makeObservable } from 'mobx';
 import { observer } from 'mobx-react';
 import core from 'osu-core-singleton';
 import * as React from 'react';
+import { hasGuestOwners } from 'utils/beatmap-helper';
 import { downloadLimited, getArtist, getTitle, toggleFavourite } from 'utils/beatmapset-helper';
 import { classWithModifiers } from 'utils/css';
 import { formatNumber } from 'utils/html';
···
       <span className='beatmapset-header__diff-name'>
         {beatmap.version}
 
-        {beatmap.user_id !== this.controller.beatmapset.user_id && (
+        {hasGuestOwners(beatmap, this.controller.beatmapset) && (
           <span className='beatmapset-header__diff-extra'>
             <StringWithComponent
               mappings={{
-                mapper: <UserLink user={this.controller.mapper(beatmap)} />,
+                mapper: <UserLinkList users={this.controller.owners(beatmap)} />,
               }}
               pattern={trans('beatmapsets.show.details.mapped_by')}
             />

resources/js/components/beatmap-list-item.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 UserLinkList from 'beatmap-discussions/user-link-list';
 import DifficultyBadge from 'components/difficulty-badge';
-import UserLink from 'components/user-link';
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
 import BeatmapJson from 'interfaces/beatmap-json';
 import BeatmapsetJson from 'interfaces/beatmapset-json';
-import UserJson from 'interfaces/user-json';
+import { hasOwners } from 'interfaces/with-beatmap-owners';
 import * as React from 'react';
+import { hasGuestOwners } from 'utils/beatmap-helper';
 import { classWithModifiers, Modifiers } from 'utils/css';
 import { trans } from 'utils/lang';
 import StringWithComponent from './string-with-component';
···
 
 type MapperProps = {
   beatmapset: BeatmapsetJson;
-  mapper: Pick<UserJson, 'id' | 'username'>;
-  showNonGuestMapper: boolean;
+  showNonGuestOwner: boolean;
+  showOwners: true;
 } | {
-  mapper: null;
+  showOwners: false;
 };
 
 type Props = BaseProps & MapperProps;
···
               : version}
             {' '}
             <span className='beatmap-list-item__mapper'>
-              {this.renderMapper()}
+              {this.renderOwners()}
             </span>
           </div>
         </div>
···
     );
   }
 
-  private renderMapper() {
-    if (this.props.mapper == null) {
+  private renderOwners() {
+    if (!this.props.showOwners) return null;
+
+    const owners = this.props.beatmap.owners;
+    if (owners == null || owners.length === 0) {
       return null;
     }
 
-    const isGuestMap = this.props.beatmapset.user_id !== this.props.beatmap.user_id;
+    const userId = this.props.beatmapset.user_id;
+    const visibleOwners = this.props.showNonGuestOwner
+      ? owners
+      : owners.filter((mapper) => mapper.id !== userId);
 
-    if (!isGuestMap && !this.props.showNonGuestMapper) {
+    if (visibleOwners.length === 0) {
       return null;
     }
 
-    const translationKey = isGuestMap
+    const translationKey = hasOwners(this.props.beatmap) && hasGuestOwners(this.props.beatmap, this.props.beatmapset)
       ? 'mapped_by_guest'
       : 'mapped_by';
-
-    const mapper = isGuestMap
-      ? this.props.mapper
-      : { id: this.props.beatmapset.user_id, username: this.props.beatmapset.creator };
 
     return (
       <StringWithComponent
-        mappings={{
-          mapper: <UserLink user={mapper} />,
-        }}
+        mappings={{ mapper: <UserLinkList users={visibleOwners} /> }}
         pattern={trans(`beatmapsets.show.details.${translationKey}`)}
       />
     );

resources/js/components/beatmapset-event.tsx

···
 // See the LICENCE file in the repository root for full licence text.
 
 import PlainTextPreview from 'beatmap-discussions/plain-text-preview';
+import UserLinkList from 'beatmap-discussions/user-link-list';
 import BeatmapsetCover from 'components/beatmapset-cover';
 import TimeWithTooltip from 'components/time-with-tooltip';
 import BeatmapsetDiscussionJson from 'interfaces/beatmapset-discussion-json';
···
       }
       case 'beatmap_owner_change': {
         const data = this.props.event.comment;
-        params.new_user = <a href={route('users.show', { user: data.new_user_id })}>{data.new_user_username}</a>;
+        const users = data.new_users ?? [{ id: data.new_user_id, username: data.new_user_username }];
+
         params.beatmap = <a href={route('beatmaps.show', { beatmap: data.beatmap_id })}>{data.beatmap_version}</a>;
+        params.new_user = <UserLinkList users={users} />;
         break;
       }
       case 'nomination_reset_received': {

resources/js/components/username-input.tsx

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 // See the LICENCE file in the repository root for full licence text.
 
-import UserJson, { UserJsonMinimum } from 'interfaces/user-json';
+import UserJson from 'interfaces/user-json';
 import { debounce } from 'lodash';
 import { action, makeObservable, observable, runInAction } from 'mobx';
 import { observer } from 'mobx-react';
···
   render() {
     return (
       <div className={classWithModifiers('username-input', this.props.modifiers)}>
-        {this.renderValidUsers()}
         <input
           className='username-input__input'
           id={this.props.id}
···
           onPaste={this.handleUsersInputPaste}
           value={this.input}
         />
+        {this.renderValidUsers()}
         <BusySpinner busy={this.busy} />
       </div>
     );
···
   };
 
   @action
-  private readonly handleRemoveUser = (user: UserJsonMinimum) => {
+  private readonly handleRemoveUser = (user: UserJson) => {
     this.validUsers.delete(user.id);
     this.props.onValidUsersChanged?.(this.validUsers);
   };

resources/js/interfaces/beatmap-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 BeatmapOwnerJson from './beatmap-owner-json';
 import BeatmapsetJson from './beatmapset-json';
 import Ruleset from './ruleset';
 import UserJson from './user-json';
···
   checksum: string | null;
   failtimes: BeatmapFailTimesArray;
   max_combo: number;
+  owners: BeatmapOwnerJson[];
   user: UserJson;
 }
 
···
 }
 
 type BeatmapJson = BeatmapJsonDefaultAttributes & Partial<BeatmapJsonAvailableIncludes>;
+
 export default BeatmapJson;

resources/js/interfaces/beatmap-owner-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 UserJson from './user-json';
+
+type BeatmapOwnerJson = Pick<UserJson, 'id' | 'username'>;
+
+export default BeatmapOwnerJson;

resources/js/interfaces/beatmapset-event-json.ts

···
     beatmap_version: string;
     new_user_id: number;
     new_user_username: string;
+    new_users?: {
+      id: number;
+      username: string;
+    }[];
   };
   type: 'beatmap_owner_change';
 }

resources/js/interfaces/beatmapset-extended-json.ts

···
 import BeatmapExtendedJson from './beatmap-extended-json';
 import BeatmapsetJson, { Availability } from './beatmapset-json';
 import Ruleset from './ruleset';
+import WithBeatmapOwners from './with-beatmap-owners';
 
 interface NominationsSummary {
   current: number;
···
 export default BeatmapsetExtendedJson;
 
 interface BeatmapsetJsonForShowOverrideIncludes {
-  beatmaps: (BeatmapExtendedJson & Required<Pick<BeatmapExtendedJson, 'failtimes' | 'max_combo'>>)[];
-  converts: (BeatmapExtendedJson & Required<Pick<BeatmapExtendedJson, 'failtimes'>>)[];
+  beatmaps: (WithBeatmapOwners<BeatmapExtendedJson> & Required<Pick<BeatmapExtendedJson, 'failtimes' | 'max_combo'>>)[];
+  converts: (WithBeatmapOwners<BeatmapExtendedJson> & Required<Pick<BeatmapExtendedJson, 'failtimes'>>)[];
 }
 
 type BeatmapsetJsonForShowIncludes = Required<Pick<BeatmapsetExtendedJson,

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

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

···
 // See the LICENCE file in the repository root for full licence text.
 
 import BeatmapExtendedJson from './beatmap-extended-json';
-import BeatmapJson from './beatmap-json';
 import Rank from './rank';
 import Ruleset from './ruleset';
 import { ScoreJsonAvailableIncludes, ScoreJsonDefaultIncludes } from './score-json';
 import ScoreModJson from './score-mod-json';
+import WithBeatmapOwners from './with-beatmap-owners';
 
 export type SoloScoreStatisticsAttribute =
   | 'good'
···
 export type SoloScoreJsonForShow = SoloScoreJson
 & Required<Pick<SoloScoreJson, 'beatmapset' | 'best_id' | 'rank_global' | 'user'>>
 & {
-  beatmap: BeatmapExtendedJson & Required<Pick<BeatmapJson, 'user'>>;
+  beatmap: WithBeatmapOwners<BeatmapExtendedJson>;
 };
 
 export type SoloScoreJsonForUser = SoloScoreJson & Required<Pick<SoloScoreJson, 'beatmap' | 'beatmapset'>>;

resources/js/interfaces/user-json.ts

···
 
 // FIXME: Using Partial isn't quite correct as the keys are there but the values are null.
 export type UserJsonDeleted = Partial<UserJson> & { username: string };
-export type UserJsonMinimum = Pick<UserJson, 'avatar_url' | 'id' | 'username'>;

resources/js/interfaces/with-beatmap-owners.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 BeatmapJson from './beatmap-json';
+
+type WithBeatmapOwners<T extends BeatmapJson> = T & Required<Pick<T, 'owners'>>;
+
+export function hasOwners<T extends BeatmapJson>(beatmap: T): beatmap is WithBeatmapOwners<T> {
+  return beatmap.owners != null;
+}
+
+export default WithBeatmapOwners;

resources/js/scores-show/beatmap-info.tsx

···
 
 import BeatmapListItem from 'components/beatmap-list-item';
 import BeatmapExtendedJson from 'interfaces/beatmap-extended-json';
-import BeatmapJson from 'interfaces/beatmap-json';
 import BeatmapsetJson from 'interfaces/beatmapset-json';
+import WithBeatmapOwners from 'interfaces/with-beatmap-owners';
 import { route } from 'laroute';
 import * as React from 'react';
 import { getArtist, getTitle } from 'utils/beatmapset-helper';
 import { trans } from 'utils/lang';
 
 interface Props {
-  beatmap: BeatmapExtendedJson & Required<Pick<BeatmapJson, 'user'>>;
+  beatmap: WithBeatmapOwners<BeatmapExtendedJson>;
   beatmapset: BeatmapsetJson;
 }
 
···
             beatmapUrl={beatmapUrl}
             beatmapset={beatmapset}
             inline
-            mapper={beatmap.user}
             modifiers='score'
-            showNonGuestMapper
+            showNonGuestOwner
+            showOwners
           />
         </span>
       </div>

resources/js/utils/beatmap-helper.ts

···
 import * as d3 from 'd3';
 import { isValid as isBeatmapExtendedJson } from 'interfaces/beatmap-extended-json';
 import BeatmapJson from 'interfaces/beatmap-json';
+import BeatmapsetJson from 'interfaces/beatmapset-json';
 import Ruleset, { rulesets } from 'interfaces/ruleset';
+import WithBeatmapOwners from 'interfaces/with-beatmap-owners';
 import * as _ from 'lodash';
 import core from 'osu-core-singleton';
 import { parseJsonNullable } from 'utils/json';
···
   });
 
   return ret;
+}
+
+export function hasGuestOwners(beatmap: WithBeatmapOwners<BeatmapJson>, beatmapset: BeatmapsetJson) {
+  return beatmap.owners.some((owner) => owner.id !== beatmapset.user_id);
+}
+
+export function isOwner(userId: number, beatmap: WithBeatmapOwners<BeatmapJson>) {
+  return beatmap.owners.some((owner) => owner.id === userId);
 }
 
 export function rulesetName(id: number): Ruleset {

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

···
 import BeatmapsetJson from 'interfaces/beatmapset-json';
 import Ruleset, { rulesets } from 'interfaces/ruleset';
 import UserJson from 'interfaces/user-json';
+import WithBeatmapOwners from 'interfaces/with-beatmap-owners';
 import { route } from 'laroute';
 import { assign, padStart, sortBy } from 'lodash';
 import * as moment from 'moment';
 import core from 'osu-core-singleton';
 import { currentUrl } from 'utils/turbolinks';
 import { linkHtml, openBeatmapEditor } from 'utils/url';
+import { isOwner } from './beatmap-helper';
 import { getInt } from './math';
 
 interface BadgeGroupParams {
   beatmapset?: BeatmapsetJson;
-  currentBeatmap?: BeatmapJson | null;
+  currentBeatmap?: WithBeatmapOwners<BeatmapJson> | null;
   discussion: BeatmapsetDiscussionJson;
   user?: UserJson;
 }
···
     return mapperGroup;
   }
 
-  if (currentBeatmap != null && discussion.beatmap_id === currentBeatmap.id && user.id === currentBeatmap.user_id) {
+  if (currentBeatmap != null && discussion.beatmap_id === currentBeatmap.id && isOwner(user.id, currentBeatmap)) {
     return guestGroup;
   }
 

resources/lang/en/beatmaps.php

···
 // See the LICENCE file in the repository root for full licence text.
 
 return [
+    'change_owner' => [
+        'too_many' => 'Too many guest mappers.',
+    ],
+
     'discussion-votes' => [
         'update' => [
             'error' => 'Failed updating vote',

resources/lang/en/multiplayer.php

···
 
         'errors' => [
             'duration_too_long' => 'Duration is too long.',
+            'name_too_long' => 'Room name is too long.',
         ],
 
         'status' => [

resources/views/teams/show.blade.php

···
                                 <div class="team-info-entry">
                                     <div class="team-info-entry__title">{{ osu_trans('teams.show.info.created') }}</div>
                                     <div class="team-info-entry__value">
-                                        {{ i18n_date($team->created_at, null, 'year_month') }}
+                                        {{ i18n_date($team->created_at, pattern: 'year_month') }}
                                     </div>
                                 </div>
                                 @if (present($team->url))

routes/web.php

···
         Route::group(['as' => 'beatmaps.', 'prefix' => '{beatmap}'], function () {
             Route::get('scores', 'BeatmapsController@scores')->name('scores');
             Route::get('solo-scores', 'BeatmapsController@soloScores')->name('solo-scores');
-            Route::put('update-owner', 'BeatmapsController@updateOwner')->name('update-owner');
+            Route::post('update-owner', 'BeatmapsController@updateOwner')->name('update-owner');
         });
     });
 
···
             Route::get('{rulesetOrScore}/{score}/download', 'ScoresController@download')->middleware(ThrottleRequests::getApiThrottle('scores_download'))->name('download-legacy');
 
             Route::get('{rulesetOrScore}/{score?}', 'ScoresController@show')->name('show');
+
+            Route::get('/', 'ScoresController@index');
         });
 
         // Beatmapsets

tests/Controllers/BeatmapsControllerTest.php

···
 
 use App\Models\Beatmap;
 use App\Models\Beatmapset;
-use App\Models\BeatmapsetEvent;
 use App\Models\User;
 use Illuminate\Testing\Fluent\AssertableJson;
 use Tests\TestCase;
···
             ->get(route('api.beatmaps.show', ['beatmap' => $beatmap->getKey()]))
             ->assertSuccessful()
             ->assertJsonPath('id', $beatmap->getKey());
-    }
-
-    public function testUpdateOwner(): void
-    {
-        $otherUser = User::factory()->create();
-        $beatmapset = Beatmapset::factory()->create([
-            'approved' => Beatmapset::STATES['pending'],
-            'user_id' => $this->user,
-        ]);
-        $this->beatmap->update([
-            'beatmapset_id' => $beatmapset->getKey(),
-            'user_id' => $this->user->getKey(),
-        ]);
-
-        $beatmapsetEventCount = BeatmapsetEvent::count();
-
-        $this->actingAsVerified($this->user)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $otherUser->getKey()],
-            ])->assertSuccessful();
-
-        $this->assertSame($otherUser->getKey(), $this->beatmap->fresh()->user_id);
-        $this->assertSame($beatmapsetEventCount + 1, BeatmapsetEvent::count());
-    }
-
-    public function testUpdateOwnerInvalidState(): void
-    {
-        $otherUser = User::factory()->create();
-        $beatmapset = Beatmapset::factory()->create([
-            'approved' => Beatmapset::STATES['qualified'],
-            'user_id' => $this->user,
-        ]);
-        $this->beatmap->update([
-            'beatmapset_id' => $beatmapset->getKey(),
-            'user_id' => $this->user->getKey(),
-        ]);
-
-        $beatmapsetEventCount = BeatmapsetEvent::count();
-
-        $this->actingAsVerified($this->user)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $otherUser->getKey()],
-            ])->assertStatus(403);
-
-        $this->assertSame($this->user->getKey(), $this->beatmap->fresh()->user_id);
-        $this->assertSame($beatmapsetEventCount, BeatmapsetEvent::count());
-    }
-
-    public function testUpdateOwnerInvalidUser(): void
-    {
-        $beatmapset = Beatmapset::factory()->create([
-            'approved' => Beatmapset::STATES['pending'],
-            'user_id' => $this->user,
-        ]);
-        $this->beatmap->update([
-            'beatmapset_id' => $beatmapset->getKey(),
-            'user_id' => $this->user->getKey(),
-        ]);
-
-        $beatmapsetEventCount = BeatmapsetEvent::count();
-
-        $this->actingAsVerified($this->user)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => User::max('user_id') + 1],
-            ])->assertStatus(422);
-
-        $this->assertSame($this->user->getKey(), $this->beatmap->fresh()->user_id);
-        $this->assertSame($beatmapsetEventCount, BeatmapsetEvent::count());
-    }
-
-    /**
-     * @dataProvider dataProviderForTestUpdateOwnerLoved
-     */
-    public function testUpdateOwnerLoved(int $approved, bool $ok): void
-    {
-        $moderator = User::factory()->withGroup('loved')->create();
-        $this->beatmap->beatmapset->update([
-            'approved' => $approved,
-            'approved_date' => now(),
-        ]);
-
-        $this->expectCountChange(fn () => BeatmapsetEvent::count(), $ok ? 1 : 0);
-        $expectedOwner = $ok ? $this->user->getKey() : $this->beatmap->fresh()->user_id;
-
-        $this->actingAsVerified($moderator)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $this->user->getKey()],
-            ])->assertStatus($ok ? 200 : 403);
-
-        $this->assertSame($expectedOwner, $this->beatmap->fresh()->user_id);
-    }
-
-    public function testUpdateOwnerModerator(): void
-    {
-        $moderator = User::factory()->withGroup('nat')->create();
-        $this->beatmap->beatmapset->update([
-            'approved' => Beatmapset::STATES['ranked'],
-            'approved_date' => now(),
-        ]);
-
-        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 1);
-
-        $this->actingAsVerified($moderator)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $this->user->getKey()],
-            ])->assertSuccessful();
-
-        $this->assertSame($this->user->getKey(), $this->beatmap->fresh()->user_id);
-    }
-
-    public function testUpdateOwnerNotOwner(): void
-    {
-        $otherUser = User::factory()->create();
-        $beatmapset = Beatmapset::factory()->create(['user_id' => $this->user]);
-        $this->beatmap->update([
-            'beatmapset_id' => $beatmapset->getKey(),
-            'user_id' => $this->user->getKey(),
-        ]);
-
-        $beatmapsetEventCount = BeatmapsetEvent::count();
-
-        $this->actingAsVerified($otherUser)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $otherUser->getKey()],
-            ])->assertStatus(403);
-
-        $this->assertSame($this->user->getKey(), $this->beatmap->fresh()->user_id);
-        $this->assertSame($beatmapsetEventCount, BeatmapsetEvent::count());
-    }
-
-    public function testUpdateOwnerSameOwner(): void
-    {
-        $beatmapset = Beatmapset::factory()->create([
-            'approved' => Beatmapset::STATES['pending'],
-            'user_id' => $this->user,
-        ]);
-        $this->beatmap->update([
-            'beatmapset_id' => $beatmapset->getKey(),
-            'user_id' => $this->user->getKey(),
-        ]);
-
-        $beatmapsetEventCount = BeatmapsetEvent::count();
-
-        $this->actingAsVerified($this->user)
-            ->json('PUT', route('beatmaps.update-owner', $this->beatmap), [
-                'beatmap' => ['user_id' => $this->user->getKey()],
-            ])->assertStatus(422);
-
-        $this->assertSame($this->user->getKey(), $this->beatmap->fresh()->user_id);
-        $this->assertSame($beatmapsetEventCount, BeatmapsetEvent::count());
     }
 
     public static function dataProviderForTestLookupForApi(): array

tests/Libraries/Beatmapset/ChangeBeatmapOwnersTest.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 Tests\Libraries\Beatmapset;
+
+use App\Exceptions\AuthorizationException;
+use App\Exceptions\InvariantException;
+use App\Jobs\Notifications\BeatmapOwnerChange;
+use App\Libraries\Beatmapset\ChangeBeatmapOwners;
+use App\Models\Beatmap;
+use App\Models\BeatmapOwner;
+use App\Models\Beatmapset;
+use App\Models\BeatmapsetEvent;
+use App\Models\DeletedUser;
+use App\Models\User;
+use Arr;
+use Bus;
+use Tests\TestCase;
+
+class ChangeBeatmapOwnersTest extends TestCase
+{
+    public static function dataProviderForUpdateOwner(): array
+    {
+        return [
+            'existing restricted user' => [['restricted', 'default'], true],
+            'new restricted user' => [['default', 'restricted'], false],
+            'new user' => [['default', 'default'], true],
+        ];
+    }
+
+    public static function dataProviderForUpdateOwnerLoved(): array
+    {
+        return [
+            [Beatmapset::STATES['graveyard'], true],
+            [Beatmapset::STATES['loved'], true],
+            [Beatmapset::STATES['ranked'], false],
+            [Beatmapset::STATES['wip'], false],
+        ];
+    }
+
+    public function testMissingUser(): void
+    {
+        $moderator = User::factory()->withGroup('nat')->create();
+        $otherUser = User::factory()->create();
+        $missingUserId = User::max('user_id') + 1;
+        $userIds = [$missingUserId, $otherUser->getKey()];
+
+        $beatmap = Beatmap::factory()
+            ->state(['user_id' => $missingUserId])
+            ->has(BeatmapOwner::factory()->state(['user_id' => $missingUserId]))
+            ->for(Beatmapset::factory()->pending()->state(['user_id' => $missingUserId]))
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 1);
+
+        (new ChangeBeatmapOwners($beatmap, $userIds, $moderator))->handle();
+
+        $beatmap = $beatmap->fresh();
+        $newOwners = $beatmap->getOwners();
+        $this->assertEqualsCanonicalizing($userIds, $newOwners->pluck('user_id')->toArray());
+        $this->assertTrue($newOwners->find($missingUserId) instanceof DeletedUser);
+        $this->assertSame($userIds[0], $beatmap->user_id);
+
+        Bus::assertDispatched(BeatmapOwnerChange::class);
+    }
+
+    /**
+     * @dataProvider dataProviderForUpdateOwner
+     */
+    public function testUpdateOwner(array $states, bool $success): void
+    {
+        $factory = User::factory();
+        $moderator = $factory->withGroup('nat')->create();
+        $users = array_map(fn ($state) => $factory->$state()->create(), $states);
+        $owner = $users[0];
+
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->pending()->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), $success ? 1 : 0);
+
+        $this->expectExceptionCallable(
+            fn () => (new ChangeBeatmapOwners($beatmap, Arr::pluck($users, 'user_id'), $moderator))->handle(),
+            $success ? null : InvariantException::class,
+        );
+
+        $beatmap = $beatmap->fresh();
+
+        if ($success) {
+            $this->assertEqualsCanonicalizing(Arr::pluck($users, 'user_id'), $beatmap->getOwners()->pluck('user_id')->toArray());
+            $this->assertSame($users[0]->getKey(), $beatmap->user_id);
+            Bus::assertDispatched(BeatmapOwnerChange::class);
+        } else {
+            $this->assertEqualsCanonicalizing([$owner->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+            Bus::assertNotDispatched(BeatmapOwnerChange::class);
+        }
+    }
+
+    public function testUpdateOwnerExistingRestrictedUser(): void
+    {
+        $source = User::factory()->withGroup('gmt')->create();
+        $owner = User::factory()->restricted()->create();
+        $users = [User::factory()->create(), $owner];
+        $ownerId = $owner->getKey();
+
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->pending()->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 1);
+
+        (new ChangeBeatmapOwners($beatmap, Arr::pluck($users, 'user_id'), $source))->handle();
+
+        $beatmap = $beatmap->fresh();
+        $newOwners = $beatmap->getOwners();
+        $this->assertCount(count($users), $newOwners);
+        $this->assertEqualsCanonicalizing(Arr::pluck($users, 'user_id'), $newOwners->pluck('user_id')->toArray());
+
+        Bus::assertDispatched(BeatmapOwnerChange::class);
+    }
+
+    public function testUpdateOwnerInvalidState(): void
+    {
+        $user = User::factory()->create();
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->qualified()->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 0);
+        $this->expectExceptionCallable(
+            fn () => (new ChangeBeatmapOwners($beatmap, [$user->getKey()], $owner))->handle(),
+            AuthorizationException::class
+        );
+
+        $beatmap = $beatmap->fresh();
+        $this->assertEqualsCanonicalizing([$owner->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($owner->getKey(), $beatmap->user_id);
+
+        Bus::assertNotDispatched(BeatmapOwnerChange::class);
+    }
+
+    public function testUpdateOwnerInvalidUser(): void
+    {
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->pending()->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 0);
+        $this->expectExceptionCallable(
+            fn () => (new ChangeBeatmapOwners($beatmap, [User::max('user_id') + 1], $owner))->handle(),
+            InvariantException::class
+        );
+
+        $beatmap = $beatmap->fresh();
+        $this->assertEqualsCanonicalizing([$owner->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($owner->getKey(), $beatmap->user_id);
+
+        Bus::assertNotDispatched(BeatmapOwnerChange::class);
+    }
+
+    /**
+     * @dataProvider dataProviderForUpdateOwnerLoved
+     */
+    public function testUpdateOwnerLoved(int $approved, bool $ok): void
+    {
+        $moderator = User::factory()->withGroup('loved')->create();
+        $user = User::factory()->create();
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->state([
+                'approved' => $approved,
+                'approved_date' => now(),
+            ])->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), $ok ? 1 : 0);
+
+        $this->expectExceptionCallable(
+            fn () => (new ChangeBeatmapOwners($beatmap, [$user->getKey()], $moderator))->handle(),
+            $ok ? null : AuthorizationException::class,
+        );
+
+        $beatmap = $beatmap->fresh();
+        $expectedUser = $ok ? $user : $owner;
+        $this->assertEqualsCanonicalizing([$expectedUser->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($expectedUser->getKey(), $beatmap->user_id);
+
+        if ($ok) {
+            Bus::assertDispatched(BeatmapOwnerChange::class);
+        } else {
+            Bus::assertNotDispatched(BeatmapOwnerChange::class);
+        }
+    }
+
+    public function testUpdateOwnerModerator(): void
+    {
+        $moderator = User::factory()->withGroup('nat')->create();
+        $user = User::factory()->create();
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->state([
+                'approved' => Beatmapset::STATES['ranked'],
+                'approved_date' => now(),
+            ])->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 1);
+
+        (new ChangeBeatmapOwners($beatmap, [$user->getKey()], $moderator))->handle();
+
+        $beatmap = $beatmap->fresh();
+        $this->assertEqualsCanonicalizing([$user->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($user->getKey(), $beatmap->user_id);
+    }
+
+    public function testUpdateOwnerNotOwner(): void
+    {
+        $user = User::factory()->create();
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->state([
+                'approved' => Beatmapset::STATES['ranked'],
+                'approved_date' => now(),
+            ])->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 0);
+        $this->expectExceptionCallable(
+            fn () => (new ChangeBeatmapOwners($beatmap, [$user->getKey()], $user))->handle(),
+            AuthorizationException::class,
+        );
+
+        $beatmap = $beatmap->fresh();
+        $this->assertEqualsCanonicalizing([$owner->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($owner->getKey(), $beatmap->user_id);
+
+        Bus::assertNotDispatched(BeatmapOwnerChange::class);
+    }
+
+    public function testUpdateOwnerSameOwner(): void
+    {
+        $owner = User::factory()->create();
+        $beatmap = Beatmap::factory()
+            ->for(Beatmapset::factory()->pending()->owner($owner))
+            ->owner($owner)
+            ->create();
+
+        $this->expectCountChange(fn () => BeatmapsetEvent::count(), 0);
+        (new ChangeBeatmapOwners($beatmap, [$owner->getKey()], $owner))->handle();
+
+        $beatmap = $beatmap->fresh();
+        $this->assertEqualsCanonicalizing([$owner->getKey()], $beatmap->getOwners()->pluck('user_id')->toArray());
+        $this->assertSame($owner->getKey(), $beatmap->user_id);
+
+        Bus::assertNotDispatched(BeatmapOwnerChange::class);
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Bus::fake([BeatmapOwnerChange::class]);
+    }
+}

tests/Models/BeatmapsetTest.php

···
 use App\Jobs\CheckBeatmapsetCovers;
 use App\Jobs\Notifications\BeatmapsetDisqualify;
 use App\Jobs\Notifications\BeatmapsetResetNominations;
+use App\Libraries\Beatmapset\ChangeBeatmapOwners;
 use App\Libraries\Beatmapset\NominateBeatmapset;
 use App\Models\Beatmap;
 use App\Models\BeatmapDiscussion;
···
         $bngUser1 = User::factory()->withGroup('bng', ['osu', 'taiko'])->create();
         $bngUser2 = User::factory()->withGroup('bng', ['osu', 'taiko'])->create();
         $bngLimitedUser = User::factory()->withGroup('bng_limited', ['osu', 'taiko'])->create();
+        $natUser = User::factory()->withGroup('nat')->create();
 
         // make taiko tha main ruleset
         $beatmapset = $this->beatmapsetFactory()
···
         $beatmapset->fresh()->nominate($bngUser1, ['osu']);
 
         // main ruleset should now be osu
-        $beatmapset->beatmaps()->where('playmode', 1)->first()->setOwner($guest->getKey());
-        $beatmapset->beatmaps()->where('playmode', 0)->last()->setOwner($beatmapset->user_id);
+        (new ChangeBeatmapOwners(
+            $beatmapset->beatmaps()->where('playmode', 1)->first(),
+            [$guest->getKey()],
+            $natUser
+        ))->handle();
+
+        (new ChangeBeatmapOwners(
+            $beatmapset->beatmaps()->where('playmode', 0)->last(),
+            [$beatmapset->user_id],
+            $natUser
+        ))->handle();
+
         $beatmapset->refresh();
 
         $this->assertSame('osu', $beatmapset->mainRuleset());

tests/api_routes.json

···
         ]
     },
     {
+        "uri": "api/v2/scores",
+        "methods": [
+            "GET",
+            "HEAD"
+        ],
+        "controller": "App\\Http\\Controllers\\ScoresController@index",
+        "middlewares": [
+            "App\\Http\\Middleware\\ThrottleRequests:1200,1,api:",
+            "App\\Http\\Middleware\\RequireScopes",
+            "App\\Http\\Middleware\\RequireScopes:public"
+        ],
+        "scopes": [
+            "public"
+        ]
+    },
+    {
         "uri": "api/v2/beatmapsets/search",
         "methods": [
             "GET",