diff --git a/app/components/match-page/MatchActionTab.module.css b/app/components/match-page/MatchActionTab.module.css
index b8b018a77..870054a45 100644
--- a/app/components/match-page/MatchActionTab.module.css
+++ b/app/components/match-page/MatchActionTab.module.css
@@ -21,7 +21,7 @@
 	}
 }
 
-.withPoints {
+.withKo {
 	grid-template-areas:
 		"header header header"
 		"actions actions actions"
diff --git a/app/components/match-page/MatchActionTab.tsx b/app/components/match-page/MatchActionTab.tsx
index 34536f839..fe6702496 100644
--- a/app/components/match-page/MatchActionTab.tsx
+++ b/app/components/match-page/MatchActionTab.tsx
@@ -39,8 +39,8 @@ interface MatchActionTabProps {
 	ownTeamId: number | null;
 	stageId: StageId;
 	mode: ModeShort;
-	withPoints: boolean;
-	onSubmit?: (data: { winnerId: number; points?: [number, number] }) => void;
+	withKo: boolean;
+	onSubmit?: (data: { winnerId: number; ko?: boolean }) => void;
 	isSubmitting?: boolean;
 	setEnding?: SetEndingData;
 	actionButtons?: React.ReactNode;
@@ -52,7 +52,7 @@ export function MatchActionTab({
 	ownTeamId,
 	stageId,
 	mode,
-	withPoints,
+	withKo,
 	onSubmit,
 	isSubmitting,
 	setEnding,
@@ -73,14 +73,7 @@ export function MatchActionTab({
 
 	const submit = () => {
 		if (winnerId === null) return;
-		const submitPoints: [number, number] | undefined = withPoints
-			? isKo
-				? winnerId === teams[0].id
-					? [100, 0]
-					: [0, 100]
-				: [0, 0]
-			: undefined;
-		onSubmit?.({ winnerId, points: submitPoints });
+		onSubmit?.({ winnerId, ko: withKo ? isKo : undefined });
 	};
 
 	return (
@@ -92,14 +85,14 @@ export function MatchActionTab({
 					mode={mode}
 					winnerId={winnerId}
 					teams={teams}
-					withPoints={withPoints}
+					withKo={withKo}
 					isKo={isKo}
 					isSubmitting={isSubmitting}
 					onBack={() => setConfirming(false)}
 					onConfirm={submit}
 				/>
 			) : (
-				<div className={clsx(styles.root, { [styles.withPoints]: withPoints })}>
+				<div className={clsx(styles.root, { [styles.withKo]: withKo })}>
 					<div className={styles.title}>{t("q:match.action.selectWinner")}</div>
 					{actionButtons ? (
 						<div className={styles.actionButtons}>{actionButtons}</div>
@@ -156,7 +149,7 @@ export function MatchActionTab({
 						/>
 					</RadioGroup>
 
-					{withPoints ? (
+					{withKo ? (
 						<div className={styles.ko}>
 							<label className={styles.koLabel}>
 								<input
@@ -199,7 +192,7 @@ function SetEndingConfirmation({
 	mode,
 	winnerId,
 	teams,
-	withPoints,
+	withKo,
 	isKo,
 	isSubmitting,
 	onBack,
@@ -210,7 +203,7 @@ function SetEndingConfirmation({
 	mode: ModeShort;
 	winnerId: number;
 	teams: [ActionTabTeam, ActionTabTeam];
-	withPoints: boolean;
+	withKo: boolean;
 	isKo: boolean;
 	isSubmitting?: boolean;
 	onBack: () => void;
@@ -226,11 +219,7 @@ function SetEndingConfirmation({
 		timestamp: Date.now(),
 		winner: winnerSide,
 		rosters: setEnding.currentRosters,
-		points: withPoints
-			? isKo
-				? [winnerSide === "ALPHA" ? 100 : 0, winnerSide === "BRAVO" ? 100 : 0]
-				: [0, 0]
-			: undefined,
+		ko: withKo ? isKo : undefined,
 	};
 
 	const updatedScore = {
diff --git a/app/components/match-page/MatchTimeline.tsx b/app/components/match-page/MatchTimeline.tsx
index fe8d8e40d..6427d40c7 100644
--- a/app/components/match-page/MatchTimeline.tsx
+++ b/app/components/match-page/MatchTimeline.tsx
@@ -48,8 +48,8 @@ export interface TimelineMap {
 		alpha: Array<MainWeaponId | null>;
 		bravo: Array<MainWeaponId | null>;
 	};
-	/** Optional point values [alpha, bravo] */
-	points?: [number, number];
+	/** Whether the game ended in a knockout. Undefined if not collected. */
+	ko?: boolean;
 	/** Side that picked this map (counterpick / postGame map PICK). Renders a click indicator next to that side's WIN/LOSS label. */
 	pickedBy?: MatchSide;
 }
@@ -210,15 +210,12 @@ function TimelineHeader({
 function TimelineMapRow({ map }: { map: TimelineMap }) {
 	const { t } = useTranslation(["game-misc"]);
 
-	const alphaPoints = map.points?.[0];
-	const bravoPoints = map.points?.[1];
-
 	return (
 		<div className={styles.mapEvent}>
 			<div className={styles.mapSide}>
 				<SideResult
 					result={map.winner === "ALPHA" ? "WIN" : "LOSS"}
-					points={alphaPoints}
+					isKo={map.ko && map.winner === "ALPHA"}
 					weapons={map.weapons?.alpha}
 					isPicked={map.pickedBy === "ALPHA"}
 				/>
@@ -242,7 +239,7 @@ function TimelineMapRow({ map }: { map: TimelineMap }) {
 			<div className={styles.mapSide}>
 				<SideResult
 					result={map.winner === "BRAVO" ? "WIN" : "LOSS"}
-					points={bravoPoints}
+					isKo={map.ko && map.winner === "BRAVO"}
 					weapons={map.weapons?.bravo}
 					isPicked={map.pickedBy === "BRAVO"}
 				/>
@@ -253,12 +250,12 @@ function TimelineMapRow({ map }: { map: TimelineMap }) {
 
 function SideResult({
 	result,
-	points,
+	isKo,
 	weapons,
 	isPicked,
 }: {
 	result: "WIN" | "LOSS";
-	points?: number;
+	isKo?: boolean;
 	weapons?: Array<MainWeaponId | null>;
 	isPicked?: boolean;
 }) {
@@ -288,7 +285,7 @@ function SideResult({
 						? t("q:match.timeline.win")
 						: t("q:match.timeline.loss")}
 				</span>
-				{points === 100 ? (
+				{isKo ? (
 					<span className={styles.resultPoints}>{t("q:match.action.ko")}</span>
 				) : null}
 			</div>
diff --git a/app/db/seed/index.ts b/app/db/seed/index.ts
index 2da620ddd..c51d41a5e 100644
--- a/app/db/seed/index.ts
+++ b/app/db/seed/index.ts
@@ -438,8 +438,8 @@ function finalizedBracket() {
 	];
 
 	const matchInsertStm = sql.prepare(
-		`insert into "TournamentMatch" ("stageId", "groupId", "roundId", "number", "status", "opponentOne", "opponentTwo")
-		 values ($stageId, $groupId, $roundId, $number, $status, $opponentOne, $opponentTwo) returning id`,
+		`insert into "TournamentMatch" ("stageId", "groupId", "roundId", "number", "opponentOne", "opponentTwo", "winnerSide")
+		 values ($stageId, $groupId, $roundId, $number, $opponentOne, $opponentTwo, $winnerSide) returning id`,
 	);
 
 	const gameResultInsertStm = sql.prepare(
@@ -454,17 +454,15 @@ function finalizedBracket() {
 				groupId,
 				roundId: roundIds[m.round],
 				number: m.number,
-				status: 4,
 				opponentOne: JSON.stringify({
 					id: m.team1,
 					score: m.winner === m.team1 ? 2 : 0,
-					result: m.winner === m.team1 ? "win" : "loss",
 				}),
 				opponentTwo: JSON.stringify({
 					id: m.team2,
 					score: m.winner === m.team2 ? 2 : 0,
-					result: m.winner === m.team2 ? "win" : "loss",
 				}),
+				winnerSide: m.winner === m.team1 ? "opponent1" : "opponent2",
 			}) as { id: number }
 		).id;
 
diff --git a/app/db/tables.ts b/app/db/tables.ts
index dad4a22ca..e2e7325d6 100644
--- a/app/db/tables.ts
+++ b/app/db/tables.ts
@@ -13,10 +13,14 @@ import type { Notification as NotificationValue } from "~/features/notifications
 import type { ScrimFilters } from "~/features/scrims/scrims-types";
 import type { TEAM_MEMBER_ROLES } from "~/features/team/team-constants";
 import type { TournamentTierNumber } from "~/features/tournament/core/tiering";
+import type {
+	ParticipantResult,
+	Side,
+	StageSettings,
+} from "~/features/tournament-bracket/core/engine/types";
 import type * as PickBan from "~/features/tournament-bracket/core/PickBan";
 import type * as Progression from "~/features/tournament-bracket/core/Progression";
 import type { StoredWidget } from "~/features/user-page/core/widgets/types";
-import type { ParticipantResult } from "~/modules/brackets-model";
 import type {
 	Ability,
 	BuildAbilitiesTuple,
@@ -644,36 +648,19 @@ export interface TournamentGroup {
 	stageId: number;
 }
 
-export const TournamentMatchStatus = {
-	/** The two matches leading to this one are not completed yet. */
-	Locked: 0,
-
-	/** One participant is ready and waiting for the other one. */
-	Waiting: 1,
-
-	/** Both participants are ready to start. */
-	Ready: 2,
-
-	/** The match is running. */
-	Running: 3,
-
-	/** The match is completed. */
-	Completed: 4,
-};
-
 export interface TournamentMatch {
 	chatCode: string | null;
 	groupId: number;
 	id: GeneratedAlways<number>;
 	number: number;
-	opponentOne: JSONColumnType<ParticipantResult>;
-	opponentTwo: JSONColumnType<ParticipantResult>;
+	opponentOne: JSONColumnTypeNullable<ParticipantResult>;
+	opponentTwo: JSONColumnTypeNullable<ParticipantResult>;
 	roundId: number;
 	stageId: number;
-	status: (typeof TournamentMatchStatus)[keyof typeof TournamentMatchStatus];
-	// set when match becomes ongoing (both teams ready and no earlier matches for either team)
-	// for swiss: set at creation time
+	// set when the match becomes playable i.e. its status is "STARTED"
 	startedAt: number | null;
+	/** The side that won the set. `null` while the match has no winner. */
+	winnerSide: Side | null;
 }
 
 /** Represents one decision, pick or ban, during tournaments pick/ban (counterpick, ban 2) phase. */
@@ -690,6 +677,8 @@ export interface TournamentMatchPickBanEvent {
 export interface TournamentMatchGameResult {
 	createdAt: Generated<number>;
 	id: GeneratedAlways<number>;
+	/** Whether the game ended in a knockout. `null` if not collected for this bracket. */
+	ko: DBBoolean | null;
 	matchId: number;
 	mode: ModeShort;
 	number: number;
@@ -697,8 +686,6 @@ export interface TournamentMatchGameResult {
 	source: string;
 	stageId: StageId;
 	winnerTeamId: number;
-	opponentOnePoints: number | null;
-	opponentTwoPoints: number | null;
 }
 
 export interface TournamentMatchGameResultParticipant {
@@ -810,7 +797,7 @@ export interface TournamentStage {
 	id: GeneratedAlways<number>;
 	name: string;
 	number: number;
-	settings: string;
+	settings: JSONColumnType<StageSettings>;
 	tournamentId: number;
 	type: (typeof TOURNAMENT_STAGE_TYPES)[number];
 	// not Generated<> because SQLite doesn't allow altering tables to add columns with default values :(
diff --git a/app/features/api-public/routes/sendouq.match.$matchId.ts b/app/features/api-public/routes/sendouq.match.$matchId.ts
index 04b57a6bc..df2d65cfa 100644
--- a/app/features/api-public/routes/sendouq.match.$matchId.ts
+++ b/app/features/api-public/routes/sendouq.match.$matchId.ts
@@ -58,7 +58,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 				? (map.source as MapListMap["source"])
 				: Number(map.source),
 			participatedUserIds: null,
-			points: null,
+			ko: null,
 		})),
 		teamAlpha: {
 			id: match.groupAlpha.id,
diff --git a/app/features/api-public/routes/tournament-match.$id.ts b/app/features/api-public/routes/tournament-match.$id.ts
index edc87d4a3..18f32a18f 100644
--- a/app/features/api-public/routes/tournament-match.$id.ts
+++ b/app/features/api-public/routes/tournament-match.$id.ts
@@ -42,6 +42,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 				"TournamentMatch.id",
 				"TournamentMatch.opponentOne",
 				"TournamentMatch.opponentTwo",
+				"TournamentMatch.winnerSide",
 				"Tournament.mapPickingStyle",
 				"TournamentRound.maps",
 				jsonArrayFrom(
@@ -52,8 +53,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 							"TournamentMatchGameResult.mode",
 							"TournamentMatchGameResult.winnerTeamId",
 							"TournamentMatchGameResult.source",
-							"TournamentMatchGameResult.opponentOnePoints",
-							"TournamentMatchGameResult.opponentTwoPoints",
+							"TournamentMatchGameResult.ko",
 							jsonArrayFrom(
 								innerEb
 									.selectFrom("TournamentMatchGameResultParticipant")
@@ -89,14 +89,12 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 		return parsed;
 	};
 	const mapList = async (): Promise<GetTournamentMatchResponse["mapList"]> => {
-		if (!match.opponentOne.id || !match.opponentTwo.id) {
+		const { opponentOne, opponentTwo } = match;
+		if (!opponentOne?.id || !opponentTwo?.id) {
 			return null;
 		}
 
-		if (
-			match.opponentOne.result === "win" ||
-			match.opponentTwo.result === "win"
-		) {
+		if (match.winnerSide) {
 			return match.playedMapList.map((playedMap) => ({
 				map: {
 					mode: playedMap.mode,
@@ -108,10 +106,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 				participatedUserIds: playedMap.participants.map((p) => p.userId),
 				winnerTeamId: playedMap.winnerTeamId,
 				source: parseSource(playedMap.source),
-				points:
-					playedMap.opponentOnePoints && playedMap.opponentTwoPoints
-						? [playedMap.opponentOnePoints, playedMap.opponentTwoPoints]
-						: null,
+				ko: playedMap.ko !== null ? Boolean(playedMap.ko) : null,
 			}));
 		}
 
@@ -122,7 +117,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 		return resolveMapList({
 			tournamentId: match.tournamentId,
 			matchId: id,
-			teams: [match.opponentOne.id, match.opponentTwo.id],
+			teams: [opponentOne.id, opponentTwo.id],
 			mapPoolByTeamId: (teamId) => tournament.teamById(teamId)?.mapPool ?? [],
 			mapPickingStyle: match.mapPickingStyle,
 			maps: match.maps,
@@ -131,7 +126,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 			recentlyPlayedMaps:
 				match.mapPickingStyle !== "TO"
 					? await TournamentTeamRepository.findRecentlyPlayedMapsByIds({
-							teamIds: [match.opponentOne.id, match.opponentTwo.id],
+							teamIds: [opponentOne.id, opponentTwo.id],
 						}).catch((error) => {
 							logger.error("Failed to fetch recently played maps", error);
 							return [];
@@ -149,7 +144,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 				participatedUserIds: null,
 				winnerTeamId: null,
 				source: mapListMap.source,
-				points: null,
+				ko: null,
 			};
 		});
 	};
@@ -158,13 +153,13 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 		tournament.matchContextNamesById(id);
 
 	const result: GetTournamentMatchResponse = {
-		teamOne: match.opponentOne.id
+		teamOne: match.opponentOne?.id
 			? {
 					id: match.opponentOne.id,
 					score: match.opponentOne.score ?? 0,
 				}
 			: null,
-		teamTwo: match.opponentTwo.id
+		teamTwo: match.opponentTwo?.id
 			? {
 					id: match.opponentTwo.id,
 					score: match.opponentTwo.score ?? 0,
diff --git a/app/features/api-public/schema.ts b/app/features/api-public/schema.ts
index 3b73bbc79..e2ad37c34 100644
--- a/app/features/api-public/schema.ts
+++ b/app/features/api-public/schema.ts
@@ -1,6 +1,6 @@
 import type { Pronouns } from "~/db/tables";
 import type { TierName } from "~/features/mmr/mmr-constants";
-import type { DataTypes, ValueToArray } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 
 /** GET /api/user/{userId|discordId} */
 
@@ -368,7 +368,10 @@ export interface GetTournamentBracketStandingsResponse {
 			setLosses: number;
 			mapWins: number;
 			mapLosses: number;
-			points: number;
+			/** @deprecated points are no longer tracked, see koCount instead */
+			points?: number;
+			/** (round robin only) how many knockout wins the team has */
+			koCount?: number;
 			winsAgainstTied: number;
 			lossesAgainstTied?: number;
 			buchholzSets?: number;
@@ -523,8 +526,8 @@ export type MapListMap = {
 		| "ROLL";
 	winnerTeamId: number | null;
 	participatedUserIds: Array<number> | null;
-	/** (round robin only) points of the match used for tiebreaker purposes. e.g. [100, 0] indicates a knockout. */
-	points: [number, number] | null;
+	/** (round robin only) whether the map ended in a knockout. `null` if not tracked. */
+	ko: boolean | null;
 };
 
 type TournamentMatchTeam = {
@@ -537,7 +540,7 @@ type TournamentBracket = {
 	name: string;
 };
 
-type TournamentBracketData = ValueToArray<DataTypes>;
+type TournamentBracketData = BracketData;
 
 /** POST /api/tournament/{id}/seeds */
 
diff --git a/app/features/bracket-test/routes/bracket-test.tsx b/app/features/bracket-test/routes/bracket-test.tsx
index 512444dcc..a2f690313 100644
--- a/app/features/bracket-test/routes/bracket-test.tsx
+++ b/app/features/bracket-test/routes/bracket-test.tsx
@@ -7,10 +7,8 @@ import { Label } from "~/components/Label";
 import { Main } from "~/components/Main";
 import type { Tables } from "~/db/tables";
 import type { Bracket as BracketType } from "~/features/tournament-bracket/core/Bracket";
-import { getTournamentManager } from "~/features/tournament-bracket/core/brackets-manager";
-import * as Swiss from "~/features/tournament-bracket/core/Swiss";
-import { fillWithNullTillPowerOfTwo } from "~/features/tournament-bracket/tournament-bracket-utils";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import * as Engine from "~/features/tournament-bracket/core/engine";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import styles from "../bracket-test.module.css";
 
 type FormatType = Tables["TournamentStage"]["type"];
@@ -204,7 +202,7 @@ function generateTeams(count: number) {
 	}));
 }
 
-function countRounds(data: TournamentManagerDataSet, isDoubleElim: boolean) {
+function countRounds(data: BracketData, isDoubleElim: boolean) {
 	const totalRounds = Math.max(...data.round.map((r) => r.number));
 
 	if (!isDoubleElim) return { totalRounds, wbRounds: 0, lbRounds: 0 };
@@ -212,14 +210,14 @@ function countRounds(data: TournamentManagerDataSet, isDoubleElim: boolean) {
 	const wbGroupId = data.group.find((g) => g.number === 1)?.id;
 	const lbGroupId = data.group.find((g) => g.number === 2)?.id;
 
-	const wbRounds = data.round.filter((r) => r.group_id === wbGroupId).length;
-	const lbRounds = data.round.filter((r) => r.group_id === lbGroupId).length;
+	const wbRounds = data.round.filter((r) => r.groupId === wbGroupId).length;
+	const lbRounds = data.round.filter((r) => r.groupId === lbGroupId).length;
 
 	return { totalRounds, wbRounds, lbRounds };
 }
 
 function simulateCompletedRoundsByGroup(
-	data: TournamentManagerDataSet,
+	data: BracketData,
 	wbCompleted: number,
 	lbCompleted: number,
 ) {
@@ -228,10 +226,10 @@ function simulateCompletedRoundsByGroup(
 
 	const completedRoundIds = new Set<number>();
 	for (const round of data.round) {
-		if (round.group_id === wbGroupId && round.number <= wbCompleted) {
+		if (round.groupId === wbGroupId && round.number <= wbCompleted) {
 			completedRoundIds.add(round.id);
 		}
-		if (round.group_id === lbGroupId && round.number <= lbCompleted) {
+		if (round.groupId === lbGroupId && round.number <= lbCompleted) {
 			completedRoundIds.add(round.id);
 		}
 	}
@@ -239,10 +237,7 @@ function simulateCompletedRoundsByGroup(
 	markMatchesCompleted(data, completedRoundIds);
 }
 
-function simulateCompletedRounds(
-	data: TournamentManagerDataSet,
-	completedRounds: number,
-) {
+function simulateCompletedRounds(data: BracketData, completedRounds: number) {
 	if (completedRounds <= 0) return;
 
 	const roundsByNumber = new Map<number, number[]>();
@@ -263,56 +258,42 @@ function simulateCompletedRounds(
 }
 
 function markMatchesCompleted(
-	data: TournamentManagerDataSet,
+	data: BracketData,
 	completedRoundIds: Set<number>,
 ) {
 	for (const match of data.match) {
-		if (!completedRoundIds.has(match.round_id)) continue;
+		if (!completedRoundIds.has(match.roundId)) continue;
 		// skip BYE matches (opponent slot is null entirely)
 		if (match.opponent1 === null || match.opponent2 === null) continue;
 
-		match.opponent1 = { ...match.opponent1, score: 2, result: "win" };
-		match.opponent2 = { ...match.opponent2, score: 0, result: "loss" };
-		match.status = 4;
+		match.opponent1 = { ...match.opponent1, score: 2 };
+		match.opponent2 = { ...match.opponent2, score: 0 };
+		match.winnerSide = "opponent1";
 	}
 }
 
 function generateBracketData(
 	format: FormatType,
 	teamIds: number[],
-): TournamentManagerDataSet {
+): BracketData {
 	if (format === "swiss") {
-		return Swiss.create({
-			tournamentId: 1,
-			name: "Test Bracket",
+		return Engine.create({
+			type: "swiss",
 			seeding: teamIds,
-			settings: {
-				swiss: { groupCount: 1, roundCount: 5 },
-			},
+			settings: { groupCount: 1, roundCount: 5 },
 		});
 	}
 
-	const manager = getTournamentManager();
-	const seeding =
-		format === "round_robin" ? teamIds : fillWithNullTillPowerOfTwo(teamIds);
-
 	const settings =
 		format === "single_elimination"
-			? { consolationFinal: false }
+			? { thirdPlaceMatch: false }
 			: format === "double_elimination"
-				? { grandFinal: "double" as const }
-				: {
-						groupCount: Math.ceil(teamIds.length / 4),
-						seedOrdering: ["groups.seed_optimized" as const],
-					};
+				? null
+				: { teamsPerGroup: 4 };
 
-	manager.create({
-		tournamentId: 1,
-		name: "Test Bracket",
+	return Engine.create({
 		type: format,
-		seeding,
+		seeding: teamIds,
 		settings,
 	});
-
-	return manager.get.tournamentData(1);
 }
diff --git a/app/features/calendar/actions/calendar.$id.server.ts b/app/features/calendar/actions/calendar.$id.server.ts
index 7425e268e..6c0112616 100644
--- a/app/features/calendar/actions/calendar.$id.server.ts
+++ b/app/features/calendar/actions/calendar.$id.server.ts
@@ -4,10 +4,8 @@ import { z } from "zod";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as CalendarRepository from "~/features/calendar/CalendarRepository.server";
 import * as ShowcaseTournaments from "~/features/front-page/core/ShowcaseTournaments.server";
-import {
-	clearTournamentDataCache,
-	tournamentManagerData,
-} from "~/features/tournament-bracket/core/Tournament.server";
+import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
+import { clearTournamentDataCache } from "~/features/tournament-bracket/core/Tournament.server";
 import { databaseTimestampToDate } from "~/utils/dates";
 import { errorToastIfFalsy, notFoundIfNullish } from "~/utils/remix.server";
 import { CALENDAR_PAGE } from "~/utils/urls";
@@ -25,7 +23,8 @@ export const action: ActionFunction = async ({ params }) => {
 
 	if (event.tournamentId) {
 		errorToastIfFalsy(
-			tournamentManagerData(event.tournamentId).stage.length === 0,
+			(await BracketRepository.findByTournamentId(event.tournamentId)).stage
+				.length === 0,
 			"Tournament has already started",
 		);
 	} else {
diff --git a/app/features/calendar/calendar-schemas.ts b/app/features/calendar/calendar-schemas.ts
index 9784c8315..eb792e087 100644
--- a/app/features/calendar/calendar-schemas.ts
+++ b/app/features/calendar/calendar-schemas.ts
@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { type CalendarEventTag, TOURNAMENT_STAGE_TYPES } from "~/db/tables";
 import { TOURNAMENT } from "~/features/tournament/tournament-constants";
+import * as Swiss from "~/features/tournament-bracket/core/engine/swiss/team-status";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
-import * as Swiss from "~/features/tournament-bracket/core/Swiss";
 import {
 	array,
 	checkboxGroup,
diff --git a/app/features/calendar/components/BracketProgressionSelector.tsx b/app/features/calendar/components/BracketProgressionSelector.tsx
index d4b3da1df..80ba37919 100644
--- a/app/features/calendar/components/BracketProgressionSelector.tsx
+++ b/app/features/calendar/components/BracketProgressionSelector.tsx
@@ -9,8 +9,8 @@ import { FormMessage } from "~/components/FormMessage";
 import { Input } from "~/components/Input";
 import { Label } from "~/components/Label";
 import { TOURNAMENT } from "~/features/tournament/tournament-constants";
+import * as Swiss from "~/features/tournament-bracket/core/engine/swiss/team-status";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
-import * as Swiss from "~/features/tournament-bracket/core/Swiss";
 import { defaultBracketSettings } from "../../tournament/tournament-utils";
 import styles from "./BracketProgressionSelector.module.css";
 
diff --git a/app/features/core/streams/streams.server.ts b/app/features/core/streams/streams.server.ts
index 218cd888b..b7d3facc8 100644
--- a/app/features/core/streams/streams.server.ts
+++ b/app/features/core/streams/streams.server.ts
@@ -1,7 +1,6 @@
 import type { TournamentTierNumber } from "~/features/tournament/core/tiering";
 import { RunningTournaments } from "~/features/tournament-bracket/core/RunningTournaments.server";
 import type { Tournament } from "~/features/tournament-bracket/core/Tournament";
-import { Status } from "~/modules/brackets-model";
 import { cache } from "~/utils/cache.server";
 import { dateToDatabaseTimestamp } from "~/utils/dates";
 import { tournamentStreamsPage } from "~/utils/urls";
@@ -70,17 +69,11 @@ function deriveCurrentRound(tournament: Tournament): string {
 		if (bracket.isUnderground) continue;
 
 		for (const match of bracket.data.match) {
-			const isActive =
-				match.status === Status.Ready || match.status === Status.Running;
-			const hasParticipants = match.opponent1 && match.opponent2;
-			const isNotFinished =
-				!match.opponent1?.result && !match.opponent2?.result;
+			if (bracket.matchStatus(match.id) !== "STARTED") continue;
 
-			if (isActive && hasParticipants && isNotFinished) {
-				const context = tournament.matchContextNamesById(match.id);
-				if (context?.roundNameWithoutMatchIdentifier) {
-					return context.roundNameWithoutMatchIdentifier;
-				}
+			const context = tournament.matchContextNamesById(match.id);
+			if (context?.roundNameWithoutMatchIdentifier) {
+				return context.roundNameWithoutMatchIdentifier;
 			}
 		}
 
diff --git a/app/features/leaderboards/LeaderboardRepository.server.test.ts b/app/features/leaderboards/LeaderboardRepository.server.test.ts
index 65279c5d3..495f51a40 100644
--- a/app/features/leaderboards/LeaderboardRepository.server.test.ts
+++ b/app/features/leaderboards/LeaderboardRepository.server.test.ts
@@ -92,7 +92,6 @@ const createTournamentMatch = async ({
 			groupId: group.id,
 			roundId: round.id,
 			number: 1,
-			status: 4,
 			opponentOne: JSON.stringify({ id: null }),
 			opponentTwo: JSON.stringify({ id: null }),
 		})
diff --git a/app/features/match-page-test/routes/match-page-test.tsx b/app/features/match-page-test/routes/match-page-test.tsx
index dd4f52350..2938f2f79 100644
--- a/app/features/match-page-test/routes/match-page-test.tsx
+++ b/app/features/match-page-test/routes/match-page-test.tsx
@@ -290,7 +290,7 @@ export default function MatchPageTestRoute() {
 							ownTeamId={1}
 							stageId={4}
 							mode="SZ"
-							withPoints={true}
+							withKo={true}
 							actionButtons={
 								<SendouButton
 									variant="minimal-destructive"
@@ -688,7 +688,7 @@ export default function MatchPageTestRoute() {
 								mode: "RM",
 								timestamp: 1712856200,
 								winner: "ALPHA",
-								points: [100, 42],
+								ko: true,
 								weapons: {
 									alpha: [40, null, 1100, 3040],
 									bravo: [null, 210, null, 4010],
diff --git a/app/features/scrims/components/ScrimMatchActionTab.tsx b/app/features/scrims/components/ScrimMatchActionTab.tsx
index 62578ca5b..81afb8844 100644
--- a/app/features/scrims/components/ScrimMatchActionTab.tsx
+++ b/app/features/scrims/components/ScrimMatchActionTab.tsx
@@ -74,7 +74,7 @@ function ReportMapSection({ viewerSide }: { viewerSide: ScrimSide }) {
 			ownTeamId={ownTeamId}
 			stageId={map.stageId}
 			mode={map.mode}
-			withPoints={false}
+			withKo={false}
 			isSubmitting={fetcher.state !== "idle"}
 			onSubmit={({ winnerId }) => {
 				fetcher.submit(
diff --git a/app/features/sendouq-match/components/SendouQMatchActionTab.tsx b/app/features/sendouq-match/components/SendouQMatchActionTab.tsx
index 5b2f72dc9..479b146b5 100644
--- a/app/features/sendouq-match/components/SendouQMatchActionTab.tsx
+++ b/app/features/sendouq-match/components/SendouQMatchActionTab.tsx
@@ -422,7 +422,7 @@ function InProgressTab({
 			ownTeamId={ownTeamId}
 			stageId={currentMap.stageId}
 			mode={currentMap.mode}
-			withPoints={false}
+			withKo={false}
 			isSubmitting={fetcher.state !== "idle"}
 			setEnding={setEnding}
 			onSubmit={({ winnerId }) => {
diff --git a/app/features/tournament-admin/actions/to.$id.admin.brackets.server.ts b/app/features/tournament-admin/actions/to.$id.admin.brackets.server.ts
index 85ebbac65..b6d98655b 100644
--- a/app/features/tournament-admin/actions/to.$id.admin.brackets.server.ts
+++ b/app/features/tournament-admin/actions/to.$id.admin.brackets.server.ts
@@ -2,6 +2,7 @@ import type { ActionFunction } from "react-router";
 import { DANGEROUS_CAN_ACCESS_DEV_CONTROLS } from "~/features/admin/core/dev-controls";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
+import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
 import {
 	clearTournamentDataCache,
@@ -57,7 +58,7 @@ export const action: ActionFunction = async ({ request, params }) => {
 				"Some bracket that sources teams from this bracket has started",
 			);
 
-			await TournamentRepository.resetBracket(data.stageId);
+			await BracketRepository.resetBracket(data.stageId);
 
 			message = "Bracket reset";
 			break;
diff --git a/app/features/tournament-admin/actions/to.$id.admin.index.server.ts b/app/features/tournament-admin/actions/to.$id.admin.index.server.ts
index 793ad0066..d5fd2643d 100644
--- a/app/features/tournament-admin/actions/to.$id.admin.index.server.ts
+++ b/app/features/tournament-admin/actions/to.$id.admin.index.server.ts
@@ -1,11 +1,12 @@
 import type { ActionFunction } from "react-router";
 import * as R from "remeda";
+import { db } from "~/db/sql";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
 import * as ShowcaseTournaments from "~/features/front-page/core/ShowcaseTournaments.server";
 import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
 import { endDroppedTeamMatches } from "~/features/tournament/tournament-utils.server";
-import { getServerTournamentManager } from "~/features/tournament-bracket/core/brackets-manager/manager.server";
+import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
 import {
 	clearTournamentDataCache,
 	tournamentFromDB,
@@ -116,7 +117,6 @@ export const action: ActionFunction = async ({ request, params }) => {
 
 			const endedMatchIds = await dropTeamOut({
 				tournament,
-				manager: getServerTournamentManager(),
 				teamId: data.teamId,
 			});
 
@@ -152,11 +152,9 @@ export const action: ActionFunction = async ({ request, params }) => {
  */
 async function dropTeamOut({
 	tournament,
-	manager,
 	teamId,
 }: {
 	tournament: Awaited<ReturnType<typeof tournamentFromDB>>;
-	manager: ReturnType<typeof getServerTournamentManager>;
 	teamId: number;
 }) {
 	const droppingTeam = tournament.teamById(teamId);
@@ -176,10 +174,22 @@ async function dropTeamOut({
 		});
 	}
 
-	const endedMatchIds = endDroppedTeamMatches({
-		tournament,
-		manager,
-		droppedTeamId: teamId,
+	const endedMatchIds = await db.transaction().execute(async (trx) => {
+		const bracketData = await BracketRepository.findByTournamentId(
+			tournament.ctx.id,
+			trx,
+		);
+		const droppedResult = endDroppedTeamMatches({
+			tournament,
+			data: bracketData,
+			droppedTeamId: teamId,
+		});
+		await BracketRepository.applyMatchChanges(
+			{ previousData: bracketData, result: droppedResult },
+			trx,
+		);
+
+		return droppedResult.endedMatchIds;
 	});
 
 	await TournamentTeamRepository.dropOut({
diff --git a/app/features/tournament-bracket/BracketRepository.server.ts b/app/features/tournament-bracket/BracketRepository.server.ts
new file mode 100644
index 000000000..7c0abd1f9
--- /dev/null
+++ b/app/features/tournament-bracket/BracketRepository.server.ts
@@ -0,0 +1,379 @@
+import {
+	type Kysely,
+	sql as kyselySql,
+	type RawBuilder,
+	type Transaction,
+} from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/sqlite";
+import { db } from "~/db/sql";
+import type { DB } from "~/db/tables";
+import { databaseTimestampNow } from "~/utils/dates";
+import { shortNanoid } from "~/utils/id";
+import { matchStatuses } from "./core/engine/status";
+import type {
+	BracketData,
+	EngineResult,
+	GeneratedRound,
+	ParticipantResult,
+} from "./core/engine/types";
+
+type DbOrTrx = Kysely<DB> | Transaction<DB>;
+
+/**
+ * Loads the full BracketData for a tournament (all stages). Includes the
+ * score/totalKos aggregation over TournamentMatchGameResult. Direct replacement
+ * for the old manager.get.tournamentData(); also called from write actions
+ * inside their transaction (propagation must be computed from fresh rows, not
+ * the cached Tournament instance).
+ */
+export async function findByTournamentId(
+	tournamentId: number,
+	trx: DbOrTrx = db,
+): Promise<BracketData> {
+	const { stage, group, round, match } = await trx
+		.selectNoFrom((eb) => [
+			jsonArrayFrom(
+				eb
+					.selectFrom("TournamentStage")
+					.select([
+						"TournamentStage.id",
+						"TournamentStage.name",
+						"TournamentStage.type",
+						"TournamentStage.settings",
+						"TournamentStage.number",
+						"TournamentStage.createdAt",
+					])
+					.where("TournamentStage.tournamentId", "=", tournamentId)
+					.orderBy("TournamentStage.id", "asc"),
+			).as("stage"),
+			jsonArrayFrom(
+				eb
+					.selectFrom("TournamentGroup")
+					.innerJoin(
+						"TournamentStage",
+						"TournamentStage.id",
+						"TournamentGroup.stageId",
+					)
+					.select([
+						"TournamentGroup.id",
+						"TournamentGroup.stageId",
+						"TournamentGroup.number",
+					])
+					.where("TournamentStage.tournamentId", "=", tournamentId)
+					.orderBy("TournamentGroup.stageId", "asc")
+					.orderBy("TournamentGroup.id", "asc"),
+			).as("group"),
+			jsonArrayFrom(
+				eb
+					.selectFrom("TournamentRound")
+					.innerJoin(
+						"TournamentStage",
+						"TournamentStage.id",
+						"TournamentRound.stageId",
+					)
+					.select([
+						"TournamentRound.id",
+						"TournamentRound.stageId",
+						"TournamentRound.groupId",
+						"TournamentRound.number",
+						"TournamentRound.maps",
+					])
+					.where("TournamentStage.tournamentId", "=", tournamentId)
+					.orderBy("TournamentRound.stageId", "asc")
+					.orderBy("TournamentRound.id", "asc"),
+			).as("round"),
+			jsonArrayFrom(
+				eb
+					.selectFrom("TournamentMatch")
+					.innerJoin(
+						"TournamentStage",
+						"TournamentStage.id",
+						"TournamentMatch.stageId",
+					)
+					.leftJoin(
+						"TournamentMatchGameResult",
+						"TournamentMatch.id",
+						"TournamentMatchGameResult.matchId",
+					)
+					.select([
+						"TournamentMatch.id",
+						"TournamentMatch.stageId",
+						"TournamentMatch.groupId",
+						"TournamentMatch.roundId",
+						"TournamentMatch.number",
+						"TournamentMatch.startedAt",
+						"TournamentMatch.winnerSide",
+						// totalKos is never persisted, it is aggregated fresh from the game results
+						serializedOpponentWithKos("opponentOne").as("opponent1"),
+						serializedOpponentWithKos("opponentTwo").as("opponent2"),
+					])
+					.where("TournamentStage.tournamentId", "=", tournamentId)
+					.groupBy("TournamentMatch.id")
+					.orderBy("TournamentMatch.stageId", "asc")
+					.orderBy("TournamentMatch.id", "asc"),
+			).as("match"),
+		])
+		.executeTakeFirstOrThrow();
+
+	return { stage, group, round, match };
+}
+
+/**
+ * Builds the opponent JSON with the freshly aggregated KO count: sets
+ * `totalKos` to the SQL sum over the match's game results. Resolves to `null`
+ * for BYEs (the column is `null`).
+ */
+function serializedOpponentWithKos(
+	column: "opponentOne" | "opponentTwo",
+): RawBuilder<ParticipantResult | null> {
+	return kyselySql<ParticipantResult | null>`json_set(
+		${kyselySql.ref(`TournamentMatch.${column}`)},
+		'$.totalKos',
+		sum(
+			case
+				when "TournamentMatchGameResult"."ko" = 1
+					and "TournamentMatchGameResult"."winnerTeamId" = ${kyselySql.ref(`TournamentMatch.${column}`)} ->> '$.id'
+				then 1
+				else 0
+			end
+		)
+	)`;
+}
+
+/**
+ * Persists Engine.create output in one transaction. Inserts stage → groups →
+ * rounds → matches, translating the engine's local ids to real row ids. The
+ * stage number is assigned from the existing stages of the tournament.
+ */
+export function insertBracket(args: {
+	tournamentId: number;
+	name: string;
+	bracket: BracketData;
+}): Promise<{ stageId: number }> {
+	const stageInput = args.bracket.stage[0];
+	if (!stageInput) throw new Error("Bracket has no stage");
+
+	return db.transaction().execute(async (trx) => {
+		const stage = await trx
+			.insertInto("TournamentStage")
+			.values({
+				tournamentId: args.tournamentId,
+				name: args.name,
+				type: stageInput.type,
+				settings: JSON.stringify(stageInput.settings),
+				number: kyselySql<number>`(select coalesce(max("number"), 0) + 1 from "TournamentStage" where "tournamentId" = ${args.tournamentId})`,
+				createdAt: databaseTimestampNow(),
+			})
+			.returning(["id"])
+			.executeTakeFirstOrThrow();
+
+		const groupIdMapping = new Map<number, number>();
+		const roundIdMapping = new Map<number, number>();
+
+		for (const group of args.bracket.group) {
+			const inserted = await trx
+				.insertInto("TournamentGroup")
+				.values({
+					stageId: stage.id,
+					number: group.number,
+				})
+				.returning(["id"])
+				.executeTakeFirstOrThrow();
+
+			groupIdMapping.set(group.id, inserted.id);
+		}
+
+		for (const round of args.bracket.round) {
+			if (!round.maps) throw new Error("Round is missing maps");
+
+			const inserted = await trx
+				.insertInto("TournamentRound")
+				.values({
+					stageId: stage.id,
+					groupId: groupIdMapping.get(round.groupId)!,
+					number: round.number,
+					maps: JSON.stringify(round.maps),
+				})
+				.returning(["id"])
+				.executeTakeFirstOrThrow();
+
+			roundIdMapping.set(round.id, inserted.id);
+		}
+
+		const statuses = matchStatuses(args.bracket);
+
+		for (const match of args.bracket.match) {
+			await trx
+				.insertInto("TournamentMatch")
+				.values({
+					stageId: stage.id,
+					groupId: groupIdMapping.get(match.groupId)!,
+					roundId: roundIdMapping.get(match.roundId)!,
+					number: match.number,
+					opponentOne: serializeOpponent(match.opponent1),
+					opponentTwo: serializeOpponent(match.opponent2),
+					winnerSide: match.winnerSide,
+					chatCode: shortNanoid(),
+					startedAt:
+						statuses.get(match.id) === "STARTED"
+							? databaseTimestampNow()
+							: null,
+				})
+				.execute();
+		}
+
+		return { stageId: stage.id };
+	});
+}
+
+/**
+ * UPDATEs the opponents of the changed matches and keeps startedAt in sync with
+ * the statuses that the new state implies. Called inside the caller's
+ * transaction with the bracket data the operation was computed from.
+ */
+export async function applyMatchChanges(
+	args: { previousData: BracketData; result: EngineResult },
+	trx: DbOrTrx = db,
+): Promise<void> {
+	for (const match of args.result.changedMatches) {
+		await trx
+			.updateTable("TournamentMatch")
+			.set({
+				opponentOne: serializeOpponent(match.opponent1),
+				opponentTwo: serializeOpponent(match.opponent2),
+				winnerSide: match.winnerSide,
+			})
+			.where("id", "=", match.id)
+			.execute();
+	}
+
+	await syncStartedAt(args.previousData, args.result.data, trx);
+}
+
+/**
+ * A match starts when it stops being pending, which can also happen as a side
+ * effect of another match's result (the teams of a round robin round becoming
+ * free, an opponent advancing). Matches that were already started keep the
+ * timestamp they got, and one that goes back to pending loses it.
+ */
+async function syncStartedAt(
+	previousData: BracketData,
+	data: BracketData,
+	trx: DbOrTrx,
+): Promise<void> {
+	const previousStatuses = matchStatuses(previousData);
+	const statuses = matchStatuses(data);
+
+	const wasPending = (matchId: number) =>
+		previousStatuses.get(matchId) === "PENDING";
+	const isPending = (matchId: number) => statuses.get(matchId) === "PENDING";
+
+	const startedMatchIds = data.match
+		.filter(
+			(match) =>
+				wasPending(match.id) && !isPending(match.id) && !match.startedAt,
+		)
+		.map((match) => match.id);
+
+	const pendingMatchIds = data.match
+		.filter(
+			(match) =>
+				!wasPending(match.id) && isPending(match.id) && match.startedAt,
+		)
+		.map((match) => match.id);
+
+	if (startedMatchIds.length > 0) {
+		await trx
+			.updateTable("TournamentMatch")
+			.set({ startedAt: databaseTimestampNow() })
+			.where("id", "in", startedMatchIds)
+			.execute();
+	}
+
+	if (pendingMatchIds.length > 0) {
+		await trx
+			.updateTable("TournamentMatch")
+			.set({ startedAt: null })
+			.where("id", "in", pendingMatchIds)
+			.execute();
+	}
+}
+
+/** INSERTs a generated round's matches (swiss advance). */
+export async function insertRoundMatches(
+	args: {
+		stageId: number;
+		round: GeneratedRound;
+	},
+	trx: DbOrTrx = db,
+): Promise<void> {
+	if (args.round.matches.length === 0) {
+		throw new Error("No matches to insert");
+	}
+
+	await trx
+		.insertInto("TournamentMatch")
+		.values(
+			args.round.matches.map((match) => ({
+				stageId: args.stageId,
+				groupId: args.round.groupId,
+				roundId: args.round.roundId,
+				number: match.number,
+				opponentOne: serializeOpponent(match.opponent1),
+				opponentTwo: serializeOpponent(match.opponent2),
+				winnerSide: null,
+				chatCode: shortNanoid(),
+				// swiss rounds are only generated once they can be played
+				startedAt:
+					match.opponent1?.id && match.opponent2?.id
+						? databaseTimestampNow()
+						: null,
+			})),
+		)
+		.execute();
+}
+
+/** DELETEs a round's matches (swiss unadvance). */
+export async function deleteRoundMatches(args: {
+	groupId: number;
+	roundId: number;
+}): Promise<void> {
+	await db
+		.deleteFrom("TournamentMatch")
+		.where("groupId", "=", args.groupId)
+		.where("roundId", "=", args.roundId)
+		.execute();
+}
+
+/** Deletes the whole stage subtree (matches, rounds, groups, stage). */
+export function resetBracket(tournamentStageId: number) {
+	return db.transaction().execute(async (trx) => {
+		await trx
+			.deleteFrom("TournamentMatch")
+			.where("stageId", "=", tournamentStageId)
+			.execute();
+
+		await trx
+			.deleteFrom("TournamentRound")
+			.where("stageId", "=", tournamentStageId)
+			.execute();
+
+		await trx
+			.deleteFrom("TournamentGroup")
+			.where("stageId", "=", tournamentStageId)
+			.execute();
+
+		await trx
+			.deleteFrom("TournamentStage")
+			.where("id", "=", tournamentStageId)
+			.execute();
+	});
+}
+
+/** Opponents are stored as JSON with the SQL-aggregated fields stripped (NULL for BYEs). */
+function serializeOpponent(opponent: ParticipantResult | null): string | null {
+	if (!opponent) return null;
+
+	const { totalKos, ...persisted } = opponent;
+	return JSON.stringify(persisted);
+}
diff --git a/app/features/tournament-bracket/actions/to.$id.brackets.server.ts b/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
index 8d4b32356..47b570de1 100644
--- a/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
+++ b/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
@@ -1,5 +1,4 @@
 import type { ActionFunction } from "react-router";
-import { sql } from "~/db/sql";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
 import { notify } from "~/features/notifications/core/notify.server";
@@ -7,12 +6,9 @@ import {
 	calculateTournamentTierFromTeams,
 	MIN_TEAMS_FOR_TIERING,
 } from "~/features/tournament/core/tiering";
-import { createSwissBracketInTransaction } from "~/features/tournament/queries/createSwissBracketInTransaction.server";
-import { updateRoundMaps } from "~/features/tournament/queries/updateRoundMaps.server";
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
 import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
-import { roundMapsFromInput } from "~/features/tournament-match/core/mapList.server";
 import invariant from "~/utils/invariant";
 import { logger } from "~/utils/logger";
 import {
@@ -24,20 +20,17 @@ import {
 import { assertUnreachable } from "~/utils/types";
 import { idObject } from "~/utils/zod";
 import type { PreparedMaps } from "../../../db/tables";
+import * as BracketRepository from "../BracketRepository.server";
 import * as AbDivisions from "../core/AbDivisions";
-import { getServerTournamentManager } from "../core/brackets-manager/manager.server";
+import * as Engine from "../core/engine";
 import * as PreparedMapsUtils from "../core/PreparedMaps";
-import * as Swiss from "../core/Swiss";
 import type { Tournament } from "../core/Tournament";
 import {
 	clearTournamentDataCache,
 	tournamentFromDB,
 } from "../core/Tournament.server";
 import { bracketSchema } from "../tournament-bracket-schemas.server";
-import {
-	fillWithNullTillPowerOfTwo,
-	tournamentWebsocketRoom,
-} from "../tournament-bracket-utils";
+import { tournamentWebsocketRoom } from "../tournament-bracket-utils";
 
 export const action: ActionFunction = async ({ params, request }) => {
 	const user = requireUser();
@@ -47,7 +40,6 @@ export const action: ActionFunction = async ({ params, request }) => {
 	});
 	const tournament = await tournamentFromDB({ tournamentId, user });
 	const data = await parseRequestPayload({ request, schema: bracketSchema });
-	const manager = getServerTournamentManager();
 
 	let emitTournamentUpdate = false;
 
@@ -70,16 +62,15 @@ export const action: ActionFunction = async ({ params, request }) => {
 				"Bracket is not ready to be started",
 			);
 
-			const groupCount = new Set(bracket.data.round.map((r) => r.group_id))
-				.size;
+			const groupCount = new Set(bracket.data.round.map((r) => r.groupId)).size;
 
-			const settings = tournament.bracketManagerSettings(
-				bracket.settings,
-				bracket.type,
-				seeding.length,
-			);
+			const hasThirdPlaceMatch = Engine.hasThirdPlaceMatch({
+				type: bracket.type,
+				settings: bracket.settings,
+				participantsCount: seeding.length,
+			});
 
-			const maps = settings.consolationFinal
+			const maps = hasThirdPlaceMatch
 				? adjustLinkedRounds({
 						maps: data.maps,
 						thirdPlaceMatchLinked: data.thirdPlaceMatchLinked,
@@ -105,38 +96,20 @@ export const action: ActionFunction = async ({ params, request }) => {
 				"Invalid map count",
 			);
 
-			sql.transaction(() => {
-				const stage =
-					bracket.type === "swiss"
-						? createSwissBracketInTransaction(
-								Swiss.create({
-									name: bracket.name,
-									seeding,
-									tournamentId,
-									settings,
-								}),
-							)
-						: manager.create({
-								tournamentId,
-								name: bracket.name,
-								type: bracket.type,
-								seeding:
-									bracket.type === "round_robin"
-										? seeding
-										: fillWithNullTillPowerOfTwo(seeding),
-								settings,
-								abDivisions,
-							});
+			const createdBracket = Engine.create({
+				type: bracket.type,
+				seeding,
+				settings: bracket.settings,
+				independentRounds: tournament.isLeagueDivision,
+				abDivisions,
+				maps,
+			});
 
-				updateRoundMaps(
-					roundMapsFromInput({
-						virtualRounds: bracket.data.round,
-						roundsFromDB: manager.get.stageData(stage.id).round,
-						maps,
-						bracket,
-					}),
-				);
-			})();
+			await BracketRepository.insertBracket({
+				tournamentId,
+				name: bracket.name,
+				bracket: createdBracket,
+			});
 
 			// persist maps as prepared even if they weren't initially so sibling brackets can reuse them
 			const existingPreparedMaps =
@@ -229,11 +202,12 @@ export const action: ActionFunction = async ({ params, request }) => {
 				"Bracket has started, preparing maps no longer possible",
 			);
 
-			const hasThirdPlaceMatch = tournament.bracketManagerSettings(
-				bracket.settings,
-				bracket.type,
-				data.eliminationTeamCount ?? (bracket.seeding ?? []).length,
-			).consolationFinal;
+			const hasThirdPlaceMatch = Engine.hasThirdPlaceMatch({
+				type: bracket.type,
+				settings: bracket.settings,
+				participantsCount:
+					data.eliminationTeamCount ?? (bracket.seeding ?? []).length,
+			});
 
 			await TournamentRepository.upsertPreparedMaps({
 				bracketIdx: data.bracketIdx,
@@ -257,14 +231,23 @@ export const action: ActionFunction = async ({ params, request }) => {
 			const bracket = tournament.bracketByIdx(data.bracketIdx);
 			errorToastIfFalsy(bracket, "Bracket not found");
 
-			const matches = Swiss.generateMatchUps({
-				bracket,
+			const round = Engine.generateRound(bracket.data, {
 				groupId: data.groupId,
+				standings: bracket.standings,
+				settings: bracket.settings,
 			});
 
-			errorToastIfErr(matches);
+			errorToastIfErr(round);
 
-			await TournamentRepository.insertSwissMatches(matches.value);
+			const stageId = bracket.data.match.find(
+				(match) => match.groupId === data.groupId,
+			)?.stageId;
+			errorToastIfFalsy(stageId, "No matches found for group");
+
+			await BracketRepository.insertRoundMatches({
+				stageId,
+				round: round.value,
+			});
 
 			emitTournamentUpdate = true;
 
@@ -281,7 +264,7 @@ export const action: ActionFunction = async ({ params, request }) => {
 			);
 			errorToastIfFalsyNoFollowUpBrackets(tournament);
 
-			await TournamentRepository.deleteSwissMatches({
+			await BracketRepository.deleteRoundMatches({
 				groupId: data.groupId,
 				roundId: data.roundId,
 			});
diff --git a/app/features/tournament-bracket/components/Bracket/Bracket.browser.test.tsx b/app/features/tournament-bracket/components/Bracket/Bracket.browser.test.tsx
index a68523637..e4218f916 100644
--- a/app/features/tournament-bracket/components/Bracket/Bracket.browser.test.tsx
+++ b/app/features/tournament-bracket/components/Bracket/Bracket.browser.test.tsx
@@ -2,7 +2,7 @@ import { createMemoryRouter, RouterProvider } from "react-router";
 import { describe, expect, test, vi } from "vitest";
 import { render } from "vitest-browser-react";
 import styles from "~/features/tournament-bracket/components/Bracket/bracket.module.css";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import type { Bracket as BracketType } from "../../core/Bracket";
 import { EliminationBracketSide } from "./Elimination";
 import { Bracket } from "./index";
@@ -108,7 +108,7 @@ vi.mock("~/features/tournament/routes/to.$id", () => ({
 	useStreamingParticipants: () => [],
 }));
 
-function createSingleEliminationData(): TournamentManagerDataSet {
+function createSingleEliminationData(): BracketData {
 	return {
 		stage: [
 			{
@@ -116,31 +116,30 @@ function createSingleEliminationData(): TournamentManagerDataSet {
 				name: "Main Bracket",
 				number: 1,
 				type: "single_elimination",
-				tournament_id: 1,
-				settings: { size: 8 },
+				settings: {},
 			},
 		],
-		group: [{ id: 1, number: 1, stage_id: 1 }],
+		group: [{ id: 1, number: 1, stageId: 1 }],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 1,
+				groupId: 1,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 5, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -148,78 +147,78 @@ function createSingleEliminationData(): TournamentManagerDataSet {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 8, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 8, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 4, score: 2, result: "win" },
-				opponent2: { id: 5, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 4, score: 2 },
+				opponent2: { id: 5, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 3,
 				number: 3,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 3, score: 0, result: "loss" },
-				opponent2: { id: 6, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 3, score: 0 },
+				opponent2: { id: 6, score: 2 },
+				winnerSide: "opponent2",
 			},
 			{
 				id: 4,
 				number: 4,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 2, score: 2, result: "win" },
-				opponent2: { id: 7, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 2, score: 2 },
+				opponent2: { id: 7, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 5,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 4, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 4, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 6,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 2,
-				opponent1: { id: 6, score: 1, result: "loss" },
-				opponent2: { id: 2, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
+				opponent1: { id: 6, score: 1 },
+				opponent2: { id: 2, score: 2 },
+				winnerSide: "opponent2",
 			},
 			{
 				id: 7,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 3,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 3,
 				opponent1: { id: 1 },
 				opponent2: { id: 2 },
+				winnerSide: null,
 			},
 		],
 	};
 }
 
-function createByeHeavySingleEliminationData(): TournamentManagerDataSet {
+function createByeHeavySingleEliminationData(): BracketData {
 	return {
 		stage: [
 			{
@@ -227,31 +226,30 @@ function createByeHeavySingleEliminationData(): TournamentManagerDataSet {
 				name: "Main Bracket",
 				number: 1,
 				type: "single_elimination",
-				tournament_id: 1,
-				settings: { size: 8 },
+				settings: {},
 			},
 		],
-		group: [{ id: 1, number: 1, stage_id: 1 }],
+		group: [{ id: 1, number: 1, stageId: 1 }],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 1,
+				groupId: 1,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 5, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -260,80 +258,80 @@ function createByeHeavySingleEliminationData(): TournamentManagerDataSet {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
 				opponent1: { id: 1 },
 				opponent2: null,
+				winnerSide: null,
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 3,
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
 				opponent1: { id: 4, score: 1 },
 				opponent2: { id: 5, score: 1 },
+				winnerSide: null,
 			},
 			{
 				id: 3,
 				number: 3,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
 				opponent1: { id: 2 },
 				opponent2: null,
+				winnerSide: null,
 			},
 			{
 				id: 4,
 				number: 4,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
 				opponent1: { id: 3 },
 				opponent2: null,
+				winnerSide: null,
 			},
 			// Round 2 - Semis
 			{
 				id: 5,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
 				opponent1: { id: 1 },
 				opponent2: { id: null },
+				winnerSide: null,
 			},
 			{
 				id: 6,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
 				opponent1: { id: 2 },
 				opponent2: { id: 3 },
+				winnerSide: null,
 			},
 			// Round 3 - Finals
 			{
 				id: 7,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 3,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 3,
 				opponent1: { id: null },
 				opponent2: { id: null },
+				winnerSide: null,
 			},
 		],
 	};
 }
 
-function createDoubleEliminationData(): TournamentManagerDataSet {
+function createDoubleEliminationData(): BracketData {
 	return {
 		stage: [
 			{
@@ -341,41 +339,40 @@ function createDoubleEliminationData(): TournamentManagerDataSet {
 				name: "Main Bracket",
 				number: 1,
 				type: "double_elimination",
-				tournament_id: 1,
-				settings: { size: 4, grandFinal: "double" },
+				settings: {},
 			},
 		],
 		group: [
-			{ id: 1, number: 1, stage_id: 1 },
-			{ id: 2, number: 2, stage_id: 1 },
+			{ id: 1, number: 1, stageId: 1 },
+			{ id: 2, number: 2, stageId: 1 },
 		],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 5, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 2,
+				groupId: 2,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 4,
-				group_id: 2,
+				groupId: 2,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 5, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -383,58 +380,58 @@ function createDoubleEliminationData(): TournamentManagerDataSet {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 4, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 4, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 2, score: 2, result: "win" },
-				opponent2: { id: 3, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 2, score: 2 },
+				opponent2: { id: 3, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 3,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
 				opponent1: { id: 1 },
 				opponent2: { id: 2 },
+				winnerSide: null,
 			},
 			{
 				id: 4,
 				number: 1,
-				stage_id: 1,
-				group_id: 2,
-				round_id: 3,
-				status: 2,
-				opponent1: { id: 4, score: 1, result: "loss" },
-				opponent2: { id: 3, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 2,
+				roundId: 3,
+				opponent1: { id: 4, score: 1 },
+				opponent2: { id: 3, score: 2 },
+				winnerSide: "opponent2",
 			},
 			{
 				id: 5,
 				number: 1,
-				stage_id: 1,
-				group_id: 2,
-				round_id: 4,
-				status: 4,
+				stageId: 1,
+				groupId: 2,
+				roundId: 4,
 				opponent1: { id: 3 },
 				opponent2: { id: null },
+				winnerSide: null,
 			},
 		],
 	};
 }
 
-function createRoundRobinData(): TournamentManagerDataSet {
+function createRoundRobinData(): BracketData {
 	return {
 		stage: [
 			{
@@ -442,55 +439,54 @@ function createRoundRobinData(): TournamentManagerDataSet {
 				name: "Group Stage",
 				number: 1,
 				type: "round_robin",
-				tournament_id: 1,
-				settings: { groupCount: 2, roundRobinMode: "simple", size: 6 },
+				settings: { groupCount: 2 },
 			},
 		],
 		group: [
-			{ id: 1, number: 1, stage_id: 1 },
-			{ id: 2, number: 2, stage_id: 1 },
+			{ id: 1, number: 1, stageId: 1 },
+			{ id: 2, number: 2, stageId: 1 },
 		],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 1,
+				groupId: 1,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 4,
-				group_id: 2,
+				groupId: 2,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 5,
-				group_id: 2,
+				groupId: 2,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 6,
-				group_id: 2,
+				groupId: 2,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -498,68 +494,68 @@ function createRoundRobinData(): TournamentManagerDataSet {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 2, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 2, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 3, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 3, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 3,
 				number: 3,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 3,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 3,
 				opponent1: { id: 2 },
 				opponent2: { id: 3 },
+				winnerSide: null,
 			},
 			{
 				id: 4,
 				number: 1,
-				stage_id: 1,
-				group_id: 2,
-				round_id: 4,
-				status: 2,
-				opponent1: { id: 4, score: 2, result: "win" },
-				opponent2: { id: 5, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 2,
+				roundId: 4,
+				opponent1: { id: 4, score: 2 },
+				opponent2: { id: 5, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 5,
 				number: 2,
-				stage_id: 1,
-				group_id: 2,
-				round_id: 5,
-				status: 4,
+				stageId: 1,
+				groupId: 2,
+				roundId: 5,
 				opponent1: { id: 4 },
 				opponent2: { id: 6 },
+				winnerSide: null,
 			},
 			{
 				id: 6,
 				number: 3,
-				stage_id: 1,
-				group_id: 2,
-				round_id: 6,
-				status: 4,
+				stageId: 1,
+				groupId: 2,
+				roundId: 6,
 				opponent1: { id: 5 },
 				opponent2: { id: 6 },
+				winnerSide: null,
 			},
 		],
 	};
 }
 
-function createSwissData(): TournamentManagerDataSet {
+function createSwissData(): BracketData {
 	return {
 		stage: [
 			{
@@ -567,31 +563,30 @@ function createSwissData(): TournamentManagerDataSet {
 				name: "Swiss Stage",
 				number: 1,
 				type: "swiss",
-				tournament_id: 1,
 				settings: { groupCount: 1 },
 			},
 		],
-		group: [{ id: 1, number: 1, stage_id: 1 }],
+		group: [{ id: 1, number: 1, stageId: 1 }],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 1,
+				groupId: 1,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -599,62 +594,62 @@ function createSwissData(): TournamentManagerDataSet {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 1, score: 2, result: "win" },
-				opponent2: { id: 8, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 1, score: 2 },
+				opponent2: { id: 8, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 2, score: 2, result: "win" },
-				opponent2: { id: 7, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 2, score: 2 },
+				opponent2: { id: 7, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 3,
 				number: 3,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 3, score: 1, result: "loss" },
-				opponent2: { id: 6, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 3, score: 1 },
+				opponent2: { id: 6, score: 2 },
+				winnerSide: "opponent2",
 			},
 			{
 				id: 4,
 				number: 4,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 4, score: 0, result: "loss" },
-				opponent2: { id: 5, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 4, score: 0 },
+				opponent2: { id: 5, score: 2 },
+				winnerSide: "opponent2",
 			},
 			{
 				id: 5,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
 				opponent1: { id: 1 },
 				opponent2: { id: 2 },
+				winnerSide: null,
 			},
 			{
 				id: 6,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
 				opponent1: { id: 5 },
 				opponent2: { id: 6 },
+				winnerSide: null,
 			},
 		],
 	};
@@ -662,7 +657,7 @@ function createSwissData(): TournamentManagerDataSet {
 
 function createLargeSingleEliminationData(options?: {
 	ongoingRoundIdx?: number;
-}): TournamentManagerDataSet {
+}): BracketData {
 	const { ongoingRoundIdx } = options ?? {};
 
 	return {
@@ -672,38 +667,37 @@ function createLargeSingleEliminationData(options?: {
 				name: "Main Bracket",
 				number: 1,
 				type: "single_elimination",
-				tournament_id: 1,
-				settings: { size: 16 },
+				settings: {},
 			},
 		],
-		group: [{ id: 1, number: 1, stage_id: 1 }],
+		group: [{ id: 1, number: 1, stageId: 1 }],
 		round: [
 			{
 				id: 1,
-				group_id: 1,
+				groupId: 1,
 				number: 1,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 2,
-				group_id: 1,
+				groupId: 1,
 				number: 2,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 3,
-				group_id: 1,
+				groupId: 1,
 				number: 3,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 3, type: "BEST_OF", pickBan: null },
 			},
 			{
 				id: 4,
-				group_id: 1,
+				groupId: 1,
 				number: 4,
-				stage_id: 1,
+				stageId: 1,
 				maps: { count: 5, type: "BEST_OF", pickBan: null },
 			},
 		],
@@ -712,103 +706,85 @@ function createLargeSingleEliminationData(options?: {
 			{
 				id: 1,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: ongoingRoundIdx === 0 ? 3 : 2,
-				opponent1:
-					ongoingRoundIdx === 0
-						? { id: 1, score: 1 }
-						: { id: 1, score: 2, result: "win" },
-				opponent2:
-					ongoingRoundIdx === 0
-						? { id: 8, score: 1 }
-						: { id: 8, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 1, score: ongoingRoundIdx === 0 ? 1 : 2 },
+				opponent2: { id: 8, score: ongoingRoundIdx === 0 ? 1 : 0 },
+				winnerSide: ongoingRoundIdx === 0 ? null : "opponent1",
 			},
 			{
 				id: 2,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 2, score: 2, result: "win" },
-				opponent2: { id: 7, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 2, score: 2 },
+				opponent2: { id: 7, score: 0 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 3,
 				number: 3,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 3, score: 2, result: "win" },
-				opponent2: { id: 6, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 3, score: 2 },
+				opponent2: { id: 6, score: 1 },
+				winnerSide: "opponent1",
 			},
 			{
 				id: 4,
 				number: 4,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 1,
-				status: 2,
-				opponent1: { id: 4, score: 2, result: "win" },
-				opponent2: { id: 5, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 1,
+				opponent1: { id: 4, score: 2 },
+				opponent2: { id: 5, score: 0 },
+				winnerSide: "opponent1",
 			},
 			// Round 2 - 4 matches (all completed unless ongoingRoundIdx === 1)
 			{
 				id: 5,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: ongoingRoundIdx === 1 ? 3 : 2,
-				opponent1:
-					ongoingRoundIdx === 1
-						? { id: 1, score: 1 }
-						: { id: 1, score: 2, result: "win" },
-				opponent2:
-					ongoingRoundIdx === 1
-						? { id: 2, score: 1 }
-						: { id: 2, score: 1, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
+				opponent1: { id: 1, score: ongoingRoundIdx === 1 ? 1 : 2 },
+				opponent2: { id: 2, score: 1 },
+				winnerSide: ongoingRoundIdx === 1 ? null : "opponent1",
 			},
 			{
 				id: 6,
 				number: 2,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 2,
-				status: 2,
-				opponent1: { id: 3, score: 1, result: "loss" },
-				opponent2: { id: 4, score: 2, result: "win" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 2,
+				opponent1: { id: 3, score: 1 },
+				opponent2: { id: 4, score: 2 },
+				winnerSide: "opponent2",
 			},
 			// Round 3 - Semifinals (completed unless ongoingRoundIdx === 2)
 			{
 				id: 7,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 3,
-				status: ongoingRoundIdx === 2 ? 3 : 2,
-				opponent1:
-					ongoingRoundIdx === 2
-						? { id: 1, score: 1 }
-						: { id: 1, score: 2, result: "win" },
-				opponent2:
-					ongoingRoundIdx === 2
-						? { id: 4, score: 1 }
-						: { id: 4, score: 0, result: "loss" },
+				stageId: 1,
+				groupId: 1,
+				roundId: 3,
+				opponent1: { id: 1, score: ongoingRoundIdx === 2 ? 1 : 2 },
+				opponent2: { id: 4, score: ongoingRoundIdx === 2 ? 1 : 0 },
+				winnerSide: ongoingRoundIdx === 2 ? null : "opponent1",
 			},
 			// Round 4 - Finals (ongoing by default)
 			{
 				id: 8,
 				number: 1,
-				stage_id: 1,
-				group_id: 1,
-				round_id: 4,
-				status: 4,
+				stageId: 1,
+				groupId: 1,
+				roundId: 4,
 				opponent1: { id: 1 },
 				opponent2: { id: 4 },
+				winnerSide: null,
 			},
 		],
 	};
@@ -816,7 +792,7 @@ function createLargeSingleEliminationData(options?: {
 
 function createMockBracket(
 	type: "single_elimination" | "double_elimination" | "round_robin" | "swiss",
-	data: TournamentManagerDataSet,
+	data: BracketData,
 ): BracketType {
 	return {
 		id: 1,
diff --git a/app/features/tournament-bracket/components/Bracket/Elimination.tsx b/app/features/tournament-bracket/components/Bracket/Elimination.tsx
index 859efdee6..2f857de74 100644
--- a/app/features/tournament-bracket/components/Bracket/Elimination.tsx
+++ b/app/features/tournament-bracket/components/Bracket/Elimination.tsx
@@ -33,14 +33,10 @@ export function EliminationBracketSide(props: EliminationBracketSideProps) {
 				if (roundIdx >= rounds.length - 2) return false;
 
 				const roundMatches = props.bracket.data.match.filter(
-					(match) => match.round_id === round.id,
+					(match) => match.roundId === round.id,
 				);
 				return !roundMatches.some(
-					(match) =>
-						match.opponent1 &&
-						match.opponent2 &&
-						match.opponent1.result !== "win" &&
-						match.opponent2.result !== "win",
+					(match) => match.opponent1 && match.opponent2 && !match.winnerSide,
 				);
 			})
 			.map((round) => round.id),
@@ -50,7 +46,7 @@ export function EliminationBracketSide(props: EliminationBracketSideProps) {
 		(round) => !hiddenRoundIds.has(round.id),
 	);
 	const firstVisibleRoundMatchCount = props.bracket.data.match.filter(
-		(match) => match.round_id === firstVisibleRound?.id,
+		(match) => match.roundId === firstVisibleRound?.id,
 	).length;
 
 	const compactedFirstRoundId = resolveCompactedFirstRoundId({
@@ -73,7 +69,7 @@ export function EliminationBracketSide(props: EliminationBracketSideProps) {
 				const bestOf = round.maps?.count;
 
 				const allRoundMatches = props.bracket.data.match.filter(
-					(match) => match.round_id === round.id,
+					(match) => match.roundId === round.id,
 				);
 				const matches =
 					round.id === compactedFirstRoundId
@@ -88,16 +84,12 @@ export function EliminationBracketSide(props: EliminationBracketSideProps) {
 				const nextRound = rounds[roundIdx + 1];
 				const nextRoundMatchCount = nextRound
 					? props.bracket.data.match.filter(
-							(match) => match.round_id === nextRound.id,
+							(match) => match.roundId === nextRound.id,
 						).length
 					: 0;
 
 				const someMatchOngoing = matches.some(
-					(match) =>
-						match.opponent1 &&
-						match.opponent2 &&
-						match.opponent1.result !== "win" &&
-						match.opponent2.result !== "win",
+					(match) => match.opponent1 && match.opponent2 && !match.winnerSide,
 				);
 
 				if (hiddenRoundIds.has(round.id)) {
@@ -219,10 +211,10 @@ function resolveCompactedFirstRoundId(args: {
 	if (firstRound.id !== args.firstVisibleRoundId) return null;
 
 	const firstRoundMatches = args.bracketData.match.filter(
-		(match) => match.round_id === firstRound.id,
+		(match) => match.roundId === firstRound.id,
 	);
 	const secondRoundMatchCount = args.bracketData.match.filter(
-		(match) => match.round_id === secondRound.id,
+		(match) => match.roundId === secondRound.id,
 	).length;
 	if (firstRoundMatches.length !== secondRoundMatchCount * 2) return null;
 
diff --git a/app/features/tournament-bracket/components/Bracket/Match.tsx b/app/features/tournament-bracket/components/Bracket/Match.tsx
index b56f2affd..a1fe03907 100644
--- a/app/features/tournament-bracket/components/Bracket/Match.tsx
+++ b/app/features/tournament-bracket/components/Bracket/Match.tsx
@@ -11,7 +11,7 @@ import {
 	useTournament,
 	useTournamentVods,
 } from "~/features/tournament/routes/to.$id";
-import { matchEndedEarly } from "~/features/tournament-match/tournament-match-utils";
+import { matchEndedEarly } from "~/features/tournament-bracket/core/engine";
 import { useAutoRerender } from "~/hooks/useAutoRerender";
 import { databaseTimestampToDate } from "~/utils/dates";
 import type { Unpacked } from "~/utils/types";
@@ -88,8 +88,7 @@ function MatchHeader({ match, type, roundNumber, group }: MatchProps) {
 		return "";
 	};
 
-	const isOver =
-		match.opponent1?.result === "win" || match.opponent2?.result === "win";
+	const isOver = Boolean(match.winnerSide);
 	const matchVods = isOver ? vods.filter((v) => v.matchId === match.id) : [];
 	const hasStreams = () => {
 		if (isOver || !match.opponent1?.id || !match.opponent2?.id) return false;
@@ -218,27 +217,29 @@ function MatchRow({
 		if (!match.opponent1?.id || !match.opponent2?.id || isPreview) return null;
 
 		const opponentScore = opponent!.score;
-		const opponentResult = opponent!.result;
 
 		// Display W/L as the score might not reflect the winner set in the early ending
-		const round = bracket.data.round.find((r) => r.id === match.round_id);
+		const round = bracket.data.round.find((r) => r.id === match.roundId);
 		if (
 			round?.maps &&
 			matchEndedEarly({
 				opponentOne: match.opponent1,
 				opponentTwo: match.opponent2,
+				winnerSide: match.winnerSide,
 				count: round.maps.count,
 				countType: round.maps.type,
 			})
 		) {
-			if (opponentResult === "win") return "W";
-			if (opponentResult === "loss") return "L";
+			return match.winnerSide === opponentKey ? "W" : "L";
 		}
 
 		return opponentScore ?? 0;
 	};
 
-	const isLoser = spoilerCensor ? false : opponent?.result === "loss";
+	const isLoser =
+		spoilerCensor || !match.winnerSide
+			? false
+			: match.winnerSide !== opponentKey;
 
 	const { team, simulated } = (() => {
 		if (opponent?.id) {
@@ -424,8 +425,7 @@ function MatchTimer({ match, bracket }: Pick<MatchProps, "match" | "bracket">) {
 	if (tournament.isLeagueDivision) return null;
 	if (!match.startedAt) return null;
 
-	const isOver =
-		match.opponent1?.result === "win" || match.opponent2?.result === "win";
+	const isOver = Boolean(match.winnerSide);
 	if (isOver) return null;
 
 	const isLocked = tournament.ctx.castedMatchesInfo?.lockedMatches?.some(
@@ -433,7 +433,7 @@ function MatchTimer({ match, bracket }: Pick<MatchProps, "match" | "bracket">) {
 	);
 	if (isLocked) return null;
 
-	const round = bracket.data.round.find((r) => r.id === match.round_id);
+	const round = bracket.data.round.find((r) => r.id === match.roundId);
 	const bestOf = round?.maps?.count;
 	if (!bestOf) return null;
 
diff --git a/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx b/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
index d05f9041f..d547d2bd2 100644
--- a/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
+++ b/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
@@ -10,10 +10,9 @@ import {
 	tournamentTeamPage,
 } from "../../../../utils/urls";
 import { useUser } from "../../../auth/core/user";
-import { TOURNAMENT } from "../../../tournament/tournament-constants";
 import type { Bracket, Standing } from "../../core/Bracket";
+import * as Swiss from "../../core/engine/swiss/team-status";
 import * as Progression from "../../core/Progression";
-import * as Swiss from "../../core/Swiss";
 import styles from "./bracket.module.css";
 
 export function PlacementsTable({
@@ -32,7 +31,7 @@ export function PlacementsTable({
 		.filter((s) => s.groupId === groupId);
 
 	const missingTeams = bracket.data.match.reduce((acc, cur) => {
-		if (cur.group_id !== groupId) return acc;
+		if (cur.groupId !== groupId) return acc;
 
 		if (
 			cur.opponent1?.id &&
@@ -60,7 +59,6 @@ export function PlacementsTable({
 				stats: {
 					mapLosses: 0,
 					mapWins: 0,
-					points: 0,
 					koCount: 0,
 					setLosses: 0,
 					setWins: 0,
@@ -88,8 +86,7 @@ export function PlacementsTable({
 				advanceThreshold: bracket.settings.advanceThreshold,
 				losses: stats.setLosses,
 				wins: stats.setWins,
-				roundCount:
-					bracket.settings.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT,
+				roundCount: bracket.swissRoundCount,
 			}) === "advanced"
 				? bracket.tournament.brackets.find((otherBracket) =>
 						otherBracket.sources?.some(
@@ -289,9 +286,7 @@ function StandingsTable({
 							advanceThreshold: bracket.settings.advanceThreshold,
 							losses: s.stats.setLosses,
 							wins: s.stats.setWins,
-							roundCount:
-								bracket.settings.roundCount ??
-								TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT,
+							roundCount: bracket.swissRoundCount,
 						}) === "eliminated";
 
 					if (renderQualifiedRow) qualifiedRowRendered = true;
diff --git a/app/features/tournament-bracket/components/Bracket/RoundRobin.tsx b/app/features/tournament-bracket/components/Bracket/RoundRobin.tsx
index 9f399d9a3..b2c2fe04d 100644
--- a/app/features/tournament-bracket/components/Bracket/RoundRobin.tsx
+++ b/app/features/tournament-bracket/components/Bracket/RoundRobin.tsx
@@ -1,4 +1,4 @@
-import type { Match as MatchType } from "~/modules/brackets-model";
+import type { MatchData as MatchType } from "~/features/tournament-bracket/core/engine/types";
 import type { Bracket as BracketType } from "../../core/Bracket";
 import { groupNumberToLetters } from "../../tournament-bracket-utils";
 import styles from "./bracket.module.css";
@@ -14,19 +14,15 @@ export function RoundRobinBracket({ bracket }: { bracket: BracketType }) {
 	return (
 		<div className="stack xl">
 			{groups.map(({ groupName, groupId }) => {
-				const rounds = bracket.data.round.filter((r) => r.group_id === groupId);
+				const rounds = bracket.data.round.filter((r) => r.groupId === groupId);
 
 				const allMatchesFinished = rounds.every((round) => {
 					const matches = bracket.data.match.filter(
-						(match) => match.round_id === round.id,
+						(match) => match.roundId === round.id,
 					);
 
 					return matches.every(
-						(match) =>
-							!match.opponent1 ||
-							!match.opponent2 ||
-							match.opponent1?.result === "win" ||
-							match.opponent2?.result === "win",
+						(match) => !match.opponent1 || !match.opponent2 || match.winnerSide,
 					);
 				});
 
@@ -41,15 +37,12 @@ export function RoundRobinBracket({ bracket }: { bracket: BracketType }) {
 								const bestOf = round.maps?.count;
 
 								const matches = bracket.data.match.filter(
-									(match) => match.round_id === round.id,
+									(match) => match.roundId === round.id,
 								);
 
 								const someMatchOngoing = matches.some(
 									(match) =>
-										match.opponent1 &&
-										match.opponent2 &&
-										match.opponent1.result !== "win" &&
-										match.opponent2.result !== "win",
+										match.opponent1 && match.opponent2 && !match.winnerSide,
 								);
 
 								return (
@@ -114,7 +107,7 @@ function getGroups(bracket: BracketType) {
 
 	for (const group of bracket.data.group) {
 		const matches = bracket.data.match.filter(
-			(match) => match.group_id === group.id,
+			(match) => match.groupId === group.id,
 		);
 
 		result.push({
diff --git a/app/features/tournament-bracket/components/Bracket/Swiss.tsx b/app/features/tournament-bracket/components/Bracket/Swiss.tsx
index fb2809b8f..bc6b1b588 100644
--- a/app/features/tournament-bracket/components/Bracket/Swiss.tsx
+++ b/app/features/tournament-bracket/components/Bracket/Swiss.tsx
@@ -8,8 +8,8 @@ import {
 	useBracketExpanded,
 	useTournament,
 } from "~/features/tournament/routes/to.$id";
+import type { MatchData as MatchType } from "~/features/tournament-bracket/core/engine/types";
 import { useSearchParamState } from "~/hooks/useSearchParamState";
-import type { Match as MatchType } from "~/modules/brackets-model";
 import type { Bracket as BracketType } from "../../core/Bracket";
 import styles from "../../tournament-bracket.module.css";
 import { groupNumberToLetters } from "../../tournament-bracket-utils";
@@ -44,7 +44,7 @@ export function SwissBracket({
 	const selectedGroup = groups.find((g) => g.groupId === selectedGroupId)!;
 
 	const rounds = bracket.data.round.filter(
-		(r) => r.group_id === selectedGroupId,
+		(r) => r.groupId === selectedGroupId,
 	);
 
 	// when bracket starts we go from "virtual id" to a real one
@@ -56,18 +56,14 @@ export function SwissBracket({
 
 	const someMatchOngoing = (matches: MatchType[]) =>
 		matches.some(
-			(match) =>
-				match.opponent1 &&
-				match.opponent2 &&
-				match.opponent1.result !== "win" &&
-				match.opponent2.result !== "win",
+			(match) => match.opponent1 && match.opponent2 && !match.winnerSide,
 		);
 
 	const allRoundsFinished = () => {
 		for (const round of rounds) {
 			const matches = bracket.data.match.filter(
 				(match) =>
-					match.round_id === round.id && match.group_id === selectedGroupId,
+					match.roundId === round.id && match.groupId === selectedGroupId,
 			);
 
 			if (matches.length === 0 || someMatchOngoing(matches)) {
@@ -84,7 +80,7 @@ export function SwissBracket({
 		for (const round of rounds) {
 			const matches = bracket.data.match.filter(
 				(match) =>
-					match.round_id === round.id && match.group_id === selectedGroupId,
+					match.roundId === round.id && match.groupId === selectedGroupId,
 			);
 
 			if (someMatchOngoing(matches) && matches.length > 0) {
@@ -127,8 +123,7 @@ export function SwissBracket({
 					{rounds.map((round, roundI) => {
 						const matches = bracket.data.match.filter(
 							(match) =>
-								match.round_id === round.id &&
-								match.group_id === selectedGroupId,
+								match.roundId === round.id && match.groupId === selectedGroupId,
 						);
 
 						if (
@@ -143,11 +138,7 @@ export function SwissBracket({
 						const bestOf = round.maps?.count;
 
 						const ongoingMatches = matches.filter(
-							(m) =>
-								m.opponent1 &&
-								m.opponent2 &&
-								!m.opponent1.result &&
-								!m.opponent2.result,
+							(m) => m.opponent1 && m.opponent2 && !m.winnerSide,
 						);
 						const startedAtValues = ongoingMatches
 							.map((m) => m.startedAt)
@@ -286,7 +277,7 @@ function getGroups(bracket: BracketType) {
 
 	for (const group of bracket.data.group) {
 		const matches = bracket.data.match.filter(
-			(match) => match.group_id === group.id,
+			(match) => match.groupId === group.id,
 		);
 
 		result.push({
diff --git a/app/features/tournament-bracket/components/BracketMapListDialog.tsx b/app/features/tournament-bracket/components/BracketMapListDialog.tsx
index 34ba9da6a..37b65ce75 100644
--- a/app/features/tournament-bracket/components/BracketMapListDialog.tsx
+++ b/app/features/tournament-bracket/components/BracketMapListDialog.tsx
@@ -29,8 +29,8 @@ import {
 	useTournamentPreparedMaps,
 } from "~/features/tournament/routes/to.$id";
 import { TOURNAMENT } from "~/features/tournament/tournament-constants";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import * as PickBan from "~/features/tournament-bracket/core/PickBan";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
 import { modesShort } from "~/modules/in-game-lists/modes";
 import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
 import { nullFilledArray } from "~/utils/arrays";
@@ -40,6 +40,7 @@ import { calendarEditPage } from "~/utils/urls";
 import { SendouButton } from "../../../components/elements/Button";
 import { logger } from "../../../utils/logger";
 import type { Bracket } from "../core/Bracket";
+import * as Engine from "../core/engine";
 import * as PreparedMaps from "../core/PreparedMaps";
 import { getRounds } from "../core/rounds";
 import type { Tournament } from "../core/Tournament";
@@ -99,11 +100,11 @@ export function BracketMapListDialog({
 	const [thirdPlaceMatchLinked, setThirdPlaceMatchLinked] = React.useState(
 		() => {
 			if (
-				!tournament.bracketManagerSettings(
-					bracket.settings,
-					bracket.type,
-					eliminationTeamCount ?? 2,
-				).consolationFinal
+				!Engine.hasThirdPlaceMatch({
+					type: bracket.type,
+					settings: bracket.settings,
+					participantsCount: eliminationTeamCount ?? 2,
+				})
 			) {
 				return true; // default to true if not applicable or elimination team count not yet set (initial state)
 			}
@@ -209,12 +210,12 @@ export function BracketMapListDialog({
 		if (bracket.type === "single_elimination") {
 			const rounds = getRounds({ type: "single", bracketData });
 
-			const hasThirdPlaceMatch = rounds.some((round) => round.group_id === 1);
+			const hasThirdPlaceMatch = rounds.some((round) => round.groupId === 1);
 
 			if (!thirdPlaceMatchLinked || !hasThirdPlaceMatch) return rounds;
 
 			return rounds
-				.filter((round) => round.group_id !== 1)
+				.filter((round) => round.groupId !== 1)
 				.map((round) =>
 					round.name === "Finals"
 						? {
@@ -342,7 +343,7 @@ export function BracketMapListDialog({
 						Array.from(maps.entries()).map(([key, value]) => ({
 							...value,
 							roundId: key,
-							groupId: rounds.find((r) => r.id === key)?.group_id,
+							groupId: rounds.find((r) => r.id === key)?.groupId,
 							type: countType,
 							customFlow: value.pickBan === "CUSTOM" ? customFlow : undefined,
 						})),
@@ -579,14 +580,14 @@ export function BracketMapListDialog({
 													);
 
 													const groupInfo = newMapCounts.get(
-														bracketRound.group_id,
+														bracketRound.groupId,
 													);
 													invariant(
 														groupInfo,
 														"Expected group info to be defined",
 													);
 													const oldMapInfo = newMapCounts
-														.get(bracketRound.group_id)
+														.get(bracketRound.groupId)
 														?.get(bracketRound.number);
 													invariant(
 														oldMapInfo,
@@ -714,7 +715,7 @@ function inferMapCounts({
 	tournamentRoundMapList,
 }: {
 	bracket: Bracket;
-	data: TournamentManagerDataSet;
+	data: BracketData;
 	tournamentRoundMapList: TournamentRoundMapList;
 }) {
 	const result: BracketMapCounts = new Map();
@@ -722,7 +723,7 @@ function inferMapCounts({
 	for (const [groupId, value] of bracket.defaultRoundBestOfs(data).entries()) {
 		for (const roundNumber of value.keys()) {
 			const roundId = data.round.find(
-				(round) => round.group_id === groupId && round.number === roundNumber,
+				(round) => round.groupId === groupId && round.number === roundNumber,
 			)?.id;
 			invariant(typeof roundId === "number", "Expected roundId to be defined");
 
diff --git a/app/features/tournament-bracket/core/Bracket.test.ts b/app/features/tournament-bracket/core/Bracket.test.ts
index 5cb8e15bb..f4f8b6bd8 100644
--- a/app/features/tournament-bracket/core/Bracket.test.ts
+++ b/app/features/tournament-bracket/core/Bracket.test.ts
@@ -1,9 +1,9 @@
 import * as R from "remeda";
 import { describe, expect, it } from "vitest";
-import { BracketsManager } from "~/modules/brackets-manager";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
 import invariant from "../../../utils/invariant";
-import * as Swiss from "../core/Swiss";
+import * as Engine from "./engine";
+import { createResolved } from "./engine/create";
+import type { BracketData, MatchData } from "./engine/types";
 import { Tournament } from "./Tournament";
 import { PADDLING_POOL_255 } from "./tests/mocks";
 import { LOW_INK_DECEMBER_2024 } from "./tests/mocks-li";
@@ -98,15 +98,12 @@ describe("swiss standings - losses against tied", () => {
 	});
 
 	const inProgressSwissTestTournament = () => {
-		const data = Swiss.create({
-			tournamentId: 1,
-			name: "Swiss",
+		const data = Engine.create({
+			type: "swiss",
 			seeding: [1, 2, 3],
 			settings: {
-				swiss: {
-					groupCount: 1,
-					roundCount: 5,
-				},
+				groupCount: 1,
+				roundCount: 5,
 			},
 		});
 
@@ -232,17 +229,11 @@ describe("round robin standings - dropped out teams", () => {
 		skipMatchups?: string[];
 		forfeitMatchups?: string[];
 	} = {}) => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "RR",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "round_robin",
 			seeding: [1, 2, 3, 4],
 			settings: {
 				groupCount: 1,
-				seedOrdering: ["groups.seed_optimized"],
 			},
 		});
 
@@ -252,34 +243,27 @@ describe("round robin standings - dropped out teams", () => {
 			winnerScore: number,
 			loserScore: number,
 		) => {
-			const match = storage.select<any>("match", matchId);
-			invariant(match, `match ${matchId} not found`);
-			const winnerIsOpp1 = match.opponent1.id === winnerId;
-			manager.update.match({
-				id: match.id,
-				opponent1: winnerIsOpp1
-					? { score: winnerScore, result: "win" }
-					: { score: loserScore },
-				opponent2: winnerIsOpp1
-					? { score: loserScore }
-					: { score: winnerScore, result: "win" },
-			});
+			const match = matchById(data, matchId);
+			const winnerIsOpp1 = match.opponent1?.id === winnerId;
+			data = Engine.reportResult(data, {
+				matchId,
+				scores: [
+					winnerIsOpp1 ? winnerScore : loserScore,
+					winnerIsOpp1 ? loserScore : winnerScore,
+				],
+				winnerSide: winnerIsOpp1 ? "opponent1" : "opponent2",
+			}).data;
 		};
 
 		// Mimics endDroppedTeamMatches: sets a winner via result only, with no
 		// score recorded on either side (the match was never actually played).
 		const forfeitMatch = (matchId: number, winnerId: number) => {
-			const match = storage.select<any>("match", matchId);
-			invariant(match, `match ${matchId} not found`);
-			manager.update.match({
-				id: match.id,
-				opponent1: {
-					result: match.opponent1.id === winnerId ? "win" : "loss",
-				},
-				opponent2: {
-					result: match.opponent2.id === winnerId ? "win" : "loss",
-				},
-			});
+			const match = matchById(data, matchId);
+			data = Engine.reportResult(data, {
+				matchId,
+				winnerSide:
+					match.opponent1?.id === winnerId ? "opponent1" : "opponent2",
+			}).data;
 		};
 
 		// Team 1 beat everyone, team 2 beat 3 and 4, team 3 beat 4.
@@ -291,9 +275,9 @@ describe("round robin standings - dropped out teams", () => {
 			"2-4": 2,
 			"3-4": 3,
 		};
-		for (const match of storage.select<any>("match")!) {
-			const a = match.opponent1.id as number;
-			const b = match.opponent2.id as number;
+		for (const match of data.match) {
+			const a = match.opponent1!.id as number;
+			const b = match.opponent2!.id as number;
 			const key = a < b ? `${a}-${b}` : `${b}-${a}`;
 			if (skipMatchups.includes(key)) continue;
 			const winnerId = winnerByMatchup[key];
@@ -305,8 +289,6 @@ describe("round robin standings - dropped out teams", () => {
 			}
 		}
 
-		const data = manager.get.tournamentData(1);
-
 		return testTournament({
 			ctx: {
 				settings: {
@@ -410,19 +392,13 @@ describe("round robin standings - dropped out teams", () => {
 
 describe("round robin A/B divisions standings", () => {
 	const abDivisionsTournament = () => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "AB RR",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "round_robin",
 			seeding: [1, 2, 3, 4],
 			abDivisions: [0, 1, 0, 1],
 			settings: {
 				groupCount: 1,
 				hasAbDivisions: true,
-				seedOrdering: ["groups.seed_optimized"],
 			},
 		});
 
@@ -432,18 +408,16 @@ describe("round robin A/B divisions standings", () => {
 			winnerScore: number,
 			loserScore: number,
 		) => {
-			const match = storage.select<any>("match", matchId);
-			invariant(match, `match ${matchId} not found`);
-			const winnerIsOpp1 = match.opponent1.id === winnerId;
-			manager.update.match({
-				id: match.id,
-				opponent1: winnerIsOpp1
-					? { score: winnerScore, result: "win" }
-					: { score: loserScore },
-				opponent2: winnerIsOpp1
-					? { score: loserScore }
-					: { score: winnerScore, result: "win" },
-			});
+			const match = matchById(data, matchId);
+			const winnerIsOpp1 = match.opponent1?.id === winnerId;
+			data = Engine.reportResult(data, {
+				matchId,
+				scores: [
+					winnerIsOpp1 ? winnerScore : loserScore,
+					winnerIsOpp1 ? loserScore : winnerScore,
+				],
+				winnerSide: winnerIsOpp1 ? "opponent1" : "opponent2",
+			}).data;
 		};
 
 		const winnerByMatchup: Record<string, number> = {
@@ -452,9 +426,9 @@ describe("round robin A/B divisions standings", () => {
 			"2-3": 2,
 			"3-4": 3,
 		};
-		for (const match of storage.select<any>("match")!) {
-			const a = match.opponent1.id as number;
-			const b = match.opponent2.id as number;
+		for (const match of data.match) {
+			const a = match.opponent1!.id as number;
+			const b = match.opponent2!.id as number;
 			const key = a < b ? `${a}-${b}` : `${b}-${a}`;
 			const winnerId = winnerByMatchup[key];
 			invariant(winnerId, `unexpected matchup ${key}`);
@@ -462,8 +436,6 @@ describe("round robin A/B divisions standings", () => {
 			setResult(match.id, winnerId, 2, loserScore);
 		}
 
-		const data = manager.get.tournamentData(1);
-
 		return testTournament({
 			ctx: {
 				settings: {
@@ -535,33 +507,28 @@ describe("single elimination standings - third place match", () => {
 	}: {
 		thirdPlaceMatchReported: boolean;
 	}) => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "SE",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "single_elimination",
 			seeding: [1, 2, 3, 4],
 			settings: { consolationFinal: true },
 		});
 
 		const reportLowerTeamIdAsWinner = (matchId: number) => {
-			manager.update.match({
-				id: matchId,
-				opponent1: { score: 2, result: "win" },
-				opponent2: { score: 0 },
-			});
+			data = Engine.reportResult(data, {
+				matchId,
+				scores: [2, 0],
+				winnerSide: "opponent1",
+			}).data;
 		};
 
-		const semifinals = storage
-			.select<any>("match")!
-			.filter((match) => match.opponent1?.id && match.opponent2?.id);
+		const semifinals = data.match.filter(
+			(match) => match.opponent1?.id && match.opponent2?.id,
+		);
 		invariant(semifinals.length === 2, "Expected two semifinal matches");
 
 		const semifinalLoserIds: number[] = [];
 		for (const match of semifinals) {
-			semifinalLoserIds.push(match.opponent2.id);
+			semifinalLoserIds.push(match.opponent2!.id!);
 			reportLowerTeamIdAsWinner(match.id);
 		}
 
@@ -569,14 +536,14 @@ describe("single elimination standings - third place match", () => {
 		let thirdPlaceLoserId: number | undefined;
 		if (thirdPlaceMatchReported) {
 			const thirdPlaceGroupId = Math.max(
-				...storage.select<any>("group")!.map((group) => group.id),
+				...data.group.map((group) => group.id),
+			);
+			const thirdPlaceMatch = data.match.find(
+				(match) => match.groupId === thirdPlaceGroupId,
 			);
-			const thirdPlaceMatch = storage
-				.select<any>("match")!
-				.find((match) => match.group_id === thirdPlaceGroupId);
 			invariant(thirdPlaceMatch, "Third place match not found");
-			thirdPlaceWinnerId = thirdPlaceMatch.opponent1.id;
-			thirdPlaceLoserId = thirdPlaceMatch.opponent2.id;
+			thirdPlaceWinnerId = thirdPlaceMatch.opponent1!.id!;
+			thirdPlaceLoserId = thirdPlaceMatch.opponent2!.id!;
 			reportLowerTeamIdAsWinner(thirdPlaceMatch.id);
 		}
 
@@ -594,7 +561,7 @@ describe("single elimination standings - third place match", () => {
 					],
 				},
 			},
-			data: manager.get.tournamentData(1),
+			data,
 		});
 
 		return { tournament, thirdPlaceWinnerId, thirdPlaceLoserId };
@@ -627,60 +594,28 @@ describe("single elimination standings - third place match", () => {
 	});
 });
 
-const reportLowerIdWinner = (
-	storage: InMemoryDatabase,
-	manager: BracketsManager,
-	matchId: number,
-) => {
-	const match = storage.select<any>("match", matchId);
-	invariant(match, `match ${matchId} not found`);
-	const opponent1Lower = match.opponent1.id < match.opponent2.id;
-	manager.update.match({
-		id: matchId,
-		opponent1: opponent1Lower ? { score: 2, result: "win" } : { score: 0 },
-		opponent2: opponent1Lower ? { score: 0 } : { score: 2, result: "win" },
-	});
-};
-
-const readyMatches = (
-	storage: InMemoryDatabase,
-	predicate: (match: any) => boolean,
-) =>
-	storage
-		.select<any>("match")!
-		.filter(
-			(match) =>
-				predicate(match) &&
-				match.opponent1?.id != null &&
-				match.opponent2?.id != null &&
-				match.opponent1.result == null &&
-				match.opponent2.result == null,
-		);
-
 describe("single elimination standings - projected ties", () => {
 	// Two semifinal losers tie for 3rd (no consolation final). Reports only one
 	// semifinal so the other is still in progress, mirroring the projected
 	// standings bug where the finished team is shown one placement too low.
 	const partialSingleEliminationTournament = () => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "SE",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "single_elimination",
 			seeding: [1, 2, 3, 4],
 			settings: {},
 		});
 
-		const semifinals = storage
-			.select<any>("match")!
-			.filter((match) => match.opponent1?.id && match.opponent2?.id);
+		const semifinals = data.match.filter(
+			(match) => match.opponent1?.id && match.opponent2?.id,
+		);
 		invariant(semifinals.length === 2, "Expected two semifinal matches");
 
 		const decided = semifinals[0];
-		const decidedLoserId = Math.max(decided.opponent1.id, decided.opponent2.id);
-		reportLowerIdWinner(storage, manager, decided.id);
+		const decidedLoserId = Math.max(
+			decided.opponent1!.id!,
+			decided.opponent2!.id!,
+		);
+		data = reportLowerIdWinner(data, decided.id);
 
 		const tournament = testTournament({
 			ctx: {
@@ -696,7 +631,7 @@ describe("single elimination standings - projected ties", () => {
 					],
 				},
 			},
-			data: manager.get.tournamentData(1),
+			data,
 		});
 
 		return { tournament, decidedLoserId };
@@ -719,64 +654,56 @@ describe("double elimination standings - projected ties", () => {
 	// losers round 2 matches so its loser should already project to tied 5th
 	// while the sibling match is still unfinished.
 	const partialDoubleEliminationTournament = () => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "DE",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "double_elimination",
 			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: { grandFinal: "double", seedOrdering: ["natural"] },
+			settings: {},
 		});
 
 		const groupId = (number: number) =>
-			storage.select<any>("group")!.find((g) => g.number === number)!.id;
+			data.group.find((group) => group.number === number)!.id;
 		const winnersGroupId = groupId(1);
 		const losersGroupId = groupId(2);
 
 		const losersRoundId = (number: number) =>
-			storage
-				.select<any>("round")!
-				.find((r) => r.group_id === losersGroupId && r.number === number)!.id;
+			data.round.find(
+				(round) => round.groupId === losersGroupId && round.number === number,
+			)!.id;
 
 		// play out the entire winners bracket so all losers feed in
-		let winnersReady = readyMatches(
-			storage,
-			(m) => m.group_id === winnersGroupId,
-		);
+		let winnersReady = readyMatches(data, (m) => m.groupId === winnersGroupId);
 		while (winnersReady.length) {
 			for (const match of winnersReady) {
-				reportLowerIdWinner(storage, manager, match.id);
+				data = reportLowerIdWinner(data, match.id);
 			}
-			winnersReady = readyMatches(
-				storage,
-				(m) => m.group_id === winnersGroupId,
-			);
+			winnersReady = readyMatches(data, (m) => m.groupId === winnersGroupId);
 		}
 
 		// losers round 1: both matches -> two teams eliminated, tied 7th/8th
 		for (const match of readyMatches(
-			storage,
-			(m) => m.round_id === losersRoundId(1),
+			data,
+			(m) => m.roundId === losersRoundId(1),
 		)) {
-			reportLowerIdWinner(storage, manager, match.id);
+			data = reportLowerIdWinner(data, match.id);
 		}
 
 		// losers round 2: report only one of the two matches
 		const losersRound2 = readyMatches(
-			storage,
-			(m) => m.round_id === losersRoundId(2),
+			data,
+			(m) => m.roundId === losersRoundId(2),
 		);
 		invariant(losersRound2.length === 2, "Expected two losers round 2 matches");
 
 		const decided = losersRound2[0];
-		const decidedLoserId = Math.max(decided.opponent1.id, decided.opponent2.id);
+		const decidedLoserId = Math.max(
+			decided.opponent1!.id!,
+			decided.opponent2!.id!,
+		);
 		const stillPlayingTeamIds = [
-			losersRound2[1].opponent1.id,
-			losersRound2[1].opponent2.id,
+			losersRound2[1].opponent1!.id,
+			losersRound2[1].opponent2!.id,
 		];
-		reportLowerIdWinner(storage, manager, decided.id);
+		data = reportLowerIdWinner(data, decided.id);
 
 		const tournament = testTournament({
 			ctx: {
@@ -792,7 +719,7 @@ describe("double elimination standings - projected ties", () => {
 					],
 				},
 			},
-			data: manager.get.tournamentData(1),
+			data,
 		});
 
 		return { tournament, decidedLoserId, stillPlayingTeamIds };
@@ -824,39 +751,29 @@ describe("single elimination source - underground", () => {
 	// 8-team SE played out fully. The four first-round losers tie for last, so
 	// sourcing [-1] should feed exactly those teams into an underground bracket.
 	const playedSingleEliminationTournament = () => {
-		const storage = new InMemoryDatabase();
-		const manager = new BracketsManager(storage);
-
-		manager.create({
-			name: "SE",
-			tournamentId: 1,
+		let data = createResolved({
 			type: "single_elimination",
 			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
 			settings: {},
 		});
 
-		const winnersGroupId = Math.min(
-			...storage.select<any>("group")!.map((g) => g.id),
-		);
-		const firstRoundId = Math.min(
-			...storage
-				.select<any>("round")!
-				.filter((r) => r.group_id === winnersGroupId)
-				.map((r) => r.id),
-		);
+		const winnersGroupId = data.group.find((group) => group.number === 1)!.id;
+		const firstRoundId = data.round.find(
+			(round) => round.groupId === winnersGroupId && round.number === 1,
+		)!.id;
 
 		// lower id wins, so the higher id in each first-round match is the loser
 		const firstRoundLoserIds = readyMatches(
-			storage,
-			(m) => m.round_id === firstRoundId,
-		).map((m) => Math.max(m.opponent1.id, m.opponent2.id));
+			data,
+			(match) => match.roundId === firstRoundId,
+		).map((match) => Math.max(match.opponent1!.id!, match.opponent2!.id!));
 
-		let ready = readyMatches(storage, (m) => m.group_id === winnersGroupId);
+		let ready = readyMatches(data, (match) => match.groupId === winnersGroupId);
 		while (ready.length) {
 			for (const match of ready) {
-				reportLowerIdWinner(storage, manager, match.id);
+				data = reportLowerIdWinner(data, match.id);
 			}
-			ready = readyMatches(storage, (m) => m.group_id === winnersGroupId);
+			ready = readyMatches(data, (match) => match.groupId === winnersGroupId);
 		}
 
 		const tournament = testTournament({
@@ -873,7 +790,7 @@ describe("single elimination source - underground", () => {
 					],
 				},
 			},
-			data: manager.get.tournamentData(1),
+			data,
 		});
 
 		return { tournament, firstRoundLoserIds };
@@ -893,3 +810,34 @@ describe("single elimination source - underground", () => {
 		);
 	});
 });
+
+function reportLowerIdWinner(data: BracketData, matchId: number): BracketData {
+	const match = matchById(data, matchId);
+	const opponent1Lower = match.opponent1!.id! < match.opponent2!.id!;
+
+	return Engine.reportResult(data, {
+		matchId,
+		scores: [opponent1Lower ? 2 : 0, opponent1Lower ? 0 : 2],
+		winnerSide: opponent1Lower ? "opponent1" : "opponent2",
+	}).data;
+}
+
+function readyMatches(
+	data: BracketData,
+	predicate: (match: MatchData) => boolean,
+) {
+	return data.match.filter(
+		(match) =>
+			predicate(match) &&
+			match.opponent1?.id != null &&
+			match.opponent2?.id != null &&
+			match.winnerSide == null,
+	);
+}
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/Bracket/Bracket.ts b/app/features/tournament-bracket/core/Bracket/Bracket.ts
index 971783fdd..7e5f0c02d 100644
--- a/app/features/tournament-bracket/core/Bracket/Bracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/Bracket.ts
@@ -2,13 +2,14 @@ import { sub } from "date-fns";
 import * as R from "remeda";
 import type { Tables, TournamentStageSettings } from "~/db/tables";
 import { TOURNAMENT } from "~/features/tournament/tournament-constants";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import type { Round } from "~/modules/brackets-model";
+import type {
+	BracketData,
+	RoundData,
+} from "~/features/tournament-bracket/core/engine/types";
 import invariant from "~/utils/invariant";
 import { logger } from "~/utils/logger";
-import { fillWithNullTillPowerOfTwo } from "../../tournament-bracket-utils";
 import * as AbDivisions from "../AbDivisions";
-import { getTournamentManager } from "../brackets-manager";
+import * as Engine from "../engine";
 import * as Progression from "../Progression";
 import type { OptionalIdObject, Tournament } from "../Tournament";
 import type { TournamentDataTeam } from "../Tournament.server";
@@ -18,7 +19,7 @@ export interface CreateBracketArgs {
 	id: number;
 	idx: number;
 	preview: boolean;
-	data?: TournamentManagerDataSet;
+	data?: BracketData;
 	type: Tables["TournamentStage"]["type"];
 	canBeStarted?: boolean;
 	name: string;
@@ -44,7 +45,6 @@ export interface Standing {
 		setLosses: number;
 		mapWins: number;
 		mapLosses: number;
-		points: number;
 		koCount?: number;
 		winsAgainstTied: number;
 		lossesAgainstTied?: number;
@@ -63,7 +63,7 @@ export abstract class Bracket {
 	idx;
 	preview;
 	data;
-	simulatedData: TournamentManagerDataSet | undefined;
+	simulatedData: BracketData | undefined;
 	canBeStarted;
 	name;
 	teamsPendingCheckIn;
@@ -74,6 +74,7 @@ export abstract class Bracket {
 	settings;
 	requiresCheckIn;
 	startTime;
+	private _matchStatuses: Map<number, Engine.MatchStatus> | undefined;
 
 	constructor({
 		id,
@@ -125,9 +126,7 @@ export abstract class Bracket {
 			return;
 
 		try {
-			const manager = getTournamentManager();
-
-			manager.importData(this.data);
+			let data = this.data;
 
 			const teamOrder = this.teamOrderForSimulation();
 
@@ -141,13 +140,9 @@ export abstract class Bracket {
 				matchesToResolve = false;
 				loopCount++;
 
-				for (const match of manager.export().match) {
-					if (!match) continue;
+				for (const match of data.match) {
 					// we have a result already
-					if (
-						match.opponent1?.result === "win" ||
-						match.opponent2?.result === "win"
-					) {
+					if (match.winnerSide) {
 						continue;
 					}
 					// no opponent yet, let's simulate this in a coming loop
@@ -176,21 +171,15 @@ export abstract class Bracket {
 							? 1
 							: 2;
 
-					manager.update.match({
-						id: match.id,
-						opponent1: {
-							score: winner === 1 ? 1 : 0,
-							result: winner === 1 ? "win" : undefined,
-						},
-						opponent2: {
-							score: winner === 2 ? 1 : 0,
-							result: winner === 2 ? "win" : undefined,
-						},
-					});
+					data = Engine.reportResult(data, {
+						matchId: match.id,
+						scores: winner === 1 ? [1, 0] : [0, 1],
+						winnerSide: winner === 1 ? "opponent1" : "opponent2",
+					}).data;
 				}
 			}
 
-			this.simulatedData = manager.export();
+			this.simulatedData = data;
 		} catch (e) {
 			logger.error("Bracket.createdSimulation: ", e);
 		}
@@ -200,11 +189,7 @@ export abstract class Bracket {
 		const result = new Map(this.tournament.ctx.teams.map((t, i) => [t.id, i]));
 
 		for (const match of this.data.match) {
-			if (
-				!match.opponent1?.id ||
-				!match.opponent2?.id ||
-				(match.opponent1?.result !== "win" && match.opponent2?.result !== "win")
-			) {
+			if (!match.opponent1?.id || !match.opponent2?.id || !match.winnerSide) {
 				continue;
 			}
 
@@ -215,11 +200,11 @@ export abstract class Bracket {
 				continue;
 			}
 
-			if (opponent1Seed < opponent2Seed && match.opponent1?.result === "win") {
+			if (opponent1Seed < opponent2Seed && match.winnerSide === "opponent1") {
 				continue;
 			}
 
-			if (opponent2Seed < opponent1Seed && match.opponent2?.result === "win") {
+			if (opponent2Seed < opponent1Seed && match.winnerSide === "opponent2") {
 				continue;
 			}
 
@@ -238,21 +223,25 @@ export abstract class Bracket {
 	simulatedMatch(matchId: number) {
 		if (!this.simulatedData) return;
 
-		return this.simulatedData.match
-			.filter(Boolean)
-			.find((match) => match.id === matchId);
+		return this.simulatedData.match.find((match) => match.id === matchId);
 	}
 
-	get collectResultsWithPoints() {
+	/** Whether reporting a game in this bracket also records if the game was a KO win. */
+	get collectsKos() {
 		return false;
 	}
 
-	get type(): Tables["TournamentStage"]["type"] {
-		throw new Error("not implemented");
-	}
+	abstract get type(): Tables["TournamentStage"]["type"];
 
-	get standings(): Standing[] {
-		throw new Error("not implemented");
+	abstract get standings(): Standing[];
+
+	/**
+	 * How many rounds a swiss bracket has. Comes from the bracket's own stage
+	 * settings rather than `settings` (the progression's, editable at any time),
+	 * so it can't drift from the bracket that actually exists.
+	 */
+	get swissRoundCount() {
+		return Engine.swissRoundCount(this.data);
 	}
 
 	get participantTournamentTeamIds() {
@@ -267,7 +256,7 @@ export abstract class Bracket {
 		return this.standings;
 	}
 
-	winnersSourceRound(_roundNumber: number): Round | undefined {
+	winnersSourceRound(_roundNumber: number): RoundData | undefined {
 		return;
 	}
 
@@ -290,49 +279,37 @@ export abstract class Bracket {
 		});
 	}
 
-	generateMatchesData(teams: number[]) {
-		const manager = getTournamentManager();
-
-		const virtualTournamentId = 1;
-
+	generateMatchesData(teams: number[]): BracketData {
 		if (teams.length >= TOURNAMENT.ENOUGH_TEAMS_TO_START) {
-			const settings = this.tournament.bracketManagerSettings(
-				this.settings,
-				this.type,
-				teams.length,
-			);
 			const abDivisions =
 				this.type === "round_robin" && this.settings?.hasAbDivisions === true
-					? this.abDivisionsForPreview(teams, settings.groupCount)
+					? this.abDivisionsForPreview(
+							teams,
+							Engine.roundRobinGroupCount(this.settings, teams.length),
+						)
 					: undefined;
 
-			manager.create({
-				tournamentId: virtualTournamentId,
-				name: "Virtual",
+			return Engine.create({
 				type: this.type,
-				seeding:
-					this.type === "round_robin"
-						? teams
-						: fillWithNullTillPowerOfTwo(teams),
+				seeding: teams,
 				settings: abDivisions
-					? settings
+					? this.settings
 					: {
-							...settings,
+							...this.settings,
 							hasAbDivisions: false,
 						},
+				independentRounds: this.tournament.isLeagueDivision,
 				abDivisions,
 			});
 		}
 
-		return manager.get.tournamentData(virtualTournamentId);
+		return { stage: [], group: [], round: [], match: [] };
 	}
 
 	private abDivisionsForPreview(
 		teams: number[],
-		groupCount: number | undefined,
+		groupCount: number,
 	): (0 | 1)[] | undefined {
-		if (!groupCount) return undefined;
-
 		const assignments = teams.map((teamId) => {
 			const team = this.tournament.teamById(teamId);
 			return team?.abDivision ?? null;
@@ -388,10 +365,7 @@ export abstract class Bracket {
 			if (match.opponent1 === null || match.opponent2 === null) {
 				continue;
 			}
-			if (
-				match.opponent1?.result !== "win" &&
-				match.opponent2?.result !== "win"
-			) {
+			if (!match.winnerSide) {
 				return false;
 			}
 		}
@@ -424,16 +398,14 @@ export abstract class Bracket {
 		return this.teamsPendingCheckIn.includes(team.id);
 	}
 
-	source(_options: {
+	abstract source(options: {
 		placements: number[];
 		advanceThreshold?: number;
 		rest?: boolean;
 	}): {
 		relevantMatchesFinished: boolean;
 		teams: number[];
-	} {
-		throw new Error("not implemented");
-	}
+	};
 
 	teamsWithNames(teams: { id: number }[]) {
 		return teams.map((team) => {
@@ -449,6 +421,23 @@ export abstract class Bracket {
 		});
 	}
 
+	/** Statuses of every match of the bracket, keyed by match id. */
+	matchStatuses() {
+		if (!this._matchStatuses) {
+			this._matchStatuses = Engine.matchStatuses(this.data);
+		}
+
+		return this._matchStatuses;
+	}
+
+	/** Status of one match of the bracket. */
+	matchStatus(matchId: number) {
+		const status = this.matchStatuses().get(matchId);
+		invariant(status, `Match not found: ${matchId}`);
+
+		return status;
+	}
+
 	/**
 	 * Returns match IDs that are currently ongoing (ready to start).
 	 * A match is ongoing when:
@@ -465,10 +454,7 @@ export abstract class Bracket {
 			(a, b) => a.number - b.number,
 		)) {
 			if (!match.opponent1?.id || !match.opponent2?.id) continue;
-			if (
-				match.opponent1.result === "win" ||
-				match.opponent2.result === "win"
-			) {
+			if (match.winnerSide) {
 				continue;
 			}
 
@@ -487,7 +473,5 @@ export abstract class Bracket {
 		return ongoingMatchIds;
 	}
 
-	defaultRoundBestOfs(_data: TournamentManagerDataSet): BracketMapCounts {
-		throw new Error("not implemented");
-	}
+	abstract defaultRoundBestOfs(data: BracketData): BracketMapCounts;
 }
diff --git a/app/features/tournament-bracket/core/Bracket/DoubleEliminationBracket.ts b/app/features/tournament-bracket/core/Bracket/DoubleEliminationBracket.ts
index 0991e962a..9026069f4 100644
--- a/app/features/tournament-bracket/core/Bracket/DoubleEliminationBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/DoubleEliminationBracket.ts
@@ -1,7 +1,9 @@
 import * as R from "remeda";
 import type { Tables } from "~/db/tables";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import type { Round } from "~/modules/brackets-model";
+import type {
+	BracketData,
+	RoundData,
+} from "~/features/tournament-bracket/core/engine/types";
 import invariant from "~/utils/invariant";
 import type { BracketMapCounts } from "../toMapList";
 import { Bracket, type Standing } from "./Bracket";
@@ -12,15 +14,15 @@ export class DoubleEliminationBracket extends Bracket {
 		return "double_elimination";
 	}
 
-	defaultRoundBestOfs(data: TournamentManagerDataSet) {
+	defaultRoundBestOfs(data: BracketData) {
 		const result: BracketMapCounts = new Map();
 
 		for (const group of data.group) {
 			const roundsOfGroup = data.round.filter(
-				(round) => round.group_id === group.id,
+				(round) => round.groupId === group.id,
 			);
 
-			const defaultOfRound = (round: Round) => {
+			const defaultOfRound = (round: RoundData) => {
 				if (group.number === 3) return 5;
 				if (group.number === 2) {
 					const lastRoundNumber = Math.max(
@@ -38,7 +40,7 @@ export class DoubleEliminationBracket extends Bracket {
 			for (const round of roundsOfGroup) {
 				const atLeastOneNonByeMatch = data.match.some(
 					(match) =>
-						match.round_id === round.id && match.opponent1 && match.opponent2,
+						match.roundId === round.id && match.opponent1 && match.opponent2,
 				);
 
 				if (!atLeastOneNonByeMatch) continue;
@@ -65,7 +67,7 @@ export class DoubleEliminationBracket extends Bracket {
 		const groupIdWB = this.data.group.find((g) => g.number === 1)?.id;
 
 		return this.data.round.find(
-			(round) => round.number === roundNumberWB && round.group_id === groupIdWB,
+			(round) => round.number === roundNumberWB && round.groupId === groupIdWB,
 		);
 	}
 
@@ -75,16 +77,13 @@ export class DoubleEliminationBracket extends Bracket {
 		const losersGroupId = this.data.group.find((g) => g.number === 2)?.id;
 
 		const losersMatches = this.data.match
-			.filter((match) => match.group_id === losersGroupId)
-			.sort((a, b) => a.round_id - b.round_id);
+			.filter((match) => match.groupId === losersGroupId)
+			.sort((a, b) => a.roundId - b.roundId);
 
 		const teams: { id: number; lostAt: number }[] = [];
 
 		for (const match of losersMatches) {
-			if (
-				match.opponent1?.result !== "win" &&
-				match.opponent2?.result !== "win"
-			) {
+			if (!match.winnerSide) {
 				continue;
 			}
 
@@ -92,10 +91,10 @@ export class DoubleEliminationBracket extends Bracket {
 			if (!match.opponent1 || !match.opponent2) continue;
 
 			const loser =
-				match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+				match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 			invariant(loser?.id, "Loser id not found");
 
-			teams.push({ id: loser.id, lostAt: match.round_id });
+			teams.push({ id: loser.id, lostAt: match.roundId });
 		}
 
 		const eliminationsThroughLosersRound =
@@ -132,16 +131,16 @@ export class DoubleEliminationBracket extends Bracket {
 		)?.id;
 		invariant(grandFinalsGroupId, "GF group not found");
 		const grandFinalMatches = this.data.match.filter(
-			(match) => match.group_id === grandFinalsGroupId,
+			(match) => match.groupId === grandFinalsGroupId,
 		);
 
 		// if opponent1 won in DE it means that bracket reset is not played
 		if (
 			grandFinalMatches[0].opponent1 &&
-			(noLosersRounds || grandFinalMatches[0].opponent1.result === "win")
+			(noLosersRounds || grandFinalMatches[0].winnerSide === "opponent1")
 		) {
 			const loser =
-				grandFinalMatches[0].opponent1.result === "win"
+				grandFinalMatches[0].winnerSide === "opponent1"
 					? "opponent2"
 					: "opponent1";
 			const winner = loser === "opponent1" ? "opponent2" : "opponent1";
@@ -164,12 +163,9 @@ export class DoubleEliminationBracket extends Bracket {
 				team: winnerTeam,
 				placement: 1,
 			});
-		} else if (
-			grandFinalMatches[1].opponent1?.result === "win" ||
-			grandFinalMatches[1].opponent2?.result === "win"
-		) {
+		} else if (grandFinalMatches[1].winnerSide) {
 			const loser =
-				grandFinalMatches[1].opponent1?.result === "win"
+				grandFinalMatches[1].winnerSide === "opponent1"
 					? "opponent2"
 					: "opponent1";
 			const winner = loser === "opponent1" ? "opponent2" : "opponent1";
@@ -211,14 +207,11 @@ export class DoubleEliminationBracket extends Bracket {
 			if (match.opponent1 === null || match.opponent2 === null) {
 				continue;
 			}
-			if (
-				match.opponent1?.result !== "win" &&
-				match.opponent2?.result !== "win"
-			) {
+			if (!match.winnerSide) {
 				return false;
 			}
 
-			lastWinner = match.opponent1?.result === "win" ? 1 : 2;
+			lastWinner = match.winnerSide === "opponent1" ? 1 : 2;
 		}
 
 		return true;
@@ -226,24 +219,24 @@ export class DoubleEliminationBracket extends Bracket {
 
 	source({ placements }: { placements: number[] }) {
 		invariant(placements.length > 0, "Empty placements not supported");
-		const resolveLosersGroupId = (data: TournamentManagerDataSet) => {
-			const minGroupId = Math.min(...data.round.map((round) => round.group_id));
+		const resolveLosersGroupId = (data: BracketData) => {
+			const minGroupId = Math.min(...data.round.map((round) => round.groupId));
 
 			return minGroupId + 1;
 		};
 		const placementsToRoundsIds = (
-			data: TournamentManagerDataSet,
+			data: BracketData,
 			losersGroupId: number,
 		) => {
 			const firstRoundIsOnlyByes = () => {
 				const losersMatches = data.match.filter(
-					(match) => match.group_id === losersGroupId,
+					(match) => match.groupId === losersGroupId,
 				);
 
-				const fistRoundId = Math.min(...losersMatches.map((m) => m.round_id));
+				const fistRoundId = Math.min(...losersMatches.map((m) => m.roundId));
 
 				const firstRoundMatches = losersMatches.filter(
-					(match) => match.round_id === fistRoundId,
+					(match) => match.roundId === fistRoundId,
 				);
 
 				return firstRoundMatches.every(
@@ -252,7 +245,7 @@ export class DoubleEliminationBracket extends Bracket {
 			};
 
 			const losersRounds = data.round.filter(
-				(round) => round.group_id === losersGroupId,
+				(round) => round.groupId === losersGroupId,
 			);
 			const orderedRoundsIds = losersRounds
 				.map((round) => round.id)
@@ -281,7 +274,7 @@ export class DoubleEliminationBracket extends Bracket {
 		let relevantMatchesFinished = true;
 		for (const roundId of sourceRoundsIds) {
 			const roundsMatches = this.data.match.filter(
-				(match) => match.round_id === roundId,
+				(match) => match.roundId === roundId,
 			);
 
 			for (const match of roundsMatches) {
@@ -289,16 +282,13 @@ export class DoubleEliminationBracket extends Bracket {
 				if (!match.opponent1 || !match.opponent2) {
 					continue;
 				}
-				if (
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win"
-				) {
+				if (!match.winnerSide) {
 					relevantMatchesFinished = false;
 					continue;
 				}
 
 				const loser =
-					match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+					match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 				invariant(loser?.id, "Loser id not found");
 
 				teams.push(loser.id);
diff --git a/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts b/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
index d32b411b8..892e75f9f 100644
--- a/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
@@ -1,14 +1,13 @@
 import * as R from "remeda";
 import type { Tables } from "~/db/tables";
 import * as Standings from "~/features/tournament/core/Standings";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import invariant from "~/utils/invariant";
-import { logger } from "~/utils/logger";
 import type { BracketMapCounts } from "../toMapList";
 import { Bracket, type Standing } from "./Bracket";
 
 export class RoundRobinBracket extends Bracket {
-	get collectResultsWithPoints() {
+	get collectsKos() {
 		return true;
 	}
 
@@ -97,7 +96,7 @@ export class RoundRobinBracket extends Bracket {
 		const placements: (Standing & { groupId: number })[] = [];
 		for (const groupId of groupIds) {
 			const matches = this.data.match.filter(
-				(match) => match.group_id === groupId,
+				(match) => match.groupId === groupId,
 			);
 
 			const groupIsFinished = matches.every(
@@ -106,8 +105,7 @@ export class RoundRobinBracket extends Bracket {
 					match.opponent1 === null ||
 					match.opponent2 === null ||
 					// match was played out
-					match.opponent1?.result === "win" ||
-					match.opponent2?.result === "win",
+					match.winnerSide,
 			);
 
 			if (!groupIsFinished && !includeUnfinishedGroups) continue;
@@ -136,7 +134,6 @@ export class RoundRobinBracket extends Bracket {
 				mapWins: number;
 				mapLosses: number;
 				winsAgainstTied: number;
-				points: number;
 				koCount: number;
 			}[] = [];
 
@@ -146,7 +143,6 @@ export class RoundRobinBracket extends Bracket {
 				setLosses,
 				mapWins,
 				mapLosses,
-				points,
 				koCount,
 			}: {
 				teamId: number;
@@ -154,7 +150,6 @@ export class RoundRobinBracket extends Bracket {
 				setLosses: number;
 				mapWins: number;
 				mapLosses: number;
-				points: number;
 				koCount: number;
 			}) => {
 				const team = teams.find((team) => team.id === teamId);
@@ -163,7 +158,6 @@ export class RoundRobinBracket extends Bracket {
 					team.setLosses += setLosses;
 					team.mapWins += mapWins;
 					team.mapLosses += mapLosses;
-					team.points += points;
 					team.koCount += koCount;
 				} else {
 					teams.push({
@@ -173,17 +167,13 @@ export class RoundRobinBracket extends Bracket {
 						mapWins,
 						mapLosses,
 						winsAgainstTied: 0,
-						points,
 						koCount,
 					});
 				}
 			};
 
 			for (const match of matches) {
-				if (
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win"
-				) {
+				if (!match.winnerSide) {
 					continue;
 				}
 
@@ -199,10 +189,10 @@ export class RoundRobinBracket extends Bracket {
 				}
 
 				const winner =
-					match.opponent1?.result === "win" ? match.opponent1 : match.opponent2;
+					match.winnerSide === "opponent1" ? match.opponent1 : match.opponent2;
 
 				const loser =
-					match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+					match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 
 				if (!winner || !loser) continue;
 
@@ -212,15 +202,6 @@ export class RoundRobinBracket extends Bracket {
 						"RoundRobinBracket.standings: winner or loser id not found",
 				);
 
-				if (
-					typeof winner.totalPoints !== "number" ||
-					typeof loser.totalPoints !== "number"
-				) {
-					logger.warn(
-						"RoundRobinBracket.standings: winner or loser points not found",
-					);
-				}
-
 				// note: score might be missing in the case the set was ended early. In the future we might want to handle this differently than defaulting both to 0.
 
 				updateTeam({
@@ -229,7 +210,6 @@ export class RoundRobinBracket extends Bracket {
 					setLosses: 0,
 					mapWins: winner.score ?? 0,
 					mapLosses: loser.score ?? 0,
-					points: winner.totalPoints ?? 0,
 					koCount: winner.totalKos ?? 0,
 				});
 				updateTeam({
@@ -238,7 +218,6 @@ export class RoundRobinBracket extends Bracket {
 					setLosses: 1,
 					mapWins: loser.score ?? 0,
 					mapLosses: winner.score ?? 0,
-					points: loser.totalPoints ?? 0,
 					koCount: loser.totalKos ?? 0,
 				});
 			}
@@ -254,10 +233,10 @@ export class RoundRobinBracket extends Bracket {
 						(match) =>
 							(match.opponent1?.id === team.id &&
 								match.opponent2?.id === team2.id &&
-								match.opponent1?.result === "win") ||
+								match.winnerSide === "opponent1") ||
 							(match.opponent1?.id === team2.id &&
 								match.opponent2?.id === team.id &&
-								match.opponent2?.result === "win"),
+								match.winnerSide === "opponent2"),
 					);
 
 					if (wonTheirMatch) {
@@ -275,7 +254,6 @@ export class RoundRobinBracket extends Bracket {
 					mapWins: 0,
 					mapLosses: 0,
 					winsAgainstTied: 0,
-					points: 0,
 					koCount: 0,
 				});
 			}
@@ -306,8 +284,8 @@ export class RoundRobinBracket extends Bracket {
 						if (a.mapLosses < b.mapLosses) return -1;
 						if (a.mapLosses > b.mapLosses) return 1;
 
-						if (a.points > b.points) return -1;
-						if (a.points < b.points) return 1;
+						if (a.koCount > b.koCount) return -1;
+						if (a.koCount < b.koCount) return 1;
 
 						const aSeed = Number(this.tournament.teamById(a.id)?.seed);
 						const bSeed = Number(this.tournament.teamById(b.id)?.seed);
@@ -327,7 +305,6 @@ export class RoundRobinBracket extends Bracket {
 								setLosses: team.setLosses,
 								mapWins: team.mapWins,
 								mapLosses: team.mapLosses,
-								points: team.points,
 								koCount: team.koCount,
 								winsAgainstTied: team.winsAgainstTied,
 							},
@@ -355,16 +332,16 @@ export class RoundRobinBracket extends Bracket {
 		return "round_robin";
 	}
 
-	defaultRoundBestOfs(data: TournamentManagerDataSet) {
+	defaultRoundBestOfs(data: BracketData) {
 		const result: BracketMapCounts = new Map();
 
 		for (const round of data.round) {
-			if (!result.get(round.group_id)) {
-				result.set(round.group_id, new Map());
+			if (!result.get(round.groupId)) {
+				result.set(round.groupId, new Map());
 			}
 
 			result
-				.get(round.group_id)!
+				.get(round.groupId)!
 				.set(round.number, { count: 3, type: "BEST_OF" });
 		}
 
diff --git a/app/features/tournament-bracket/core/Bracket/SingleEliminationBracket.ts b/app/features/tournament-bracket/core/Bracket/SingleEliminationBracket.ts
index eec96a6fb..8c70c303a 100644
--- a/app/features/tournament-bracket/core/Bracket/SingleEliminationBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/SingleEliminationBracket.ts
@@ -1,7 +1,9 @@
 import * as R from "remeda";
 import type { Tables } from "~/db/tables";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import type { Round } from "~/modules/brackets-model";
+import type {
+	BracketData,
+	RoundData,
+} from "~/features/tournament-bracket/core/engine/types";
 import invariant from "~/utils/invariant";
 import type { BracketMapCounts } from "../toMapList";
 import { Bracket, type Standing } from "./Bracket";
@@ -12,16 +14,16 @@ export class SingleEliminationBracket extends Bracket {
 		return "single_elimination";
 	}
 
-	defaultRoundBestOfs(data: TournamentManagerDataSet) {
+	defaultRoundBestOfs(data: BracketData) {
 		const result: BracketMapCounts = new Map();
 
 		const maxRoundNumber = Math.max(...data.round.map((round) => round.number));
 		for (const group of data.group) {
 			const roundsOfGroup = data.round.filter(
-				(round) => round.group_id === group.id,
+				(round) => round.groupId === group.id,
 			);
 
-			const defaultOfRound = (round: Round) => {
+			const defaultOfRound = (round: RoundData) => {
 				// 3rd place match
 				if (group.number === 2) return 5;
 
@@ -40,7 +42,7 @@ export class SingleEliminationBracket extends Bracket {
 			for (const round of roundsOfGroup) {
 				const atLeastOneNonByeMatch = data.match.some(
 					(match) =>
-						match.round_id === round.id && match.opponent1 && match.opponent2,
+						match.roundId === round.id && match.opponent1 && match.opponent2,
 				);
 
 				if (!atLeastOneNonByeMatch) continue;
@@ -59,7 +61,7 @@ export class SingleEliminationBracket extends Bracket {
 	}
 
 	private hasThirdPlaceMatch() {
-		return R.unique(this.data.match.map((m) => m.group_id)).length > 1;
+		return R.unique(this.data.match.map((m) => m.groupId)).length > 1;
 	}
 
 	get standings(): Standing[] {
@@ -71,27 +73,24 @@ export class SingleEliminationBracket extends Bracket {
 			}
 
 			const thirdPlaceMatch = this.data.match.find(
-				(m) => m.group_id === Math.max(...this.data.group.map((g) => g.id)),
+				(m) => m.groupId === Math.max(...this.data.group.map((g) => g.id)),
 			);
 
 			return this.data.match.filter(
-				(m) => m.group_id !== thirdPlaceMatch?.group_id,
+				(m) => m.groupId !== thirdPlaceMatch?.groupId,
 			);
 		})();
 
-		for (const match of matches.sort((a, b) => a.round_id - b.round_id)) {
-			if (
-				match.opponent1?.result !== "win" &&
-				match.opponent2?.result !== "win"
-			) {
+		for (const match of matches.sort((a, b) => a.roundId - b.roundId)) {
+			if (!match.winnerSide) {
 				continue;
 			}
 
 			const loser =
-				match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+				match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 			invariant(loser?.id, "Loser id not found");
 
-			teams.push({ id: loser.id, lostAt: match.round_id });
+			teams.push({ id: loser.id, lostAt: match.roundId });
 		}
 
 		const teamCountWhoDidntLoseYet =
@@ -138,12 +137,12 @@ export class SingleEliminationBracket extends Bracket {
 		}
 
 		const thirdPlaceMatch = this.hasThirdPlaceMatch()
-			? this.data.match.find((m) => m.group_id !== matches[0].group_id)
+			? this.data.match.find((m) => m.groupId !== matches[0].groupId)
 			: undefined;
 		const thirdPlaceMatchWinner =
-			thirdPlaceMatch?.opponent1?.result === "win"
+			thirdPlaceMatch?.winnerSide === "opponent1"
 				? thirdPlaceMatch.opponent1
-				: thirdPlaceMatch?.opponent2?.result === "win"
+				: thirdPlaceMatch?.winnerSide === "opponent2"
 					? thirdPlaceMatch.opponent2
 					: undefined;
 
@@ -174,7 +173,7 @@ export class SingleEliminationBracket extends Bracket {
 		const mainGroupId = Math.min(...this.data.group.map((group) => group.id));
 
 		const orderedRoundsIds = this.data.round
-			.filter((round) => round.group_id === mainGroupId)
+			.filter((round) => round.groupId === mainGroupId)
 			.map((round) => round.id)
 			.sort((a, b) => a - b);
 
@@ -189,7 +188,7 @@ export class SingleEliminationBracket extends Bracket {
 		let relevantMatchesFinished = true;
 		for (const roundId of sourceRoundsIds) {
 			const roundsMatches = this.data.match.filter(
-				(match) => match.round_id === roundId,
+				(match) => match.roundId === roundId,
 			);
 
 			for (const match of roundsMatches) {
@@ -197,16 +196,13 @@ export class SingleEliminationBracket extends Bracket {
 				if (!match.opponent1 || !match.opponent2) {
 					continue;
 				}
-				if (
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win"
-				) {
+				if (!match.winnerSide) {
 					relevantMatchesFinished = false;
 					continue;
 				}
 
 				const loser =
-					match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+					match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 				invariant(loser?.id, "Loser id not found");
 
 				teams.push(loser.id);
diff --git a/app/features/tournament-bracket/core/Bracket/SwissBracket.ts b/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
index c4ec10613..0d2d25083 100644
--- a/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
@@ -1,20 +1,15 @@
 import * as R from "remeda";
 import type { Tables } from "~/db/tables";
 import * as Standings from "~/features/tournament/core/Standings";
-import { TOURNAMENT } from "~/features/tournament/tournament-constants";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import invariant from "~/utils/invariant";
 import { logger } from "~/utils/logger";
 import { cutToNDecimalPlaces } from "../../../../utils/number";
-import { calculateTeamStatus } from "../Swiss";
+import { calculateTeamStatus } from "../engine/swiss/team-status";
 import type { BracketMapCounts } from "../toMapList";
 import { Bracket, type Standing, type TeamTrackRecord } from "./Bracket";
 
 export class SwissBracket extends Bracket {
-	get collectResultsWithPoints() {
-		return false;
-	}
-
 	source({
 		placements,
 		advanceThreshold,
@@ -38,19 +33,14 @@ export class SwissBracket extends Bracket {
 
 		const relevantMatchesFinished = this.data.round.every((round) => {
 			const roundsMatches = this.data.match.filter(
-				(match) => match.round_id === round.id,
+				(match) => match.roundId === round.id,
 			);
 
 			// some round has not started yet
 			if (roundsMatches.length === 0) return false;
 
 			return roundsMatches.every((match) => {
-				if (
-					match.opponent1 &&
-					match.opponent2 &&
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win"
-				) {
+				if (match.opponent1 && match.opponent2 && !match.winnerSide) {
 					return false;
 				}
 
@@ -68,9 +58,7 @@ export class SwissBracket extends Bracket {
 							advanceThreshold,
 							wins: standing.stats?.setWins ?? 0,
 							losses: standing.stats?.setLosses ?? 0,
-							roundCount:
-								this.settings?.roundCount ??
-								TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT,
+							roundCount: this.swissRoundCount,
 						}),
 					}))
 					.filter((t) => t.status === "advanced")
@@ -108,7 +96,7 @@ export class SwissBracket extends Bracket {
 		const placements: (Standing & { groupId: number })[] = [];
 		for (const groupId of groupIds) {
 			const matches = this.data.match.filter(
-				(match) => match.group_id === groupId,
+				(match) => match.groupId === groupId,
 			);
 
 			const groupIsFinished = matches.every(
@@ -117,8 +105,7 @@ export class SwissBracket extends Bracket {
 					match.opponent1 === null ||
 					match.opponent2 === null ||
 					// match was played out
-					match.opponent1?.result === "win" ||
-					match.opponent2?.result === "win",
+					match.winnerSide,
 			);
 
 			if (!groupIsFinished && !includeUnfinishedGroups) continue;
@@ -195,18 +182,15 @@ export class SwissBracket extends Bracket {
 					]);
 				}
 
-				if (
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win"
-				) {
+				if (!match.winnerSide) {
 					continue;
 				}
 
 				const winner =
-					match.opponent1?.result === "win" ? match.opponent1 : match.opponent2;
+					match.winnerSide === "opponent1" ? match.opponent1 : match.opponent2;
 
 				const loser =
-					match.opponent1?.result === "win" ? match.opponent2 : match.opponent1;
+					match.winnerSide === "opponent1" ? match.opponent2 : match.opponent1;
 
 				if (!winner || !loser) continue;
 
@@ -246,7 +230,7 @@ export class SwissBracket extends Bracket {
 				}
 
 				const round = this.data.round.find(
-					(round) => round.id === match.round_id,
+					(round) => round.id === match.roundId,
 				);
 				const mapWins =
 					round?.maps?.type === "PLAY_ALL"
@@ -323,9 +307,7 @@ export class SwissBracket extends Bracket {
 							(match.opponent1?.id === team2.id &&
 								match.opponent2?.id === team.id);
 
-						const isFinished =
-							match.opponent1?.result === "win" ||
-							match.opponent2?.result === "win";
+						const isFinished = Boolean(match.winnerSide);
 
 						return isBetweenTeams && isFinished;
 					});
@@ -335,9 +317,9 @@ export class SwissBracket extends Bracket {
 
 					const wonTheirMatch =
 						(finishedMatchBetweenTeams.opponent1!.id === team.id &&
-							finishedMatchBetweenTeams.opponent1!.result === "win") ||
+							finishedMatchBetweenTeams.winnerSide === "opponent1") ||
 						(finishedMatchBetweenTeams.opponent2!.id === team.id &&
-							finishedMatchBetweenTeams.opponent2!.result === "win");
+							finishedMatchBetweenTeams.winnerSide === "opponent2");
 
 					if (wonTheirMatch) {
 						team.winsAgainstTied++;
@@ -438,7 +420,6 @@ export class SwissBracket extends Bracket {
 								opponentMapWinPercentage: this.trackRecordToWinPercentage(
 									team.opponentMaps,
 								),
-								points: 0,
 							},
 						};
 					}),
@@ -476,16 +457,16 @@ export class SwissBracket extends Bracket {
 		return "swiss";
 	}
 
-	defaultRoundBestOfs(data: TournamentManagerDataSet) {
+	defaultRoundBestOfs(data: BracketData) {
 		const result: BracketMapCounts = new Map();
 
 		for (const round of data.round) {
-			if (!result.get(round.group_id)) {
-				result.set(round.group_id, new Map());
+			if (!result.get(round.groupId)) {
+				result.set(round.groupId, new Map());
 			}
 
 			result
-				.get(round.group_id)!
+				.get(round.groupId)!
 				.set(round.number, { count: 3, type: "BEST_OF" });
 		}
 
diff --git a/app/features/tournament-bracket/core/Bracket/utils.ts b/app/features/tournament-bracket/core/Bracket/utils.ts
index 234c5b61b..07f59f1d8 100644
--- a/app/features/tournament-bracket/core/Bracket/utils.ts
+++ b/app/features/tournament-bracket/core/Bracket/utils.ts
@@ -1,19 +1,19 @@
 import * as R from "remeda";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 
 /**
- * Maps each round_id to the cumulative number of teams eliminated by the end of
+ * Maps each roundId to the cumulative number of teams eliminated by the end of
  * that round, counting one elimination per non-bye match. This is a structural
  * property of the bracket that does not depend on which matches have already
  * been reported, so teams tied at the same placement resolve to the same
  * placement even while some of their round's matches are still in progress.
  */
 export function cumulativeEliminationsByRound(
-	matches: TournamentManagerDataSet["match"],
+	matches: BracketData["match"],
 ): Map<number, number> {
 	const result = new Map<number, number>();
 
-	const roundIds = R.unique(matches.map((match) => match.round_id)).sort(
+	const roundIds = R.unique(matches.map((match) => match.roundId)).sort(
 		(a, b) => a - b,
 	);
 
@@ -21,7 +21,7 @@ export function cumulativeEliminationsByRound(
 	for (const roundId of roundIds) {
 		const eliminationsThisRound = matches.filter(
 			(match) =>
-				match.round_id === roundId && match.opponent1 && match.opponent2,
+				match.roundId === roundId && match.opponent1 && match.opponent2,
 		).length;
 		cumulativeEliminations += eliminationsThisRound;
 		result.set(roundId, cumulativeEliminations);
diff --git a/app/features/tournament-bracket/core/PreparedMaps.ts b/app/features/tournament-bracket/core/PreparedMaps.ts
index 12f432ae6..a28bcb00c 100644
--- a/app/features/tournament-bracket/core/PreparedMaps.ts
+++ b/app/features/tournament-bracket/core/PreparedMaps.ts
@@ -128,7 +128,7 @@ function trimMapsByTeamCount({
 	const result = { ...preparedMaps };
 	for (const groupId of groupIds) {
 		const actualRoundsForGroup = actualRounds.filter(
-			(r) => r.group_id === groupId,
+			(r) => r.groupId === groupId,
 		);
 
 		const preparedRoundsForGroup = preparedMaps.maps.filter(
diff --git a/app/features/tournament-bracket/core/Swiss.test.ts b/app/features/tournament-bracket/core/Swiss.test.ts
index d3baeedbc..5b4262b13 100644
--- a/app/features/tournament-bracket/core/Swiss.test.ts
+++ b/app/features/tournament-bracket/core/Swiss.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import type { TournamentStageSettings } from "~/db/tables";
 import { Tournament } from "~/features/tournament-bracket/core/Tournament";
 import {
 	LOW_INK_AUGUST_2025,
@@ -6,28 +7,33 @@ import {
 } from "~/features/tournament-bracket/core/tests/mocks-swiss";
 import { ZONES_WEEKLY_38 } from "~/features/tournament-bracket/core/tests/mocks-zones-weekly";
 import invariant from "~/utils/invariant";
-import * as Swiss from "./Swiss";
+import * as Engine from "./engine";
+import { pairUp } from "./engine/swiss/pairing";
+import * as TeamStatus from "./engine/swiss/team-status";
+
+const Swiss = {
+	...TeamStatus,
+	pairUp,
+	create: (args: { seeding: number[]; settings?: TournamentStageSettings }) =>
+		Engine.create({
+			...args,
+			type: "swiss",
+			settings: args.settings ?? null,
+		}),
+};
 
 describe("Swiss", () => {
 	const createArgsWithDefaults = (
 		args: Partial<Parameters<typeof Swiss.create>[0]> = {},
 	): Parameters<typeof Swiss.create>[0] => {
 		return {
-			name: "Swiss Tournament",
 			seeding: [1, 2, 3, 4],
 			settings: {},
-			tournamentId: 1,
 			...args,
 		};
 	};
 
 	describe("create()", () => {
-		it("attaches the correct tournament id to the data", () => {
-			const data = Swiss.create(createArgsWithDefaults());
-
-			expect(data.stage[0].tournament_id).toBe(1);
-		});
-
 		it("creates a swiss bracket with correct amount of initial matches", () => {
 			const data = Swiss.create(createArgsWithDefaults());
 
@@ -44,10 +50,8 @@ describe("Swiss", () => {
 			const data = Swiss.create(
 				createArgsWithDefaults({
 					settings: {
-						swiss: {
-							groupCount: 1,
-							roundCount: 4,
-						},
+						groupCount: 1,
+						roundCount: 4,
 					},
 				}),
 			);
@@ -59,17 +63,15 @@ describe("Swiss", () => {
 			const data = Swiss.create(
 				createArgsWithDefaults({
 					settings: {
-						swiss: {
-							groupCount: 2,
-							roundCount: 5,
-						},
+						groupCount: 2,
+						roundCount: 5,
 					},
 				}),
 			);
 
 			expect(data.round).toHaveLength(10);
 
-			const matchGroupIds = data.match.map((m) => m.group_id);
+			const matchGroupIds = data.match.map((m) => m.groupId);
 			expect(matchGroupIds).toContain(0);
 			expect(matchGroupIds).toContain(1);
 		});
@@ -114,17 +116,18 @@ describe("Swiss", () => {
 
 			const bracket = tournament.bracketByIdx(0)!;
 
-			const matches = Swiss.generateMatchUps({
-				bracket,
+			const matches = Engine.generateRound(bracket.data as Engine.BracketData, {
 				groupId: 4443,
-			})._unsafeUnwrap();
+				standings: bracket.standings,
+				settings: bracket.settings,
+			})._unsafeUnwrap().matches;
 
 			it("finds new opponents for each team in the last round", () => {
 				for (const match of matches) {
-					if (match.opponentTwo === "null") continue;
+					if (match.opponent2 === null) continue;
 
-					const opponent1 = JSON.parse(match.opponentOne).id as number;
-					const opponent2 = JSON.parse(match.opponentTwo).id as number;
+					const opponent1 = match.opponent1!.id as number;
+					const opponent2 = match.opponent2.id as number;
 
 					const existingMatch = bracket.data.match.find(
 						(m) =>
@@ -138,16 +141,16 @@ describe("Swiss", () => {
 			});
 
 			it("generates a bye", () => {
-				const byes = matches.filter((match) => match.opponentTwo === "null");
+				const byes = matches.filter((match) => match.opponent2 === null);
 				expect(byes).toHaveLength(1);
 			});
 
 			it("every pair is max one set win from each other", () => {
 				for (const match of matches) {
-					if (match.opponentTwo === "null") continue;
+					if (match.opponent2 === null) continue;
 
-					const opponent1 = JSON.parse(match.opponentOne).id as number;
-					const opponent2 = JSON.parse(match.opponentTwo).id as number;
+					const opponent1 = match.opponent1!.id as number;
+					const opponent2 = match.opponent2.id as number;
 
 					const opponent1Stats = bracket.standings.find(
 						(s) => s.team.id === opponent1,
diff --git a/app/features/tournament-bracket/core/Swiss.ts b/app/features/tournament-bracket/core/Swiss.ts
deleted file mode 100644
index ad4b40bf9..000000000
--- a/app/features/tournament-bracket/core/Swiss.ts
+++ /dev/null
@@ -1,533 +0,0 @@
-// separate from brackets-manager as this wasn't part of the original brackets-manager library
-
-import blossom from "edmonds-blossom-fixed";
-import { err, ok } from "neverthrow";
-import * as R from "remeda";
-import type { TournamentRepositoryInsertableMatch } from "~/features/tournament/TournamentRepository.server";
-import { TOURNAMENT } from "~/features/tournament/tournament-constants";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import type { InputStage, Match } from "~/modules/brackets-model";
-import { nullFilledArray } from "~/utils/arrays";
-import invariant from "~/utils/invariant";
-import type { Bracket } from "./Bracket";
-
-/**
- * Creates a Swiss tournament data set (initial matches) based on the provided arguments. Mimics bracket-manager module's interfaces.
- */
-export function create(
-	args: Omit<InputStage, "type" | "number" | "seeding"> & { seeding: number[] },
-): TournamentManagerDataSet {
-	const swissSettings = args.settings?.swiss;
-
-	const groupCount =
-		swissSettings?.groupCount ?? TOURNAMENT.SWISS_DEFAULT_GROUP_COUNT;
-	const roundCount =
-		swissSettings?.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT;
-
-	const group = nullFilledArray(groupCount).map((_, i) => ({
-		id: i,
-		stage_id: 0,
-		number: i + 1,
-	}));
-
-	let roundId = 0;
-	return {
-		group,
-		match: firstRoundMatches({ seeding: args.seeding, groupCount, roundCount }),
-		round: group.flatMap((g) =>
-			nullFilledArray(roundCount).map((_, i) => ({
-				id: roundId++,
-				group_id: g.id,
-				number: i + 1,
-				stage_id: 0,
-			})),
-		),
-		stage: [
-			{
-				id: 0,
-				name: args.name,
-				number: 1,
-				settings: args.settings ?? {},
-				tournament_id: args.tournamentId,
-				type: "swiss",
-			},
-		],
-	};
-}
-
-function firstRoundMatches({
-	seeding,
-	groupCount,
-	roundCount,
-}: {
-	seeding: InputStage["seeding"];
-	groupCount: number;
-	roundCount: number;
-}): Match[] {
-	// split the teams to one or more groups. For example with 16 teams and 3 groups this would result in
-	// group 1: 1, 4, 7, 10, 13, 16
-	// group 2: 2, 5, 8, 11, 14
-	// group 3: 3, 6, 9, 12, 15
-	const groups = splitToGroups();
-
-	const result: Match[] = [];
-
-	let matchId = 0;
-	for (const [groupIdx, participants] of groups.entries()) {
-		// if there is an uneven number of teams the last seed gets a bye
-		const bye = participants.length % 2 === 0 ? null : participants.pop();
-
-		const halfI = participants.length / 2;
-		const upperHalf = participants.slice(0, halfI);
-		const lowerHalf = participants.slice(halfI);
-
-		invariant(
-			upperHalf.length === lowerHalf.length,
-			"firstRoundMatches: halfs not equal",
-		);
-
-		// first round every team plays the matching team "on the opposite side"
-		// so for example with 8 teams match ups look like this:
-		// seed 1 vs. seed 5
-		// seed 2 vs. seed 6
-		// seed 3 vs. seed 7
-		// seed 4 vs. seed 8
-		// ---
-		// this way each match has "equal distance"
-		const roundId = groupIdx * roundCount;
-		for (let i = 0; i < upperHalf.length; i++) {
-			const upper = upperHalf[i];
-			const lower = lowerHalf[i];
-
-			result.push({
-				id: matchId++,
-				group_id: groupIdx,
-				stage_id: 0,
-				round_id: roundId,
-				number: i + 1,
-				opponent1: {
-					id: upper,
-				},
-				opponent2: {
-					id: lower,
-				},
-				status: 2,
-			});
-		}
-
-		if (bye) {
-			result.push({
-				id: matchId++,
-				group_id: groupIdx,
-				stage_id: 0,
-				round_id: roundId,
-				number: upperHalf.length + 1,
-				opponent1: {
-					id: bye,
-				},
-				opponent2: null,
-				status: 2,
-			});
-		}
-	}
-
-	return result;
-
-	function splitToGroups() {
-		if (!seeding) return [];
-		if (groupCount === 1) return [[...seeding]];
-
-		const groups: number[][] = nullFilledArray(groupCount).map(() => []);
-
-		for (let i = 0; i < seeding.length; i++) {
-			const groupIndex = i % groupCount;
-			groups[groupIndex].push(seeding[i]!);
-		}
-
-		return groups;
-	}
-}
-
-function everyMatchOver(matches: Match[]) {
-	for (const match of matches) {
-		// bye
-		if (!match.opponent1 || !match.opponent2) continue;
-
-		if (match.opponent1.result !== "win" && match.opponent2.result !== "win") {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Generates the next round of matchups for a Swiss tournament bracket within a specific group.
- *
- * Considers only the matches and teams within the specified group. Teams that have dropped out are excluded from the pairing process.
- * If the group has an uneven number of teams, the lowest standing team that has not already received a bye is preferred to receive one.
- * Matches are generated such that teams do not replay previous opponents if possible.
- */
-export function generateMatchUps({
-	bracket,
-	groupId,
-}: {
-	bracket: Bracket;
-	groupId: number;
-}) {
-	// lets consider only this groups matches
-	// in the case that there are more than one group
-	const groupsMatches = bracket.data.match.filter(
-		(m) => m.group_id === groupId,
-	);
-
-	if (groupsMatches.length === 0) return err("No matches found for group");
-	if (bracket.type !== "swiss") return err("Bracket is not Swiss type");
-
-	// new matches can't be generated till old are over
-	if (!everyMatchOver(groupsMatches)) {
-		return err("Not all matches are over");
-	}
-
-	const groupsTeams = groupsMatches
-		.flatMap((match) => [match.opponent1, match.opponent2])
-		.filter(Boolean);
-	const groupsStandings = bracket.standings.filter((standing) => {
-		return groupsTeams.some((team) => team?.id === standing.team.id);
-	});
-
-	// teams who have dropped out are not considered
-	let standingsWithoutDropouts = groupsStandings.filter(
-		(s) => !s.team.droppedOut,
-	);
-
-	// filter out teams that have advanced or been eliminated if early advance/elimination is enabled
-	if (typeof bracket.settings?.advanceThreshold === "number") {
-		const roundCount =
-			bracket.settings.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT;
-		const advanceThreshold = bracket.settings.advanceThreshold;
-
-		standingsWithoutDropouts = standingsWithoutDropouts.filter((standing) => {
-			const wins = standing.stats?.setWins ?? 0;
-			const losses = standing.stats?.setLosses ?? 0;
-			const status = calculateTeamStatus({
-				wins,
-				losses,
-				advanceThreshold,
-				roundCount,
-			});
-
-			return status === "active";
-		});
-	}
-
-	// if there are fewer than 2 active teams, no more matches can be generated
-	if (standingsWithoutDropouts.length < 2) {
-		return err("Not enough active teams to generate matches");
-	}
-
-	const teamsThatHaveHadByes = groupsMatches
-		.filter((m) => m.opponent2 === null)
-		.map((m) => m.opponent1?.id);
-
-	const pairs = pairUp(
-		standingsWithoutDropouts.map((standing) => ({
-			id: standing.team.id,
-			score: standing.stats?.setWins ?? 0,
-			receivedBye: teamsThatHaveHadByes.includes(standing.team.id),
-			avoid: groupsMatches.flatMap((match) => {
-				if (match.opponent1?.id === standing.team.id) {
-					return match.opponent2?.id ? [match.opponent2.id] : [];
-				}
-				if (match.opponent2?.id === standing.team.id) {
-					return match.opponent1?.id ? [match.opponent1.id] : [];
-				}
-				return [];
-			}),
-		})),
-	);
-
-	let matchNumber = 1;
-	const newRoundId = bracket.data.round
-		.slice()
-		.sort((a, b) => a.id - b.id)
-		.filter((r) => r.group_id === groupId)
-		.find(
-			(r) => r.id > Math.max(...groupsMatches.map((match) => match.round_id)),
-		)?.id;
-	invariant(newRoundId, "newRoundId not found");
-	const result: TournamentRepositoryInsertableMatch[] = pairs.map(
-		({ opponentOne, opponentTwo }) => ({
-			groupId,
-			number: matchNumber++,
-			roundId: newRoundId,
-			stageId: groupsMatches[0].stage_id,
-			opponentOne: JSON.stringify({
-				id: opponentOne,
-			}),
-			opponentTwo:
-				typeof opponentTwo === "number"
-					? JSON.stringify({
-							id: opponentTwo,
-						})
-					: JSON.stringify(null),
-		}),
-	);
-
-	return ok(result);
-}
-
-interface SwissPairingTeam {
-	id: number;
-	/** How many matches has the team won */
-	score: number;
-	/** List of tournament team ids this team already played */
-	avoid: Array<number>;
-	receivedBye?: boolean;
-}
-
-// adapted from https://github.com/slashinfty/tournament-pairings
-export function pairUp(players: SwissPairingTeam[]) {
-	if (players.length < 2) {
-		throw new Error("Need at least two players to pair up");
-	}
-	if (players.length === 2) {
-		return [{ opponentOne: players[0].id, opponentTwo: players[1].id }];
-	}
-
-	// uncomment to add a new test case to PAIR_UP_TEST_CASES
-	// console.log(players);
-
-	const matches = [];
-	const playerArray = R.shuffle(players).map((p, i) => ({ ...p, index: i }));
-	const scoreGroups = [...new Set(playerArray.map((p) => p.score))].sort(
-		(a, b) => a - b,
-	);
-	const scoreSums = [
-		...new Set(
-			scoreGroups.flatMap((s, i, a) => {
-				const sums = [];
-				for (let j = i; j < a.length; j++) {
-					sums.push(s + a[j]);
-				}
-				return sums;
-			}),
-		),
-	].sort((a, b) => a - b);
-
-	let pairs = generateWeightedPairs({ playerArray, scoreGroups, scoreSums });
-	if (pairs.length === 0) {
-		// no possible pairs without rematches, try again allowing rematches
-		pairs = generateWeightedPairs({
-			playerArray,
-			scoreGroups,
-			scoreSums,
-			considerAvoid: false,
-		});
-	}
-
-	const blossomPairs = blossom(pairs, true);
-	const playerCopy = [...playerArray];
-	let byeArray = [];
-	do {
-		const indexA = playerCopy[0].index;
-		const indexB = blossomPairs[indexA];
-		if (indexB === -1) {
-			byeArray.push(playerCopy.splice(0, 1)[0]);
-			continue;
-		}
-		playerCopy.splice(0, 1);
-		playerCopy.splice(
-			playerCopy.findIndex((p) => p.index === indexB),
-			1,
-		);
-		const playerA = playerArray.find((p) => p.index === indexA);
-		const playerB = playerArray.find((p) => p.index === indexB);
-		invariant(playerA, "Player A not found");
-		invariant(playerB, "Player B not found");
-
-		matches.push({
-			opponentOne: playerA.id,
-			opponentTwo: playerB.id,
-		});
-	} while (
-		playerCopy.length >
-		blossomPairs.reduce(
-			(sum: number, idx: number) => (idx === -1 ? sum + 1 : sum),
-			0,
-		)
-	);
-	byeArray = [...byeArray, ...playerCopy];
-	for (let i = 0; i < byeArray.length; i++) {
-		matches.push({
-			opponentOne: byeArray[i].id,
-			opponentTwo: null,
-		});
-	}
-
-	return matches;
-}
-
-function generateWeightedPairs({
-	playerArray,
-	scoreGroups,
-	scoreSums,
-	considerAvoid = true,
-}: {
-	playerArray: (SwissPairingTeam & { index: number })[];
-	scoreGroups: number[];
-	scoreSums: number[];
-	considerAvoid?: boolean;
-}) {
-	const pairs: [number, number, number][] = [];
-	for (let i = 0; i < playerArray.length; i++) {
-		const curr = playerArray[i];
-		const next = playerArray.slice(i + 1);
-		for (let j = 0; j < next.length; j++) {
-			const opp = next[j];
-			if (
-				considerAvoid &&
-				Object.hasOwn(curr, "avoid") &&
-				curr.avoid.includes(opp.id)
-			) {
-				continue;
-			}
-			let wt =
-				75 - 75 / (scoreGroups.indexOf(Math.min(curr.score, opp.score)) + 2);
-			wt +=
-				5 - 5 / (scoreSums.findIndex((s) => s === curr.score + opp.score) + 1);
-			const scoreGroupDiff = Math.abs(
-				scoreGroups.indexOf(curr.score) - scoreGroups.indexOf(opp.score),
-			);
-
-			// TODO: consider "pairedUpDown"
-			// if (
-			// 	scoreGroupDiff === 1 &&
-			// 	curr.hasOwnProperty("pairedUpDown") &&
-			// 	curr.pairedUpDown === false &&
-			// 	opp.hasOwnProperty("pairedUpDown") &&
-			// 	opp.pairedUpDown === false
-			// ) {
-			// 	scoreGroupDiff -= 0.65;
-			// } else if (
-			// 	scoreGroupDiff > 0 &&
-			// 	((curr.hasOwnProperty("pairedUpDown") && curr.pairedUpDown === true) ||
-			// 		(opp.hasOwnProperty("pairedUpDown") && opp.pairedUpDown === true))
-			// ) {
-			// 	scoreGroupDiff += 0.2;
-			// }
-
-			wt += 23 / (2 * (scoreGroupDiff + 2));
-
-			// Lower weight for larger score differences, we really want to avoid 2-0 playing 0-2 etc.
-			if (scoreGroupDiff >= 2) {
-				wt -= 10;
-			}
-
-			if (
-				(Object.hasOwn(curr, "receivedBye") && curr.receivedBye) ||
-				(Object.hasOwn(opp, "receivedBye") && opp.receivedBye)
-			) {
-				wt += 40;
-			}
-			pairs.push([curr.index, opp.index, wt]);
-		}
-	}
-
-	return pairs;
-}
-
-export type SwissTeamStatus = "active" | "advanced" | "eliminated";
-
-/**
- * Calculates whether a team should advance, be eliminated, or remain active
- * in a Swiss tournament with early advance/elimination rules.
- *
- * @returns The team's status: "advanced" if they've secured advancement,
- *          "eliminated" if they can no longer mathematically advance, or "active" if still competing
- *
- * @example
- * // In a 5-round Swiss where teams need 3 wins to advance:
- * calculateTeamStatus({ wins: 3, losses: 1, advanceThreshold: 3, roundCount: 5 }) // "advanced"
- * calculateTeamStatus({ wins: 2, losses: 3, advanceThreshold: 3, roundCount: 5 }) // "eliminated"
- * calculateTeamStatus({ wins: 2, losses: 2, advanceThreshold: 3, roundCount: 5 }) // "active"
- */
-export function calculateTeamStatus({
-	wins,
-	losses,
-	advanceThreshold,
-	roundCount,
-}: {
-	/** Number of matches the team has won */
-	wins: number;
-	/** Number of matches the team has lost */
-	losses: number;
-	/** Number of wins required to advance to the next stage */
-	advanceThreshold: number;
-	/** Total number of rounds in the Swiss stage */
-	roundCount: number;
-}): SwissTeamStatus {
-	if (wins >= advanceThreshold) {
-		return "advanced";
-	}
-
-	if (losses >= eliminationThreshold({ roundCount, advanceThreshold })) {
-		return "eliminated";
-	}
-
-	return "active";
-}
-
-/**
- * Calculates the maximum valid advance threshold for a given round count.
- * The threshold must allow for meaningful play - teams need a chance to both advance and be eliminated.
- */
-export function maxAdvanceThreshold({ roundCount }: { roundCount: number }) {
-	return Math.ceil(roundCount / 2) + 1;
-}
-
-/**
- * Calculates the maximum losses allowed before elimination given an advance threshold and round count.
- */
-export function eliminationThreshold({
-	roundCount,
-	advanceThreshold,
-}: {
-	roundCount: number;
-	advanceThreshold: number;
-}) {
-	return roundCount - advanceThreshold + 1;
-}
-
-/**
- * Validates if an advance threshold is valid for the given round count.
- */
-export function isValidAdvanceThreshold({
-	roundCount,
-	advanceThreshold,
-}: {
-	roundCount: number;
-	advanceThreshold: number;
-}) {
-	return validAdvanceThresholdOptions({ roundCount }).includes(
-		advanceThreshold,
-	);
-}
-
-/**
- * Returns a list of valid advance threshold options for a given round count.
- * Starts from 2 wins minimum up to the calculated maximum.
- */
-export function validAdvanceThresholdOptions({
-	roundCount,
-}: {
-	roundCount: number;
-}) {
-	const result: number[] = [];
-
-	for (let i = 2; i <= maxAdvanceThreshold({ roundCount }); i++) {
-		result.push(i);
-	}
-
-	return result;
-}
diff --git a/app/features/tournament-bracket/core/Tournament.server.ts b/app/features/tournament-bracket/core/Tournament.server.ts
index 8bce636c0..38c221acc 100644
--- a/app/features/tournament-bracket/core/Tournament.server.ts
+++ b/app/features/tournament-bracket/core/Tournament.server.ts
@@ -2,27 +2,22 @@ import { sub } from "date-fns";
 import { ServerConfig } from "~/config.server";
 import { clearCombinedStreamsCache } from "~/features/core/streams/streams.server";
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
+import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import { getTentativeTier } from "~/features/tournament-organization/core/tentativeTiers.server";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
 import { isAdmin } from "~/modules/permissions/utils";
 import { databaseTimestampToDate } from "~/utils/dates";
 import { notFoundIfNullish } from "~/utils/remix.server";
 import type { Unwrapped } from "~/utils/types";
-import { getServerTournamentManager } from "./brackets-manager/manager.server";
 import { RunningTournaments } from "./RunningTournaments.server";
 import { Tournament } from "./Tournament";
 
-const manager = getServerTournamentManager();
-
-export const tournamentManagerData = (tournamentId: number) =>
-	manager.get.tournamentData(tournamentId);
-
 const combinedTournamentData = async (tournamentId: number) => {
 	const ctx = await TournamentRepository.findById(tournamentId);
 	if (!ctx) return null;
 
 	return {
-		data: tournamentManagerData(tournamentId),
+		data: await BracketRepository.findByTournamentId(tournamentId),
 		ctx,
 	};
 };
@@ -47,7 +42,7 @@ function dataMapped({
 	ctx,
 	user,
 }: {
-	data: TournamentManagerDataSet;
+	data: BracketData;
 	ctx: TournamentRepository.FindById;
 	user?: { id: number };
 }) {
diff --git a/app/features/tournament-bracket/core/Tournament.test.ts b/app/features/tournament-bracket/core/Tournament.test.ts
index 43e18f40f..b92880bb9 100644
--- a/app/features/tournament-bracket/core/Tournament.test.ts
+++ b/app/features/tournament-bracket/core/Tournament.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it, test } from "vitest";
-import type { Match } from "~/modules/brackets-model";
+import type { MatchData } from "~/features/tournament-bracket/core/engine/types";
 import { Tournament } from "./Tournament";
 import {
 	IN_THE_ZONE_32,
@@ -117,7 +117,10 @@ describe("Follow-up bracket progression", () => {
 		).toBe(AMOUNT_OF_BEST_VS_BEST);
 	});
 
-	const validateNoRematches = (rrMatches: Match[], topCutMatches: Match[]) => {
+	const validateNoRematches = (
+		rrMatches: MatchData[],
+		topCutMatches: MatchData[],
+	) => {
 		for (const topCutMatch of topCutMatches) {
 			if (!topCutMatch.opponent1?.id || !topCutMatch.opponent2?.id) {
 				continue;
diff --git a/app/features/tournament-bracket/core/Tournament.ts b/app/features/tournament-bracket/core/Tournament.ts
index dead58fa1..566ab0201 100644
--- a/app/features/tournament-bracket/core/Tournament.ts
+++ b/app/features/tournament-bracket/core/Tournament.ts
@@ -13,9 +13,11 @@ import {
 	tournamentInWeaponReportingWindow,
 	tournamentIsRanked,
 } from "~/features/tournament/tournament-utils";
+import type {
+	BracketData,
+	MatchData,
+} from "~/features/tournament-bracket/core/engine/types";
 import type * as Progression from "~/features/tournament-bracket/core/Progression";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import type { Match, Stage } from "~/modules/brackets-model";
 import type { ModeShort } from "~/modules/in-game-lists/types";
 import { isAdmin } from "~/modules/permissions/utils";
 import {
@@ -26,14 +28,10 @@ import {
 import invariant from "~/utils/invariant";
 import { logger } from "~/utils/logger";
 import { assertUnreachable } from "~/utils/types";
-import {
-	fillWithNullTillPowerOfTwo,
-	groupNumberToLetters,
-} from "../tournament-bracket-utils";
+import { groupNumberToLetters } from "../tournament-bracket-utils";
 import { type Bracket, createBracket } from "./Bracket";
-import { getTournamentManager } from "./brackets-manager";
+import * as Engine from "./engine";
 import { getRounds } from "./rounds";
-import * as Swiss from "./Swiss";
 import type { TournamentData, TournamentDataTeam } from "./Tournament.server";
 
 export type OptionalIdObject = { id: number } | undefined;
@@ -77,7 +75,7 @@ export class Tournament {
 		this.initBrackets(data);
 	}
 
-	private initBrackets(data: TournamentManagerDataSet) {
+	private initBrackets(data: BracketData) {
 		for (const [
 			bracketIdx,
 			{
@@ -93,7 +91,7 @@ export class Tournament {
 
 			if (inProgressStage) {
 				const match = data.match.filter(
-					(match) => match.stage_id === inProgressStage.id,
+					(match) => match.stageId === inProgressStage.id,
 				);
 
 				this.brackets.push(
@@ -111,64 +109,19 @@ export class Tournament {
 						data: {
 							...data,
 							group: data.group.filter(
-								(group) => group.stage_id === inProgressStage.id,
+								(group) => group.stageId === inProgressStage.id,
 							),
 							match,
 							stage: data.stage.filter(
 								(stage) => stage.id === inProgressStage.id,
 							),
 							round: data.round.filter(
-								(round) => round.stage_id === inProgressStage.id,
+								(round) => round.stageId === inProgressStage.id,
 							),
 						},
 						type,
 					}),
 				);
-			} else if (type === "swiss") {
-				const { teams, relevantMatchesFinished } = sources
-					? this.resolveTeamsFromSources(sources, bracketIdx)
-					: this.resolveTeamsFromSignups(bracketIdx);
-
-				const { checkedInTeams, notCheckedInTeams } =
-					this.divideTeamsToCheckedInAndNotCheckedIn({
-						teams,
-						bracketIdx,
-						usesRegularCheckIn: !sources,
-						requiresCheckIn,
-					});
-
-				this.brackets.push(
-					createBracket({
-						id: -1 * bracketIdx,
-						idx: bracketIdx,
-						tournament: this,
-						seeding: checkedInTeams,
-						preview: true,
-						name,
-						requiresCheckIn,
-						startTime: startTime ? databaseTimestampToDate(startTime) : null,
-						settings: settings ?? null,
-						data: Swiss.create({
-							tournamentId: this.ctx.id,
-							name,
-							seeding: checkedInTeams,
-							settings: this.bracketManagerSettings(
-								settings,
-								type,
-								checkedInTeams.length,
-							),
-						}),
-						type,
-						sources,
-						createdAt: null,
-						canBeStarted:
-							(!startTime || startTime < databaseTimestampNow()) &&
-							checkedInTeams.length >= TOURNAMENT.ENOUGH_TEAMS_TO_START &&
-							(sources ? relevantMatchesFinished : this.regularCheckInHasEnded),
-						teamsPendingCheckIn:
-							bracketIdx !== 0 ? notCheckedInTeams : undefined,
-					}),
-				);
 			} else {
 				const { teams, relevantMatchesFinished } = sources
 					? this.resolveTeamsFromSources(sources, bracketIdx)
@@ -385,23 +338,14 @@ export class Tournament {
 		);
 
 		const bracketReplays = (candidateTeams: number[]) => {
-			const manager = getTournamentManager();
-			manager.create({
-				tournamentId: this.ctx.id,
-				name: "X",
+			const matches = Engine.create({
 				type: bracket.type as Exclude<
 					TournamentStage["type"],
 					"round_robin" | "swiss"
 				>,
-				seeding: fillWithNullTillPowerOfTwo(candidateTeams),
-				settings: this.bracketManagerSettings(
-					settings,
-					bracket.type,
-					candidateTeams.length,
-				),
-			});
-
-			const matches = manager.get.tournamentData(this.ctx.id).match;
+				seeding: candidateTeams,
+				settings,
+			}).match;
 			const replays: [number, number][] = [];
 			for (const match of matches) {
 				if (!match.opponent1?.id || !match.opponent2?.id) continue;
@@ -532,61 +476,6 @@ export class Tournament {
 		);
 	}
 
-	/** Provides settings for the brackets-manager module with our selected defaults */
-	bracketManagerSettings(
-		selectedSettings: TournamentStageSettings | null,
-		type: Tables["TournamentStage"]["type"],
-		participantsCount: number,
-	): Stage["settings"] {
-		switch (type) {
-			case "single_elimination": {
-				if (participantsCount < 4) {
-					return { consolationFinal: false };
-				}
-
-				return {
-					consolationFinal:
-						selectedSettings?.thirdPlaceMatch ??
-						TOURNAMENT.SE_DEFAULT_HAS_THIRD_PLACE_MATCH,
-				};
-			}
-			case "double_elimination": {
-				return {
-					grandFinal: "double",
-				};
-			}
-			case "round_robin": {
-				const teamsPerGroup =
-					selectedSettings?.teamsPerGroup ??
-					TOURNAMENT.RR_DEFAULT_TEAM_COUNT_PER_GROUP;
-
-				return {
-					groupCount: Math.ceil(participantsCount / teamsPerGroup),
-					seedOrdering: ["groups.seed_optimized"],
-					hasAbDivisions: selectedSettings?.hasAbDivisions ?? false,
-					...(this.isLeagueDivision ? { independentRounds: true } : {}),
-				};
-			}
-			case "swiss": {
-				return {
-					swiss:
-						selectedSettings?.groupCount && selectedSettings.roundCount
-							? {
-									groupCount: selectedSettings.groupCount,
-									roundCount: selectedSettings.roundCount,
-								}
-							: {
-									groupCount: TOURNAMENT.SWISS_DEFAULT_GROUP_COUNT,
-									roundCount: TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT,
-								},
-				};
-			}
-			default: {
-				assertUnreachable(type);
-			}
-		}
-	}
-
 	/** Is tournament ranked (affects SP/Skill). For tournament to be ranked the organizer needs to enable it and it needs to fit the conditions e.g. it needs to happen when a ranked season is active. */
 	get ranked() {
 		return tournamentIsRanked({
@@ -739,6 +628,20 @@ export class Tournament {
 		);
 	}
 
+	/** Status of the given match, derived from the state of its bracket. */
+	matchStatusById(matchId: number) {
+		for (const bracket of this.brackets) {
+			// preview brackets have locally generated match ids that can collide with real ones
+			if (bracket.preview) continue;
+
+			if (bracket.data.match.some((match) => match.id === matchId)) {
+				return bracket.matchStatus(matchId);
+			}
+		}
+
+		throw new Error("Match not found");
+	}
+
 	matchIdToBracketIdx(matchId: number) {
 		const idx = this.brackets.findIndex((bracket) =>
 			bracket.data.match.some((match) => match.id === matchId),
@@ -767,7 +670,7 @@ export class Tournament {
 
 			return this.brackets[0].data.round.every((round) => {
 				const hasMatches = this.brackets[0].data.match.some(
-					(match) => match.round_id === round.id,
+					(match) => match.roundId === round.id,
 				);
 
 				return hasMatches;
@@ -947,19 +850,19 @@ export class Tournament {
 
 					if (bracket.type === "round_robin") {
 						const group = bracket.data.group.find(
-							(group) => group.id === match.group_id,
+							(group) => group.id === match.groupId,
 						);
 						const round = bracket.data.round.find(
-							(round) => round.id === match.round_id,
+							(round) => round.id === match.roundId,
 						);
 
 						roundName = `Groups ${group?.number ? groupNumberToLetters(group.number) : ""}${round?.number ?? ""}.${match.number}`;
 					} else if (bracket.type === "swiss") {
 						const group = bracket.data.group.find(
-							(group) => group.id === match.group_id,
+							(group) => group.id === match.groupId,
 						);
 						const round = bracket.data.round.find(
-							(round) => round.id === match.round_id,
+							(round) => round.id === match.roundId,
 						);
 
 						const oneGroupOnly = bracket.data.group.length === 1;
@@ -980,7 +883,7 @@ export class Tournament {
 										...getRounds({ type: "losers", bracketData: bracket.data }),
 									];
 
-						const round = rounds.find((round) => round.id === match.round_id);
+						const round = rounds.find((round) => round.id === match.roundId);
 
 						if (round) {
 							const specifier = () => {
@@ -1112,10 +1015,7 @@ export class Tournament {
 				const isParticipant =
 					match.opponent1?.id === team.id || match.opponent2?.id === team.id;
 				const isNotFinished =
-					match.opponent1 &&
-					match.opponent2 &&
-					match.opponent1?.result !== "win" &&
-					match.opponent2?.result !== "win";
+					match.opponent1 && match.opponent2 && !match.winnerSide;
 				const isWaitingForTeam =
 					(match.opponent1 && match.opponent1.id === null) ||
 					(match.opponent2 && match.opponent2.id === null);
@@ -1133,8 +1033,7 @@ export class Tournament {
 							(match) =>
 								(match.opponent1?.id === otherTeam.id ||
 									match.opponent2?.id === otherTeam.id) &&
-								match.opponent1?.result !== "win" &&
-								match.opponent2?.result !== "win",
+								!match.winnerSide,
 						)?.id !== match.id;
 
 					if (otherTeamBusyWithPreviousMatch) {
@@ -1189,8 +1088,7 @@ export class Tournament {
 					match.opponent1?.id === team.id || match.opponent2?.id === team.id,
 			).length;
 			const notAllRoundsGenerated =
-				bracket.settings?.roundCount &&
-				setsGeneratedCount !== bracket.settings.roundCount;
+				setsGeneratedCount !== bracket.swissRoundCount;
 
 			if (isParticipant && notAllRoundsGenerated) {
 				return { type: "WAITING_FOR_ROUND" } as const;
@@ -1300,7 +1198,7 @@ export class Tournament {
 		matchBracket,
 		bracketIdx,
 	}: {
-		match: Match;
+		match: MatchData;
 		matchBracket: Bracket;
 		bracketIdx: number;
 	}) {
@@ -1344,8 +1242,7 @@ export class Tournament {
 		return bracket.data.match
 			.filter(
 				// only interested in matches of the same bracket & not the match  itself
-				(match2) =>
-					match2.stage_id === match.stage_id && match2.id !== match.id,
+				(match2) => match2.stageId === match.stageId && match2.id !== match.id,
 			)
 			.filter((match2) => {
 				const hasSameParticipant =
@@ -1355,7 +1252,7 @@ export class Tournament {
 					match2.opponent2?.id === match.opponent2?.id;
 
 				const comesAfter =
-					match2.group_id > match.group_id || match2.round_id > match.round_id;
+					match2.groupId > match.groupId || match2.roundId > match.roundId;
 
 				return hasSameParticipant && comesAfter;
 			});
diff --git a/app/features/tournament-bracket/core/brackets-manager/crud-db.server.ts b/app/features/tournament-bracket/core/brackets-manager/crud-db.server.ts
deleted file mode 100644
index efd74bc71..000000000
--- a/app/features/tournament-bracket/core/brackets-manager/crud-db.server.ts
+++ /dev/null
@@ -1,501 +0,0 @@
-// this file offers database functions specifically for the crud.server.ts file
-
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-import type {
-	Group as GroupType,
-	Match as MatchType,
-	Round as RoundType,
-	Stage as StageType,
-} from "~/modules/brackets-model";
-import { dateToDatabaseTimestamp } from "~/utils/dates";
-import { shortNanoid } from "~/utils/id";
-
-const stage_getByIdStm = sql.prepare(/*sql*/ `
-  select
-    *
-  from
-    "TournamentStage"
-  where
-    "TournamentStage"."id" = @id
-`);
-
-const stage_getByTournamentIdStm = sql.prepare(/*sql*/ `
-  select
-    *
-  from
-    "TournamentStage"
-  where
-    "TournamentStage"."tournamentId" = @tournamentId
-`);
-
-const stage_insertStm = sql.prepare(/*sql*/ `
-  insert into
-    "TournamentStage"
-    ("tournamentId", "number", "name", "type", "settings", "createdAt")
-  values
-    (@tournamentId, @number, @name, @type, @settings, @createdAt)
-  returning *
-`);
-
-const stage_updateSettingsStm = sql.prepare(/*sql*/ `
-  update
-    "TournamentStage"
-  set
-    "settings" = @settings
-  where
-    "TournamentStage"."id" = @id
-`);
-
-export class Stage {
-	id?: Tables["TournamentStage"]["id"];
-	tournamentId: Tables["TournamentStage"]["tournamentId"];
-	number: Tables["TournamentStage"]["number"];
-	name: Tables["TournamentStage"]["name"];
-	type: StageType["type"];
-	settings: Tables["TournamentStage"]["settings"];
-
-	constructor(
-		id: Tables["TournamentStage"]["id"] | undefined,
-		tournamentId: Tables["TournamentStage"]["tournamentId"],
-		number: Tables["TournamentStage"]["number"],
-		name: Tables["TournamentStage"]["name"],
-		type: StageType["type"],
-		settings: Tables["TournamentStage"]["settings"],
-	) {
-		this.id = id;
-		this.tournamentId = tournamentId;
-		this.number = number;
-		this.name = name;
-		this.type = type;
-		this.settings = settings;
-	}
-
-	insert() {
-		const stage = stage_insertStm.get({
-			tournamentId: this.tournamentId,
-			number: this.number,
-			name: this.name,
-			type: this.type,
-			settings: this.settings,
-			createdAt: dateToDatabaseTimestamp(new Date()),
-		}) as any;
-
-		this.id = stage.id;
-
-		return true;
-	}
-
-	static #convertStage(rawStage: Tables["TournamentStage"]): StageType {
-		return {
-			id: rawStage.id,
-			name: rawStage.name,
-			number: rawStage.number,
-			settings: JSON.parse(rawStage.settings),
-			tournament_id: rawStage.tournamentId,
-			type: rawStage.type,
-			createdAt: rawStage.createdAt,
-		};
-	}
-
-	static getById(id: Tables["TournamentStage"]["id"]): StageType {
-		const stage = stage_getByIdStm.get({ id }) as any;
-		if (!stage) return stage;
-		return Stage.#convertStage(stage);
-	}
-
-	static getByTournamentId(tournamentId: number): StageType[] {
-		return (stage_getByTournamentIdStm.all({ tournamentId }) as any[]).map(
-			Stage.#convertStage,
-		);
-	}
-
-	static updateSettings(
-		id: Tables["TournamentStage"]["id"],
-		settings: Tables["TournamentStage"]["settings"],
-	) {
-		stage_updateSettingsStm.run({ id, settings });
-
-		return true;
-	}
-}
-
-const group_getByIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentGroup"
-    where "TournamentGroup"."id" = @id
-`);
-
-const group_getByStageIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentGroup"
-    where "TournamentGroup"."stageId" = @stageId
-`);
-
-const group_getByStageAndNumberStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentGroup"
-    where "TournamentGroup"."stageId" = @stageId
-      and "TournamentGroup"."number" = @number
-`);
-
-const group_insertStm = sql.prepare(/*sql*/ `
-  insert into
-    "TournamentGroup"
-    ("stageId", "number")
-  values
-    (@stageId, @number)
-  returning *
-`);
-
-export class Group {
-	id?: Tables["TournamentGroup"]["id"];
-	stageId: Tables["TournamentGroup"]["stageId"];
-	number: Tables["TournamentGroup"]["number"];
-
-	constructor(
-		id: Tables["TournamentGroup"]["id"] | undefined,
-		stageId: Tables["TournamentGroup"]["stageId"],
-		number: Tables["TournamentGroup"]["number"],
-	) {
-		this.id = id;
-		this.stageId = stageId;
-		this.number = number;
-	}
-
-	static #convertGroup(rawGroup: Tables["TournamentGroup"]): GroupType {
-		return {
-			id: rawGroup.id,
-			number: rawGroup.number,
-			stage_id: rawGroup.stageId,
-		};
-	}
-
-	static getById(id: Tables["TournamentGroup"]["id"]): GroupType {
-		const group = group_getByIdStm.get({ id }) as any;
-		if (!group) return group;
-		return Group.#convertGroup(group);
-	}
-
-	static getByStageId(stageId: Tables["TournamentStage"]["id"]): GroupType[] {
-		return (group_getByStageIdStm.all({ stageId }) as any[]).map(
-			Group.#convertGroup,
-		);
-	}
-
-	static getByStageAndNumber(
-		stageId: Tables["TournamentStage"]["id"],
-		number: Tables["TournamentGroup"]["number"],
-	): GroupType {
-		const group = group_getByStageAndNumberStm.get({ stageId, number }) as any;
-		if (!group) return group;
-		return Group.#convertGroup(group_getByStageAndNumberStm.get(group) as any);
-	}
-
-	insert() {
-		const group = group_insertStm.get({
-			stageId: this.stageId,
-			number: this.number,
-		}) as any;
-
-		this.id = group.id;
-
-		return true;
-	}
-}
-
-const round_getByIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentRound"
-    where "TournamentRound"."id" = @id
-`);
-
-const round_getByGroupIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentRound"
-    where "TournamentRound"."groupId" = @groupId
-`);
-
-const round_getByStageIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentRound"
-    where "TournamentRound"."stageId" = @stageId
-`);
-
-const round_getByGroupAndNumberStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentRound"
-    where "TournamentRound"."groupId" = @groupId
-      and "TournamentRound"."number" = @number
-`);
-
-const round_insertStm = sql.prepare(/*sql*/ `
-  insert into
-    "TournamentRound"
-    ("stageId", "groupId", "number")
-  values
-    (@stageId, @groupId, @number)
-  returning *
-`);
-
-export class Round {
-	id?: Tables["TournamentRound"]["id"];
-	stageId: Tables["TournamentRound"]["stageId"];
-	groupId: Tables["TournamentRound"]["groupId"];
-	number: Tables["TournamentRound"]["number"];
-
-	constructor(
-		id: Tables["TournamentRound"]["id"] | undefined,
-		stageId: Tables["TournamentRound"]["stageId"],
-		groupId: Tables["TournamentRound"]["groupId"],
-		number: Tables["TournamentRound"]["number"],
-	) {
-		this.id = id;
-		this.stageId = stageId;
-		this.groupId = groupId;
-		this.number = number;
-	}
-
-	insert() {
-		const round = round_insertStm.get({
-			stageId: this.stageId,
-			groupId: this.groupId,
-			number: this.number,
-		}) as any;
-
-		this.id = round.id;
-
-		return true;
-	}
-
-	static #convertRound(
-		rawRound: Tables["TournamentRound"] & { maps?: string | null },
-	): RoundType {
-		const parsedMaps = rawRound.maps ? JSON.parse(rawRound.maps) : null;
-
-		return {
-			id: rawRound.id,
-			group_id: rawRound.groupId,
-			number: rawRound.number,
-			stage_id: rawRound.stageId,
-			maps: parsedMaps
-				? {
-						count: parsedMaps.count,
-						type: parsedMaps.type,
-						pickBan: parsedMaps.pickBan,
-					}
-				: null,
-		};
-	}
-
-	static getByStageId(stageId: Tables["TournamentStage"]["id"]): RoundType[] {
-		return (round_getByStageIdStm.all({ stageId }) as any[]).map(
-			Round.#convertRound,
-		);
-	}
-
-	static getByGroupId(groupId: Tables["TournamentGroup"]["id"]): RoundType[] {
-		return (round_getByGroupIdStm.all({ groupId }) as any[]).map(
-			Round.#convertRound,
-		);
-	}
-
-	static getByGroupAndNumber(
-		groupId: Tables["TournamentGroup"]["id"],
-		number: Tables["TournamentRound"]["number"],
-	): RoundType {
-		const round = round_getByGroupAndNumberStm.get({ groupId, number }) as any;
-		if (!round) return round;
-		return Round.#convertRound(round);
-	}
-
-	static getById(id: Tables["TournamentRound"]["id"]): RoundType {
-		const round = round_getByIdStm.get({ id }) as any;
-		if (!round) return round;
-		return Round.#convertRound(round);
-	}
-}
-
-const match_getByIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentMatch"
-    where "TournamentMatch"."id" = @id
-`);
-
-const match_getByRoundIdStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentMatch"
-    where "TournamentMatch"."roundId" = @roundId
-`);
-
-const match_getByStageIdStm = sql.prepare(/*sql*/ `
-  select
-    "TournamentMatch".*,
-    sum("TournamentMatchGameResult"."opponentOnePoints") as "opponentOnePointsTotal",
-    sum("TournamentMatchGameResult"."opponentTwoPoints") as "opponentTwoPointsTotal",
-    sum(case when "TournamentMatchGameResult"."opponentOnePoints" = 100 and "TournamentMatchGameResult"."opponentTwoPoints" = 0 then 1 else 0 end) as "opponentOneKosTotal",
-    sum(case when "TournamentMatchGameResult"."opponentTwoPoints" = 100 and "TournamentMatchGameResult"."opponentOnePoints" = 0 then 1 else 0 end) as "opponentTwoKosTotal"
-  from "TournamentMatch"
-  left join "TournamentMatchGameResult" on "TournamentMatch"."id" = "TournamentMatchGameResult"."matchId"
-  where "TournamentMatch"."stageId" = @stageId
-  group by "TournamentMatch"."id"
-`);
-
-const match_getByRoundAndNumberStm = sql.prepare(/*sql*/ `
-  select *
-    from "TournamentMatch"
-    where "TournamentMatch"."roundId" = @roundId
-      and "TournamentMatch"."number" = @number
-`);
-
-const match_insertStm = sql.prepare(/*sql*/ `
-  insert into
-    "TournamentMatch"
-    ("roundId", "stageId", "groupId", "number", "opponentOne", "opponentTwo", "status", "chatCode", "startedAt")
-  values
-    (@roundId, @stageId, @groupId, @number, @opponentOne, @opponentTwo, @status, @chatCode, @startedAt)
-  returning *
-`);
-
-const match_updateStm = sql.prepare(/*sql*/ `
-  update "TournamentMatch"
-    set
-      "roundId" = @roundId,
-      "stageId" = @stageId,
-      "groupId" = @groupId,
-      "number" = @number,
-      "opponentOne" = @opponentOne,
-      "opponentTwo" = @opponentTwo,
-      "status" = @status
-    where
-      "TournamentMatch"."id" = @id
-`);
-
-export class Match {
-	id?: Tables["TournamentMatch"]["id"];
-	roundId: Tables["TournamentMatch"]["roundId"];
-	stageId: Tables["TournamentMatch"]["stageId"];
-	groupId: Tables["TournamentMatch"]["groupId"];
-	number: Tables["TournamentMatch"]["number"];
-	opponentOne: string;
-	opponentTwo: string;
-	status: Tables["TournamentMatch"]["status"];
-
-	constructor(
-		id: Tables["TournamentMatch"]["id"] | undefined,
-		status: Tables["TournamentMatch"]["status"],
-		stageId: Tables["TournamentMatch"]["stageId"],
-		groupId: Tables["TournamentMatch"]["groupId"],
-		roundId: Tables["TournamentMatch"]["roundId"],
-		number: Tables["TournamentMatch"]["number"],
-		opponentOne: string,
-		opponentTwo: string,
-	) {
-		this.id = id;
-		this.roundId = roundId;
-		this.stageId = stageId;
-		this.groupId = groupId;
-		this.number = number;
-		this.opponentOne = opponentOne;
-		this.opponentTwo = opponentTwo;
-		this.status = status;
-	}
-
-	static #convertMatch(
-		rawMatch: Tables["TournamentMatch"] & {
-			opponentOne: string;
-			opponentTwo: string;
-			opponentOnePointsTotal: number | null;
-			opponentTwoPointsTotal: number | null;
-			opponentOneKosTotal: number | null;
-			opponentTwoKosTotal: number | null;
-			startedAt: number | null;
-		},
-	): MatchType {
-		return {
-			id: rawMatch.id,
-			group_id: rawMatch.groupId,
-			number: rawMatch.number,
-			opponent1:
-				rawMatch.opponentOne === "null"
-					? null
-					: {
-							...JSON.parse(rawMatch.opponentOne),
-							totalPoints: rawMatch.opponentOnePointsTotal ?? undefined,
-							totalKos: rawMatch.opponentOneKosTotal ?? undefined,
-						},
-			opponent2:
-				rawMatch.opponentTwo === "null"
-					? null
-					: {
-							...JSON.parse(rawMatch.opponentTwo),
-							totalPoints: rawMatch.opponentTwoPointsTotal ?? undefined,
-							totalKos: rawMatch.opponentTwoKosTotal ?? undefined,
-						},
-			round_id: rawMatch.roundId,
-			stage_id: rawMatch.stageId,
-			status: rawMatch.status,
-			startedAt: rawMatch.startedAt,
-		};
-	}
-
-	static getById(id: Tables["TournamentMatch"]["id"]): MatchType {
-		const match = match_getByIdStm.get({ id }) as any;
-		if (!match) return match;
-		return Match.#convertMatch(match);
-	}
-
-	static getByRoundId(roundId: Tables["TournamentRound"]["id"]): MatchType[] {
-		return (match_getByRoundIdStm.all({ roundId }) as any[]).map(
-			Match.#convertMatch,
-		);
-	}
-
-	static getByStageId(stageId: Tables["TournamentStage"]["id"]): MatchType[] {
-		return (match_getByStageIdStm.all({ stageId }) as any[]).map(
-			Match.#convertMatch,
-		);
-	}
-
-	static getByRoundAndNumber(
-		roundId: Tables["TournamentRound"]["id"],
-		number: Tables["TournamentMatch"]["number"],
-	): MatchType {
-		const match = match_getByRoundAndNumberStm.get({ roundId, number }) as any;
-		if (!match) return match;
-		return Match.#convertMatch(match);
-	}
-
-	insert() {
-		const match = match_insertStm.get({
-			roundId: this.roundId,
-			stageId: this.stageId,
-			groupId: this.groupId,
-			number: this.number,
-			opponentOne: this.opponentOne ?? "null",
-			opponentTwo: this.opponentTwo ?? "null",
-			status: this.status,
-			chatCode: shortNanoid(),
-			startedAt: null,
-		}) as any;
-
-		this.id = match.id;
-
-		return true;
-	}
-
-	update() {
-		match_updateStm.run({
-			id: this.id ?? null,
-			roundId: this.roundId,
-			stageId: this.stageId,
-			groupId: this.groupId,
-			number: this.number,
-			opponentOne: this.opponentOne ?? "null",
-			opponentTwo: this.opponentTwo ?? "null",
-			status: this.status,
-		});
-
-		return true;
-	}
-}
diff --git a/app/features/tournament-bracket/core/brackets-manager/crud.server.ts b/app/features/tournament-bracket/core/brackets-manager/crud.server.ts
deleted file mode 100644
index 31dad6068..000000000
--- a/app/features/tournament-bracket/core/brackets-manager/crud.server.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import type {
-	CrudInterface,
-	DataTypes,
-	OmitId,
-	Table,
-} from "~/modules/brackets-manager/types";
-import { Group, Match, Round, Stage } from "./crud-db.server";
-
-export class SqlDatabase implements CrudInterface {
-	insert<T extends Table>(table: T, value: OmitId<DataTypes[T]>): number;
-	insert<T extends Table>(table: T, values: OmitId<DataTypes[T]>[]): boolean;
-	insert<T extends Table>(
-		table: T,
-		arg: OmitId<DataTypes[T]> | OmitId<DataTypes[T]>[],
-	): number | boolean {
-		switch (table) {
-			case "stage": {
-				const value = arg as OmitId<DataTypes["stage"]>;
-				const stage = new Stage(
-					undefined,
-					value.tournament_id,
-					value.number,
-					value.name,
-					value.type,
-					JSON.stringify(value.settings),
-				);
-				stage.insert();
-				return stage.id!;
-			}
-
-			case "group": {
-				const value = arg as OmitId<DataTypes["group"]>;
-				const group = new Group(undefined, value.stage_id, value.number);
-				group.insert();
-				return group.id!;
-			}
-
-			case "round": {
-				const value = arg as OmitId<DataTypes["round"]>;
-				const round = new Round(
-					undefined,
-					value.stage_id,
-					value.group_id,
-					value.number,
-				);
-				round.insert();
-				return round.id!;
-			}
-
-			case "match": {
-				const value = arg as OmitId<DataTypes["match"]>;
-				const match = new Match(
-					undefined,
-					value.status,
-					value.stage_id,
-					value.group_id,
-					value.round_id,
-					value.number,
-					JSON.stringify(value.opponent1),
-					JSON.stringify(value.opponent2),
-				);
-				match.insert();
-				return match.id!;
-			}
-		}
-	}
-
-	select<T extends Table>(table: T): Array<DataTypes[T]> | null;
-	select<T extends Table>(table: T, id: number): DataTypes[T] | null;
-	select<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-	): Array<DataTypes[T]> | null;
-	select<T extends Table>(
-		table: T,
-		arg?: number | Partial<DataTypes[T]>,
-	): DataTypes[T] | Array<DataTypes[T]> | null {
-		switch (table) {
-			case "stage": {
-				if (typeof arg === "number") {
-					return Stage.getById(arg) as DataTypes[T];
-				}
-
-				const filter = arg as Partial<DataTypes["stage"]> | undefined;
-				if (filter?.tournament_id) {
-					return Stage.getByTournamentId(filter.tournament_id) as Array<
-						DataTypes[T]
-					>;
-				}
-
-				break;
-			}
-
-			case "group": {
-				if (typeof arg === "number") {
-					return Group.getById(arg) as DataTypes[T];
-				}
-
-				const filter = arg as Partial<DataTypes["group"]> | undefined;
-				if (filter?.stage_id && filter.number) {
-					const group = Group.getByStageAndNumber(
-						filter.stage_id,
-						filter.number,
-					);
-					return group ? ([group] as Array<DataTypes[T]>) : null;
-				}
-
-				if (filter?.stage_id) {
-					return Group.getByStageId(filter.stage_id) as Array<DataTypes[T]>;
-				}
-
-				break;
-			}
-
-			case "round": {
-				if (typeof arg === "number") {
-					return Round.getById(arg) as DataTypes[T];
-				}
-
-				const filter = arg as Partial<DataTypes["round"]> | undefined;
-				if (filter?.group_id && filter.number) {
-					const round = Round.getByGroupAndNumber(
-						filter.group_id,
-						filter.number,
-					);
-					return round ? ([round] as Array<DataTypes[T]>) : null;
-				}
-
-				if (filter?.group_id) {
-					return Round.getByGroupId(filter.group_id) as Array<DataTypes[T]>;
-				}
-
-				if (filter?.stage_id) {
-					return Round.getByStageId(filter.stage_id) as Array<DataTypes[T]>;
-				}
-
-				break;
-			}
-
-			case "match": {
-				if (typeof arg === "number") {
-					return Match.getById(arg) as DataTypes[T];
-				}
-
-				const filter = arg as Partial<DataTypes["match"]> | undefined;
-				if (filter?.round_id && filter.number) {
-					const match = Match.getByRoundAndNumber(
-						filter.round_id,
-						filter.number,
-					);
-					return match ? ([match] as Array<DataTypes[T]>) : null;
-				}
-
-				if (filter?.stage_id) {
-					return Match.getByStageId(filter.stage_id) as Array<DataTypes[T]>;
-				}
-
-				if (filter?.round_id) {
-					return Match.getByRoundId(filter.round_id) as Array<DataTypes[T]>;
-				}
-
-				break;
-			}
-		}
-
-		return null;
-	}
-
-	update<T extends Table>(table: T, id: number, value: DataTypes[T]): boolean;
-	update<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-		value: Partial<DataTypes[T]>,
-	): boolean;
-	update<T extends Table>(
-		table: T,
-		query: number | Partial<DataTypes[T]>,
-		value: DataTypes[T] | Partial<DataTypes[T]>,
-	): boolean {
-		switch (table) {
-			case "stage": {
-				if (typeof query === "number") {
-					const update = value as Partial<DataTypes["stage"]>;
-					return Stage.updateSettings(query, JSON.stringify(update.settings));
-				}
-
-				break;
-			}
-
-			case "match": {
-				if (typeof query === "number") {
-					const update = value as DataTypes["match"];
-					const match = new Match(
-						query,
-						update.status,
-						update.stage_id,
-						update.group_id,
-						update.round_id,
-						update.number,
-						JSON.stringify(update.opponent1),
-						JSON.stringify(update.opponent2),
-					);
-					return match.update();
-				}
-
-				break;
-			}
-		}
-
-		return false;
-	}
-
-	delete<T extends Table>(table: T): boolean;
-	delete<T extends Table>(table: T, filter: Partial<DataTypes[T]>): boolean;
-	delete(): boolean {
-		throw new Error("not implemented");
-	}
-}
diff --git a/app/features/tournament-bracket/core/brackets-manager/index.ts b/app/features/tournament-bracket/core/brackets-manager/index.ts
deleted file mode 100644
index 5daec5533..000000000
--- a/app/features/tournament-bracket/core/brackets-manager/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { getTournamentManager } from "./manager";
diff --git a/app/features/tournament-bracket/core/brackets-manager/manager.server.ts b/app/features/tournament-bracket/core/brackets-manager/manager.server.ts
deleted file mode 100644
index ce23cce3d..000000000
--- a/app/features/tournament-bracket/core/brackets-manager/manager.server.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { BracketsManager } from "~/modules/brackets-manager";
-import { SqlDatabase } from "./crud.server";
-
-export function getServerTournamentManager() {
-	const storage = new SqlDatabase();
-	const manager = new BracketsManager(storage);
-
-	return manager;
-}
diff --git a/app/features/tournament-bracket/core/brackets-manager/manager.ts b/app/features/tournament-bracket/core/brackets-manager/manager.ts
deleted file mode 100644
index 8139a09b6..000000000
--- a/app/features/tournament-bracket/core/brackets-manager/manager.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { BracketsManager } from "~/modules/brackets-manager";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-
-export function getTournamentManager() {
-	const storage = new InMemoryDatabase();
-	const manager = new BracketsManager(storage);
-
-	return manager;
-}
diff --git a/app/features/tournament-bracket/core/engine/create/builder.ts b/app/features/tournament-bracket/core/engine/create/builder.ts
new file mode 100644
index 000000000..09ef4aa60
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/builder.ts
@@ -0,0 +1,368 @@
+import type {
+	BracketData,
+	Duel,
+	GroupData,
+	MatchData,
+	ParticipantSlot,
+	ResolvedCreateBracketInput,
+	RoundData,
+	Seeding,
+	SeedOrdering,
+	StageData,
+	StageSettings,
+	StandardBracketResults,
+} from "../types";
+import * as helpers from "./helpers";
+import {
+	defaultMinorOrdering,
+	ordering,
+	padSeedingToPowerOfTwo,
+} from "./seeding";
+
+/**
+ * Accumulates the rows of a stage being created. Pure port of the old
+ * brackets-manager `Create` class: same call order, same inserted values, but
+ * rows are collected into arrays with local ids (0..n-1 per table) instead of
+ * being written to storage.
+ */
+export class StageCreator {
+	readonly input: ResolvedCreateBracketInput;
+	settings: StageSettings;
+	seeding: Seeding;
+	readonly data: BracketData;
+
+	constructor(input: ResolvedCreateBracketInput) {
+		this.input = input;
+		this.settings = structuredClone(input.settings) ?? {};
+		const seeding = [...input.seeding];
+		this.seeding =
+			input.type !== "round_robin" ? padSeedingToPowerOfTwo(seeding) : seeding;
+		this.data = { stage: [], group: [], round: [], match: [] };
+
+		if (input.type === "single_elimination")
+			this.settings.consolationFinal = this.settings.consolationFinal || false;
+	}
+
+	insertGroup(group: Omit<GroupData, "id">): number {
+		const id = this.data.group.length;
+		this.data.group.push({ id, ...group });
+		return id;
+	}
+
+	insertRound(round: Omit<RoundData, "id">): number {
+		const id = this.data.round.length;
+		this.data.round.push({ id, ...round });
+		return id;
+	}
+
+	insertMatch(match: Omit<MatchData, "id">): number {
+		const id = this.data.match.length;
+		this.data.match.push({ id, ...match });
+		return id;
+	}
+
+	/**
+	 * Creates a round-robin group.
+	 *
+	 * This will make as many rounds as needed to let each participant match every other once.
+	 */
+	createRoundRobinGroup(
+		stageId: number,
+		number: number,
+		slots: ParticipantSlot[],
+	): void {
+		const groupId = this.insertGroup({
+			stageId: stageId,
+			number,
+		});
+
+		// Groups can be padded with empty slots when teams don't divide evenly
+		// (`null`) or by the seed ordering (`undefined`). An empty slot is just an
+		// absent team, so drop it to round-robin only the present teams — otherwise
+		// the padding becomes BYE rounds that strand real matches in later rounds.
+		// TBD slots (`{ id: null }`) are kept; only nullish placeholders are removed.
+		const presentSlots = slots.filter(
+			(slot) => slot !== null && slot !== undefined,
+		);
+
+		const rounds = helpers.makeRoundRobinMatches(presentSlots);
+
+		for (let i = 0; i < rounds.length; i++)
+			this.createRound(stageId, groupId, i + 1, rounds[0].length, rounds[i]);
+	}
+
+	/**
+	 * Creates a bipartite round-robin group where every A team plays every B team exactly once.
+	 */
+	createAbDivisionRoundRobinGroup(
+		stageId: number,
+		number: number,
+		slotsA: ParticipantSlot[],
+		slotsB: ParticipantSlot[],
+	): void {
+		const groupId = this.insertGroup({
+			stageId: stageId,
+			number,
+		});
+
+		const rounds = helpers.makeAbDivisionRoundRobinMatches(slotsA, slotsB);
+
+		for (let i = 0; i < rounds.length; i++)
+			this.createRound(stageId, groupId, i + 1, rounds[0].length, rounds[i]);
+	}
+
+	/**
+	 * Creates a standard bracket, which is the only one in single elimination and the upper one in double elimination.
+	 *
+	 * This will make as many rounds as needed to end with one winner.
+	 */
+	createStandardBracket(
+		stageId: number,
+		number: number,
+		slots: ParticipantSlot[],
+	): StandardBracketResults {
+		const roundCount = helpers.getUpperBracketRoundCount(slots.length);
+		const groupId = this.insertGroup({
+			stageId: stageId,
+			number,
+		});
+
+		let duels = helpers.makePairs(slots);
+		let roundNumber = 1;
+
+		const losers: ParticipantSlot[][] = [];
+
+		for (let i = roundCount - 1; i >= 0; i--) {
+			const matchCount = 2 ** i;
+			duels = this.getCurrentDuels(duels, matchCount);
+			losers.push(duels.map(helpers.byeLoser));
+			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
+		}
+
+		return { losers, winner: helpers.byeWinner(duels[0]) };
+	}
+
+	/**
+	 * Creates a lower bracket, alternating between major and minor rounds.
+	 *
+	 * - A major round is a regular round.
+	 * - A minor round matches the previous (major) round's winners against upper bracket losers of the corresponding round.
+	 */
+	createLowerBracket(
+		stageId: number,
+		number: number,
+		losers: ParticipantSlot[][],
+	): ParticipantSlot {
+		const participantCount = this.seeding.length;
+		const roundPairCount = helpers.getRoundPairCount(participantCount);
+
+		let losersId = 0;
+
+		const method = this.getMajorOrdering(participantCount);
+		const ordered = ordering[method](losers[losersId++]);
+
+		const groupId = this.insertGroup({
+			stageId: stageId,
+			number,
+		});
+
+		let duels = helpers.makePairs(ordered);
+		let roundNumber = 1;
+
+		for (let i = 0; i < roundPairCount; i++) {
+			const matchCount = 2 ** (roundPairCount - i - 1);
+
+			// Major round.
+			duels = this.getCurrentDuels(duels, matchCount, true);
+			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
+
+			// Minor round.
+			const minorOrdering = this.getMinorOrdering(
+				participantCount,
+				i,
+				roundPairCount,
+			);
+			duels = this.getCurrentDuels(
+				duels,
+				matchCount,
+				false,
+				losers[losersId++],
+				minorOrdering,
+			);
+			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
+		}
+
+		return helpers.byeWinnerToGrandFinal(duels[0]);
+	}
+
+	/**
+	 * Creates a bracket with rounds that only have 1 match each. Used for finals.
+	 */
+	createUniqueMatchBracket(
+		stageId: number,
+		number: number,
+		duels: Duel[],
+	): void {
+		const groupId = this.insertGroup({
+			stageId: stageId,
+			number,
+		});
+
+		for (let i = 0; i < duels.length; i++)
+			this.createRound(stageId, groupId, i + 1, 1, [duels[i]]);
+	}
+
+	/**
+	 * Creates a round, which contain matches.
+	 */
+	createRound(
+		stageId: number,
+		groupId: number,
+		roundNumber: number,
+		matchCount: number,
+		duels: Duel[],
+	): void {
+		const roundId = this.insertRound({
+			number: roundNumber,
+			stageId: stageId,
+			groupId: groupId,
+		});
+
+		for (let i = 0; i < matchCount; i++) {
+			this.createMatch(stageId, groupId, roundId, i + 1, duels[i]);
+		}
+	}
+
+	/**
+	 * Creates a match of the stage.
+	 */
+	createMatch(
+		stageId: number,
+		groupId: number,
+		roundId: number,
+		matchNumber: number,
+		opponents: Duel,
+	): void {
+		const opponent1 = helpers.toResultWithPosition(opponents[0]);
+		const opponent2 = helpers.toResultWithPosition(opponents[1]);
+
+		// Round-robin matches can easily be removed. Prevent BYE vs. BYE matches.
+		if (
+			this.input.type === "round_robin" &&
+			opponent1 === null &&
+			opponent2 === null
+		)
+			return;
+
+		this.insertMatch({
+			number: matchNumber,
+			stageId: stageId,
+			groupId: groupId,
+			roundId: roundId,
+			opponent1,
+			opponent2,
+			winnerSide: null,
+		});
+	}
+
+	/**
+	 * Gets the duels for the current round based on the previous one. No ordering is done for
+	 * major rounds, it must be done beforehand for the first round. Ordering is done for LB
+	 * minor rounds via the given method.
+	 */
+	getCurrentDuels(previousDuels: Duel[], currentDuelCount: number): Duel[];
+	getCurrentDuels(
+		previousDuels: Duel[],
+		currentDuelCount: number,
+		major: true,
+	): Duel[];
+	getCurrentDuels(
+		previousDuels: Duel[],
+		currentDuelCount: number,
+		major: false,
+		losers: ParticipantSlot[],
+		method?: SeedOrdering,
+	): Duel[];
+	getCurrentDuels(
+		previousDuels: Duel[],
+		currentDuelCount: number,
+		major?: boolean,
+		losers?: ParticipantSlot[],
+		method?: SeedOrdering,
+	): Duel[] {
+		if (
+			(major === undefined || major) &&
+			previousDuels.length === currentDuelCount
+		) {
+			// First round.
+			return previousDuels;
+		}
+
+		if (major === undefined || major) {
+			// From major to major (WB) or minor to major (LB).
+			return helpers.transitionToMajor(previousDuels);
+		}
+
+		// From major to minor (LB).
+		// Losers and method won't be undefined.
+		return helpers.transitionToMinor(previousDuels, losers!, method);
+	}
+
+	/**
+	 * Returns the list of slots from the seeding.
+	 */
+	getSlots(): ParticipantSlot[] {
+		helpers.ensureValidSize(this.input.type, this.seeding.length);
+		helpers.ensureNoDuplicates(this.seeding);
+
+		return this.getSlotsUsingIds(this.seeding);
+	}
+
+	/**
+	 * Returns the list of slots with a seeding containing IDs.
+	 */
+	private getSlotsUsingIds(seeding: Seeding): ParticipantSlot[] {
+		return seeding.map((slot, i) => {
+			if (slot === null) return null; // BYE.
+
+			return { id: slot, position: i + 1 };
+		});
+	}
+
+	/**
+	 * The only major ordering for the lower bracket.
+	 */
+	private getMajorOrdering(participantCount: number): SeedOrdering {
+		return defaultMinorOrdering[participantCount]?.[0] || "natural";
+	}
+
+	/**
+	 * A minor ordering for the lower bracket by its index.
+	 */
+	private getMinorOrdering(
+		participantCount: number,
+		index: number,
+		minorRoundCount: number,
+	): SeedOrdering | undefined {
+		// No ordering for the last minor round. There is only one participant to order.
+		if (index === minorRoundCount - 1) return undefined;
+
+		return defaultMinorOrdering[participantCount]?.[1 + index] || "natural";
+	}
+
+	/**
+	 * Creates the stage row.
+	 */
+	createStage(): StageData {
+		const stage: StageData = {
+			id: 0,
+			type: this.input.type,
+			number: this.input.number ?? 1,
+			settings: this.settings,
+		};
+
+		this.data.stage.push(stage);
+
+		return stage;
+	}
+}
diff --git a/app/features/tournament-bracket/core/engine/create/double-elimination.test.ts b/app/features/tournament-bracket/core/engine/create/double-elimination.test.ts
new file mode 100644
index 000000000..97f6e4f52
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/double-elimination.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, test } from "vitest";
+import { createResolved } from "./index";
+
+describe("Create double elimination stage", () => {
+	test("should create a double elimination stage", () => {
+		const data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+			settings: {},
+		});
+
+		expect(data.stage[0].type).toBe("double_elimination");
+
+		expect(data.group.length).toBe(3);
+		expect(data.round.length).toBe(4 + 6 + 2);
+		expect(data.match.length).toBe(31);
+	});
+
+	test("should create a tournament with 256+ tournaments", () => {
+		expect(() =>
+			createResolved({
+				type: "double_elimination",
+				seeding: Array.from({ length: 256 }, (_, i) => i + 1),
+				settings: {},
+			}),
+		).not.toThrow();
+	});
+
+	test("should create a tournament with a double grand final", () => {
+		const data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: {},
+		});
+
+		expect(data.group.length).toBe(3);
+		expect(data.round.length).toBe(3 + 4 + 2);
+		expect(data.match.length).toBe(15);
+	});
+});
diff --git a/app/features/tournament-bracket/core/engine/create/double-elimination.ts b/app/features/tournament-bracket/core/engine/create/double-elimination.ts
new file mode 100644
index 000000000..f55b6b752
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/double-elimination.ts
@@ -0,0 +1,44 @@
+import type { Duel, ParticipantSlot } from "../types";
+import type { StageCreator } from "./builder";
+import * as helpers from "./helpers";
+import { ordering, STANDARD_BRACKET_FIRST_ROUND_ORDERING } from "./seeding";
+
+/**
+ * Creates a double elimination stage.
+ *
+ * One upper bracket (winner bracket, WB), one lower bracket (loser bracket, LB) and a double grand final
+ * between the winner of both brackets.
+ */
+export function createDoubleElimination(creator: StageCreator): void {
+	const slots = creator.getSlots();
+	const stage = creator.createStage();
+	const ordered = ordering[STANDARD_BRACKET_FIRST_ROUND_ORDERING](slots);
+
+	const { losers: losersWb, winner: winnerWb } = creator.createStandardBracket(
+		stage.id,
+		1,
+		ordered,
+	);
+
+	if (helpers.isDoubleEliminationNecessary(slots.length)) {
+		const winnerLb = creator.createLowerBracket(stage.id, 2, losersWb);
+		createGrandFinal(creator, stage.id, winnerWb, winnerLb);
+	}
+}
+
+/**
+ * Creates a double grand final for winners of both brackets in a double elimination stage.
+ */
+function createGrandFinal(
+	creator: StageCreator,
+	stageId: number,
+	winnerWb: ParticipantSlot,
+	winnerLb: ParticipantSlot,
+): void {
+	const finalDuels: Duel[] = [
+		[winnerWb, winnerLb],
+		[{ id: null }, { id: null }],
+	];
+
+	creator.createUniqueMatchBracket(stageId, 3, finalDuels);
+}
diff --git a/app/modules/brackets-manager/test/helpers.test.ts b/app/features/tournament-bracket/core/engine/create/helpers.test.ts
similarity index 74%
rename from app/modules/brackets-manager/test/helpers.test.ts
rename to app/features/tournament-bracket/core/engine/create/helpers.test.ts
index 9a8de5d86..d590ccf0c 100644
--- a/app/modules/brackets-manager/test/helpers.test.ts
+++ b/app/features/tournament-bracket/core/engine/create/helpers.test.ts
@@ -1,14 +1,11 @@
 import { describe, expect, test } from "vitest";
 import {
-	assertAbDivisionRoundRobin,
-	assertRoundRobin,
-	balanceByes,
 	makeAbDivisionGroups,
 	makeAbDivisionRoundRobinMatches,
 	makeGroups,
 	makeRoundRobinMatches,
-} from "../helpers";
-import { ordering } from "../ordering";
+} from "./helpers";
+import { ordering } from "./seeding";
 
 describe("Round-robin groups", () => {
 	test("should place participants in groups", () => {
@@ -289,32 +286,6 @@ describe("A/B division group distribution", () => {
 });
 
 describe("Seed ordering methods", () => {
-	test("should place 2 participants with inner-outer method", () => {
-		const teams = [1, 2];
-		const placement = ordering.inner_outer(teams);
-		expect(placement).toEqual([1, 2]);
-	});
-
-	test("should place 4 participants with inner-outer method", () => {
-		const teams = [1, 2, 3, 4];
-		const placement = ordering.inner_outer(teams);
-		expect(placement).toEqual([1, 4, 2, 3]);
-	});
-
-	test("should place 8 participants with inner-outer method", () => {
-		const teams = [1, 2, 3, 4, 5, 6, 7, 8];
-		const placement = ordering.inner_outer(teams);
-		expect(placement).toEqual([1, 8, 4, 5, 2, 7, 3, 6]);
-	});
-
-	test("should place 16 participants with inner-outer method", () => {
-		const teams = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
-		const placement = ordering.inner_outer(teams);
-		expect(placement).toEqual([
-			1, 16, 8, 9, 4, 13, 5, 12, 2, 15, 7, 10, 3, 14, 6, 11,
-		]);
-	});
-
 	test("should make a natural ordering", () => {
 		expect(ordering.natural([1, 2, 3, 4, 5, 6, 7, 8])).toEqual([
 			1, 2, 3, 4, 5, 6, 7, 8,
@@ -345,23 +316,6 @@ describe("Seed ordering methods", () => {
 		]);
 	});
 
-	test("should make an effort balanced ordering for groups", () => {
-		expect(
-			ordering["groups.effort_balanced"]([1, 2, 3, 4, 5, 6, 7, 8], 4),
-		).toEqual([1, 5, 2, 6, 3, 7, 4, 8]);
-
-		expect(
-			ordering["groups.effort_balanced"](
-				[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-				4,
-			),
-		).toEqual([1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16]);
-
-		expect(
-			ordering["groups.effort_balanced"]([1, 2, 3, 4, 5, 6, 7, 8], 2),
-		).toEqual([1, 3, 5, 7, 2, 4, 6, 8]);
-	});
-
 	test("should make a snake ordering for groups", () => {
 		expect(
 			ordering["groups.seed_optimized"]([1, 2, 3, 4, 5, 6, 7, 8], 4),
@@ -380,131 +334,97 @@ describe("Seed ordering methods", () => {
 	});
 });
 
-describe("Balance BYEs", () => {
-	test("should ignore input BYEs in the seeding", () => {
-		expect(
-			balanceByes(
-				[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, null, null, null, null],
-				16,
-			),
-		).toEqual(balanceByes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 16));
+/**
+ * A helper to assert our generated round-robin is correct.
+ *
+ * @param input The input seeding.
+ * @param output The resulting distribution of seeds in groups.
+ */
+function assertRoundRobin(input: number[], output: [number, number][][]): void {
+	const n = input.length;
+	const matchPerRound = Math.floor(n / 2);
+	const roundCount = n % 2 === 0 ? n - 1 : n;
 
-		expect(
-			balanceByes(
-				[1, 2, 3, null, 4, 5, 6, 7, 8, null, 9, 10, null, 11, null, 12, null],
-				16,
-			),
-		).toEqual(balanceByes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 16));
-	});
+	if (output.length !== roundCount) throw Error("Round count is wrong");
+	if (!output.every((round) => round.length === matchPerRound))
+		throw Error("Not every round has the good number of matches");
 
-	test("should take the target size as an argument or calculate it", () => {
-		expect(balanceByes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 16)).toEqual(
-			balanceByes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
-		);
-	});
+	const checkAllOpponents = Object.fromEntries(
+		input.map((element) => [element, new Set<number>()]),
+	) as Record<number, Set<number>>;
 
-	test("should prefer matches with only one BYE", () => {
-		expect(
-			balanceByes([
-				1,
-				2,
-				3,
-				4,
-				5,
-				6,
-				7,
-				8,
-				9,
-				10,
-				11,
-				12,
-				null,
-				null,
-				null,
-				null,
-			]),
-		).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, null, 10, null, 11, null, 12, null]);
+	for (const round of output) {
+		const checkUnique = new Set<number>();
 
-		expect(
-			balanceByes(
-				[
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					8,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-				],
-				16,
-			),
-		).toEqual([
-			1,
-			null,
-			2,
-			null,
-			3,
-			null,
-			4,
-			null,
-			5,
-			null,
-			6,
-			null,
-			7,
-			null,
-			8,
-			null,
-		]);
+		for (const match of round) {
+			if (match.length !== 2) throw Error("One match is not a pair");
 
-		expect(
-			balanceByes(
-				[
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-					null,
-				],
-				16,
-			),
-		).toEqual([
-			1,
-			null,
-			2,
-			null,
-			3,
-			null,
-			4,
-			null,
-			5,
-			null,
-			6,
-			null,
-			7,
-			null,
-			null,
-			null,
-		]);
-	});
-});
+			if (checkUnique.has(match[0]))
+				throw Error("This team is already playing");
+			checkUnique.add(match[0]);
+
+			if (checkUnique.has(match[1]))
+				throw Error("This team is already playing");
+			checkUnique.add(match[1]);
+
+			if (checkAllOpponents[match[0]].has(match[1]))
+				throw Error("The team has already matched this team");
+			checkAllOpponents[match[0]].add(match[1]);
+
+			if (checkAllOpponents[match[1]].has(match[0]))
+				throw Error("The team has already matched this team");
+			checkAllOpponents[match[1]].add(match[0]);
+		}
+	}
+}
+
+/**
+ * A helper to assert our generated bipartite round-robin is correct.
+ *
+ * @param divisionA Seeds in division A (ordered by seed).
+ * @param divisionB Seeds in division B (ordered by seed).
+ * @param output The resulting rounds of matches.
+ */
+function assertAbDivisionRoundRobin(
+	divisionA: number[],
+	divisionB: number[],
+	output: [number, number][][],
+): void {
+	const roundCount = Math.max(divisionA.length, divisionB.length);
+	const matchesPerRound = Math.min(divisionA.length, divisionB.length);
+
+	if (output.length !== roundCount) throw Error("Round count is wrong");
+	if (!output.every((round) => round.length === matchesPerRound))
+		throw Error("Not every round has the good number of matches");
+
+	const aSet = new Set(divisionA);
+	const bSet = new Set(divisionB);
+	const seenPairings = new Set<string>();
+
+	for (const round of output) {
+		const playingInRound = new Set<number>();
+
+		for (const match of round) {
+			if (match.length !== 2) throw Error("One match is not a pair");
+
+			const [a, b] = match;
+
+			if (!aSet.has(a)) throw Error(`${a} is not a division A participant`);
+			if (!bSet.has(b)) throw Error(`${b} is not a division B participant`);
+
+			if (playingInRound.has(a)) throw Error("This team is already playing");
+			playingInRound.add(a);
+
+			if (playingInRound.has(b)) throw Error("This team is already playing");
+			playingInRound.add(b);
+
+			const pairingKey = `${a}-${b}`;
+			if (seenPairings.has(pairingKey))
+				throw Error("The teams have already been paired");
+			seenPairings.add(pairingKey);
+		}
+	}
+
+	if (seenPairings.size !== divisionA.length * divisionB.length)
+		throw Error("Not every A vs B pairing was generated");
+}
diff --git a/app/features/tournament-bracket/core/engine/create/helpers.ts b/app/features/tournament-bracket/core/engine/create/helpers.ts
new file mode 100644
index 000000000..b05ca9a47
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/helpers.ts
@@ -0,0 +1,357 @@
+import type { Duel, ParticipantSlot, SeedOrdering, StageType } from "../types";
+import { ordering } from "./seeding";
+
+/**
+ * Makes a list of rounds containing the matches of a round-robin group.
+ *
+ * @param participants The participants to distribute.
+ * @param mode The round-robin mode.
+ */
+export function makeRoundRobinMatches<T>(participants: T[]): [T, T][][] {
+	const n = participants.length;
+	const n1 = n % 2 === 0 ? n : n + 1;
+	const roundCount = n1 - 1;
+	const matchPerRound = n1 / 2;
+
+	const rounds: [T, T][][] = [];
+
+	for (let roundId = 0; roundId < roundCount; roundId++) {
+		const matches: [T, T][] = [];
+
+		for (let matchId = 0; matchId < matchPerRound; matchId++) {
+			if (matchId === 0 && n % 2 === 1) continue;
+
+			const opponentsIds = [
+				(roundId - matchId - 1 + n1) % (n1 - 1),
+				matchId === 0 ? n1 - 1 : (roundId + matchId) % (n1 - 1),
+			];
+
+			matches.push([
+				participants[opponentsIds[0]],
+				participants[opponentsIds[1]],
+			]);
+		}
+
+		rounds.push(matches);
+	}
+
+	return rounds;
+}
+
+/**
+ * Makes a list of rounds containing the matches of a bipartite (A/B divisions) round-robin group.
+ *
+ * Every A team plays every B team exactly once; there are no A-vs-A or B-vs-B matches.
+ * Round 1 is cross-seeded (strongest A vs weakest B), and B is rotated cyclically downward
+ * in each subsequent round.
+ *
+ * When the divisions have different sizes, the shorter side is padded with bye slots so the
+ * rotation still works. Those bye pairings are filtered out of the output, so each round has
+ * exactly `min(|A|, |B|)` real matches and the total is `|A| * |B|`.
+ *
+ * @param divisionA Participants in division A, ordered by seed.
+ * @param divisionB Participants in division B, ordered by seed.
+ */
+export function makeAbDivisionRoundRobinMatches<T>(
+	divisionA: T[],
+	divisionB: T[],
+): [T, T][][] {
+	const n = Math.max(divisionA.length, divisionB.length);
+	const paddedA: (T | null)[] = [
+		...divisionA,
+		...Array(n - divisionA.length).fill(null),
+	];
+	const paddedB: (T | null)[] = [
+		...divisionB,
+		...Array(n - divisionB.length).fill(null),
+	];
+	const rounds: [T, T][][] = [];
+
+	for (let roundIdx = 0; roundIdx < n; roundIdx++) {
+		const matches: [T, T][] = [];
+
+		for (let i = 0; i < n; i++) {
+			const bIdx = (((n - 1 - i - roundIdx) % n) + n) % n;
+			const a = paddedA[i];
+			const b = paddedB[bIdx];
+			if (a === null || b === null) continue;
+			matches.push([a, b]);
+		}
+
+		rounds.push(matches);
+	}
+
+	return rounds;
+}
+
+/**
+ * Distributes A/B division participants into groups such that each group has an
+ * equal number of A and B participants.
+ *
+ * The snake ordering used by `groups.seed_optimized` is applied independently to
+ * each pool, so that relative seed order within each pool is preserved within
+ * every group.
+ *
+ * @param divisionA Participants in division A, ordered by seed.
+ * @param divisionB Participants in division B, ordered by seed.
+ * @param groupCount Number of groups to distribute into.
+ */
+export function makeAbDivisionGroups<T>(
+	divisionA: T[],
+	divisionB: T[],
+	groupCount: number,
+): { a: T[]; b: T[] }[] {
+	if (groupCount <= 0) throw Error("Group count must be strictly positive.");
+
+	if (divisionA.length !== divisionB.length) {
+		if (groupCount !== 1)
+			throw Error(
+				"Uneven A/B divisions are only supported with a single group.",
+			);
+
+		return [{ a: divisionA, b: divisionB }];
+	}
+
+	if (divisionA.length % groupCount !== 0)
+		throw Error("Pool size must be divisible by group count.");
+
+	const aOrdered = ordering["groups.seed_optimized"](divisionA, groupCount);
+	const bOrdered = ordering["groups.seed_optimized"](divisionB, groupCount);
+
+	const perPoolGroupSize = divisionA.length / groupCount;
+	const groups: { a: T[]; b: T[] }[] = [];
+
+	for (let i = 0; i < groupCount; i++) {
+		groups.push({
+			a: aOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
+			b: bOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
+		});
+	}
+
+	return groups;
+}
+
+/**
+ * Distributes elements in groups of equal size.
+ *
+ * @param elements A list of elements to distribute in groups.
+ * @param groupCount The group count.
+ */
+export function makeGroups<T>(elements: T[], groupCount: number): T[][] {
+	const groupSize = Math.ceil(elements.length / groupCount);
+	const result: T[][] = [];
+
+	for (let i = 0; i < elements.length; i++) {
+		if (i % groupSize === 0) result.push([]);
+
+		result[result.length - 1].push(elements[i]);
+	}
+
+	return result;
+}
+
+/**
+ * Makes pairs with each element and its next one.
+ *
+ * @example [1, 2, 3, 4] --> [[1, 2], [3, 4]]
+ * @param array A list of elements.
+ */
+export function makePairs<T>(array: T[]): [T, T][] {
+	return array
+		.map((_, i) => (i % 2 === 0 ? [array[i], array[i + 1]] : []))
+		.filter((v): v is [T, T] => v.length === 2);
+}
+
+/**
+ * Ensures there are no duplicates in a list of elements.
+ *
+ * @param array A list of elements.
+ */
+export function ensureNoDuplicates<T>(array: (T | null)[]): void {
+	const nonNull = getNonNull(array);
+	const unique = nonNull.filter((item, index) => {
+		const stringifiedItem = JSON.stringify(item);
+		return (
+			nonNull.findIndex((obj) => JSON.stringify(obj) === stringifiedItem) ===
+			index
+		);
+	});
+
+	if (unique.length < nonNull.length)
+		throw new Error("The seeding has a duplicate participant.");
+}
+
+/**
+ * Ensures that the participant count is valid.
+ *
+ * @param stageType Type of the stage to test.
+ * @param participantCount The number to test.
+ */
+export function ensureValidSize(
+	stageType: StageType,
+	participantCount: number,
+): void {
+	if (participantCount < 2)
+		throw Error("Impossible to create a stage with less than 2 participants.");
+
+	if (stageType === "round_robin") {
+		// Round robin supports any number of participants.
+		return;
+	}
+
+	if (!Number.isInteger(Math.log2(participantCount)))
+		throw Error(
+			"The library only supports a participant count which is a power of two.",
+		);
+}
+
+/**
+ * Converts a participant slot to a result stored in storage, with the position the participant is coming from.
+ *
+ * @param slot A participant slot.
+ */
+export function toResultWithPosition(slot: ParticipantSlot): ParticipantSlot {
+	return (
+		slot && {
+			id: slot.id,
+			position: slot.position,
+		}
+	);
+}
+
+/**
+ * Returns the pre-computed winner for a match because of BYEs.
+ *
+ * @param opponents Two opponents.
+ */
+export function byeWinner(opponents: Duel): ParticipantSlot {
+	if (opponents[0] === null && opponents[1] === null)
+		// Double BYE.
+		return null; // BYE.
+
+	if (opponents[0] === null && opponents[1] !== null)
+		// opponent1 BYE.
+		return { id: opponents[1].id }; // opponent2.
+
+	if (opponents[0] !== null && opponents[1] === null)
+		// opponent2 BYE.
+		return { id: opponents[0].id }; // opponent1.
+
+	return { id: null }; // Normal.
+}
+
+/**
+ * Returns the pre-computed winner for a match because of BYEs in a lower bracket.
+ *
+ * @param opponents Two opponents.
+ */
+export function byeWinnerToGrandFinal(opponents: Duel): ParticipantSlot {
+	const winner = byeWinner(opponents);
+	if (winner) winner.position = 1;
+	return winner;
+}
+
+/**
+ * Returns the pre-computed loser for a match because of BYEs.
+ *
+ * Only used for loser bracket.
+ *
+ * @param opponents Two opponents.
+ * @param index The index of the duel in the round.
+ */
+export function byeLoser(opponents: Duel, index: number): ParticipantSlot {
+	if (opponents[0] === null || opponents[1] === null)
+		// At least one BYE.
+		return null; // BYE.
+
+	return { id: null, position: index + 1 }; // Normal.
+}
+
+/**
+ * Makes the transition to a major round for duels of the previous round. The duel count is divided by 2.
+ *
+ * @param previousDuels The previous duels to transition from.
+ */
+export function transitionToMajor(previousDuels: Duel[]): Duel[] {
+	const currentDuelCount = previousDuels.length / 2;
+	const currentDuels: Duel[] = [];
+
+	for (let duelIndex = 0; duelIndex < currentDuelCount; duelIndex++) {
+		const prevDuelId = duelIndex * 2;
+		currentDuels.push([
+			byeWinner(previousDuels[prevDuelId]),
+			byeWinner(previousDuels[prevDuelId + 1]),
+		]);
+	}
+
+	return currentDuels;
+}
+
+/**
+ * Makes the transition to a minor round for duels of the previous round. The duel count stays the same.
+ *
+ * @param previousDuels The previous duels to transition from.
+ * @param losers Losers from the previous major round.
+ * @param method The ordering method for the losers.
+ */
+export function transitionToMinor(
+	previousDuels: Duel[],
+	losers: ParticipantSlot[],
+	method?: SeedOrdering,
+): Duel[] {
+	const orderedLosers = method ? ordering[method](losers) : losers;
+	const currentDuelCount = previousDuels.length;
+	const currentDuels: Duel[] = [];
+
+	for (let duelIndex = 0; duelIndex < currentDuelCount; duelIndex++) {
+		const prevDuelId = duelIndex;
+		currentDuels.push([
+			orderedLosers[prevDuelId],
+			byeWinner(previousDuels[prevDuelId]),
+		]);
+	}
+
+	return currentDuels;
+}
+
+/**
+ * Returns the number of rounds an upper bracket has given the number of participants in the stage.
+ *
+ * @param participantCount The number of participants in the stage.
+ */
+export function getUpperBracketRoundCount(participantCount: number): number {
+	return Math.log2(participantCount);
+}
+
+/**
+ * Returns the count of round pairs (major & minor) in a loser bracket.
+ *
+ * @param participantCount The number of participants in the stage.
+ */
+export function getRoundPairCount(participantCount: number): number {
+	return getUpperBracketRoundCount(participantCount) - 1;
+}
+
+/**
+ * Determines whether a double elimination stage is really necessary.
+ *
+ * If the size is only two (less is impossible), then a lower bracket and a grand final are not necessary.
+ *
+ * @param participantCount The number of participants in the stage.
+ */
+export function isDoubleEliminationNecessary(
+	participantCount: number,
+): boolean {
+	return participantCount > 2;
+}
+
+/**
+ * Returns only the non null elements.
+ *
+ * @param array The array to process.
+ */
+function getNonNull<T>(array: (T | null)[]): T[] {
+	// Use a TS type guard to exclude null from the resulting type.
+	const nonNull = array.filter((element): element is T => element !== null);
+	return nonNull;
+}
diff --git a/app/features/tournament-bracket/core/engine/create/index.ts b/app/features/tournament-bracket/core/engine/create/index.ts
new file mode 100644
index 000000000..1e8c29ba0
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/index.ts
@@ -0,0 +1,120 @@
+import type { TournamentRoundMaps } from "~/db/tables";
+import type {
+	BracketData,
+	CreateBracketInput,
+	ResolvedCreateBracketInput,
+	RoundMapsInput,
+	StageType,
+} from "../types";
+import { StageCreator } from "./builder";
+import { createDoubleElimination } from "./double-elimination";
+import { createRoundRobin } from "./round-robin";
+import { resolveStageSettings } from "./settings";
+import { createSingleElimination } from "./single-elimination";
+import { createSwiss } from "./swiss";
+
+/**
+ * Generates the full structure for a new bracket of any type from the
+ * user-selected settings. Pure function: returns rows with local ids
+ * (0..n-1 per table); the repository maps them to real row ids on insert.
+ * For swiss this includes the empty future rounds + round 1 matches.
+ */
+export function create(input: CreateBracketInput): BracketData {
+	const data = createResolved({
+		type: input.type,
+		seeding: input.seeding,
+		settings: resolveStageSettings(input),
+		abDivisions: input.abDivisions,
+		number: input.number,
+	});
+
+	if (input.maps) {
+		attachRoundMaps(data, input.maps, input.type);
+	}
+
+	return data;
+}
+
+/**
+ * Engine-internal `create` taking already-resolved internal stage settings.
+ * Tests use this to control knobs that are an implementation detail to the
+ * app (seed ordering, byes balancing).
+ */
+export function createResolved(input: ResolvedCreateBracketInput): BracketData {
+	if (input.type === "swiss") return createSwiss(input);
+
+	const creator = new StageCreator(input);
+
+	switch (input.type) {
+		case "round_robin":
+			createRoundRobin(creator);
+			break;
+		case "single_elimination":
+			createSingleElimination(creator);
+			break;
+		case "double_elimination":
+			createDoubleElimination(creator);
+			break;
+		default:
+			throw Error("Unknown stage type.");
+	}
+
+	return creator.data;
+}
+
+function attachRoundMaps(
+	data: BracketData,
+	mapsInput: RoundMapsInput[],
+	type: StageType,
+) {
+	const roundsById = new Map(data.round.map((round) => [round.id, round]));
+
+	const resolveRound = (roundId: number) => {
+		const round = roundsById.get(roundId);
+		if (!round) throw Error(`No round found for map list round id ${roundId}`);
+		return round;
+	};
+
+	if (type === "round_robin" || type === "swiss") {
+		// groups share one map list per round number, and groups can have
+		// different round counts when teams divide unevenly
+		const distinctRoundNumberCount = new Set(
+			data.round.map((round) => round.number),
+		).size;
+		if (mapsInput.length !== distinctRoundNumberCount) {
+			throw Error("Invalid map list count");
+		}
+
+		const mapsByRoundNumber = new Map(
+			mapsInput.map((input) => [
+				resolveRound(input.roundId).number,
+				toRoundMaps(input),
+			]),
+		);
+
+		for (const round of data.round) {
+			const maps = mapsByRoundNumber.get(round.number);
+			if (!maps) throw Error(`No maps found for round number ${round.number}`);
+			round.maps = { ...maps };
+		}
+
+		return;
+	}
+
+	if (mapsInput.length !== data.round.length) {
+		throw Error("Invalid map list count");
+	}
+
+	for (const input of mapsInput) {
+		resolveRound(input.roundId).maps = toRoundMaps(input);
+	}
+
+	for (const round of data.round) {
+		if (!round.maps) throw Error(`Round id ${round.id} is missing maps`);
+	}
+}
+
+function toRoundMaps(input: RoundMapsInput): TournamentRoundMaps {
+	const { roundId, groupId, ...maps } = input;
+	return maps;
+}
diff --git a/app/features/tournament-bracket/core/engine/create/round-robin.test.ts b/app/features/tournament-bracket/core/engine/create/round-robin.test.ts
new file mode 100644
index 000000000..03a8ba263
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/round-robin.test.ts
@@ -0,0 +1,212 @@
+import { describe, expect, test } from "vitest";
+import type { BracketData, MatchData } from "../types";
+import { createResolved } from "./index";
+
+describe("Create a round-robin stage", () => {
+	test("should create a round-robin stage", () => {
+		const data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: { groupCount: 2 },
+		});
+
+		expect(data.stage[0].type).toBe("round_robin");
+
+		expect(data.group.length).toBe(2);
+		expect(data.round.length).toBe(6);
+		expect(data.match.length).toBe(12);
+	});
+
+	test("should drop empty slots instead of creating BYE matches", () => {
+		const data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4, 5, null, null, null],
+			settings: { groupCount: 2 },
+		});
+
+		// 5 teams in 2 groups -> groups of 3 and 2 with no BYE matches at all.
+		expect(data.match.length).toBe(4);
+		for (const match of data.match) {
+			expect(match.opponent1?.id).not.toBeNull();
+			expect(match.opponent2?.id).not.toBeNull();
+		}
+	});
+
+	test("should not pad a short group with empty rounds when teams divide unevenly", () => {
+		// 5 teams in 2 groups -> groups of 3 and 2. The 2-team group must be a
+		// clean single-round single-match group, not padded with BYE-only rounds
+		// that strand the real match in a later round.
+		const data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4, 5],
+			settings: { groupCount: 2 },
+		});
+
+		const shortGroup = data.group.find(
+			(group) =>
+				data.match.filter(
+					(match) => match.groupId === group.id && isRealMatch(match),
+				).length === 1,
+		)!;
+
+		const rounds = data.round.filter(
+			(round) => round.groupId === shortGroup.id,
+		);
+		const matches = data.match.filter(
+			(match) => match.groupId === shortGroup.id,
+		);
+		const realMatch = matches.find(isRealMatch)!;
+		const realMatchRound = rounds.find(
+			(round) => round.id === realMatch.roundId,
+		)!;
+
+		// No BYE matches and no empty rounds, just the single match in round 1.
+		expect(matches.length).toBe(1);
+		expect(rounds.length).toBe(1);
+		expect(realMatchRound.number).toBe(1);
+	});
+
+	test("should create a round-robin stage split across multiple groups", () => {
+		const data = createResolved({
+			type: "round_robin",
+			seeding: Array.from({ length: 16 }, (_, i) => i + 1),
+			settings: {
+				groupCount: 4,
+			},
+		});
+
+		expect(data.group.length).toBe(4);
+		expect(data.round.length).toBe(4 * 3);
+		expect(data.match.length).toBe(4 * 3 * 2);
+	});
+
+	test("should order the groups with snake seeding", () => {
+		const data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: {
+				groupCount: 2,
+			},
+		});
+
+		expect(matchById(data, 0).opponent1?.id).toBe(1);
+		expect(matchById(data, 0).opponent2?.id).toBe(8);
+	});
+
+	test("should throw if no group count given", () => {
+		expect(() =>
+			createResolved({
+				type: "round_robin",
+				seeding: [1, 2, 3, 4],
+				settings: {},
+			}),
+		).toThrow("You must specify a group count for round-robin stages.");
+	});
+
+	test("should throw if the group count is not strictly positive", () => {
+		expect(() =>
+			createResolved({
+				type: "round_robin",
+				seeding: [1, 2, 3, 4],
+				settings: {
+					groupCount: 0,
+				},
+			}),
+		).toThrow("You must provide a strictly positive group count.");
+	});
+
+	test("creates an A/B divisions round-robin where every A team plays every B team once", () => {
+		const seeding = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+		// alternate A (0) / B (1) so that seed order 1..12 gives A=[1,3,5,7,9,11], B=[2,4,6,8,10,12]
+		const abDivisions = seeding.map((_, i) => (i % 2 === 0 ? 0 : 1)) as (
+			| 0
+			| 1
+		)[];
+
+		const data = createResolved({
+			type: "round_robin",
+			seeding,
+			abDivisions,
+			settings: {
+				groupCount: 1,
+				hasAbDivisions: true,
+			},
+		});
+
+		expect(data.group.length).toBe(1);
+		expect(data.round.length).toBe(6);
+		expect(data.match.length).toBe(36);
+
+		const divisionAIds = new Set([1, 3, 5, 7, 9, 11]);
+		const divisionBIds = new Set([2, 4, 6, 8, 10, 12]);
+		const pairings = new Set<string>();
+
+		for (const match of data.match) {
+			const aId = match.opponent1?.id;
+			const bId = match.opponent2?.id;
+
+			expect(divisionAIds.has(aId!)).toBe(true);
+			expect(divisionBIds.has(bId!)).toBe(true);
+
+			const key = `${aId}-${bId}`;
+			expect(pairings.has(key)).toBe(false);
+			pairings.add(key);
+		}
+
+		expect(pairings.size).toBe(36);
+	});
+
+	test("throws when A/B divisions are requested but abDivisions is missing", () => {
+		expect(() =>
+			createResolved({
+				type: "round_robin",
+				seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+				settings: {
+					groupCount: 1,
+					hasAbDivisions: true,
+				},
+			}),
+		).toThrow("abDivisions must be provided when hasAbDivisions is enabled.");
+	});
+
+	test("creates an A/B divisions round-robin with uneven (±1) divisions and a single group", () => {
+		const data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+			abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+			settings: {
+				groupCount: 1,
+				hasAbDivisions: true,
+			},
+		});
+
+		expect(data.group.length).toBe(1);
+		expect(data.round.length).toBe(6);
+		expect(data.match.length).toBe(30);
+	});
+
+	test("throws when A/B divisions are uneven with multiple groups", () => {
+		expect(() =>
+			createResolved({
+				type: "round_robin",
+				seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+				abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+				settings: {
+					groupCount: 2,
+					hasAbDivisions: true,
+				},
+			}),
+		).toThrow("Uneven A/B divisions are only supported with a single group.");
+	});
+});
+
+function isRealMatch(match: MatchData) {
+	return match.opponent1?.id != null && match.opponent2?.id != null;
+}
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/create/round-robin.ts b/app/features/tournament-bracket/core/engine/create/round-robin.ts
new file mode 100644
index 000000000..024f6a515
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/round-robin.ts
@@ -0,0 +1,112 @@
+import type { ParticipantSlot } from "../types";
+import type { StageCreator } from "./builder";
+import * as helpers from "./helpers";
+import { ordering } from "./seeding";
+
+/**
+ * Creates a round-robin stage.
+ *
+ * Group count must be given. It will distribute participants in groups and rounds.
+ */
+export function createRoundRobin(creator: StageCreator): void {
+	if (creator.settings.hasAbDivisions) {
+		createAbDivisionRoundRobin(creator);
+		return;
+	}
+
+	const groups = getRoundRobinGroups(creator);
+	const stage = creator.createStage();
+
+	for (let i = 0; i < groups.length; i++)
+		creator.createRoundRobinGroup(stage.id, i + 1, groups[i]);
+}
+
+/**
+ * Creates a bipartite (A/B divisions) round-robin stage.
+ *
+ * Participants are partitioned into two pools by `abDivisions` (parallel to the seeding).
+ * Each group receives equal A and B teams, and matches only pair A against B.
+ */
+function createAbDivisionRoundRobin(creator: StageCreator): void {
+	const groups = getAbDivisionGroups(creator);
+	const stage = creator.createStage();
+
+	for (let i = 0; i < groups.length; i++)
+		creator.createAbDivisionRoundRobinGroup(
+			stage.id,
+			i + 1,
+			groups[i].a,
+			groups[i].b,
+		);
+}
+
+/**
+ * Gets the slots in groups for a round-robin stage.
+ */
+function getRoundRobinGroups(creator: StageCreator): ParticipantSlot[][] {
+	if (
+		creator.settings.groupCount === undefined ||
+		!Number.isInteger(creator.settings.groupCount)
+	)
+		throw Error("You must specify a group count for round-robin stages.");
+
+	if (creator.settings.groupCount <= 0)
+		throw Error("You must provide a strictly positive group count.");
+
+	const slots = creator.getSlots();
+	const ordered = ordering["groups.seed_optimized"](
+		slots,
+		creator.settings.groupCount,
+	);
+	return helpers.makeGroups(ordered, creator.settings.groupCount);
+}
+
+/**
+ * Partitions the seeded slots into A and B pools then distributes them into groups
+ * such that each group has an equal number of A and B participants.
+ */
+function getAbDivisionGroups(creator: StageCreator): {
+	a: ParticipantSlot[];
+	b: ParticipantSlot[];
+}[] {
+	if (
+		creator.settings.groupCount === undefined ||
+		!Number.isInteger(creator.settings.groupCount)
+	)
+		throw Error("You must specify a group count for round-robin stages.");
+
+	if (creator.settings.groupCount <= 0)
+		throw Error("You must provide a strictly positive group count.");
+
+	const abDivisions = creator.input.abDivisions;
+	if (!abDivisions)
+		throw Error("abDivisions must be provided when hasAbDivisions is enabled.");
+
+	const slots = creator.getSlots();
+
+	if (abDivisions.length !== slots.length)
+		throw Error("abDivisions length must match the seeding length.");
+
+	const divisionA: ParticipantSlot[] = [];
+	const divisionB: ParticipantSlot[] = [];
+
+	for (let i = 0; i < slots.length; i++) {
+		const slot = slots[i];
+		if (slot === null)
+			throw Error("BYEs are not supported with A/B divisions.");
+
+		const division = abDivisions[i];
+		if (division === 0) divisionA.push(slot);
+		else if (division === 1) divisionB.push(slot);
+		else
+			throw Error(
+				`Participant at seed ${i + 1} is missing an A/B division assignment.`,
+			);
+	}
+
+	return helpers.makeAbDivisionGroups(
+		divisionA,
+		divisionB,
+		creator.settings.groupCount,
+	);
+}
diff --git a/app/modules/brackets-manager/ordering.ts b/app/features/tournament-bracket/core/engine/create/seeding.ts
similarity index 61%
rename from app/modules/brackets-manager/ordering.ts
rename to app/features/tournament-bracket/core/engine/create/seeding.ts
index aed1c1a08..ebc38eb04 100644
--- a/app/modules/brackets-manager/ordering.ts
+++ b/app/features/tournament-bracket/core/engine/create/seeding.ts
@@ -1,8 +1,7 @@
 // https://web.archive.org/web/20200601102344/https://tl.net/forum/sc2-tournaments/202139-superior-double-elimination-losers-bracket-seeding
 
-import type { SeedOrdering } from "~/modules/brackets-model";
 import invariant from "~/utils/invariant";
-import type { OrderingMap } from "./types";
+import type { OrderingMap, Seeding, SeedOrdering } from "../types";
 
 export const ordering: OrderingMap = {
 	natural: <T>(array: T[]) => [...array],
@@ -49,61 +48,6 @@ export const ordering: OrderingMap = {
 			});
 		}
 	},
-	inner_outer: <T>(array: T[]) => {
-		if (array.length === 2) return array;
-
-		const size = array.length / 4;
-
-		const innerPart = [
-			array.slice(size, 2 * size),
-			array.slice(2 * size, 3 * size),
-		]; // [_, X, X, _]
-		const outerPart = [array.slice(0, size), array.slice(3 * size, 4 * size)]; // [X, _, _, X]
-
-		const methods = {
-			inner(part: T[][]): T[] {
-				return [part[0].pop()!, part[1].shift()!];
-			},
-			outer(part: T[][]): T[] {
-				return [part[0].shift()!, part[1].pop()!];
-			},
-		};
-
-		const result: T[] = [];
-
-		/**
-		 * Adds a part (inner or outer) of a part.
-		 *
-		 * @param part The part to process.
-		 * @param method The method to use.
-		 */
-		function add(part: T[][], method: "inner" | "outer"): void {
-			if (part[0].length > 0 && part[1].length > 0)
-				result.push(...methods[method](part));
-		}
-
-		for (let i = 0; i < size / 2; i++) {
-			add(outerPart, "outer"); // Outer part's outer
-			add(innerPart, "inner"); // Inner part's inner
-			add(outerPart, "inner"); // Outer part's inner
-			add(innerPart, "outer"); // Inner part's outer
-		}
-
-		return result;
-	},
-	"groups.effort_balanced": <T>(array: T[], groupCount: number) => {
-		const result: T[] = [];
-		let i = 0;
-		let j = 0;
-
-		while (result.length < array.length) {
-			result.push(array[i]);
-			i += groupCount;
-			if (i >= array.length) i = ++j;
-		}
-
-		return result;
-	},
 	"groups.seed_optimized": <T>(array: T[], groupCount: number) => {
 		const groups = Array.from(Array(groupCount), (_): T[] => []);
 
@@ -119,11 +63,12 @@ export const ordering: OrderingMap = {
 
 		return groups.flat();
 	},
-	"groups.bracket_optimized": () => {
-		throw Error("Not implemented.");
-	},
 };
 
+/** The ordering method for the first round of the upper bracket of an elimination stage. */
+export const STANDARD_BRACKET_FIRST_ROUND_ORDERING: SeedOrdering =
+	"space_between";
+
 export const defaultMinorOrdering: { [key: number]: SeedOrdering[] } = {
 	// 1 or 2: Not possible.
 	4: ["natural", "reverse"],
@@ -141,3 +86,32 @@ export const defaultMinorOrdering: { [key: number]: SeedOrdering[] } = {
 		"natural",
 	],
 };
+
+/**
+ * Pads the seeding with BYEs (`null`) until its length is a power of two.
+ *
+ * @param seeding The seeding of the stage.
+ */
+export function padSeedingToPowerOfTwo(seeding: Seeding): Seeding {
+	return setArraySize(seeding, getNearestPowerOfTwo(seeding.length), null);
+}
+
+/**
+ * Sets the size of an array with a placeholder if the size is bigger.
+ *
+ * @param array The original array.
+ * @param length The new length.
+ * @param placeholder A placeholder to use to fill the empty space.
+ */
+function setArraySize<T>(array: T[], length: number, placeholder: T): T[] {
+	return Array.from(Array(length), (_, i) => array[i] || placeholder);
+}
+
+/**
+ * Returns the nearest power of two **greater than** or equal to the given number.
+ *
+ * @param input The input number.
+ */
+function getNearestPowerOfTwo(input: number): number {
+	return 2 ** Math.ceil(Math.log2(input));
+}
diff --git a/app/features/tournament-bracket/core/engine/create/settings.ts b/app/features/tournament-bracket/core/engine/create/settings.ts
new file mode 100644
index 000000000..cdbf66f00
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/settings.ts
@@ -0,0 +1,88 @@
+import type { TournamentStageSettings } from "~/db/tables";
+import { TOURNAMENT } from "~/features/tournament/tournament-constants";
+import { assertUnreachable } from "~/utils/types";
+import type {
+	BracketData,
+	CreateBracketInput,
+	StageSettings,
+	StageType,
+} from "../types";
+
+/**
+ * Resolves the user-selected settings into the engine's internal stage
+ * settings, applying our defaults (seed ordering, group counts etc.).
+ */
+export function resolveStageSettings(input: CreateBracketInput): StageSettings {
+	const { type, settings, seeding } = input;
+
+	switch (type) {
+		case "single_elimination": {
+			return {
+				consolationFinal: hasThirdPlaceMatch({
+					type,
+					settings,
+					participantsCount: seeding.length,
+				}),
+			};
+		}
+		case "double_elimination": {
+			return {};
+		}
+		case "round_robin": {
+			return {
+				groupCount: roundRobinGroupCount(settings, seeding.length),
+				hasAbDivisions: settings?.hasAbDivisions ?? false,
+				...(input.independentRounds ? { independentRounds: true } : {}),
+			};
+		}
+		case "swiss": {
+			return {
+				groupCount:
+					settings?.groupCount ?? TOURNAMENT.SWISS_DEFAULT_GROUP_COUNT,
+				roundCount:
+					settings?.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT,
+			};
+		}
+		default: {
+			assertUnreachable(type);
+		}
+	}
+}
+
+/**
+ * How many rounds a swiss bracket was created with. Read off the stage's own
+ * settings (resolved and persisted when the bracket was created) so that later
+ * edits to the tournament's bracket progression can't change the advance and
+ * elimination math of a bracket that already exists.
+ */
+export function swissRoundCount(data: BracketData): number {
+	return (
+		data.stage[0]?.settings.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT
+	);
+}
+
+/** Whether the bracket will include a third place match. Only possible for single elimination with at least 4 participants. */
+export function hasThirdPlaceMatch(args: {
+	type: StageType;
+	settings: TournamentStageSettings | null;
+	participantsCount: number;
+}): boolean {
+	if (args.type !== "single_elimination") return false;
+	if (args.participantsCount < 4) return false;
+
+	return (
+		args.settings?.thirdPlaceMatch ??
+		TOURNAMENT.SE_DEFAULT_HAS_THIRD_PLACE_MATCH
+	);
+}
+
+/** How many groups a round robin bracket will have, derived from the user-selected teams per group count and the participant count. */
+export function roundRobinGroupCount(
+	settings: TournamentStageSettings | null,
+	participantsCount: number,
+): number {
+	const teamsPerGroup =
+		settings?.teamsPerGroup ?? TOURNAMENT.RR_DEFAULT_TEAM_COUNT_PER_GROUP;
+
+	return Math.ceil(participantsCount / teamsPerGroup);
+}
diff --git a/app/features/tournament-bracket/core/engine/create/single-elimination.test.ts b/app/features/tournament-bracket/core/engine/create/single-elimination.test.ts
new file mode 100644
index 000000000..0014654c4
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/single-elimination.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, test } from "vitest";
+import type { BracketData } from "../types";
+import { createResolved } from "./index";
+
+describe("Create single elimination stage", () => {
+	test("should create a single elimination stage", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+			settings: {},
+		});
+
+		expect(data.stage[0].type).toBe("single_elimination");
+
+		expect(data.group.length).toBe(1);
+		expect(data.round.length).toBe(4);
+		expect(data.match.length).toBe(15);
+	});
+
+	test("should create a single elimination stage with BYEs", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [1, null, 3, 4, null, null, 7, 8],
+			settings: {},
+		});
+
+		expect(matchById(data, 4).opponent1?.id).toBe(null);
+		expect(matchById(data, 4).opponent2?.id).toBe(4);
+		expect(matchById(data, 5).opponent1?.id).toBe(7);
+		expect(matchById(data, 5).opponent2?.id).toBe(3);
+	});
+
+	test("should create a single elimination stage with consolation final", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: { consolationFinal: true },
+		});
+
+		expect(data.group.length).toBe(2);
+		expect(data.round.length).toBe(4);
+		expect(data.match.length).toBe(8);
+	});
+
+	test("should create a single elimination stage with consolation final and BYEs", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [null, null, null, 4, 5, 6, 7, 8],
+			settings: { consolationFinal: true },
+		});
+
+		expect(matchById(data, 4).opponent1?.id).toBe(8);
+		expect(matchById(data, 4).opponent2?.id).toBe(null);
+
+		// Consolation final
+		expect(matchById(data, 7).opponent1?.id).toBe(null);
+		expect(matchById(data, 7).opponent2?.id).toBe(null);
+	});
+
+	test("should create a single elimination stage with Bo3 matches", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: {},
+		});
+
+		expect(data.group.length).toBe(1);
+		expect(data.round.length).toBe(3);
+		expect(data.match.length).toBe(7);
+	});
+
+	test("should throw if the seeding has duplicate participants", () => {
+		expect(() =>
+			createResolved({
+				type: "single_elimination",
+				seeding: [
+					1,
+					1, // Duplicate
+					3,
+					4,
+				],
+				settings: {},
+			}),
+		).toThrow("The seeding has a duplicate participant.");
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/create/single-elimination.ts b/app/features/tournament-bracket/core/engine/create/single-elimination.ts
new file mode 100644
index 000000000..c002ad054
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/single-elimination.ts
@@ -0,0 +1,31 @@
+import type { Duel, ParticipantSlot } from "../types";
+import type { StageCreator } from "./builder";
+import { ordering, STANDARD_BRACKET_FIRST_ROUND_ORDERING } from "./seeding";
+
+/**
+ * Creates a single elimination stage.
+ *
+ * One bracket and optionally a consolation final between semi-final losers.
+ */
+export function createSingleElimination(creator: StageCreator): void {
+	const slots = creator.getSlots();
+	const stage = creator.createStage();
+	const ordered = ordering[STANDARD_BRACKET_FIRST_ROUND_ORDERING](slots);
+
+	const { losers } = creator.createStandardBracket(stage.id, 1, ordered);
+	createConsolationFinal(creator, stage.id, losers);
+}
+
+/**
+ * Creates a consolation final for the semi final losers of a single elimination stage.
+ */
+function createConsolationFinal(
+	creator: StageCreator,
+	stageId: number,
+	losers: ParticipantSlot[][],
+): void {
+	if (!creator.settings.consolationFinal) return;
+
+	const semiFinalLosers = losers[losers.length - 2] as Duel;
+	creator.createUniqueMatchBracket(stageId, 2, [semiFinalLosers]);
+}
diff --git a/app/features/tournament-bracket/core/engine/create/swiss.ts b/app/features/tournament-bracket/core/engine/create/swiss.ts
new file mode 100644
index 000000000..e16e41bd8
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/create/swiss.ts
@@ -0,0 +1,144 @@
+import { TOURNAMENT } from "~/features/tournament/tournament-constants";
+import { nullFilledArray } from "~/utils/arrays";
+import invariant from "~/utils/invariant";
+import type {
+	BracketData,
+	MatchData,
+	ResolvedCreateBracketInput,
+} from "../types";
+
+/**
+ * Creates a Swiss bracket data set: all rounds up front, matches for round 1 only.
+ * Ported from the old core/Swiss.ts create()/firstRoundMatches().
+ */
+export function createSwiss(input: ResolvedCreateBracketInput): BracketData {
+	const groupCount =
+		input.settings.groupCount ?? TOURNAMENT.SWISS_DEFAULT_GROUP_COUNT;
+	const roundCount =
+		input.settings.roundCount ?? TOURNAMENT.SWISS_DEFAULT_ROUND_COUNT;
+
+	const group = nullFilledArray(groupCount).map((_, i) => ({
+		id: i,
+		stageId: 0,
+		number: i + 1,
+	}));
+
+	let roundId = 0;
+	return {
+		group,
+		match: firstRoundMatches({
+			seeding: input.seeding,
+			groupCount,
+			roundCount,
+		}),
+		round: group.flatMap((g) =>
+			nullFilledArray(roundCount).map((_, i) => ({
+				id: roundId++,
+				groupId: g.id,
+				number: i + 1,
+				stageId: 0,
+			})),
+		),
+		stage: [
+			{
+				id: 0,
+				number: 1,
+				settings: input.settings,
+				type: "swiss",
+			},
+		],
+	};
+}
+
+function firstRoundMatches({
+	seeding,
+	groupCount,
+	roundCount,
+}: {
+	seeding: ResolvedCreateBracketInput["seeding"];
+	groupCount: number;
+	roundCount: number;
+}): MatchData[] {
+	// split the teams to one or more groups. For example with 16 teams and 3 groups this would result in
+	// group 1: 1, 4, 7, 10, 13, 16
+	// group 2: 2, 5, 8, 11, 14
+	// group 3: 3, 6, 9, 12, 15
+	const groups = splitToGroups();
+
+	const result: MatchData[] = [];
+
+	let matchId = 0;
+	for (const [groupIdx, participants] of groups.entries()) {
+		// if there is an uneven number of teams the last seed gets a bye
+		const bye = participants.length % 2 === 0 ? null : participants.pop();
+
+		const halfI = participants.length / 2;
+		const upperHalf = participants.slice(0, halfI);
+		const lowerHalf = participants.slice(halfI);
+
+		invariant(
+			upperHalf.length === lowerHalf.length,
+			"firstRoundMatches: halfs not equal",
+		);
+
+		// first round every team plays the matching team "on the opposite side"
+		// so for example with 8 teams match ups look like this:
+		// seed 1 vs. seed 5
+		// seed 2 vs. seed 6
+		// seed 3 vs. seed 7
+		// seed 4 vs. seed 8
+		// ---
+		// this way each match has "equal distance"
+		const roundId = groupIdx * roundCount;
+		for (let i = 0; i < upperHalf.length; i++) {
+			const upper = upperHalf[i];
+			const lower = lowerHalf[i];
+
+			result.push({
+				id: matchId++,
+				groupId: groupIdx,
+				stageId: 0,
+				roundId: roundId,
+				number: i + 1,
+				opponent1: {
+					id: upper,
+				},
+				opponent2: {
+					id: lower,
+				},
+				winnerSide: null,
+			});
+		}
+
+		if (bye) {
+			result.push({
+				id: matchId++,
+				groupId: groupIdx,
+				stageId: 0,
+				roundId: roundId,
+				number: upperHalf.length + 1,
+				opponent1: {
+					id: bye,
+				},
+				opponent2: null,
+				winnerSide: null,
+			});
+		}
+	}
+
+	return result;
+
+	function splitToGroups() {
+		if (!seeding) return [];
+		if (groupCount === 1) return [seeding.map((id) => id!)];
+
+		const groups: number[][] = nullFilledArray(groupCount).map(() => []);
+
+		for (let i = 0; i < seeding.length; i++) {
+			const groupIndex = i % groupCount;
+			groups[groupIndex].push(seeding[i]!);
+		}
+
+		return groups;
+	}
+}
diff --git a/app/features/tournament-bracket/core/engine/general.test.ts b/app/features/tournament-bracket/core/engine/general.test.ts
new file mode 100644
index 000000000..0e4f2a685
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/general.test.ts
@@ -0,0 +1,258 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { createResolved } from "./create";
+import * as Engine from "./index";
+import type { BracketData } from "./types";
+
+describe("BYE handling", () => {
+	test("should propagate BYEs through the brackets", () => {
+		const data = createResolved({
+			type: "double_elimination",
+			seeding: [1, null, null, null],
+			settings: {},
+		});
+
+		expect(matchById(data, 2).opponent1?.id).toBe(1);
+		expect(matchById(data, 2).opponent2).toBe(null);
+
+		expect(matchById(data, 3).opponent1).toBe(null);
+		expect(matchById(data, 3).opponent2).toBe(null);
+
+		expect(matchById(data, 4).opponent1).toBe(null);
+		expect(matchById(data, 4).opponent2).toBe(null);
+
+		expect(matchById(data, 5).opponent1?.id).toBe(1);
+		expect(matchById(data, 5).opponent2).toBe(null);
+	});
+
+	test("should handle incomplete seeding during creation", () => {
+		const data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, null, null],
+			settings: {},
+		});
+
+		expect(matchById(data, 0).opponent1?.id).toBe(1);
+		expect(matchById(data, 0).opponent2).toBe(null);
+
+		expect(matchById(data, 1).opponent1?.id).toBe(2);
+		expect(matchById(data, 1).opponent2).toBe(null);
+	});
+});
+
+describe("Position checks", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: {},
+		});
+	});
+
+	test("should not have a position when we don't need the origin of a participant", () => {
+		const matchFromWbRound2 = matchById(data, 4);
+		expect(matchFromWbRound2.opponent1?.position).toBe(undefined);
+		expect(matchFromWbRound2.opponent2?.position).toBe(undefined);
+
+		const matchFromLbRound2 = matchById(data, 9);
+		expect(matchFromLbRound2.opponent2?.position).toBe(undefined);
+
+		const matchFromGrandFinal = matchById(data, 13);
+		expect(matchFromGrandFinal.opponent1?.position).toBe(undefined);
+	});
+
+	test("should have a position where we need the origin of a participant", () => {
+		const matchFromWbRound1 = matchById(data, 0);
+		expect(matchFromWbRound1.opponent1?.position).toBe(1);
+		expect(matchFromWbRound1.opponent2?.position).toBe(8);
+
+		const matchFromLbRound1 = matchById(data, 7);
+		expect(matchFromLbRound1.opponent1?.position).toBe(1);
+		expect(matchFromLbRound1.opponent2?.position).toBe(2);
+
+		const matchFromLbRound2 = matchById(data, 9);
+		expect(matchFromLbRound2.opponent1?.position).toBe(2);
+
+		const matchFromGrandFinal = matchById(data, 13);
+		expect(matchFromGrandFinal.opponent2?.position).toBe(1);
+	});
+});
+
+describe("Special cases", () => {
+	test("should pad the seeding with BYEs to the next power of two", () => {
+		const data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7],
+			settings: {},
+		});
+
+		expect(matchById(data, 0).opponent1?.id).toBe(1);
+		expect(matchById(data, 0).opponent2).toBe(null);
+	});
+
+	test("should throw if the participant count of a stage is less than two", () => {
+		expect(() =>
+			createResolved({
+				type: "single_elimination",
+				seeding: [],
+				settings: {},
+			}),
+		).toThrow("Impossible to create a stage with less than 2 participants.");
+
+		expect(() =>
+			createResolved({
+				type: "single_elimination",
+				seeding: [1],
+				settings: {},
+			}),
+		).toThrow("Impossible to create a stage with less than 2 participants.");
+	});
+});
+
+describe("Seeding and ordering in elimination", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+			settings: {},
+		});
+	});
+
+	test("should have the good orderings everywhere", () => {
+		const firstRoundMatchWB = matchById(data, 0);
+		expect(firstRoundMatchWB.opponent1?.position).toBe(1);
+		expect(firstRoundMatchWB.opponent2?.position).toBe(16);
+
+		const firstRoundMatchLB = matchById(data, 15);
+		expect(firstRoundMatchLB.opponent1?.position).toBe(1);
+		expect(firstRoundMatchLB.opponent2?.position).toBe(2);
+
+		const secondRoundMatchLB = matchById(data, 19);
+		expect(secondRoundMatchLB.opponent1?.position).toBe(2);
+
+		const secondRoundSecondMatchLB = matchById(data, 20);
+		expect(secondRoundSecondMatchLB.opponent1?.position).toBe(1);
+
+		const fourthRoundMatchLB = matchById(data, 25);
+		expect(fourthRoundMatchLB.opponent1?.position).toBe(2);
+
+		const finalRoundMatchLB = matchById(data, 28);
+		expect(finalRoundMatchLB.opponent1?.position).toBe(1);
+	});
+});
+
+describe("Reset match", () => {
+	test("should reset results of a match", () => {
+		// Seeds 1 and 2 are placed into the same first-round match (positions 1
+		// and 8) so that match 0 is a real two-team match under the default
+		// space_between ordering, while the rest of the bracket is BYEs.
+		let data = createResolved({
+			type: "single_elimination",
+			seeding: [1, null, null, null, null, null, null, 2],
+			settings: {},
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(matchById(data, 0).opponent1?.score).toBe(16);
+		expect(matchById(data, 0).opponent2?.score).toBe(12);
+		expect(matchById(data, 0).winnerSide).toBe("opponent1");
+
+		expect(matchById(data, 4).winnerSide).toBe("opponent1");
+		expect(matchById(data, 4).opponent2).toBe(null);
+
+		expect(matchById(data, 6).winnerSide).toBe("opponent1");
+		expect(matchById(data, 6).opponent2).toBe(null);
+
+		data = Engine.resetMatchResults(data, 0).data; // Score stays as is.
+
+		expect(matchById(data, 0).opponent1?.score).toBe(16);
+		expect(matchById(data, 0).opponent2?.score).toBe(12);
+		expect(matchById(data, 0).winnerSide).toBe(null);
+
+		expect(matchById(data, 4).winnerSide).toBe(null);
+		expect(matchById(data, 4).opponent2).toBe(null);
+
+		expect(matchById(data, 6).winnerSide).toBe(null);
+		expect(matchById(data, 6).opponent2).toBe(null);
+	});
+
+	test("should throw when at least one of the following match is locked", () => {
+		let data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		});
+
+		for (const matchId of [0, 1, 2]) {
+			data = Engine.reportResult(data, {
+				matchId,
+				scores: [16, 12],
+				winnerSide: "opponent1",
+			}).data;
+		}
+
+		expect(() => Engine.resetMatchResults(data, 0)).toThrow(
+			"The match is locked.",
+		);
+	});
+});
+
+describe("Engine data immutability", () => {
+	test("engine operations return new data and leave the input untouched", () => {
+		const initial = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		});
+
+		const snapshot = structuredClone(initial);
+
+		const afterReport = Engine.reportResult(initial, {
+			matchId: 0,
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		});
+
+		expect(initial).toEqual(snapshot);
+		expect(afterReport.data.match[0].winnerSide).toBe("opponent1");
+
+		const afterReset = Engine.resetMatchResults(afterReport.data, 0);
+
+		expect(afterReport.data.match[0].winnerSide).toBe("opponent1");
+		expect(afterReset.data.match[0].winnerSide).toBeNull();
+	});
+
+	test("changedMatches contains only genuinely changed rows", () => {
+		const initial = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		});
+
+		const afterReport = Engine.reportResult(initial, {
+			matchId: 0,
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		});
+
+		const changedIds = afterReport.changedMatches.map((match) => match.id);
+		expect(changedIds).toContain(0); // The reported match.
+		expect(changedIds).toContain(2); // The final receiving the winner.
+		expect(changedIds).not.toContain(1); // The other semi is untouched.
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/index.ts b/app/features/tournament-bracket/core/engine/index.ts
new file mode 100644
index 000000000..0f3a0ec67
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/index.ts
@@ -0,0 +1,24 @@
+/**
+ * Pure bracket engine. No I/O anywhere in this module tree — callers hydrate
+ * BracketData via BracketRepository, call engine functions, persist the
+ * returned delta via BracketRepository.
+ */
+
+export { create } from "./create";
+export {
+	hasThirdPlaceMatch,
+	roundRobinGroupCount,
+	swissRoundCount,
+} from "./create/settings";
+export { endDroppedTeamMatches } from "./propagation/dropped-teams";
+export { reportResult } from "./propagation/report-result";
+export { resetMatchResults } from "./propagation/reset-result";
+export {
+	endSet,
+	reopenMatch,
+	reportGameResult,
+	undoGameResult,
+} from "./propagation/set";
+export * from "./status";
+export { generateRound } from "./swiss/pairing";
+export * from "./types";
diff --git a/app/features/tournament-bracket/core/engine/propagation/double-elimination.test.ts b/app/features/tournament-bracket/core/engine/propagation/double-elimination.test.ts
new file mode 100644
index 000000000..5a92e9e89
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/double-elimination.test.ts
@@ -0,0 +1,273 @@
+import { describe, expect, test } from "vitest";
+import { createResolved } from "../create";
+import * as Engine from "../index";
+import type { BracketData } from "../types";
+
+describe("Previous and next match update in double elimination stage", () => {
+	test("should end a match and determine next matches", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+			settings: {},
+		});
+
+		const before = matchById(data, 8); // First match of WB round 2
+		expect(before.opponent2?.id).toBeNull();
+
+		data = Engine.reportResult(data, {
+			matchId: 0, // First match of WB round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 1, // Second match of WB round 1
+			scores: [13, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 15, // First match of LB round 1
+			scores: [16, 10],
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(
+			matchById(data, 8).opponent1?.id, // Determined opponent for WB round 2
+		).toBe(matchById(data, 0).opponent1?.id); // Winner of first match round 1
+
+		expect(
+			matchById(data, 8).opponent2?.id, // Determined opponent for WB round 2
+		).toBe(matchById(data, 1).opponent2?.id); // Winner of second match round 1
+
+		expect(
+			matchById(data, 15).opponent2?.id, // Determined opponent for LB round 1
+		).toBe(matchById(data, 1).opponent1?.id); // Loser of second match round 1
+
+		expect(
+			matchById(data, 19).opponent2?.id, // Determined opponent for LB round 2
+		).toBe(matchById(data, 0).opponent2?.id); // Loser of first match round 1
+	});
+
+	test("should propagate winner when BYE is already in next match in loser bracket", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, null],
+			settings: {},
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 1, // Second match of WB round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		const loserId = matchById(data, 1).opponent2?.id;
+
+		expect(matchById(data, 3).opponent2?.id).toBe(loserId);
+		expect(matchById(data, 3).winnerSide).toBe("opponent2");
+		expect(Engine.matchStatus(data, 3)).toBe("COMPLETED");
+
+		expect(
+			matchById(data, 4).opponent2?.id, // Propagated winner in LB Final because of the BYE.
+		).toBe(loserId);
+
+		data = Engine.resetMatchResults(data, 1).data; // Second match of WB round 1
+
+		expect(matchById(data, 3).opponent2?.id).toBeNull();
+		expect(matchById(data, 3).winnerSide).toBeNull();
+		expect(Engine.matchStatus(data, 3)).toBe("PENDING");
+
+		expect(matchById(data, 4).opponent2?.id).toBeNull(); // Propagated winner is removed.
+	});
+
+	test("should determine matches in grand final", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0, // First match of WB round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 1, // Second match of WB round 1
+			scores: [13, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 2, // WB Final
+			scores: [16, 9],
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(
+			matchById(data, 5).opponent1?.id, // Determined opponent for the grand final (round 1)
+		).toBe(matchById(data, 0).opponent1?.id); // Winner of WB Final
+
+		data = Engine.reportResult(data, {
+			matchId: 3, // Only match of LB round 1
+			scores: [12, 8],
+			winnerSide: "opponent1", // Team 4
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 4, // LB Final
+			scores: [14, 7],
+			winnerSide: "opponent1", // Team 3
+		}).data;
+
+		expect(
+			matchById(data, 5).opponent2?.id, // Determined opponent for the grand final (round 1)
+		).toBe(matchById(data, 1).opponent2?.id); // Winner of LB Final
+
+		data = Engine.reportResult(data, {
+			matchId: 5, // Grand Final round 1
+			scores: [10, 16],
+			winnerSide: "opponent2", // Team 3
+		}).data;
+
+		expect(
+			matchById(data, 6).opponent2?.id, // Determined opponent for the grand final (round 2)
+		).toBe(matchById(data, 1).opponent2?.id); // Winner of LB Final
+
+		expect(Engine.matchStatus(data, 5)).toBe("COMPLETED"); // Grand final (round 1)
+		expect(Engine.matchStatus(data, 6)).toBe("STARTED"); // Grand final (round 2)
+
+		expect(() =>
+			Engine.reportResult(data, {
+				matchId: 6, // Grand Final round 2
+				scores: [16, 10],
+				winnerSide: "opponent1",
+			}),
+		).not.toThrow();
+	});
+
+	test("should determine next matches and reset them", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0, // First match of WB round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		const beforeReset = matchById(data, 3); // Determined opponent for LB round 1
+		expect(beforeReset.opponent1?.id).toBe(matchById(data, 0).opponent2?.id);
+		expect(beforeReset.opponent1?.position).toBe(1); // Must be set.
+
+		data = Engine.resetMatchResults(data, 0).data; // First match of WB round 1
+
+		const afterReset = matchById(data, 3); // Determined opponent for LB round 1
+		expect(afterReset.opponent1?.id).toBeNull();
+		expect(afterReset.opponent1?.position).toBe(1); // It must stay.
+	});
+
+	test("should choose the correct previous and next matches based on losers ordering", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+			settings: {},
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1",
+		}).data; // WB 1.1
+		expect(
+			matchById(data, 15).opponent1?.id, // Determined opponent for first match of LB round 1 (natural ordering for losers)
+		).toBe(matchById(data, 0).opponent2?.id); // Loser of first match round 1
+
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			winnerSide: "opponent1",
+		}).data; // WB 1.2
+		expect(
+			matchById(data, 15).opponent2?.id, // Determined opponent for first match of LB round 1 (natural ordering for losers)
+		).toBe(matchById(data, 1).opponent2?.id); // Loser of second match round 1
+
+		data = Engine.reportResult(data, {
+			matchId: 8,
+			winnerSide: "opponent1",
+		}).data; // WB 2.1
+		expect(
+			matchById(data, 20).opponent1?.id, // Determined opponent for first match of LB round 2
+		).toBe(matchById(data, 8).opponent2?.id); // Loser of first match round 2
+
+		for (const matchId of [
+			6, // WB 1.7
+			7, // WB 1.8
+			11, // WB 2.4
+			15, // LB 1.1
+			18, // LB 1.4
+		]) {
+			data = Engine.reportResult(data, {
+				matchId,
+				winnerSide: "opponent1",
+			}).data;
+		}
+
+		expect(Engine.matchStatus(data, 8)).toBe("COMPLETED"); // WB 2.1
+	});
+
+	test("should send the losers to the right LB matches in round 1", () => {
+		let data = createResolved({
+			type: "double_elimination",
+			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
+			settings: {},
+		});
+
+		expect(matchById(data, 7).opponent1?.position).toBe(1);
+		expect(matchById(data, 7).opponent2?.position).toBe(2);
+		expect(matchById(data, 8).opponent1?.position).toBe(3);
+		expect(matchById(data, 8).opponent2?.position).toBe(4);
+
+		// Match of position 1.
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1", // Loser id: 8.
+		}).data;
+
+		expect(matchById(data, 7).opponent1?.id).toBe(8);
+
+		// Match of position 2.
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			winnerSide: "opponent1", // Loser id: 5.
+		}).data;
+
+		expect(matchById(data, 7).opponent2?.id).toBe(5);
+
+		// Match of position 3.
+		data = Engine.reportResult(data, {
+			matchId: 2,
+			winnerSide: "opponent1", // Loser id: 7.
+		}).data;
+
+		expect(matchById(data, 8).opponent1?.id).toBe(7);
+
+		// Match of position 4.
+		data = Engine.reportResult(data, {
+			matchId: 3,
+			winnerSide: "opponent1", // Loser id: 6.
+		}).data;
+
+		expect(matchById(data, 8).opponent2?.id).toBe(6);
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/dropped-teams.ts b/app/features/tournament-bracket/core/engine/propagation/dropped-teams.ts
new file mode 100644
index 000000000..6272eac38
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/dropped-teams.ts
@@ -0,0 +1,59 @@
+import type { BracketData, DroppedTeamsResult } from "../types";
+import { Store } from "./store";
+import { Propagator } from "./traversal";
+
+/**
+ * Ends all unfinished matches involving dropped teams by awarding wins to
+ * their opponents. Ported from tournament-utils.server.ts. When both teams in
+ * a match have dropped, a random winner is picked.
+ *
+ * Matches that only gain a dropped opponent through propagation caused by this
+ * call are not ended (same as the old implementation, which iterated a
+ * snapshot); they are picked up by the next call.
+ */
+export function endDroppedTeamMatches(
+	data: BracketData,
+	droppedTeamIds: number[],
+): DroppedTeamsResult {
+	const store = new Store(data);
+	const propagator = new Propagator(store);
+	const droppedTeamIdsSet = new Set(droppedTeamIds);
+
+	const endedMatchIds: number[] = [];
+
+	for (const match of data.match) {
+		if (!match.opponent1?.id || !match.opponent2?.id) continue;
+		if (match.winnerSide) continue;
+
+		const team1Dropped = droppedTeamIdsSet.has(match.opponent1.id);
+		const team2Dropped = droppedTeamIdsSet.has(match.opponent2.id);
+
+		if (!team1Dropped && !team2Dropped) continue;
+
+		const winnerTeamId = (() => {
+			if (team1Dropped && !team2Dropped) return match.opponent2.id;
+			if (!team1Dropped && team2Dropped) return match.opponent1.id;
+			return Math.random() < 0.5 ? match.opponent1.id : match.opponent2.id;
+		})();
+
+		const stored = store.matchById(match.id);
+		if (!stored) throw Error("Match not found.");
+
+		propagator.updateMatch(
+			stored,
+			{
+				winnerSide:
+					winnerTeamId === match.opponent1.id ? "opponent1" : "opponent2",
+			},
+			true,
+		);
+
+		endedMatchIds.push(match.id);
+	}
+
+	return {
+		data: store.data,
+		changedMatches: store.changedMatches(),
+		endedMatchIds,
+	};
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/helpers.ts b/app/features/tournament-bracket/core/engine/propagation/helpers.ts
new file mode 100644
index 000000000..bf0fcfe50
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/helpers.ts
@@ -0,0 +1,382 @@
+import { defaultMinorOrdering, ordering } from "../create/seeding";
+import { isMatchByeCompleted, isMatchCompleted } from "../status";
+import type {
+	GroupType,
+	MatchData,
+	MatchResults,
+	MatchResultsInput,
+	SeedOrdering,
+	Side,
+	StageData,
+	StageType,
+} from "../types";
+
+export type SetNextOpponent = (
+	nextMatch: MatchData,
+	nextSide: Side,
+	match?: MatchData,
+	currentSide?: Side,
+) => void;
+
+/**
+ * Returns the winner side or `null` if no winner.
+ *
+ * @param match A match's results.
+ */
+export function getMatchResult(match: MatchResults): Side | null {
+	if (!isMatchCompleted(match)) return null;
+
+	if (match.winnerSide) return match.winnerSide;
+
+	// a BYE that has not been propagated yet
+	if (match.opponent1 === null && match.opponent2 !== null) return "opponent2";
+	if (match.opponent2 === null && match.opponent1 !== null) return "opponent1";
+
+	return null;
+}
+
+/**
+ * Gets the other side of a match.
+ *
+ * @param side The side that we don't want.
+ */
+export function getOtherSide(side: Side): Side {
+	return side === "opponent1" ? "opponent2" : "opponent1";
+}
+
+/**
+ * Indicates whether a match has at least one BYE or not.
+ *
+ * @param match A match's results.
+ */
+export function hasBye(match: MatchResults): boolean {
+	return match.opponent1 === null || match.opponent2 === null;
+}
+
+/**
+ * Updates a match results based on an input.
+ *
+ * @param stored A reference to what will be updated in the storage.
+ * @param scores Games won by each side. `undefined` keeps them, `null` clears them.
+ * @param winnerSide The resolved winner of the set, if any.
+ * @returns `true` if the match was completed or un-completed by the update.
+ */
+export function setMatchResults(
+	stored: MatchResults,
+	scores: MatchResultsInput["scores"],
+	winnerSide: Side | undefined,
+): boolean {
+	const currentlyCompleted = isMatchCompleted(stored);
+
+	setScores(stored, scores);
+
+	if (winnerSide) {
+		stored.winnerSide = winnerSide;
+		return true;
+	}
+
+	if (currentlyCompleted) {
+		clearWinner(stored);
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Clears the winner of a match, marking it as not completed.
+ *
+ * @param stored A reference to what will be updated in the storage.
+ */
+export function clearWinner(stored: MatchResults): void {
+	stored.winnerSide = null;
+}
+
+/**
+ * Completes a match that is decided by a BYE, marking the side that has an
+ * opponent as the winner. Does nothing to a match that is not decided by a BYE.
+ *
+ * @param match A reference to what will be updated in the storage.
+ */
+export function resolveByeWinner(match: MatchResults): void {
+	if (match.winnerSide) return;
+	if (!isMatchByeCompleted(match)) return;
+
+	if (match.opponent1 && !match.opponent2) {
+		match.winnerSide = "opponent1";
+	} else if (!match.opponent1 && match.opponent2) {
+		match.winnerSide = "opponent2";
+	}
+}
+
+/**
+ * Gets the side the winner of the current match will go to in the next match.
+ *
+ * @param matchNumber Number of the current match.
+ * @param roundNumber Number of the current round.
+ * @param roundCount Count of rounds.
+ * @param matchLocation Location of the current match.
+ */
+export function getNextSide(
+	matchNumber: number,
+	roundNumber: number,
+	roundCount: number,
+	matchLocation: GroupType,
+): Side {
+	// The nextSide comes from the same bracket.
+	if (matchLocation === "loser_bracket" && roundNumber % 2 === 1)
+		return "opponent2";
+
+	// The nextSide comes from the loser bracket to the final group.
+	if (matchLocation === "loser_bracket" && roundNumber === roundCount)
+		return "opponent2";
+
+	return getSide(matchNumber);
+}
+
+/**
+ * Gets the side the winner of the current match in loser bracket will go in the next match.
+ *
+ * @param matchNumber Number of the match.
+ * @param nextMatch The next match.
+ * @param roundNumber Number of the current round.
+ */
+export function getNextSideLoserBracket(
+	matchNumber: number,
+	nextMatch: MatchData,
+	roundNumber: number,
+): Side {
+	// The nextSide comes from the WB.
+	if (roundNumber > 1) return "opponent1";
+
+	// The nextSide comes from the WB round 1.
+	if (nextMatch.opponent1?.position === matchNumber) return "opponent1";
+
+	return "opponent2";
+}
+
+/**
+ * Sets an opponent in the next match he has to go.
+ *
+ * @param nextMatch A match which follows the current one.
+ * @param nextSide The side the opponent will be on in the next match.
+ * @param match The current match.
+ * @param currentSide The side the opponent is currently on.
+ */
+export function setNextOpponent(
+	nextMatch: MatchData,
+	nextSide: Side,
+	match?: MatchData,
+	currentSide?: Side,
+): void {
+	nextMatch[nextSide] = match![currentSide!] && {
+		// Keep BYE.
+		id: getOpponentId(match!, currentSide!), // This implementation of SetNextOpponent always has those arguments.
+		position: nextMatch[nextSide]?.position, // Keep position.
+	};
+	nextMatch.winnerSide = null; // A match whose opponents changed can't keep its winner.
+}
+
+/**
+ * Resets an opponent in the match following the current one.
+ *
+ * @param nextMatch A match which follows the current one.
+ * @param nextSide The side the opponent will be on in the next match.
+ */
+export function resetNextOpponent(nextMatch: MatchData, nextSide: Side): void {
+	nextMatch[nextSide] = nextMatch[nextSide] && {
+		// Keep BYE.
+		id: null,
+		position: nextMatch[nextSide]?.position, // Keep position.
+	};
+	nextMatch.winnerSide = null; // A match whose opponents changed can't keep its winner.
+}
+
+/**
+ * Returns the real (because of loser ordering) number of a match in a loser bracket.
+ *
+ * @param participantCount The number of participants in a stage.
+ * @param roundNumber Number of the round.
+ * @param matchNumber Number of the match.
+ * @param method The method used for the round.
+ */
+export function findLoserMatchNumber(
+	participantCount: number,
+	roundNumber: number,
+	matchNumber: number,
+	method?: SeedOrdering,
+): number {
+	const loserCount = getLoserRoundLoserCount(participantCount, roundNumber);
+	const losers = Array.from(Array(loserCount), (_, i) => i + 1);
+	const ordered = method ? ordering[method](losers) : losers;
+	const matchNumberLB = ordered.indexOf(matchNumber) + 1;
+
+	// For LB round 1, the list of losers is spread over the matches 2 by 2.
+	if (roundNumber === 1) return Math.ceil(matchNumberLB / 2);
+
+	return matchNumberLB;
+}
+
+/**
+ * Returns the ordering method of a round of a loser bracket.
+ *
+ * @param participantCount The number of participants in the stage.
+ * @param roundNumber Number of the round.
+ */
+export function getLoserOrdering(
+	participantCount: number,
+	roundNumber: number,
+): SeedOrdering | undefined {
+	return defaultMinorOrdering[participantCount]?.[Math.floor(roundNumber / 2)];
+}
+
+/**
+ * Returns the match number of the corresponding match in the next round by dividing by two.
+ *
+ * @param matchNumber The current match number.
+ */
+export function getDiagonalMatchNumber(matchNumber: number): number {
+	return Math.ceil(matchNumber / 2);
+}
+
+/**
+ * Checks if a stage is a round-robin stage.
+ *
+ * @param stage The stage to check.
+ */
+export function isRoundRobin(stage: StageData): boolean {
+	return stage.type === "round_robin";
+}
+
+/**
+ * Checks if a stage is a swiss stage.
+ *
+ * @param stage The stage to check.
+ */
+export function isSwiss(stage: StageData): boolean {
+	return stage.type === "swiss";
+}
+
+/**
+ * Returns the type of group the match is located into.
+ *
+ * @param stageType Type of the stage.
+ * @param groupNumber Number of the group.
+ */
+export function getMatchLocation(
+	stageType: StageType,
+	groupNumber: number,
+): GroupType {
+	if (isWinnerBracket(stageType, groupNumber)) return "winner_bracket";
+
+	if (isLoserBracket(stageType, groupNumber)) return "loser_bracket";
+
+	if (isFinalGroup(stageType, groupNumber)) return "final_group";
+
+	return "single_bracket";
+}
+
+/**
+ * Gets the side where the winner of the given match will go in the next match.
+ *
+ * @param matchNumber Number of the match.
+ */
+function getSide(matchNumber: number): Side {
+	return matchNumber % 2 === 1 ? "opponent1" : "opponent2";
+}
+
+/**
+ * Updates the scores of a match.
+ *
+ * @param stored A reference to what will be updated in the storage.
+ * @param scores Games won by each side. `undefined` keeps them, `null` clears them.
+ */
+function setScores(
+	stored: MatchResults,
+	scores: MatchResultsInput["scores"],
+): void {
+	if (scores === undefined) return;
+
+	if (stored.opponent1) stored.opponent1.score = scores?.[0];
+	if (stored.opponent2) stored.opponent2.score = scores?.[1];
+}
+
+/**
+ * Gets the id of the opponent at the given side of the given match.
+ *
+ * @param match The match to get the opponent from.
+ * @param side The side where to get the opponent from.
+ */
+function getOpponentId(match: MatchResults, side: Side): number | null {
+	const opponent = match[side];
+	return opponent?.id ?? null;
+}
+
+/**
+ * Returns the count of matches in a round of a loser bracket.
+ *
+ * @param participantCount The number of participants in a stage.
+ * @param roundNumber Number of the round.
+ */
+function getLoserRoundMatchCount(
+	participantCount: number,
+	roundNumber: number,
+): number {
+	const roundPairIndex = Math.ceil(roundNumber / 2) - 1;
+	const roundPairCount = Math.log2(participantCount) - 1;
+	const matchCount = 2 ** (roundPairCount - roundPairIndex - 1);
+	return matchCount;
+}
+
+/**
+ * Returns the count of losers in a round of a loser bracket.
+ *
+ * @param participantCount The number of participants in a stage.
+ * @param roundNumber Number of the round.
+ */
+function getLoserRoundLoserCount(
+	participantCount: number,
+	roundNumber: number,
+): number {
+	const matchCount = getLoserRoundMatchCount(participantCount, roundNumber);
+
+	// Two per match for LB round 1 (losers coming from WB round 1).
+	if (roundNumber === 1) return matchCount * 2;
+
+	return matchCount; // One per match for LB minor rounds.
+}
+
+/**
+ * Checks if a group is a winner bracket.
+ *
+ * It's not always the opposite of `isLoserBracket()`: it could be the only bracket of a single elimination stage.
+ *
+ * @param stageType Type of the stage.
+ * @param groupNumber Number of the group.
+ */
+function isWinnerBracket(stageType: StageType, groupNumber: number): boolean {
+	return stageType === "double_elimination" && groupNumber === 1;
+}
+
+/**
+ * Checks if a group is a loser bracket.
+ *
+ * @param stageType Type of the stage.
+ * @param groupNumber Number of the group.
+ */
+function isLoserBracket(stageType: StageType, groupNumber: number): boolean {
+	return stageType === "double_elimination" && groupNumber === 2;
+}
+
+/**
+ * Checks if a group is a final group (consolation final or grand final).
+ *
+ * @param stageType Type of the stage.
+ * @param groupNumber Number of the group.
+ */
+function isFinalGroup(stageType: StageType, groupNumber: number): boolean {
+	return (
+		(stageType === "single_elimination" && groupNumber === 2) ||
+		(stageType === "double_elimination" && groupNumber === 3)
+	);
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/report-result.ts b/app/features/tournament-bracket/core/engine/propagation/report-result.ts
new file mode 100644
index 000000000..b42a9bbc8
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/report-result.ts
@@ -0,0 +1,25 @@
+import invariant from "~/utils/invariant";
+import type { BracketData, EngineResult, ReportResultInput } from "../types";
+import { Store } from "./store";
+import { Propagator } from "./traversal";
+
+/**
+ * Applies a result to a match and propagates:
+ * winner/loser advancement (SE/DE), BYE cascades, grand final + bracket reset,
+ * next-round unlocking (RR), no downstream propagation for swiss/RR completed
+ * matches. Throws on locked matches.
+ */
+export function reportResult(
+	data: BracketData,
+	input: ReportResultInput,
+): EngineResult {
+	const store = new Store(data);
+	const propagator = new Propagator(store);
+
+	const stored = store.matchById(input.matchId);
+	invariant(stored, "Match not found");
+
+	propagator.updateMatch(stored, input);
+
+	return { data: store.data, changedMatches: store.changedMatches() };
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/reset-result.ts b/app/features/tournament-bracket/core/engine/propagation/reset-result.ts
new file mode 100644
index 000000000..bcb163273
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/reset-result.ts
@@ -0,0 +1,64 @@
+import {
+	isMatchByeCompleted,
+	isMatchCompleted,
+	isMatchStarted,
+} from "../status";
+import type { BracketData, EngineResult } from "../types";
+import * as helpers from "./helpers";
+import { Store } from "./store";
+import { Propagator } from "./traversal";
+
+/**
+ * Clears a match's results and rolls back everything that was propagated
+ * from it. 1:1 with the old reset.ts, including the swiss/round_robin early
+ * return.
+ */
+export function resetMatchResults(
+	data: BracketData,
+	matchId: number,
+): EngineResult {
+	const store = new Store(data);
+	const propagator = new Propagator(store);
+
+	const stored = store.matchById(matchId);
+	if (!stored) throw Error("Match not found.");
+
+	const stage = store.stageById(stored.stageId);
+	if (!stage) throw Error("Stage not found.");
+
+	const group = store.groupById(stored.groupId);
+	if (!group) throw Error("Group not found.");
+
+	const { roundNumber, roundCount } = propagator.getRoundPositionalInfo(
+		stored.roundId,
+	);
+	const matchLocation = helpers.getMatchLocation(stage.type, group.number);
+	const nextMatches =
+		stage.type !== "round_robin" && stage.type !== "swiss"
+			? propagator.getNextMatches(
+					stored,
+					matchLocation,
+					stage,
+					roundNumber,
+					roundCount,
+				)
+			: [];
+
+	if (
+		nextMatches.some(
+			(match) =>
+				match &&
+				(isMatchStarted(match) || isMatchCompleted(match)) &&
+				!isMatchByeCompleted(match),
+		)
+	)
+		throw Error("The match is locked.");
+
+	helpers.clearWinner(stored);
+	store.markMatchChanged(stored);
+
+	if (!helpers.isRoundRobin(stage) && !helpers.isSwiss(stage))
+		propagator.updateRelatedMatches(stored);
+
+	return { data: store.data, changedMatches: store.changedMatches() };
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/round-robin.test.ts b/app/features/tournament-bracket/core/engine/propagation/round-robin.test.ts
new file mode 100644
index 000000000..5bdfd1a3c
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/round-robin.test.ts
@@ -0,0 +1,245 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { createResolved } from "../create";
+import * as Engine from "../index";
+import type { BracketData } from "../types";
+
+describe("Update scores in a round-robin stage", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4],
+			settings: { groupCount: 1 },
+		});
+	});
+
+	test("should set all the scores", () => {
+		const results: Engine.ReportResultInput[] = [
+			{
+				matchId: 0,
+				scores: [16, 9], // AQUELLEHEURE?!
+				winnerSide: "opponent1", // POCEBLO
+			},
+			{
+				matchId: 1,
+				scores: [3, 16], // Ballec Squad
+				winnerSide: "opponent2", // twitch.tv/mrs_fly
+			},
+			{
+				matchId: 2,
+				scores: [16, 0], // AQUELLEHEURE?!
+				winnerSide: "opponent1", // twitch.tv/mrs_fly
+			},
+			{
+				matchId: 3,
+				scores: [16, 2], // Ballec Squad
+				winnerSide: "opponent1", // POCEBLO
+			},
+			{
+				matchId: 4,
+				scores: [16, 12], // AQUELLEHEURE?!
+				winnerSide: "opponent1", // Ballec Squad
+			},
+			{
+				matchId: 5,
+				scores: [4, 16], // twitch.tv/mrs_fly
+				winnerSide: "opponent2", // POCEBLO
+			},
+		];
+
+		for (const result of results) {
+			data = Engine.reportResult(data, result).data;
+		}
+
+		for (const result of results) {
+			expect(matchById(data, result.matchId).winnerSide).toBe(
+				result.winnerSide,
+			);
+		}
+	});
+
+	test("should unlock next round matches as soon as both participants are ready", () => {
+		// Round robin with 4 teams: [1, 2, 3, 4]
+		// Round 1: Match 0 (1 vs 2), Match 1 (3 vs 4)
+		// Round 2: Match 2 (1 vs 3), Match 3 (2 vs 4)
+		// Round 3: Match 4 (1 vs 4), Match 5 (2 vs 3)
+
+		// Initially, only round 1 matches should be ready
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED"); // Ready (1 vs 2)
+		expect(Engine.matchStatus(data, 1)).toBe("STARTED"); // Ready (3 vs 4)
+		expect(Engine.matchStatus(data, 2)).toBe("PENDING"); // Locked (1 vs 3)
+		expect(Engine.matchStatus(data, 3)).toBe("PENDING"); // Locked (2 vs 4)
+
+		// Complete first match of round 1 (1 vs 2)
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [16, 9], // Team 2 loses
+			winnerSide: "opponent1", // Team 1 wins
+		}).data;
+
+		// Round 2 Match 1 (1 vs 3) should still be locked because team 3 hasn't finished
+		// Round 2 Match 2 (2 vs 4) should still be locked because team 4 hasn't finished
+		expect(Engine.matchStatus(data, 2)).toBe("PENDING"); // Still Locked
+		expect(Engine.matchStatus(data, 3)).toBe("PENDING"); // Still Locked
+
+		// Complete second match of round 1 (3 vs 4)
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			scores: [3, 16], // Team 3 loses
+			winnerSide: "opponent2", // Team 4 wins
+		}).data;
+
+		// Now both matches in round 2 should be unlocked
+		// Match 2 (1 vs 3): both team 1 and team 3 have finished round 1
+		// Match 3 (2 vs 4): both team 2 and team 4 have finished round 1
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED"); // Ready
+		expect(Engine.matchStatus(data, 3)).toBe("STARTED"); // Ready
+	});
+
+	test("should lock the next round again if a result of the previous round is reset", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [16, 9],
+			winnerSide: "opponent1",
+		}).data;
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			scores: [3, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+
+		data = Engine.resetMatchResults(data, 0).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("PENDING");
+	});
+
+	test("should keep a started next round match playable if a result of the previous round is reset (issue #2690)", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [16, 9],
+			winnerSide: "opponent1",
+		}).data;
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			scores: [3, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		// team 1 and team 3 start playing their round 2 match
+		data = Engine.reportResult(data, {
+			matchId: 2,
+			scores: [1, 0],
+		}).data;
+
+		data = Engine.resetMatchResults(data, 0).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+		expect(() =>
+			Engine.reportResult(data, {
+				matchId: 2,
+				scores: [2, 0],
+				winnerSide: "opponent1",
+			}),
+		).not.toThrow();
+	});
+
+	test("should leave every match Ready when independentRounds is set", () => {
+		data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3, 4],
+			settings: { groupCount: 1, independentRounds: true },
+		});
+
+		for (const match of data.match) {
+			expect(Engine.matchStatus(data, match.id)).toBe("STARTED");
+		}
+
+		// reporting a round-2 match before round-1 finishes must not throw
+		expect(() =>
+			Engine.reportResult(data, {
+				matchId: 2,
+				scores: [16, 4],
+				winnerSide: "opponent1",
+			}),
+		).not.toThrow();
+	});
+
+	test("should let the only real match be played in a group with fewer teams than slots", () => {
+		// Group sized for 3 but only 2 teams placed (the 3rd slot is a BYE).
+		// The two real teams only meet in round 3, preceded by two BYE rounds
+		// that can never be reported. The real match must still be playable.
+		data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, null],
+			settings: { groupCount: 1 },
+		});
+
+		const realMatch = data.match.find(
+			(match) => match.opponent1?.id && match.opponent2?.id,
+		)!;
+
+		expect(Engine.matchStatus(data, realMatch.id)).toBe("STARTED");
+
+		expect(() =>
+			Engine.reportResult(data, {
+				matchId: realMatch.id,
+				scores: [16, 9],
+				winnerSide: "opponent1",
+			}),
+		).not.toThrow();
+	});
+
+	test("should unlock next round matches with BYE participants", () => {
+		// Create a round robin with 3 teams (odd number creates rounds where one team doesn't play)
+		data = createResolved({
+			type: "round_robin",
+			seeding: [1, 2, 3],
+			settings: { groupCount: 1 },
+		});
+
+		// With 3 teams, the rounds look like:
+		// Round 1: Match (teams 3 vs 2) - Team 1 doesn't play
+		// Round 2: Match (teams 1 vs 3) - Team 2 doesn't play
+		// Round 3: Match (teams 2 vs 1) - Team 3 doesn't play
+
+		// Find the actual match (not BYE vs BYE which doesn't exist)
+		const round1RealMatch = data.match.find(
+			(match) =>
+				match.roundId === data.round[0].id &&
+				match.opponent1 &&
+				match.opponent2,
+		)!;
+		const round2RealMatch = data.match.find(
+			(match) =>
+				match.roundId === data.round[1].id &&
+				match.opponent1 &&
+				match.opponent2,
+		)!;
+
+		expect(Engine.matchStatus(data, round1RealMatch.id)).toBe("STARTED");
+		expect(Engine.matchStatus(data, round2RealMatch.id)).toBe("PENDING"); // initially
+
+		// Complete the only real match in round 1 (teams 3 vs 2)
+		// Team 1 didn't play in round 1
+		data = Engine.reportResult(data, {
+			matchId: round1RealMatch.id,
+			scores: [16, 9],
+			winnerSide: "opponent1",
+		}).data;
+
+		// The real match in round 2 (teams 1 vs 3) should now be unlocked
+		// because team 1 didn't play in round 1 (considered ready)
+		// and team 3 just finished their match
+		expect(Engine.matchStatus(data, round2RealMatch.id)).toBe("STARTED");
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/set.test.ts b/app/features/tournament-bracket/core/engine/propagation/set.test.ts
new file mode 100644
index 000000000..309c2bb60
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/set.test.ts
@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import type { TournamentRoundMaps } from "~/db/tables";
+import { create } from "../create";
+import * as Engine from "../index";
+import type { BracketData, MatchData } from "../types";
+
+const TEAM_ONE = 1;
+const TEAM_TWO = 2;
+
+describe("Set results in a bracket with map info", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = bracketWithMaps({ count: 3, type: "BEST_OF" });
+	});
+
+	test("should resolve the winner from the scores once the set is over", () => {
+		data = Engine.reportGameResult(data, {
+			matchId: 0,
+			winnerTeamId: TEAM_ONE,
+		}).data;
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+
+		const reported = Engine.reportGameResult(data, {
+			matchId: 0,
+			winnerTeamId: TEAM_ONE,
+		});
+		data = reported.data;
+
+		expect(reported.setOver).toBe(true);
+		expect(matchById(data, 0).winnerSide).toBe("opponent1");
+	});
+
+	test("should resolve the winner when only the scores are reported", () => {
+		data = Engine.reportResult(data, { matchId: 0, scores: [0, 2] }).data;
+
+		expect(matchById(data, 0).winnerSide).toBe("opponent2");
+	});
+
+	test("should not resolve a winner for a play all set that ended in a tie", () => {
+		data = bracketWithMaps({ count: 2, type: "PLAY_ALL" });
+
+		data = Engine.reportResult(data, { matchId: 0, scores: [1, 1] }).data;
+
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+	});
+
+	test("should end the set early with the given winner, keeping the scores", () => {
+		data = Engine.reportGameResult(data, {
+			matchId: 0,
+			winnerTeamId: TEAM_TWO,
+		}).data;
+
+		data = Engine.endSet(data, { matchId: 0, winnerTeamId: TEAM_TWO }).data;
+
+		const after = matchById(data, 0);
+		expect(after.winnerSide).toBe("opponent2");
+		expect(after.opponent1?.score).toBe(0);
+		expect(after.opponent2?.score).toBe(1);
+	});
+
+	test("should clear the winner when a game is undone", () => {
+		for (const _ of [1, 2]) {
+			data = Engine.reportGameResult(data, {
+				matchId: 0,
+				winnerTeamId: TEAM_ONE,
+			}).data;
+		}
+
+		data = Engine.undoGameResult(data, {
+			matchId: 0,
+			lastGameWinnerTeamId: TEAM_ONE,
+		}).data;
+
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+		expect(matchById(data, 0).opponent1?.score).toBe(1);
+	});
+
+	test("should clear the winner when the match is reopened", () => {
+		for (const _ of [1, 2]) {
+			data = Engine.reportGameResult(data, {
+				matchId: 0,
+				winnerTeamId: TEAM_ONE,
+			}).data;
+		}
+
+		const reopened = Engine.reopenMatch(data, 0);
+		data = reopened.data;
+
+		expect(reopened.endedEarly).toBe(false);
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+		expect(matchById(data, 0).opponent1?.score).toBe(1);
+	});
+
+	test("should clear the winner when a set that ended early is reopened", () => {
+		data = Engine.reportGameResult(data, {
+			matchId: 0,
+			winnerTeamId: TEAM_ONE,
+		}).data;
+		data = Engine.endSet(data, { matchId: 0, winnerTeamId: TEAM_ONE }).data;
+
+		const reopened = Engine.reopenMatch(data, 0);
+		data = reopened.data;
+
+		expect(reopened.endedEarly).toBe(true);
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+		expect(matchById(data, 0).opponent1?.score).toBe(1);
+	});
+});
+
+function bracketWithMaps(maps: Pick<TournamentRoundMaps, "count" | "type">) {
+	const input = {
+		type: "single_elimination" as const,
+		seeding: [TEAM_ONE, TEAM_TWO],
+		settings: null,
+	};
+
+	return create({
+		...input,
+		maps: create(input).round.map((round) => ({
+			roundId: round.id,
+			...maps,
+		})),
+	});
+}
+
+function matchById(data: BracketData, id: number): MatchData {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/set.ts b/app/features/tournament-bracket/core/engine/propagation/set.ts
new file mode 100644
index 000000000..397977e30
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/set.ts
@@ -0,0 +1,142 @@
+import invariant from "~/utils/invariant";
+import { isSetOverByScore, matchEndedEarly } from "../status";
+import type { BracketData, EngineResult, MatchData, Side } from "../types";
+import { reportResult } from "./report-result";
+import { resetMatchResults } from "./reset-result";
+
+const SIDES = ["opponent1", "opponent2"] as const satisfies Side[];
+
+/**
+ * Records one game win for the given team, resolving from the round's map
+ * info (count & best of / play all) whether the set is now over. When it is,
+ * the win/loss results are set and propagated (advancements, unlocks etc.).
+ */
+export function reportGameResult(
+	data: BracketData,
+	input: { matchId: number; winnerTeamId: number },
+): EngineResult & { setOver: boolean } {
+	const { match, maps } = findMatchWithMaps(data, input.matchId);
+
+	const scores = currentScores(match);
+	scores[sideOfTeam(match, input.winnerTeamId)]++;
+
+	const reported = reportResult(data, { matchId: input.matchId, scores });
+
+	return {
+		...reported,
+		setOver: isSetOverByScore({
+			scores,
+			count: maps.count,
+			countType: maps.type,
+		}),
+	};
+}
+
+/**
+ * Removes the last played game from a match. If the match goes back to no
+ * games played, the whole match result is reset, rolling back anything that
+ * was propagated from it.
+ */
+export function undoGameResult(
+	data: BracketData,
+	input: { matchId: number; lastGameWinnerTeamId: number },
+): EngineResult {
+	const match = findMatch(data, input.matchId);
+
+	const scores = currentScores(match);
+	const side = sideOfTeam(match, input.lastGameWinnerTeamId);
+	invariant(scores[side] > 0, "No game to undo for the given team");
+	scores[side]--;
+
+	const shouldReset = scores[0] === 0 && scores[1] === 0;
+
+	const reported = reportResult(data, {
+		matchId: input.matchId,
+		scores: shouldReset ? null : scores,
+	});
+
+	if (!shouldReset) return reported;
+
+	const reset = resetMatchResults(reported.data, input.matchId);
+
+	return {
+		data: reset.data,
+		changedMatches: [...reported.changedMatches, ...reset.changedMatches],
+	};
+}
+
+/**
+ * Ends the set early with the given team as the winner, keeping the current
+ * scores as they are (an organizer action; e.g. the opponent can not play out
+ * the rest of the set).
+ */
+export function endSet(
+	data: BracketData,
+	input: { matchId: number; winnerTeamId: number },
+): EngineResult {
+	const match = findMatch(data, input.matchId);
+
+	return reportResult(data, {
+		matchId: input.matchId,
+		winnerSide: SIDES[sideOfTeam(match, input.winnerTeamId)],
+	});
+}
+
+/**
+ * Reopens a completed match for further reporting, clearing the set result.
+ * Resolves from the round's map info whether the set had been force-ended
+ * early: if it was, the scores are kept as is; otherwise the deciding game's
+ * score is removed (the caller is expected to delete the corresponding game
+ * result row, see `endedEarly` in the return value).
+ */
+export function reopenMatch(
+	data: BracketData,
+	matchId: number,
+): EngineResult & { endedEarly: boolean } {
+	const { match, maps } = findMatchWithMaps(data, matchId);
+
+	invariant(match.winnerSide, "Match has no result to reopen");
+
+	const endedEarly = matchEndedEarly({
+		opponentOne: match.opponent1,
+		opponentTwo: match.opponent2,
+		winnerSide: match.winnerSide,
+		count: maps.count,
+		countType: maps.type,
+	});
+
+	const scores = currentScores(match);
+	if (!endedEarly) {
+		invariant(scores[0] !== scores[1], "Scores are equal");
+		scores[SIDES.indexOf(match.winnerSide)]--;
+	}
+
+	const reported = reportResult(data, { matchId, scores });
+
+	return { ...reported, endedEarly };
+}
+
+function findMatch(data: BracketData, matchId: number): MatchData {
+	const match = data.match.find((match) => match.id === matchId);
+	invariant(match, "Match not found");
+	return match;
+}
+
+function findMatchWithMaps(data: BracketData, matchId: number) {
+	const match = findMatch(data, matchId);
+	const round = data.round.find((round) => round.id === match.roundId);
+	invariant(round?.maps, "Round of the match has no maps");
+
+	return { match, maps: round.maps };
+}
+
+function currentScores(match: MatchData): [number, number] {
+	return [match.opponent1?.score ?? 0, match.opponent2?.score ?? 0];
+}
+
+function sideOfTeam(match: MatchData, teamId: number): 0 | 1 {
+	if (match.opponent1?.id === teamId) return 0;
+	if (match.opponent2?.id === teamId) return 1;
+
+	throw Error(`Team id ${teamId} is not in the match`);
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/single-elimination.test.ts b/app/features/tournament-bracket/core/engine/propagation/single-elimination.test.ts
new file mode 100644
index 000000000..2ec74e878
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/single-elimination.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, test } from "vitest";
+import { createResolved } from "../create";
+import * as Engine from "../index";
+import type { BracketData } from "../types";
+
+describe("Previous and next match update", () => {
+	test("should determine matches in consolation final", () => {
+		let data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: { consolationFinal: true },
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0, // First match of round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 1, // Second match of round 1
+			scores: [13, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		expect(matchById(data, 3).opponent1?.id).toBe(
+			matchById(data, 0).opponent2?.id,
+		);
+		expect(matchById(data, 3).opponent2?.id).toBe(
+			matchById(data, 1).opponent1?.id,
+		);
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+		expect(Engine.matchStatus(data, 3)).toBe("STARTED");
+	});
+
+	test("should play both the final and consolation final in parallel", () => {
+		let data = createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: { consolationFinal: true },
+		});
+
+		data = Engine.reportResult(data, {
+			matchId: 0, // First match of round 1
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 1, // Second match of round 1
+			scores: [13, 16],
+			winnerSide: "opponent2",
+		}).data;
+
+		data = Engine.reportResult(data, {
+			matchId: 2, // Final
+			scores: [12, 9],
+		}).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+		expect(Engine.matchStatus(data, 3)).toBe("STARTED");
+
+		data = Engine.reportResult(data, {
+			matchId: 3, // Consolation final
+			scores: [12, 9],
+		}).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+		expect(Engine.matchStatus(data, 3)).toBe("STARTED");
+
+		data = Engine.reportResult(data, {
+			matchId: 3, // Consolation final
+			scores: [16, 9],
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(Engine.matchStatus(data, 2)).toBe("STARTED");
+
+		expect(() =>
+			Engine.reportResult(data, {
+				matchId: 2, // Final
+				scores: [16, 9],
+				winnerSide: "opponent1",
+			}),
+		).not.toThrow();
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/store.ts b/app/features/tournament-bracket/core/engine/propagation/store.ts
new file mode 100644
index 000000000..dd6daaf8a
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/store.ts
@@ -0,0 +1,120 @@
+import type {
+	BracketData,
+	GroupData,
+	MatchData,
+	RoundData,
+	StageData,
+} from "../types";
+
+/**
+ * A working copy of BracketData. The input is cloned once on construction and
+ * every row handed out afterwards is a live reference into that copy, so
+ * mutating a row is the write. Callers report the match rows they mutated so
+ * that a delta can be emitted.
+ */
+export class Store {
+	readonly data: BracketData;
+	private readonly stagesById: Map<number, StageData>;
+	private readonly groupsById: Map<number, GroupData>;
+	private readonly roundsById: Map<number, RoundData>;
+	private readonly matchesById: Map<number, MatchData>;
+	private readonly groupsByStageId: Map<number, GroupData[]>;
+	private readonly roundsByGroupId: Map<number, RoundData[]>;
+	private readonly matchesByRoundId: Map<number, MatchData[]>;
+	private readonly changedMatchIds = new Set<number>();
+
+	constructor(data: BracketData) {
+		this.data = structuredClone(data);
+
+		this.stagesById = indexById(this.data.stage);
+		this.groupsById = indexById(this.data.group);
+		this.roundsById = indexById(this.data.round);
+		this.matchesById = indexById(this.data.match);
+
+		this.groupsByStageId = groupByKey(
+			this.data.group,
+			(group) => group.stageId,
+		);
+		this.roundsByGroupId = groupByKey(
+			this.data.round,
+			(round) => round.groupId,
+		);
+		this.matchesByRoundId = groupByKey(
+			this.data.match,
+			(match) => match.roundId,
+		);
+	}
+
+	stageById(id: number): StageData | null {
+		return this.stagesById.get(id) ?? null;
+	}
+
+	groupById(id: number): GroupData | null {
+		return this.groupsById.get(id) ?? null;
+	}
+
+	roundById(id: number): RoundData | null {
+		return this.roundsById.get(id) ?? null;
+	}
+
+	matchById(id: number): MatchData | null {
+		return this.matchesById.get(id) ?? null;
+	}
+
+	groupByNumber(stageId: number, groupNumber: number): GroupData | null {
+		const groups = this.groupsByStageId.get(stageId);
+		return groups?.find((group) => group.number === groupNumber) ?? null;
+	}
+
+	roundByNumber(groupId: number, roundNumber: number): RoundData | null {
+		const rounds = this.roundsByGroupId.get(groupId);
+		return rounds?.find((round) => round.number === roundNumber) ?? null;
+	}
+
+	matchByNumber(roundId: number, matchNumber: number): MatchData | null {
+		const matches = this.matchesByRoundId.get(roundId);
+		return matches?.find((match) => match.number === matchNumber) ?? null;
+	}
+
+	roundCountInGroup(groupId: number): number {
+		return this.roundsByGroupId.get(groupId)?.length ?? 0;
+	}
+
+	matchCountInRound(roundId: number): number {
+		return this.matchesByRoundId.get(roundId)?.length ?? 0;
+	}
+
+	/** Records that a match row of this store was mutated. */
+	markMatchChanged(match: MatchData): void {
+		if (this.matchesById.get(match.id) !== match)
+			throw Error("Match is not a row of this store.");
+
+		this.changedMatchIds.add(match.id);
+	}
+
+	/** Returns the final version of every match row that was written during this operation. */
+	changedMatches(): MatchData[] {
+		return this.data.match.filter((match) =>
+			this.changedMatchIds.has(match.id),
+		);
+	}
+}
+
+function indexById<T extends { id: number }>(rows: T[]): Map<number, T> {
+	return new Map(rows.map((row) => [row.id, row]));
+}
+
+function groupByKey<T>(rows: T[], key: (row: T) => number): Map<number, T[]> {
+	const result = new Map<number, T[]>();
+
+	for (const row of rows) {
+		const existing = result.get(key(row));
+		if (existing) {
+			existing.push(row);
+		} else {
+			result.set(key(row), [row]);
+		}
+	}
+
+	return result;
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/traversal.ts b/app/features/tournament-bracket/core/engine/propagation/traversal.ts
new file mode 100644
index 000000000..13a1dc25a
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/traversal.ts
@@ -0,0 +1,612 @@
+import { matchStatus, winnerSideByScore } from "../status";
+import type {
+	GroupData,
+	GroupType,
+	MatchData,
+	MatchResultsInput,
+	Side,
+	StageData,
+	StageType,
+} from "../types";
+import type { SetNextOpponent } from "./helpers";
+import * as helpers from "./helpers";
+import type { Store } from "./store";
+
+interface RoundPositionalInfo {
+	roundNumber: number;
+	roundCount: number;
+}
+
+/**
+ * Resolves the matches following another match and applies result propagation
+ * to them. Port of the old base/getter.ts + base/updater.ts, mutating the rows
+ * of a Store instead of writing to storage.
+ */
+export class Propagator {
+	readonly store: Store;
+
+	constructor(store: Store) {
+		this.store = store;
+	}
+
+	/* ------------------------------------------------------------------ */
+	/* Updater (base/updater.ts)                                           */
+	/* ------------------------------------------------------------------ */
+
+	/**
+	 * Propagates the results of a match to the matches following it.
+	 *
+	 * @param match A match.
+	 */
+	updateRelatedMatches(match: MatchData): void {
+		const { roundNumber, roundCount } = this.getRoundPositionalInfo(
+			match.roundId,
+		);
+
+		const stage = this.store.stageById(match.stageId);
+		if (!stage) throw Error("Stage not found.");
+
+		const group = this.store.groupById(match.groupId);
+		if (!group) throw Error("Group not found.");
+
+		const matchLocation = helpers.getMatchLocation(stage.type, group.number);
+
+		this.updateNext(match, matchLocation, stage, roundNumber, roundCount);
+	}
+
+	/**
+	 * Updates a match based on a reported result.
+	 *
+	 * @param stored The match row of the store that is mutated.
+	 * @param input Input of the update.
+	 * @param force Whether to force update matches that can't be played yet.
+	 */
+	updateMatch(
+		stored: MatchData,
+		input: MatchResultsInput,
+		force?: boolean,
+	): void {
+		if (!force && matchStatus(this.store.data, stored.id) === "PENDING")
+			throw Error("The match is locked.");
+
+		const stage = this.store.stageById(stored.stageId);
+		if (!stage) throw Error("Stage not found.");
+
+		const resultChanged = helpers.setMatchResults(
+			stored,
+			input.scores,
+			input.winnerSide ?? this.winnerSideAfter(stored, input.scores),
+		);
+		this.store.markMatchChanged(stored);
+
+		// Don't propagate if it's a simple score update.
+		if (!resultChanged) return;
+
+		if (
+			stage.type === "single_elimination" ||
+			stage.type === "double_elimination"
+		) {
+			this.updateRelatedMatches(stored);
+		}
+	}
+
+	/**
+	 * The winner the scores decide once the input has been applied. `undefined`
+	 * when the set is not over or the round has no map count to decide it by
+	 * (a bracket created without map lists).
+	 */
+	private winnerSideAfter(
+		stored: MatchData,
+		scores: MatchResultsInput["scores"],
+	): Side | undefined {
+		const maps = this.store.roundById(stored.roundId)?.maps;
+		if (!maps) return undefined;
+
+		return winnerSideByScore({
+			scores: scoresAfter(stored, scores),
+			count: maps.count,
+			countType: maps.type,
+		});
+	}
+
+	/**
+	 * Updates the match(es) following the current match based on this match results.
+	 *
+	 * @param match Input of the update.
+	 * @param matchLocation Location of the current match.
+	 * @param stage The parent stage.
+	 * @param roundNumber Number of the round.
+	 * @param roundCount Count of rounds.
+	 */
+	private updateNext(
+		match: MatchData,
+		matchLocation: GroupType,
+		stage: StageData,
+		roundNumber: number,
+		roundCount: number,
+	): void {
+		const nextMatches = this.getNextMatches(
+			match,
+			matchLocation,
+			stage,
+			roundNumber,
+			roundCount,
+		);
+		if (nextMatches.length === 0) {
+			return;
+		}
+
+		const winnerSide = helpers.getMatchResult(match);
+
+		if (winnerSide)
+			this.applyToNextMatches(
+				helpers.setNextOpponent,
+				match,
+				matchLocation,
+				roundNumber,
+				roundCount,
+				nextMatches,
+				winnerSide,
+			);
+		else
+			this.applyToNextMatches(
+				helpers.resetNextOpponent,
+				match,
+				matchLocation,
+				roundNumber,
+				roundCount,
+				nextMatches,
+			);
+	}
+
+	/**
+	 * Applies a SetNextOpponent function to matches following the current match.
+	 *
+	 * @param setNextOpponent The SetNextOpponent function.
+	 * @param match The current match.
+	 * @param matchLocation Location of the current match.
+	 * @param roundNumber Number of the current round.
+	 * @param roundCount Count of rounds.
+	 * @param nextMatches The matches following the current match.
+	 * @param winnerSide Side of the winner in the current match.
+	 */
+	private applyToNextMatches(
+		setNextOpponent: SetNextOpponent,
+		match: MatchData,
+		matchLocation: GroupType,
+		roundNumber: number,
+		roundCount: number,
+		nextMatches: (MatchData | null)[],
+		winnerSide?: Side,
+	): void {
+		if (matchLocation === "final_group") {
+			if (!nextMatches[0]) throw Error("First next match is null.");
+			setNextOpponent(nextMatches[0], "opponent1", match, "opponent1");
+			setNextOpponent(nextMatches[0], "opponent2", match, "opponent2");
+			this.store.markMatchChanged(nextMatches[0]);
+			return;
+		}
+
+		const nextSide = helpers.getNextSide(
+			match.number,
+			roundNumber,
+			roundCount,
+			matchLocation,
+		);
+
+		if (nextMatches[0]) {
+			setNextOpponent(nextMatches[0], nextSide, match, winnerSide);
+			this.propagateByeWinners(nextMatches[0]);
+		}
+
+		if (nextMatches.length !== 2) return;
+		if (!nextMatches[1]) throw Error("Second next match is null.");
+
+		// The second match is either the consolation final (single elimination) or a loser bracket match (double elimination).
+
+		if (matchLocation === "single_bracket") {
+			setNextOpponent(
+				nextMatches[1],
+				nextSide,
+				match,
+				winnerSide && helpers.getOtherSide(winnerSide),
+			);
+			this.store.markMatchChanged(nextMatches[1]);
+		} else {
+			const nextSideLB = helpers.getNextSideLoserBracket(
+				match.number,
+				nextMatches[1],
+				roundNumber,
+			);
+			setNextOpponent(
+				nextMatches[1],
+				nextSideLB,
+				match,
+				winnerSide && helpers.getOtherSide(winnerSide),
+			);
+			this.propagateByeWinners(nextMatches[1]);
+		}
+	}
+
+	/**
+	 * Propagates winner against BYEs in related matches.
+	 *
+	 * @param match The current match.
+	 */
+	propagateByeWinners(match: MatchData): void {
+		helpers.resolveByeWinner(match); // BYE propagation is only in non round-robin stages.
+		this.store.markMatchChanged(match);
+
+		if (helpers.hasBye(match)) this.updateRelatedMatches(match);
+	}
+
+	/* ------------------------------------------------------------------ */
+	/* Getter (base/getter.ts)                                             */
+	/* ------------------------------------------------------------------ */
+
+	/**
+	 * Gets the positional information (number in group and total number of rounds in group) of a round based on its id.
+	 *
+	 * @param roundId ID of the round.
+	 */
+	getRoundPositionalInfo(roundId: number): RoundPositionalInfo {
+		const round = this.store.roundById(roundId);
+		if (!round) throw Error("Round not found.");
+
+		return {
+			roundNumber: round.number,
+			roundCount: this.store.roundCountInGroup(round.groupId),
+		};
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match will go just after.
+	 *
+	 * @param match The current match.
+	 * @param matchLocation Location of the current match.
+	 * @param stage The parent stage.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount Count of rounds.
+	 */
+	getNextMatches(
+		match: MatchData,
+		matchLocation: GroupType,
+		stage: StageData,
+		roundNumber: number,
+		roundCount: number,
+	): (MatchData | null)[] {
+		switch (matchLocation) {
+			case "single_bracket":
+				return this.getNextMatchesUpperBracket(
+					match,
+					stage.type,
+					roundNumber,
+					roundCount,
+				);
+			case "winner_bracket":
+				return this.getNextMatchesWB(match, stage, roundNumber, roundCount);
+			case "loser_bracket":
+				return this.getNextMatchesLB(
+					match,
+					stage.type,
+					roundNumber,
+					roundCount,
+				);
+			case "final_group":
+				return this.getNextMatchesFinal(match, roundNumber, roundCount);
+			default:
+				throw Error("Unknown bracket kind.");
+		}
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of winner bracket will go just after.
+	 *
+	 * @param match The current match.
+	 * @param stage The parent stage.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount Count of rounds.
+	 */
+	private getNextMatchesWB(
+		match: MatchData,
+		stage: StageData,
+		roundNumber: number,
+		roundCount: number,
+	): (MatchData | null)[] {
+		const loserBracket = this.getLoserBracket(match.stageId);
+		if (loserBracket === null)
+			// Only one match in the stage, there is no loser bracket.
+			return [];
+
+		const roundNumberLB = roundNumber > 1 ? (roundNumber - 1) * 2 : 1;
+
+		const participantCount = this.participantCount(match.stageId);
+		const method = helpers.getLoserOrdering(participantCount, roundNumberLB);
+		const actualMatchNumberLB = helpers.findLoserMatchNumber(
+			participantCount,
+			roundNumberLB,
+			match.number,
+			method,
+		);
+
+		return [
+			...this.getNextMatchesUpperBracket(
+				match,
+				stage.type,
+				roundNumber,
+				roundCount,
+			),
+			this.findMatch(loserBracket.id, roundNumberLB, actualMatchNumberLB),
+		];
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of an upper bracket will go just after.
+	 *
+	 * @param match The current match.
+	 * @param stageType Type of the stage.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount Count of rounds.
+	 */
+	private getNextMatchesUpperBracket(
+		match: MatchData,
+		stageType: StageType,
+		roundNumber: number,
+		roundCount: number,
+	): (MatchData | null)[] {
+		if (stageType === "single_elimination")
+			return this.getNextMatchesUpperBracketSingleElimination(
+				match,
+				stageType,
+				roundNumber,
+				roundCount,
+			);
+
+		if (stageType === "double_elimination" && roundNumber === roundCount)
+			return [this.getFirstMatchFinal(match, stageType)];
+
+		return [this.getDiagonalMatch(match.groupId, roundNumber, match.number)];
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of the unique bracket of a single elimination will go just after.
+	 *
+	 * @param match The current match.
+	 * @param stageType Type of the stage.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount Count of rounds.
+	 */
+	private getNextMatchesUpperBracketSingleElimination(
+		match: MatchData,
+		stageType: StageType,
+		roundNumber: number,
+		roundCount: number,
+	): MatchData[] {
+		if (roundNumber === roundCount - 1) {
+			const final = this.getFirstMatchFinal(match, stageType);
+			return [
+				this.getDiagonalMatch(match.groupId, roundNumber, match.number),
+				...(final ? [final] : []),
+			];
+		}
+
+		if (roundNumber === roundCount) return [];
+
+		return [this.getDiagonalMatch(match.groupId, roundNumber, match.number)];
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of loser bracket will go just after.
+	 *
+	 * @param match The current match.
+	 * @param stageType Type of the stage.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount Count of rounds.
+	 */
+	private getNextMatchesLB(
+		match: MatchData,
+		stageType: StageType,
+		roundNumber: number,
+		roundCount: number,
+	): MatchData[] {
+		if (roundNumber === roundCount) {
+			const final = this.getFirstMatchFinal(match, stageType);
+			return final ? [final] : [];
+		}
+
+		if (roundNumber % 2 === 1)
+			return this.getMatchAfterMajorRoundLB(match, roundNumber);
+
+		return this.getMatchAfterMinorRoundLB(match, roundNumber);
+	}
+
+	/**
+	 * Gets the first match of the final group (consolation final or grand final).
+	 *
+	 * @param match The current match.
+	 * @param stageType Type of the stage.
+	 */
+	private getFirstMatchFinal(
+		match: MatchData,
+		stageType: StageType,
+	): MatchData | null {
+		const finalGroupId = this.getFinalGroupId(match.stageId, stageType);
+		if (finalGroupId === null) return null;
+
+		return this.findMatch(finalGroupId, 1, 1);
+	}
+
+	/**
+	 * Gets the matches following the current match, which is in the final group (consolation final or grand final).
+	 *
+	 * @param match The current match.
+	 * @param roundNumber The number of the current round.
+	 * @param roundCount The count of rounds.
+	 */
+	private getNextMatchesFinal(
+		match: MatchData,
+		roundNumber: number,
+		roundCount: number,
+	): MatchData[] {
+		if (
+			roundNumber === roundCount ||
+			// avoid putting teams to bracket reset if tournament is over
+			match.winnerSide === "opponent1"
+		) {
+			return [];
+		}
+
+		return [this.findMatch(match.groupId, roundNumber + 1, 1)];
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of a winner bracket's major round will go just after.
+	 *
+	 * @param match The current match.
+	 * @param roundNumber The number of the current round.
+	 */
+	private getMatchAfterMajorRoundLB(
+		match: MatchData,
+		roundNumber: number,
+	): MatchData[] {
+		return [this.getParallelMatch(match.groupId, roundNumber, match.number)];
+	}
+
+	/**
+	 * Gets the match(es) where the opponents of the current match of a winner bracket's minor round will go just after.
+	 *
+	 * @param match The current match.
+	 * @param roundNumber The number of the current round.
+	 */
+	private getMatchAfterMinorRoundLB(
+		match: MatchData,
+		roundNumber: number,
+	): MatchData[] {
+		return [this.getDiagonalMatch(match.groupId, roundNumber, match.number)];
+	}
+
+	/**
+	 * Returns the id of the final group (consolation final or grand final).
+	 *
+	 * @param stageId ID of the stage.
+	 * @param stageType Type of the stage.
+	 */
+	private getFinalGroupId(
+		stageId: number,
+		stageType: StageType,
+	): number | null {
+		const groupNumber =
+			stageType === "single_elimination"
+				? 2 /* Consolation final */
+				: 3; /* Grand final */
+		const finalGroup = this.store.groupByNumber(stageId, groupNumber);
+		if (!finalGroup) return null;
+		return finalGroup.id;
+	}
+
+	/**
+	 * Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).
+	 *
+	 * @param stageId ID of the stage.
+	 */
+	private getUpperBracket(stageId: number): GroupData {
+		const winnerBracket = this.store.groupByNumber(stageId, 1);
+		if (!winnerBracket) throw Error("Winner bracket not found.");
+		return winnerBracket;
+	}
+
+	/**
+	 * Gets the participant count of an elimination stage, derived from its upper
+	 * bracket's first round (two participants per match, BYEs included).
+	 *
+	 * @param stageId ID of the stage.
+	 */
+	private participantCount(stageId: number): number {
+		const upperBracket = this.getUpperBracket(stageId);
+		const firstRound = this.store.roundByNumber(upperBracket.id, 1);
+		if (!firstRound) throw Error("First round not found.");
+
+		return this.store.matchCountInRound(firstRound.id) * 2;
+	}
+
+	/**
+	 * Gets the loser bracket.
+	 *
+	 * @param stageId ID of the stage.
+	 */
+	private getLoserBracket(stageId: number): GroupData | null {
+		return this.store.groupByNumber(stageId, 2);
+	}
+
+	/**
+	 * Gets the corresponding match in the next round ("diagonal match") the usual way.
+	 *
+	 * Just like from Round 1 to Round 2 in a single elimination stage.
+	 *
+	 * @param groupId ID of the group.
+	 * @param roundNumber Number of the round in its parent group.
+	 * @param matchNumber Number of the match in its parent round.
+	 */
+	private getDiagonalMatch(
+		groupId: number,
+		roundNumber: number,
+		matchNumber: number,
+	): MatchData {
+		return this.findMatch(
+			groupId,
+			roundNumber + 1,
+			helpers.getDiagonalMatchNumber(matchNumber),
+		);
+	}
+
+	/**
+	 * Gets the corresponding match in the next round ("parallel match") the "major round to minor round" way.
+	 *
+	 * Just like from Round 1 to Round 2 in the loser bracket of a double elimination stage.
+	 *
+	 * @param groupId ID of the group.
+	 * @param roundNumber Number of the round in its parent group.
+	 * @param matchNumber Number of the match in its parent round.
+	 */
+	private getParallelMatch(
+		groupId: number,
+		roundNumber: number,
+		matchNumber: number,
+	): MatchData {
+		return this.findMatch(groupId, roundNumber + 1, matchNumber);
+	}
+
+	/**
+	 * Finds a match in a given group. The match must have the given number in a round of which the number in group is given.
+	 *
+	 * @param groupId ID of the group.
+	 * @param roundNumber Number of the round in its parent group.
+	 * @param matchNumber Number of the match in its parent round.
+	 */
+	findMatch(
+		groupId: number,
+		roundNumber: number,
+		matchNumber: number,
+	): MatchData {
+		const round = this.store.roundByNumber(groupId, roundNumber);
+
+		if (!round) throw Error("Round not found.");
+
+		const match = this.store.matchByNumber(round.id, matchNumber);
+
+		if (!match) throw Error("Match not found.");
+
+		return match;
+	}
+}
+
+function scoresAfter(
+	stored: MatchData,
+	scores: MatchResultsInput["scores"],
+): [number, number] {
+	if (scores === undefined) {
+		return [stored.opponent1?.score ?? 0, stored.opponent2?.score ?? 0];
+	}
+
+	return scores ?? [0, 0];
+}
diff --git a/app/features/tournament-bracket/core/engine/propagation/update.test.ts b/app/features/tournament-bracket/core/engine/propagation/update.test.ts
new file mode 100644
index 000000000..4f8762c63
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/propagation/update.test.ts
@@ -0,0 +1,178 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { createResolved } from "../create";
+import * as Engine from "../index";
+import type { BracketData, ResolvedCreateBracketInput } from "../types";
+
+const EXAMPLE: ResolvedCreateBracketInput = {
+	type: "double_elimination",
+	seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+	settings: {},
+};
+
+describe("Update matches", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = createResolved(EXAMPLE);
+	});
+
+	test("should start a match", () => {
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED");
+
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [0, 0],
+		}).data;
+
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED");
+		expect(matchById(data, 0).opponent1?.score).toBe(0);
+	});
+
+	test("should update the scores for a match", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [2, 1],
+		}).data;
+
+		const after = matchById(data, 0);
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED");
+		expect(after.opponent1?.score).toBe(2);
+
+		// Id should stay. It shouldn't be overwritten.
+		expect(after.opponent1?.id).toBe(1);
+	});
+
+	test("should end the match by only setting the winner", () => {
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(Engine.matchStatus(data, 0)).toBe("COMPLETED");
+		expect(matchById(data, 0).winnerSide).toBe("opponent1");
+	});
+
+	test("should change the winner of the match and update in the next match", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(matchById(data, 8).opponent1?.id).toBe(1);
+
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent2",
+		}).data;
+
+		expect(Engine.matchStatus(data, 0)).toBe("COMPLETED");
+		expect(matchById(data, 0).winnerSide).toBe("opponent2");
+
+		expect(Engine.matchStatus(data, 8)).toBe("PENDING");
+		expect(matchById(data, 8).opponent1?.id).toBe(16);
+	});
+
+	test("should update the status of the next match", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(Engine.matchStatus(data, 8)).toBe("PENDING");
+
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			winnerSide: "opponent1",
+		}).data;
+
+		expect(Engine.matchStatus(data, 8)).toBe("STARTED");
+	});
+
+	test("should remove results from a match without score", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.resetMatchResults(data, 0).data;
+
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED");
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+	});
+
+	test("should remove results from a match with score", () => {
+		data = Engine.reportResult(data, {
+			matchId: 0,
+			scores: [16, 12],
+			winnerSide: "opponent1",
+		}).data;
+
+		data = Engine.resetMatchResults(data, 0).data;
+
+		expect(Engine.matchStatus(data, 0)).toBe("STARTED");
+		expect(matchById(data, 0).winnerSide).toBeFalsy();
+	});
+
+	test("should keep the scores as they are if none given", () => {
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			scores: [1, 0],
+		}).data;
+
+		data = Engine.reportResult(data, { matchId: 1 }).data;
+
+		const after = matchById(data, 1);
+		expect(Engine.matchStatus(data, 1)).toBe("STARTED");
+		expect(after.opponent1?.score).toBe(1);
+		expect(after.opponent2?.score).toBe(0);
+	});
+
+	test("should end the match by setting the winner and the scores", () => {
+		data = Engine.reportResult(data, {
+			matchId: 1,
+			scores: [6, 3],
+			winnerSide: "opponent2",
+		}).data;
+
+		const after = matchById(data, 1);
+		expect(Engine.matchStatus(data, 1)).toBe("COMPLETED");
+
+		expect(after.winnerSide).toBe("opponent2");
+		expect(after.opponent1?.score).toBe(6);
+		expect(after.opponent2?.score).toBe(3);
+	});
+});
+
+describe("Locked matches", () => {
+	let data: BracketData;
+
+	beforeEach(() => {
+		data = createResolved(EXAMPLE);
+	});
+
+	test("should throw when the matches leading to the match have not been completed yet", () => {
+		expect(() => Engine.reportResult(data, { matchId: 0 })).not.toThrow(); // No problem when no previous match.
+
+		expect(() => Engine.reportResult(data, { matchId: 8 })).toThrow(
+			"The match is locked.",
+		); // First match of WB Round 2.
+		expect(() => Engine.reportResult(data, { matchId: 15 })).toThrow(
+			"The match is locked.",
+		); // First match of LB Round 1.
+		expect(() => Engine.reportResult(data, { matchId: 19 })).toThrow(
+			"The match is locked.",
+		); // First match of LB Round 1.
+		expect(() => Engine.reportResult(data, { matchId: 23 })).toThrow(
+			"The match is locked.",
+		); // First match of LB Round 3.
+	});
+});
+
+function matchById(data: BracketData, id: number) {
+	const found = data.match.find((match) => match.id === id);
+	if (!found) throw new Error(`Match ${id} not found`);
+
+	return found;
+}
diff --git a/app/features/tournament-bracket/core/engine/status.test.ts b/app/features/tournament-bracket/core/engine/status.test.ts
new file mode 100644
index 000000000..71065c00e
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/status.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, test } from "vitest";
+import { matchEndedEarly } from "./status";
+
+describe("matchEndedEarly", () => {
+	test("returns false when no winner", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 1 },
+				opponentTwo: { score: 1 },
+				winnerSide: null,
+				count: 3,
+				countType: "BEST_OF",
+			}),
+		).toBe(false);
+	});
+
+	test("returns false when match completed normally (best of 3)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 2 },
+				opponentTwo: { score: 1 },
+				winnerSide: "opponent1",
+				count: 3,
+				countType: "BEST_OF",
+			}),
+		).toBe(false);
+	});
+
+	test("returns true when match ended early (best of 3)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 1 },
+				opponentTwo: { score: 0 },
+				winnerSide: "opponent1",
+				count: 3,
+				countType: "BEST_OF",
+			}),
+		).toBe(true);
+	});
+
+	test("returns true when match ended early (best of 5)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 2 },
+				opponentTwo: { score: 1 },
+				winnerSide: "opponent1",
+				count: 5,
+				countType: "BEST_OF",
+			}),
+		).toBe(true);
+	});
+
+	test("returns false when match completed normally (best of 5)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 3 },
+				opponentTwo: { score: 2 },
+				winnerSide: "opponent1",
+				count: 5,
+				countType: "BEST_OF",
+			}),
+		).toBe(false);
+	});
+
+	test("returns false when all maps played (play all)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 2 },
+				opponentTwo: { score: 1 },
+				winnerSide: "opponent1",
+				count: 3,
+				countType: "PLAY_ALL",
+			}),
+		).toBe(false);
+	});
+
+	test("returns true when not all maps played (play all)", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: { score: 2 },
+				opponentTwo: { score: 0 },
+				winnerSide: "opponent1",
+				count: 3,
+				countType: "PLAY_ALL",
+			}),
+		).toBe(true);
+	});
+
+	test("handles missing scores as 0", () => {
+		expect(
+			matchEndedEarly({
+				opponentOne: {},
+				opponentTwo: {},
+				winnerSide: "opponent1",
+				count: 3,
+				countType: "BEST_OF",
+			}),
+		).toBe(true);
+	});
+});
diff --git a/app/features/tournament-bracket/core/engine/status.ts b/app/features/tournament-bracket/core/engine/status.ts
new file mode 100644
index 000000000..9f46fe7f7
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/status.ts
@@ -0,0 +1,232 @@
+import * as R from "remeda";
+import type { TournamentRoundMaps } from "~/db/tables";
+import type {
+	BracketData,
+	MatchData,
+	MatchResults,
+	RoundData,
+	Side,
+} from "./types";
+
+/**
+ * The state of a match. Never persisted, always derived from the opponents of
+ * the match and (for round robin) the progress of the previous round.
+ *
+ * - `PENDING` an opponent is still unknown, the match is a BYE or the teams are
+ *   busy playing an earlier round.
+ * - `STARTED` the match can be played and might already be in progress.
+ * - `COMPLETED` the match has a winner.
+ */
+export type MatchStatus = "PENDING" | "STARTED" | "COMPLETED";
+
+/** Derives the status of every match of the bracket, keyed by match id. */
+export function matchStatuses(data: BracketData): Map<number, MatchStatus> {
+	const context = bracketContext(data);
+
+	return new Map(
+		data.match.map((match) => [match.id, resolveStatus(match, context)]),
+	);
+}
+
+/**
+ * Derives the status of one match of the bracket. Prefer {@link matchStatuses}
+ * when the status of many matches of the same bracket is needed.
+ */
+export function matchStatus(data: BracketData, matchId: number): MatchStatus {
+	const match = data.match.find((match) => match.id === matchId);
+	if (!match) throw new Error(`Match not found: ${matchId}`);
+
+	return resolveStatus(match, bracketContext(data));
+}
+
+/**
+ * Checks if a match has had at least one game reported.
+ *
+ * @param match A match's results.
+ */
+export function isMatchStarted(match: MatchResults): boolean {
+	return (
+		match.opponent1?.score !== undefined || match.opponent2?.score !== undefined
+	);
+}
+
+/**
+ * Checks if a match is completed.
+ *
+ * @param match A match's results.
+ */
+export function isMatchCompleted(match: MatchResults): boolean {
+	return isMatchByeCompleted(match) || Boolean(match.winnerSide);
+}
+
+/**
+ * Checks if a match is completed because of at least one BYE.
+ *
+ * A match "BYE vs. TBD" isn't considered completed yet.
+ *
+ * @param match A match's results.
+ */
+export function isMatchByeCompleted(match: MatchResults): boolean {
+	return (
+		(match.opponent1 === null && match.opponent2?.id !== null) || // BYE vs. someone
+		(match.opponent2 === null && match.opponent1?.id !== null) || // someone vs. BYE
+		(match.opponent1 === null && match.opponent2 === null)
+	); // BYE vs. BYE
+}
+
+/** Whether a set is decided given the games each side has won and the round's count settings. */
+export function isSetOverByScore({
+	scores,
+	count,
+	countType,
+}: {
+	scores: [number, number];
+	count: number;
+	countType: TournamentRoundMaps["type"];
+}) {
+	if (countType === "PLAY_ALL") {
+		return R.sum(scores) === count;
+	}
+
+	const matchOverAtXWins = Math.ceil(count / 2);
+	return scores[0] === matchOverAtXWins || scores[1] === matchOverAtXWins;
+}
+
+/**
+ * The side the scores decide as the winner of the set, `undefined` while the
+ * set is not over yet (or a play all set ended in a tie).
+ */
+export function winnerSideByScore(args: {
+	scores: [number, number];
+	count: number;
+	countType: TournamentRoundMaps["type"];
+}): Side | undefined {
+	if (!isSetOverByScore(args)) return undefined;
+
+	const [scoreOne, scoreTwo] = args.scores;
+	if (scoreOne > scoreTwo) return "opponent1";
+	if (scoreTwo > scoreOne) return "opponent2";
+
+	return undefined;
+}
+
+/** Whether a completed match was ended before the set was decided by the games played (e.g. by an organizer force-ending it). */
+export function matchEndedEarly({
+	opponentOne,
+	opponentTwo,
+	winnerSide,
+	count,
+	countType,
+}: {
+	opponentOne: { score?: number } | null;
+	opponentTwo: { score?: number } | null;
+	winnerSide: Side | null;
+	count: number;
+	countType: TournamentRoundMaps["type"];
+}) {
+	if (!winnerSide) return false;
+
+	const scores: [number, number] = [
+		opponentOne?.score ?? 0,
+		opponentTwo?.score ?? 0,
+	];
+
+	return !isSetOverByScore({ scores, count, countType });
+}
+
+interface BracketContext {
+	roundsById: Map<number, RoundData>;
+	roundByGroupAndNumber: Map<string, RoundData>;
+	matchesByRoundId: Map<number, MatchData[]>;
+	hasDependentRoundsByStageId: Map<number, boolean>;
+}
+
+function resolveStatus(match: MatchData, context: BracketContext): MatchStatus {
+	if (isMatchCompleted(match)) return "COMPLETED";
+
+	if (!match.opponent1?.id || !match.opponent2?.id) return "PENDING";
+
+	// a match that is being played can't go back to pending e.g. because the
+	// result of an earlier match was reopened (issue #2690)
+	if (isMatchStarted(match)) return "STARTED";
+
+	if (isWaitingForPreviousRound(match, context)) return "PENDING";
+
+	return "STARTED";
+}
+
+/**
+ * In a round robin where the rounds are not independent both opponents are
+ * known from the start but they can only play once they are done with the
+ * previous round.
+ */
+function isWaitingForPreviousRound(
+	match: MatchData,
+	context: BracketContext,
+): boolean {
+	if (!context.hasDependentRoundsByStageId.get(match.stageId)) return false;
+
+	const round = context.roundsById.get(match.roundId);
+	if (!round || round.number === 1) return false;
+
+	const previousRound = context.roundByGroupAndNumber.get(
+		roundKey(round.groupId, round.number - 1),
+	);
+	if (!previousRound) return false;
+
+	const previousMatches = context.matchesByRoundId.get(previousRound.id) ?? [];
+
+	return [match.opponent1?.id, match.opponent2?.id].some(
+		(opponentId) =>
+			opponentId && !hasFinishedRound(opponentId, previousMatches),
+	);
+}
+
+function hasFinishedRound(opponentId: number, roundMatches: MatchData[]) {
+	const match = roundMatches.find(
+		(match) =>
+			match.opponent1?.id === opponentId || match.opponent2?.id === opponentId,
+	);
+
+	// no match in the round = they sat the round out
+	if (!match) return true;
+
+	return isMatchCompleted(match);
+}
+
+function bracketContext(data: BracketData): BracketContext {
+	const roundsById = new Map<number, RoundData>();
+	const roundByGroupAndNumber = new Map<string, RoundData>();
+	for (const round of data.round) {
+		roundsById.set(round.id, round);
+		roundByGroupAndNumber.set(roundKey(round.groupId, round.number), round);
+	}
+
+	const matchesByRoundId = new Map<number, MatchData[]>();
+	for (const match of data.match) {
+		const matches = matchesByRoundId.get(match.roundId);
+		if (matches) {
+			matches.push(match);
+		} else {
+			matchesByRoundId.set(match.roundId, [match]);
+		}
+	}
+
+	const hasDependentRoundsByStageId = new Map(
+		data.stage.map((stage) => [
+			stage.id,
+			stage.type === "round_robin" && !stage.settings.independentRounds,
+		]),
+	);
+
+	return {
+		roundsById,
+		roundByGroupAndNumber,
+		matchesByRoundId,
+		hasDependentRoundsByStageId,
+	};
+}
+
+function roundKey(groupId: number, roundNumber: number) {
+	return `${groupId}-${roundNumber}`;
+}
diff --git a/app/features/tournament-bracket/core/engine/swiss/pairing.ts b/app/features/tournament-bracket/core/engine/swiss/pairing.ts
new file mode 100644
index 000000000..0749b9049
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/swiss/pairing.ts
@@ -0,0 +1,295 @@
+import blossom from "edmonds-blossom-fixed";
+import { err, ok, type Result } from "neverthrow";
+import * as R from "remeda";
+import invariant from "~/utils/invariant";
+import { swissRoundCount } from "../create/settings";
+import type {
+	BracketData,
+	GeneratedRound,
+	MatchData,
+	SwissStanding,
+} from "../types";
+import { calculateTeamStatus } from "./team-status";
+
+/**
+ * Generates the next round of matchups for a Swiss tournament bracket within a specific group.
+ *
+ * Considers only the matches and teams within the specified group. Teams that have dropped out are excluded from the pairing process.
+ * If the group has an uneven number of teams, the lowest standing team that has not already received a bye is preferred to receive one.
+ * Matches are generated such that teams do not replay previous opponents if possible.
+ */
+export function generateRound(
+	data: BracketData,
+	args: {
+		groupId: number;
+		standings: SwissStanding[];
+		settings: { advanceThreshold?: number } | null;
+	},
+): Result<GeneratedRound, string> {
+	// lets consider only this groups matches
+	// in the case that there are more than one group
+	const groupsMatches = data.match.filter((m) => m.groupId === args.groupId);
+
+	if (groupsMatches.length === 0) return err("No matches found for group");
+	if (data.stage[0]?.type !== "swiss") return err("Bracket is not Swiss type");
+
+	// new matches can't be generated till old are over
+	if (!everyMatchOver(groupsMatches)) {
+		return err("Not all matches are over");
+	}
+
+	const groupsTeams = groupsMatches
+		.flatMap((match) => [match.opponent1, match.opponent2])
+		.filter(Boolean);
+	const groupsStandings = args.standings.filter((standing) => {
+		return groupsTeams.some((team) => team?.id === standing.team.id);
+	});
+
+	// teams who have dropped out are not considered
+	let standingsWithoutDropouts = groupsStandings.filter(
+		(s) => !s.team.droppedOut,
+	);
+
+	// filter out teams that have advanced or been eliminated if early advance/elimination is enabled
+	if (typeof args.settings?.advanceThreshold === "number") {
+		const roundCount = swissRoundCount(data);
+		const advanceThreshold = args.settings.advanceThreshold;
+
+		standingsWithoutDropouts = standingsWithoutDropouts.filter((standing) => {
+			const wins = standing.stats?.setWins ?? 0;
+			const losses = standing.stats?.setLosses ?? 0;
+			const status = calculateTeamStatus({
+				wins,
+				losses,
+				advanceThreshold,
+				roundCount,
+			});
+
+			return status === "active";
+		});
+	}
+
+	// if there are fewer than 2 active teams, no more matches can be generated
+	if (standingsWithoutDropouts.length < 2) {
+		return err("Not enough active teams to generate matches");
+	}
+
+	const teamsThatHaveHadByes = groupsMatches
+		.filter((m) => m.opponent2 === null)
+		.map((m) => m.opponent1?.id);
+
+	const pairs = pairUp(
+		standingsWithoutDropouts.map((standing) => ({
+			id: standing.team.id,
+			score: standing.stats?.setWins ?? 0,
+			receivedBye: teamsThatHaveHadByes.includes(standing.team.id),
+			avoid: groupsMatches.flatMap((match) => {
+				if (match.opponent1?.id === standing.team.id) {
+					return match.opponent2?.id ? [match.opponent2.id] : [];
+				}
+				if (match.opponent2?.id === standing.team.id) {
+					return match.opponent1?.id ? [match.opponent1.id] : [];
+				}
+				return [];
+			}),
+		})),
+	);
+
+	let matchNumber = 1;
+	const newRoundId = data.round
+		.slice()
+		.sort((a, b) => a.id - b.id)
+		.filter((r) => r.groupId === args.groupId)
+		.find(
+			(r) => r.id > Math.max(...groupsMatches.map((match) => match.roundId)),
+		)?.id;
+	invariant(newRoundId, "newRoundId not found");
+
+	return ok({
+		groupId: args.groupId,
+		roundId: newRoundId,
+		matches: pairs.map(({ opponentOne, opponentTwo }) => ({
+			number: matchNumber++,
+			opponent1: { id: opponentOne },
+			opponent2: typeof opponentTwo === "number" ? { id: opponentTwo } : null,
+		})),
+	});
+}
+
+function everyMatchOver(matches: MatchData[]) {
+	for (const match of matches) {
+		// bye
+		if (!match.opponent1 || !match.opponent2) continue;
+
+		if (!match.winnerSide) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+interface SwissPairingTeam {
+	id: number;
+	/** How many matches has the team won */
+	score: number;
+	/** List of tournament team ids this team already played */
+	avoid: Array<number>;
+	receivedBye?: boolean;
+}
+
+/**
+ * Pairs up teams for a swiss round using maximum weighted matching, avoiding
+ * rematches if possible and preferring teams with equal scores to play each other.
+ *
+ * Adapted from https://github.com/slashinfty/tournament-pairings
+ */
+export function pairUp(players: SwissPairingTeam[]) {
+	if (players.length < 2) {
+		throw new Error("Need at least two players to pair up");
+	}
+	if (players.length === 2) {
+		return [{ opponentOne: players[0].id, opponentTwo: players[1].id }];
+	}
+
+	// uncomment to add a new test case to PAIR_UP_TEST_CASES
+	// console.log(players);
+
+	const matches = [];
+	const playerArray = R.shuffle(players).map((p, i) => ({ ...p, index: i }));
+	const scoreGroups = [...new Set(playerArray.map((p) => p.score))].sort(
+		(a, b) => a - b,
+	);
+	const scoreSums = [
+		...new Set(
+			scoreGroups.flatMap((s, i, a) => {
+				const sums = [];
+				for (let j = i; j < a.length; j++) {
+					sums.push(s + a[j]);
+				}
+				return sums;
+			}),
+		),
+	].sort((a, b) => a - b);
+
+	let pairs = generateWeightedPairs({ playerArray, scoreGroups, scoreSums });
+	if (pairs.length === 0) {
+		// no possible pairs without rematches, try again allowing rematches
+		pairs = generateWeightedPairs({
+			playerArray,
+			scoreGroups,
+			scoreSums,
+			considerAvoid: false,
+		});
+	}
+
+	const blossomPairs = blossom(pairs, true);
+	const playerCopy = [...playerArray];
+	let byeArray = [];
+	do {
+		const indexA = playerCopy[0].index;
+		const indexB = blossomPairs[indexA];
+		if (indexB === -1) {
+			byeArray.push(playerCopy.splice(0, 1)[0]);
+			continue;
+		}
+		playerCopy.splice(0, 1);
+		playerCopy.splice(
+			playerCopy.findIndex((p) => p.index === indexB),
+			1,
+		);
+		const playerA = playerArray.find((p) => p.index === indexA);
+		const playerB = playerArray.find((p) => p.index === indexB);
+		invariant(playerA, "Player A not found");
+		invariant(playerB, "Player B not found");
+
+		matches.push({
+			opponentOne: playerA.id,
+			opponentTwo: playerB.id,
+		});
+	} while (
+		playerCopy.length >
+		blossomPairs.reduce(
+			(sum: number, idx: number) => (idx === -1 ? sum + 1 : sum),
+			0,
+		)
+	);
+	byeArray = [...byeArray, ...playerCopy];
+	for (let i = 0; i < byeArray.length; i++) {
+		matches.push({
+			opponentOne: byeArray[i].id,
+			opponentTwo: null,
+		});
+	}
+
+	return matches;
+}
+
+function generateWeightedPairs({
+	playerArray,
+	scoreGroups,
+	scoreSums,
+	considerAvoid = true,
+}: {
+	playerArray: (SwissPairingTeam & { index: number })[];
+	scoreGroups: number[];
+	scoreSums: number[];
+	considerAvoid?: boolean;
+}) {
+	const pairs: [number, number, number][] = [];
+	for (let i = 0; i < playerArray.length; i++) {
+		const curr = playerArray[i];
+		const next = playerArray.slice(i + 1);
+		for (let j = 0; j < next.length; j++) {
+			const opp = next[j];
+			if (
+				considerAvoid &&
+				Object.hasOwn(curr, "avoid") &&
+				curr.avoid.includes(opp.id)
+			) {
+				continue;
+			}
+			let wt =
+				75 - 75 / (scoreGroups.indexOf(Math.min(curr.score, opp.score)) + 2);
+			wt +=
+				5 - 5 / (scoreSums.findIndex((s) => s === curr.score + opp.score) + 1);
+			const scoreGroupDiff = Math.abs(
+				scoreGroups.indexOf(curr.score) - scoreGroups.indexOf(opp.score),
+			);
+
+			// TODO: consider "pairedUpDown"
+			// if (
+			// 	scoreGroupDiff === 1 &&
+			// 	curr.hasOwnProperty("pairedUpDown") &&
+			// 	curr.pairedUpDown === false &&
+			// 	opp.hasOwnProperty("pairedUpDown") &&
+			// 	opp.pairedUpDown === false
+			// ) {
+			// 	scoreGroupDiff -= 0.65;
+			// } else if (
+			// 	scoreGroupDiff > 0 &&
+			// 	((curr.hasOwnProperty("pairedUpDown") && curr.pairedUpDown === true) ||
+			// 		(opp.hasOwnProperty("pairedUpDown") && opp.pairedUpDown === true))
+			// ) {
+			// 	scoreGroupDiff += 0.2;
+			// }
+
+			wt += 23 / (2 * (scoreGroupDiff + 2));
+
+			// Lower weight for larger score differences, we really want to avoid 2-0 playing 0-2 etc.
+			if (scoreGroupDiff >= 2) {
+				wt -= 10;
+			}
+
+			if (
+				(Object.hasOwn(curr, "receivedBye") && curr.receivedBye) ||
+				(Object.hasOwn(opp, "receivedBye") && opp.receivedBye)
+			) {
+				wt += 40;
+			}
+			pairs.push([curr.index, opp.index, wt]);
+		}
+	}
+
+	return pairs;
+}
diff --git a/app/features/tournament-bracket/core/engine/swiss/team-status.ts b/app/features/tournament-bracket/core/engine/swiss/team-status.ts
new file mode 100644
index 000000000..d5062930c
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/swiss/team-status.ts
@@ -0,0 +1,94 @@
+export type SwissTeamStatus = "active" | "advanced" | "eliminated";
+
+/**
+ * Calculates whether a team should advance, be eliminated, or remain active
+ * in a Swiss tournament with early advance/elimination rules.
+ *
+ * @returns The team's status: "advanced" if they've secured advancement,
+ *          "eliminated" if they can no longer mathematically advance, or "active" if still competing
+ *
+ * @example
+ * // In a 5-round Swiss where teams need 3 wins to advance:
+ * calculateTeamStatus({ wins: 3, losses: 1, advanceThreshold: 3, roundCount: 5 }) // "advanced"
+ * calculateTeamStatus({ wins: 2, losses: 3, advanceThreshold: 3, roundCount: 5 }) // "eliminated"
+ * calculateTeamStatus({ wins: 2, losses: 2, advanceThreshold: 3, roundCount: 5 }) // "active"
+ */
+export function calculateTeamStatus({
+	wins,
+	losses,
+	advanceThreshold,
+	roundCount,
+}: {
+	/** Number of matches the team has won */
+	wins: number;
+	/** Number of matches the team has lost */
+	losses: number;
+	/** Number of wins required to advance to the next stage */
+	advanceThreshold: number;
+	/** Total number of rounds in the Swiss stage */
+	roundCount: number;
+}): SwissTeamStatus {
+	if (wins >= advanceThreshold) {
+		return "advanced";
+	}
+
+	if (losses >= eliminationThreshold({ roundCount, advanceThreshold })) {
+		return "eliminated";
+	}
+
+	return "active";
+}
+
+/**
+ * Calculates the maximum valid advance threshold for a given round count.
+ * The threshold must allow for meaningful play - teams need a chance to both advance and be eliminated.
+ */
+export function maxAdvanceThreshold({ roundCount }: { roundCount: number }) {
+	return Math.ceil(roundCount / 2) + 1;
+}
+
+/**
+ * Calculates the maximum losses allowed before elimination given an advance threshold and round count.
+ */
+export function eliminationThreshold({
+	roundCount,
+	advanceThreshold,
+}: {
+	roundCount: number;
+	advanceThreshold: number;
+}) {
+	return roundCount - advanceThreshold + 1;
+}
+
+/**
+ * Validates if an advance threshold is valid for the given round count.
+ */
+export function isValidAdvanceThreshold({
+	roundCount,
+	advanceThreshold,
+}: {
+	roundCount: number;
+	advanceThreshold: number;
+}) {
+	return validAdvanceThresholdOptions({ roundCount }).includes(
+		advanceThreshold,
+	);
+}
+
+/**
+ * Returns a list of valid advance threshold options for a given round count.
+ * Starts from 2 wins minimum up to the calculated maximum.
+ */
+export function validAdvanceThresholdOptions({
+	roundCount,
+}: {
+	roundCount: number;
+}) {
+	const result: number[] = [];
+
+	for (let i = 2; i <= maxAdvanceThreshold({ roundCount }); i++) {
+		result.push(i);
+	}
+
+	return result;
+}
diff --git a/app/features/tournament-bracket/core/engine/types.ts b/app/features/tournament-bracket/core/engine/types.ts
new file mode 100644
index 000000000..1d1adb975
--- /dev/null
+++ b/app/features/tournament-bracket/core/engine/types.ts
@@ -0,0 +1,278 @@
+import type {
+	Tables,
+	TournamentRoundMaps,
+	TournamentStageSettings,
+} from "~/db/tables";
+
+/**
+ * The side of an opponent. Upstream brackets-model also allowed a draw —
+ * intentionally dropped, draws are impossible in our formats.
+ */
+export type Side = "opponent1" | "opponent2";
+
+export type StageType = Tables["TournamentStage"]["type"];
+
+/**
+ * All the possible types of group in an elimination stage.
+ *
+ * - `single_bracket` for single elimination.
+ * - `winner_bracket` and `loser_bracket` for double elimination.
+ * - `final_group` for both single and double elimination.
+ */
+export type GroupType =
+	| "single_bracket"
+	| "winner_bracket"
+	| "loser_bracket"
+	| "final_group";
+
+export type SeedOrdering =
+	| "natural"
+	| "reverse"
+	| "half_shift"
+	| "reverse_half_shift"
+	| "pair_flip"
+	| "space_between"
+	| "groups.seed_optimized";
+
+/** The seeding for a stage. Each element is a participant id or a BYE: `null`. */
+export type Seeding = (number | null)[];
+
+/**
+ * The possible settings for a stage. Same shape as what is persisted in
+ * TournamentStage.settings today (the old brackets-model StageSettings).
+ */
+export interface StageSettings {
+	/** Number of groups in a round robin or swiss stage. */
+	groupCount?: number;
+
+	/** Number of rounds in a swiss stage. */
+	roundCount?: number;
+
+	/**
+	 * Whether to generate a bipartite round-robin where teams are split into two
+	 * A/B divisions and every match pairs one A team with one B team.
+	 */
+	hasAbDivisions?: boolean;
+
+	/**
+	 * Whether matches in a round-robin stage are playable independently of each other.
+	 *
+	 * - If `false` (default), only round 1 matches start `Ready`; later rounds start
+	 *   `Locked` and unlock as both opponents complete the previous round.
+	 * - If `true`, every match with two opponents starts `Ready`.
+	 */
+	independentRounds?: boolean;
+
+	/** Optional final between semi-final losers. */
+	consolationFinal?: boolean;
+}
+
+export interface ParticipantResult {
+	/** `null` = to be determined (source match unfinished). */
+	id: number | null;
+
+	/** Seed position this slot was filled from. */
+	position?: number;
+
+	/** The current score of the participant. */
+	score?: number;
+
+	/**
+	 * KO win count this set, aggregated on hydrate. Upstream's totalPoints is
+	 * intentionally gone — scoring is KO-only.
+	 */
+	totalKos?: number;
+}
+
+/* ------------------------------------------------------------------ */
+/* Bracket data — identical shape to the old BracketData  */
+/* ------------------------------------------------------------------ */
+
+export interface StageData {
+	id: number;
+	/** Only set on stages read from the database, the engine does not create names. */
+	name?: string;
+	type: StageType;
+	settings: StageSettings;
+	number: number;
+	createdAt?: number | null;
+}
+
+export interface GroupData {
+	id: number;
+	stageId: number;
+	number: number;
+}
+
+export interface RoundData {
+	id: number;
+	stageId: number;
+	groupId: number;
+	number: number;
+	maps?: TournamentRoundMaps | null;
+}
+
+export interface MatchResults {
+	opponent1: ParticipantResult | null;
+	opponent2: ParticipantResult | null;
+
+	/**
+	 * The side that won the set, `null` while the match has no winner. A match
+	 * won against a BYE gets it set once the BYE is propagated.
+	 */
+	winnerSide: Side | null;
+}
+
+export interface MatchData extends MatchResults {
+	id: number;
+	stageId: number;
+	groupId: number;
+	roundId: number;
+	number: number;
+	startedAt?: number | null;
+}
+
+/**
+ * The whole state of one tournament's brackets. This is the single value the
+ * engine reads and returns. Never mutated in place — every engine operation
+ * returns a new BracketData.
+ */
+export interface BracketData {
+	stage: StageData[];
+	group: GroupData[];
+	round: RoundData[];
+	match: MatchData[];
+}
+
+/* ------------------------------------------------------------------ */
+/* Engine internals                                                    */
+/* ------------------------------------------------------------------ */
+
+/** Used by the engine to handle placements. Is `null` if is a BYE. Has a `null` id if it's yet to be determined. */
+export type ParticipantSlot = { id: number | null; position?: number } | null;
+
+/** The engine only handles duels. It's one participant versus another participant. */
+export type Duel = [ParticipantSlot, ParticipantSlot];
+
+/** Type of an object implementing every ordering method. */
+export type OrderingMap = Record<
+	SeedOrdering,
+	<T>(array: T[], ...args: number[]) => T[]
+>;
+
+/** Contains the losers and the winner of a standard bracket. */
+export interface StandardBracketResults {
+	/** The list of losers for each round of the bracket. */
+	losers: ParticipantSlot[][];
+
+	/** The winner of the bracket. */
+	winner: ParticipantSlot;
+}
+
+/* ------------------------------------------------------------------ */
+/* Engine inputs                                                       */
+/* ------------------------------------------------------------------ */
+
+export interface CreateBracketInput {
+	type: StageType;
+	/** Team ids in seed order; `null` = BYE. */
+	seeding: Seeding;
+	/** User-selected settings; the engine derives its internal stage settings (defaults, group counts, seed ordering) from these. */
+	settings: TournamentStageSettings | null;
+	/** (Round robin only) Whether matches are playable independently of rounds (league divisions). */
+	independentRounds?: boolean;
+	/** Parallel to seeding; required when settings.hasAbDivisions. 0 = A, 1 = B. */
+	abDivisions?: (0 | 1)[];
+	/** Stage number within the tournament. Defaults to 1 (local data; the repository assigns the real number on insert). */
+	number?: number;
+	/**
+	 * Per-round map info to assign onto the created rounds, keyed by the local
+	 * round ids of an identically created bracket (the preview the maps were
+	 * picked against). For round robin and swiss one entry per distinct round
+	 * number — groups share map lists.
+	 */
+	maps?: RoundMapsInput[];
+}
+
+/** One round's map info as picked by the organizer against a bracket preview. */
+export type RoundMapsInput = TournamentRoundMaps & {
+	roundId: number;
+	groupId?: number;
+};
+
+/**
+ * Engine-internal variant of {@link CreateBracketInput}: settings are the
+ * already-resolved internal {@link StageSettings}.
+ */
+export interface ResolvedCreateBracketInput
+	extends Omit<CreateBracketInput, "settings" | "independentRounds"> {
+	settings: StageSettings;
+}
+
+/**
+ * A result to apply to a match. The opponents of a match are decided by the
+ * bracket, never by a reported result, so only the scores and the winner can be
+ * given.
+ */
+export interface MatchResultsInput {
+	/**
+	 * Games won by each side. Leaving it out keeps the current scores, `null`
+	 * clears them.
+	 */
+	scores?: [number, number] | null;
+	/**
+	 * Ends the set with this side as the winner even when the scores don't
+	 * decide it (an organizer force-ending a set, a team dropping out). Leaving
+	 * it out resolves the winner from the scores and the round's map count.
+	 */
+	winnerSide?: Side;
+}
+
+/** A {@link MatchResultsInput} targeted at one match of the bracket. */
+export interface ReportResultInput extends MatchResultsInput {
+	matchId: number;
+}
+
+/** The subset of a standing the swiss round generation needs. */
+export interface SwissStanding {
+	team: {
+		id: number;
+		/** Truthy when the team has dropped out (DB stores 0/1). */
+		droppedOut?: number | boolean;
+	};
+	stats?: {
+		setWins: number;
+		setLosses: number;
+	};
+}
+
+/* ------------------------------------------------------------------ */
+/* Engine outputs                                                      */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Every engine mutation returns the full next state plus the delta. The
+ * repository persists ONLY the delta; the state is for the caller to keep
+ * working with (chained operations, simulations, revalidation payloads).
+ */
+export interface EngineResult {
+	data: BracketData;
+	/** Matches whose row must be UPDATEd (opponents changed). */
+	changedMatches: MatchData[];
+}
+
+/** Matches to INSERT when a new round is generated (swiss). */
+export interface GeneratedRound {
+	groupId: number;
+	roundId: number;
+	matches: Array<{
+		number: number;
+		opponent1: ParticipantResult | null;
+		/** null opponent = BYE */
+		opponent2: ParticipantResult | null;
+	}>;
+}
+
+export interface DroppedTeamsResult extends EngineResult {
+	endedMatchIds: number[];
+}
diff --git a/app/features/tournament-bracket/core/rounds.ts b/app/features/tournament-bracket/core/rounds.ts
index c7ed696b9..d708da2db 100644
--- a/app/features/tournament-bracket/core/rounds.ts
+++ b/app/features/tournament-bracket/core/rounds.ts
@@ -1,9 +1,9 @@
 import * as R from "remeda";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import { TOURNAMENT } from "../../tournament/tournament-constants";
 
 export function getRounds(args: {
-	bracketData: TournamentManagerDataSet;
+	bracketData: BracketData;
 	type: "winners" | "losers" | "single";
 }) {
 	const groupIds = args.bracketData.group.flatMap((group) => {
@@ -17,8 +17,8 @@ export function getRounds(args: {
 	const rounds = args.bracketData.round
 		.flatMap((round) => {
 			if (
-				typeof round.group_id === "number" &&
-				!groupIds.includes(round.group_id)
+				typeof round.groupId === "number" &&
+				!groupIds.includes(round.groupId)
 			) {
 				return [];
 			}
@@ -30,17 +30,17 @@ export function getRounds(args: {
 			const grandFinalsMatch =
 				args.type === "winners"
 					? args.bracketData.match.find(
-							(match) => match.round_id === rounds[rounds.length - 2]?.id,
+							(match) => match.roundId === rounds[rounds.length - 2]?.id,
 						)
 					: undefined;
 
-			if (isBracketReset && grandFinalsMatch?.opponent1?.result === "win") {
+			if (isBracketReset && grandFinalsMatch?.winnerSide === "opponent1") {
 				showingBracketReset = false;
 				return false;
 			}
 
 			const matches = args.bracketData.match.filter(
-				(match) => match.round_id === round.id,
+				(match) => match.roundId === round.id,
 			);
 
 			const atLeastOneNonByeMatch = matches.some(
@@ -52,7 +52,7 @@ export function getRounds(args: {
 
 	const hasThirdPlaceMatch =
 		args.type === "single" &&
-		R.unique(args.bracketData.match.map((m) => m.group_id)).length > 1;
+		R.unique(args.bracketData.match.map((m) => m.groupId)).length > 1;
 	const namedRounds = rounds.map((round, i) => {
 		const name = () => {
 			if (
diff --git a/app/features/tournament-bracket/core/summarizer.server.ts b/app/features/tournament-bracket/core/summarizer.server.ts
index 46dd1a3f1..5960bbed6 100644
--- a/app/features/tournament-bracket/core/summarizer.server.ts
+++ b/app/features/tournament-bracket/core/summarizer.server.ts
@@ -9,12 +9,12 @@ import {
 } from "~/features/mmr/mmr-utils";
 import { getBracketProgressionLabel } from "~/features/tournament/tournament-utils";
 import type { AllMatchResult } from "~/features/tournament-match/TournamentMatchRepository.server";
-import { matchEndedEarly } from "~/features/tournament-match/tournament-match-utils";
 import invariant from "~/utils/invariant";
 import { roundToNDecimalPlaces } from "~/utils/number";
 import type { Tables, WinLossParticipationArray } from "../../../db/tables";
 import { ensureOneStandingPerUser } from "../tournament-bracket-utils";
 import type { Standing } from "./Bracket";
+import { matchEndedEarly } from "./engine";
 import type { ParsedBracket } from "./Progression";
 import * as Progression from "./Progression";
 
@@ -76,6 +76,7 @@ export function tournamentSummary({
 		const endedEarly = matchEndedEarly({
 			opponentOne: match.opponentOne,
 			opponentTwo: match.opponentTwo,
+			winnerSide: match.winnerSide,
 			count: match.roundMaps.count,
 			countType: match.roundMaps.type,
 		});
@@ -209,9 +210,9 @@ function calculateIndividualPlayerSkills({
  */
 function matchToSetMostPlayedUsers(match: AllMatchResult) {
 	const winner =
-		match.opponentOne.result === "win" ? match.opponentOne : match.opponentTwo;
+		match.winnerSide === "opponent1" ? match.opponentOne : match.opponentTwo;
 	const loser =
-		match.opponentOne.result === "win" ? match.opponentTwo : match.opponentOne;
+		match.winnerSide === "opponent1" ? match.opponentTwo : match.opponentOne;
 
 	// Handle dropped team sets without game results - use active roster or member list
 	if (match.maps.length === 0) {
@@ -285,13 +286,9 @@ function calculateTeamSkills({
 
 	for (const match of results) {
 		const winner =
-			match.opponentOne.result === "win"
-				? match.opponentOne
-				: match.opponentTwo;
+			match.winnerSide === "opponent1" ? match.opponentOne : match.opponentTwo;
 		const loser =
-			match.opponentOne.result === "win"
-				? match.opponentTwo
-				: match.opponentOne;
+			match.winnerSide === "opponent1" ? match.opponentTwo : match.opponentOne;
 
 		// Handle dropped team sets without game results - use active roster or member list
 		let winnerTeamIdentifier: string;
@@ -535,11 +532,11 @@ function playerResultDeltas(
 			for (const otherParticipant of mostPopularParticipants) {
 				if (ownerParticipant.userId === otherParticipant.userId) continue;
 
-				const result =
+				const ownerSide =
 					match.opponentOne.id === ownerParticipant.tournamentTeamId
-						? match.opponentOne.result
-						: match.opponentTwo.result;
-				const won = result === "win";
+						? "opponent1"
+						: "opponent2";
+				const won = match.winnerSide === ownerSide;
 
 				addPlayerResult({
 					ownerUserId: ownerParticipant.userId,
diff --git a/app/features/tournament-bracket/core/summarizer.test.ts b/app/features/tournament-bracket/core/summarizer.test.ts
index 2eb874b0a..df94fb99d 100644
--- a/app/features/tournament-bracket/core/summarizer.test.ts
+++ b/app/features/tournament-bracket/core/summarizer.test.ts
@@ -9,14 +9,12 @@ import type { TournamentDataTeam } from "./Tournament.server";
 
 const createOpponent = (
 	id: number,
-	result: "win" | "loss",
 	score: number,
 	droppedOut = false,
 	activeRosterUserIds: number[] | null = null,
 	memberUserIds: number[] = [],
 ): AllMatchResult["opponentOne"] => ({
 	id,
-	result,
 	score,
 	droppedOut,
 	activeRosterUserIds,
@@ -195,8 +193,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 2),
-					opponentTwo: createOpponent(2, "loss", 0),
+					opponentOne: createOpponent(1, 2),
+					opponentTwo: createOpponent(2, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -304,8 +303,9 @@ describe("tournamentSummary()", () => {
 					winnerTeamId: 1,
 				},
 			],
-			opponentOne: createOpponent(1, "win", 2),
-			opponentTwo: createOpponent(2, "loss", 0),
+			opponentOne: createOpponent(1, 2),
+			opponentTwo: createOpponent(2, 0),
+			winnerSide: "opponent1",
 			roundMaps: {
 				count: 3,
 				type: "BEST_OF",
@@ -344,8 +344,9 @@ describe("tournamentSummary()", () => {
 					winnerTeamId: 1,
 				},
 			],
-			opponentOne: createOpponent(1, "win", 2),
-			opponentTwo: createOpponent(2, "loss", 0),
+			opponentOne: createOpponent(1, 2),
+			opponentTwo: createOpponent(2, 0),
+			winnerSide: "opponent1",
 			roundMaps: {
 				count: 3,
 				type: "BEST_OF",
@@ -430,8 +431,9 @@ describe("tournamentSummary()", () => {
 					winnerTeamId: 1,
 				},
 			],
-			opponentOne: createOpponent(1, "win", 2),
-			opponentTwo: createOpponent(2, "loss", 1),
+			opponentOne: createOpponent(1, 2),
+			opponentTwo: createOpponent(2, 1),
+			winnerSide: "opponent1",
 			roundMaps: {
 				count: 3,
 				type: "BEST_OF",
@@ -595,8 +597,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 3),
-					opponentTwo: createOpponent(2, "loss", 0),
+					opponentOne: createOpponent(1, 3),
+					opponentTwo: createOpponent(2, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -645,8 +648,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 2),
-					opponentTwo: createOpponent(2, "loss", 0),
+					opponentOne: createOpponent(1, 2),
+					opponentTwo: createOpponent(2, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -901,8 +905,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 0),
-					opponentTwo: createOpponent(2, "loss", 0),
+					opponentOne: createOpponent(1, 0),
+					opponentTwo: createOpponent(2, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -937,8 +942,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 1),
-					opponentTwo: createOpponent(2, "loss", 0),
+					opponentOne: createOpponent(1, 1),
+					opponentTwo: createOpponent(2, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -962,8 +968,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 3,
 						},
 					],
-					opponentOne: createOpponent(3, "win", 0),
-					opponentTwo: createOpponent(4, "loss", 0),
+					opponentOne: createOpponent(3, 0),
+					opponentTwo: createOpponent(4, 0),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -1012,8 +1019,9 @@ describe("tournamentSummary()", () => {
 							winnerTeamId: 1,
 						},
 					],
-					opponentOne: createOpponent(1, "win", 1, false),
-					opponentTwo: createOpponent(2, "loss", 0, true),
+					opponentOne: createOpponent(1, 1, false),
+					opponentTwo: createOpponent(2, 0, true),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -1038,8 +1046,9 @@ describe("tournamentSummary()", () => {
 			results: [
 				{
 					maps: [],
-					opponentOne: createOpponent(1, "win", 0, false, [1, 2, 3, 4]),
-					opponentTwo: createOpponent(2, "loss", 0, true, [5, 6, 7, 8]),
+					opponentOne: createOpponent(1, 0, false, [1, 2, 3, 4]),
+					opponentTwo: createOpponent(2, 0, true, [5, 6, 7, 8]),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
@@ -1065,8 +1074,9 @@ describe("tournamentSummary()", () => {
 				{
 					maps: [],
 					// No activeRosterUserIds, but memberUserIds is set
-					opponentOne: createOpponent(1, "win", 0, false, null, [1, 2, 3, 4]),
-					opponentTwo: createOpponent(2, "loss", 0, true, null, [5, 6, 7, 8]),
+					opponentOne: createOpponent(1, 0, false, null, [1, 2, 3, 4]),
+					opponentTwo: createOpponent(2, 0, true, null, [5, 6, 7, 8]),
+					winnerSide: "opponent1",
 					roundMaps: {
 						count: 3,
 						type: "BEST_OF",
diff --git a/app/features/tournament-bracket/core/tests/mocks-li.ts b/app/features/tournament-bracket/core/tests/mocks-li.ts
index a8588abe7..3d86044aa 100644
--- a/app/features/tournament-bracket/core/tests/mocks-li.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-li.ts
@@ -9,12 +9,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 				name: "Group Stage",
 				number: 1,
 				settings: {
-					swiss: {
-						groupCount: 2,
-						roundCount: 6,
-					},
+					groupCount: 2,
+					roundCount: 6,
 				},
-				tournament_id: 815,
 				type: "swiss",
 				createdAt: 1734199362,
 			},
@@ -22,17 +19,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 				id: 1429,
 				name: "Beta Bracket",
 				number: 2,
-				settings: {
-					grandFinal: "double",
-					size: 16,
-					seedOrdering: [
-						"space_between",
-						"natural",
-						"reverse_half_shift",
-						"reverse",
-					],
-				},
-				tournament_id: 815,
+				settings: {},
 				type: "double_elimination",
 				createdAt: 1734286247,
 			},
@@ -40,17 +27,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 				id: 1430,
 				name: "Alpha Bracket",
 				number: 3,
-				settings: {
-					grandFinal: "double",
-					size: 16,
-					seedOrdering: [
-						"space_between",
-						"natural",
-						"reverse_half_shift",
-						"reverse",
-					],
-				},
-				tournament_id: 815,
+				settings: {},
 				type: "double_elimination",
 				createdAt: 1734286249,
 			},
@@ -58,17 +35,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 				id: 1431,
 				name: "Gamma Bracket",
 				number: 4,
-				settings: {
-					grandFinal: "double",
-					size: 16,
-					seedOrdering: [
-						"space_between",
-						"natural",
-						"reverse_half_shift",
-						"reverse",
-					],
-				},
-				tournament_id: 815,
+				settings: {},
 				type: "double_elimination",
 				createdAt: 1734286340,
 			},
@@ -77,65 +44,65 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			{
 				id: 4327,
 				number: 1,
-				stage_id: 1420,
+				stageId: 1420,
 			},
 			{
 				id: 4328,
 				number: 2,
-				stage_id: 1420,
+				stageId: 1420,
 			},
 			{
 				id: 4359,
 				number: 1,
-				stage_id: 1429,
+				stageId: 1429,
 			},
 			{
 				id: 4360,
 				number: 2,
-				stage_id: 1429,
+				stageId: 1429,
 			},
 			{
 				id: 4361,
 				number: 3,
-				stage_id: 1429,
+				stageId: 1429,
 			},
 			{
 				id: 4362,
 				number: 1,
-				stage_id: 1430,
+				stageId: 1430,
 			},
 			{
 				id: 4363,
 				number: 2,
-				stage_id: 1430,
+				stageId: 1430,
 			},
 			{
 				id: 4364,
 				number: 3,
-				stage_id: 1430,
+				stageId: 1430,
 			},
 			{
 				id: 4365,
 				number: 1,
-				stage_id: 1431,
+				stageId: 1431,
 			},
 			{
 				id: 4366,
 				number: 2,
-				stage_id: 1431,
+				stageId: 1431,
 			},
 			{
 				id: 4367,
 				number: 3,
-				stage_id: 1431,
+				stageId: 1431,
 			},
 		],
 		round: [
 			{
 				id: 13348,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -143,9 +110,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13349,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -153,9 +120,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13350,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -163,9 +130,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13351,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -173,9 +140,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13352,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -183,9 +150,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13353,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -193,9 +160,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13354,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -203,9 +170,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13355,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -213,9 +180,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13356,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -223,9 +190,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13357,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -233,9 +200,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13358,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -243,9 +210,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13359,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
-				stage_id: 1420,
+				stageId: 1420,
 				maps: {
 					count: 3,
 					type: "PLAY_ALL",
@@ -253,9 +220,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13452,
-				group_id: 4359,
+				groupId: 4359,
 				number: 1,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -264,9 +231,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13453,
-				group_id: 4359,
+				groupId: 4359,
 				number: 2,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -275,9 +242,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13454,
-				group_id: 4359,
+				groupId: 4359,
 				number: 3,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -286,9 +253,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13455,
-				group_id: 4359,
+				groupId: 4359,
 				number: 4,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -297,9 +264,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13456,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -308,9 +275,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13457,
-				group_id: 4360,
+				groupId: 4360,
 				number: 2,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -319,9 +286,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13458,
-				group_id: 4360,
+				groupId: 4360,
 				number: 3,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -330,9 +297,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13459,
-				group_id: 4360,
+				groupId: 4360,
 				number: 4,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -341,9 +308,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13460,
-				group_id: 4360,
+				groupId: 4360,
 				number: 5,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -352,9 +319,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13461,
-				group_id: 4360,
+				groupId: 4360,
 				number: 6,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -363,9 +330,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13462,
-				group_id: 4361,
+				groupId: 4361,
 				number: 1,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -374,9 +341,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13463,
-				group_id: 4361,
+				groupId: 4361,
 				number: 2,
-				stage_id: 1429,
+				stageId: 1429,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -385,9 +352,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13464,
-				group_id: 4362,
+				groupId: 4362,
 				number: 1,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -396,9 +363,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13465,
-				group_id: 4362,
+				groupId: 4362,
 				number: 2,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -407,9 +374,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13466,
-				group_id: 4362,
+				groupId: 4362,
 				number: 3,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -418,9 +385,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13467,
-				group_id: 4362,
+				groupId: 4362,
 				number: 4,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -429,9 +396,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13468,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -440,9 +407,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13469,
-				group_id: 4363,
+				groupId: 4363,
 				number: 2,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -451,9 +418,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13470,
-				group_id: 4363,
+				groupId: 4363,
 				number: 3,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -462,9 +429,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13471,
-				group_id: 4363,
+				groupId: 4363,
 				number: 4,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -473,9 +440,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13472,
-				group_id: 4363,
+				groupId: 4363,
 				number: 5,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -484,9 +451,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13473,
-				group_id: 4363,
+				groupId: 4363,
 				number: 6,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -495,9 +462,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13474,
-				group_id: 4364,
+				groupId: 4364,
 				number: 1,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -506,9 +473,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13475,
-				group_id: 4364,
+				groupId: 4364,
 				number: 2,
-				stage_id: 1430,
+				stageId: 1430,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -517,9 +484,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13476,
-				group_id: 4365,
+				groupId: 4365,
 				number: 1,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -528,9 +495,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13477,
-				group_id: 4365,
+				groupId: 4365,
 				number: 2,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -539,9 +506,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13478,
-				group_id: 4365,
+				groupId: 4365,
 				number: 3,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -550,9 +517,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13479,
-				group_id: 4365,
+				groupId: 4365,
 				number: 4,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -561,9 +528,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13480,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -572,9 +539,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13481,
-				group_id: 4366,
+				groupId: 4366,
 				number: 2,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -583,9 +550,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13482,
-				group_id: 4366,
+				groupId: 4366,
 				number: 3,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -594,9 +561,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13483,
-				group_id: 4366,
+				groupId: 4366,
 				number: 4,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -605,9 +572,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13484,
-				group_id: 4366,
+				groupId: 4366,
 				number: 5,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -616,9 +583,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13485,
-				group_id: 4366,
+				groupId: 4366,
 				number: 6,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -627,9 +594,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13486,
-				group_id: 4367,
+				groupId: 4367,
 				number: 1,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -638,9 +605,9 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 			},
 			{
 				id: 13487,
-				group_id: 4367,
+				groupId: 4367,
 				number: 2,
-				stage_id: 1431,
+				stageId: 1431,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -651,4929 +618,4417 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 		match: [
 			{
 				id: 37409,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 16805,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17769,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37410,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 16814,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16803,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37411,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 16825,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17056,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37412,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17368,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37413,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 16984,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17431,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37414,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 17155,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17468,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37415,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 16828,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17482,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37416,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 16878,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17626,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37417,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 16996,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17634,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37418,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 17168,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17698,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37419,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17292,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17750,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37420,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17505,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17202,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37421,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 17659,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17444,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37422,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17765,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17606,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37423,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 16872,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37424,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 17067,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17697,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37425,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17256,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17768,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37426,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17529,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16915,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37427,
-				group_id: 4327,
+				groupId: 4327,
 				number: 19,
 				opponent1: {
 					id: 17650,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17265,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37428,
-				group_id: 4327,
+				groupId: 4327,
 				number: 20,
 				opponent1: {
 					id: 17731,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17485,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13348,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13348,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37429,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 16806,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16802,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37430,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 16829,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16821,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37431,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 16863,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17138,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37432,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 16974,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17411,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37433,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 17119,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17434,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37434,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17479,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37435,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 16830,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17500,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37436,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 16887,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17633,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37437,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 17148,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17641,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37438,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 17280,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17713,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37439,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 17423,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17191,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37440,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 17513,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17208,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37441,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 17710,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17457,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37442,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 16870,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17636,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37443,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17052,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17654,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37444,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17188,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17723,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37445,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17354,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16832,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37446,
-				group_id: 4328,
+				groupId: 4328,
 				number: 18,
 				opponent1: {
 					id: 17609,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17179,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37447,
-				group_id: 4328,
+				groupId: 4328,
 				number: 19,
 				opponent1: {
 					id: 17707,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17438,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37448,
-				group_id: 4328,
+				groupId: 4328,
 				number: 20,
 				opponent1: {
 					id: 17749,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17770,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13354,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13354,
+				stageId: 1420,
 				startedAt: 1734199362,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37449,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 16825,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17650,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37450,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17529,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37451,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 16984,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17256,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37452,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 17155,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16872,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37453,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 16828,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17765,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37454,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 16878,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17505,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37455,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 16996,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37456,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 16805,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17698,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37457,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 16814,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17731,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37458,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 17659,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17067,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37459,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17168,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17444,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37460,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17769,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16803,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37461,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 17056,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17265,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37462,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17368,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16915,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37463,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 17431,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17768,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37464,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 17468,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17697,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37465,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17482,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37466,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17634,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17606,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37467,
-				group_id: 4327,
+				groupId: 4327,
 				number: 19,
 				opponent1: {
 					id: 17750,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17202,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13349,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37468,
-				group_id: 4327,
+				groupId: 4327,
 				number: 20,
 				opponent1: {
 					id: 17485,
 				},
 				opponent2: null,
-				round_id: 13349,
-				stage_id: 1420,
-				status: 2,
+				roundId: 13349,
+				stageId: 1420,
 				startedAt: 1734201461,
+				winnerSide: null,
 			},
 			{
 				id: 37469,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 16806,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17749,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37470,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 16829,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17707,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37471,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 16974,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17609,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37472,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 17119,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17188,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37473,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16870,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37474,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 16830,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17710,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37475,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 16887,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17513,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37476,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 17280,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17423,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37477,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 16863,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17354,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37478,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 17148,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17052,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37479,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 17138,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16832,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37480,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 17641,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17654,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37481,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 16802,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17770,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37482,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 16821,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17438,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37483,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17411,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17179,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37484,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17434,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17723,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37485,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17479,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17636,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37486,
-				group_id: 4328,
+				groupId: 4328,
 				number: 18,
 				opponent1: {
 					id: 17500,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17457,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37487,
-				group_id: 4328,
+				groupId: 4328,
 				number: 19,
 				opponent1: {
 					id: 17633,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17208,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37488,
-				group_id: 4328,
+				groupId: 4328,
 				number: 20,
 				opponent1: {
 					id: 17713,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17191,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13355,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13355,
+				stageId: 1420,
 				startedAt: 1734201464,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37489,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 16910,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17292,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37490,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 16814,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17698,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37491,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 16825,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17067,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37492,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 16984,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16872,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37493,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 16828,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17505,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37494,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 17256,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17650,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37495,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 17168,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17765,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37496,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 16803,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16878,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37497,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 17431,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16996,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37498,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 17731,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17697,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37499,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17155,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17750,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37500,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17529,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17368,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37501,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 16805,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17482,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37502,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17485,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17659,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37503,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 17265,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17634,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37504,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 17769,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17444,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37505,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17056,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16915,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37506,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17202,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17768,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37507,
-				group_id: 4327,
+				groupId: 4327,
 				number: 19,
 				opponent1: {
 					id: 17606,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13350,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13350,
+				stageId: 1420,
 				startedAt: 1734203865,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37508,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 16806,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17119,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37509,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 16829,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17148,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37510,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 16974,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16887,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37511,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 17561,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16830,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37512,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 16832,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17423,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37513,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 17354,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17707,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37514,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 17280,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17609,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37515,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 17710,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17513,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37516,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 16821,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16870,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37517,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 17188,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16863,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37518,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 17749,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17479,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37519,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 16802,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17434,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37520,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 17052,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17411,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37521,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 17457,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17713,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37522,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17641,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17208,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37523,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17138,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17633,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37524,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17500,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17770,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37525,
-				group_id: 4328,
+				groupId: 4328,
 				number: 18,
 				opponent1: {
 					id: 17636,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17438,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37526,
-				group_id: 4328,
+				groupId: 4328,
 				number: 19,
 				opponent1: {
 					id: 17723,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17179,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13356,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13356,
+				stageId: 1420,
 				startedAt: 1734203867,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37591,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 16806,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17561,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37592,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 17280,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16887,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37593,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 16829,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17423,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37594,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 17354,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17119,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37595,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 17148,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17513,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37596,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 16974,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16830,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37597,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 16870,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17749,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37598,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 17434,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16863,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37599,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 17713,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17411,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37600,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 16821,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17208,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37601,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 16832,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17188,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37602,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 17707,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17710,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37603,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 17633,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17609,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37604,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 17479,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16802,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37605,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17457,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17052,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37606,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17636,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17723,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37607,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17641,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17500,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37608,
-				group_id: 4328,
+				groupId: 4328,
 				number: 18,
 				opponent1: {
 					id: 17138,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17770,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37609,
-				group_id: 4328,
+				groupId: 4328,
 				number: 19,
 				opponent1: {
 					id: 17179,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17438,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13357,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13357,
+				stageId: 1420,
 				startedAt: 1734205934,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37610,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 16814,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16828,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37611,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 16825,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37612,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 17292,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16872,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37613,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 16984,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16803,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37614,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 17482,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17155,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37615,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 17067,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17368,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37616,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 17698,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17505,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37617,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 17168,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17256,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37618,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 17765,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17697,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37619,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 16996,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17650,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37620,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17634,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17659,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37621,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17529,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17431,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37622,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 17750,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16878,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37623,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17731,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16805,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37624,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 17769,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17265,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37625,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 17485,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17056,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37626,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17606,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17768,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37627,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17202,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16915,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37628,
-				group_id: 4327,
+				groupId: 4327,
 				number: 19,
 				opponent1: {
 					id: 17444,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13351,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13351,
+				stageId: 1420,
 				startedAt: 1734205937,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37629,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 16910,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16828,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37630,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 17155,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37631,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 16825,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16984,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37632,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 16814,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16872,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37633,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 17505,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17168,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37634,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 16803,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17067,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37635,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 17659,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17697,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37636,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 17368,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17256,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37637,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 17698,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17482,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37638,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 16878,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17485,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37639,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17650,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17529,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37640,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17769,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16996,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37641,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 17634,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17768,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37642,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17765,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16805,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37643,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 17265,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17444,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37644,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 17750,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17731,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37645,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17056,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37646,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17202,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17606,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13352,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37647,
-				group_id: 4327,
+				groupId: 4327,
 				number: 19,
 				opponent1: {
 					id: 16915,
 				},
 				opponent2: null,
-				round_id: 13352,
-				stage_id: 1420,
-				status: 2,
+				roundId: 13352,
+				stageId: 1420,
 				startedAt: 1734207931,
+				winnerSide: null,
 			},
 			{
 				id: 37648,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 17423,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16887,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37649,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 16829,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16806,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37650,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 17119,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17513,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37651,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 17749,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37652,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 17434,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17713,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37653,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 17354,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16830,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37654,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 17280,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17208,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37655,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 17148,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17710,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37656,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 16802,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16974,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37657,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 16863,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16870,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37658,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 17411,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17188,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37659,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 17457,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17723,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37660,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 16821,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17609,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37661,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 16832,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17707,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37662,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17179,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17052,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37663,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17636,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17641,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37664,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17138,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17500,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37665,
-				group_id: 4328,
+				groupId: 4328,
 				number: 18,
 				opponent1: {
 					id: 17438,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17770,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13358,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13358,
+				stageId: 1420,
 				startedAt: 1734207933,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37666,
-				group_id: 4327,
+				groupId: 4327,
 				number: 1,
 				opponent1: {
 					id: 17659,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16828,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37667,
-				group_id: 4327,
+				groupId: 4327,
 				number: 2,
 				opponent1: {
 					id: 16910,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17505,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37668,
-				group_id: 4327,
+				groupId: 4327,
 				number: 3,
 				opponent1: {
 					id: 17650,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37669,
-				group_id: 4327,
+				groupId: 4327,
 				number: 4,
 				opponent1: {
 					id: 16825,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16872,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37670,
-				group_id: 4327,
+				groupId: 4327,
 				number: 5,
 				opponent1: {
 					id: 16984,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16814,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37671,
-				group_id: 4327,
+				groupId: 4327,
 				number: 6,
 				opponent1: {
 					id: 17155,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17768,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37672,
-				group_id: 4327,
+				groupId: 4327,
 				number: 7,
 				opponent1: {
 					id: 17168,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16878,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37673,
-				group_id: 4327,
+				groupId: 4327,
 				number: 8,
 				opponent1: {
 					id: 16996,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17697,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37674,
-				group_id: 4327,
+				groupId: 4327,
 				number: 9,
 				opponent1: {
 					id: 17067,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17698,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37675,
-				group_id: 4327,
+				groupId: 4327,
 				number: 10,
 				opponent1: {
 					id: 16803,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17368,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37676,
-				group_id: 4327,
+				groupId: 4327,
 				number: 11,
 				opponent1: {
 					id: 17256,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17765,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37677,
-				group_id: 4327,
+				groupId: 4327,
 				number: 12,
 				opponent1: {
 					id: 17482,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17529,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37678,
-				group_id: 4327,
+				groupId: 4327,
 				number: 13,
 				opponent1: {
 					id: 17750,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17634,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37679,
-				group_id: 4327,
+				groupId: 4327,
 				number: 14,
 				opponent1: {
 					id: 17769,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17485,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37680,
-				group_id: 4327,
+				groupId: 4327,
 				number: 15,
 				opponent1: {
 					id: 17265,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17202,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37681,
-				group_id: 4327,
+				groupId: 4327,
 				number: 16,
 				opponent1: {
 					id: 16805,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17056,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37682,
-				group_id: 4327,
+				groupId: 4327,
 				number: 17,
 				opponent1: {
 					id: 17606,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17444,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37683,
-				group_id: 4327,
+				groupId: 4327,
 				number: 18,
 				opponent1: {
 					id: 17669,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17731,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13353,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13353,
+				stageId: 1420,
 				startedAt: 1734210194,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37684,
-				group_id: 4328,
+				groupId: 4328,
 				number: 1,
 				opponent1: {
 					id: 16829,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17561,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37685,
-				group_id: 4328,
+				groupId: 4328,
 				number: 2,
 				opponent1: {
 					id: 17434,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16806,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37686,
-				group_id: 4328,
+				groupId: 4328,
 				number: 3,
 				opponent1: {
 					id: 16830,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17423,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37687,
-				group_id: 4328,
+				groupId: 4328,
 				number: 4,
 				opponent1: {
 					id: 17749,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17513,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37688,
-				group_id: 4328,
+				groupId: 4328,
 				number: 5,
 				opponent1: {
 					id: 16887,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17710,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37689,
-				group_id: 4328,
+				groupId: 4328,
 				number: 6,
 				opponent1: {
 					id: 17280,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16974,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37690,
-				group_id: 4328,
+				groupId: 4328,
 				number: 7,
 				opponent1: {
 					id: 17713,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17354,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37691,
-				group_id: 4328,
+				groupId: 4328,
 				number: 8,
 				opponent1: {
 					id: 17208,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16863,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37692,
-				group_id: 4328,
+				groupId: 4328,
 				number: 9,
 				opponent1: {
 					id: 17188,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17609,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37693,
-				group_id: 4328,
+				groupId: 4328,
 				number: 10,
 				opponent1: {
 					id: 17411,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17457,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37694,
-				group_id: 4328,
+				groupId: 4328,
 				number: 11,
 				opponent1: {
 					id: 17723,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16870,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37695,
-				group_id: 4328,
+				groupId: 4328,
 				number: 12,
 				opponent1: {
 					id: 17707,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16802,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37696,
-				group_id: 4328,
+				groupId: 4328,
 				number: 13,
 				opponent1: {
 					id: 16832,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17641,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37697,
-				group_id: 4328,
+				groupId: 4328,
 				number: 14,
 				opponent1: {
 					id: 17500,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17052,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37698,
-				group_id: 4328,
+				groupId: 4328,
 				number: 15,
 				opponent1: {
 					id: 17179,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16821,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37699,
-				group_id: 4328,
+				groupId: 4328,
 				number: 16,
 				opponent1: {
 					id: 17636,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17770,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37700,
-				group_id: 4328,
+				groupId: 4328,
 				number: 17,
 				opponent1: {
 					id: 17438,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17138,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13359,
-				stage_id: 1420,
-				status: 4,
+				roundId: 13359,
+				stageId: 1420,
 				startedAt: 1734210198,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37875,
-				group_id: 4359,
+				groupId: 4359,
 				number: 1,
 				opponent1: {
 					id: 16984,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17749,
 					position: 16,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37876,
-				group_id: 4359,
+				groupId: 4359,
 				number: 2,
 				opponent1: {
 					id: 17208,
 					position: 8,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17659,
 					position: 9,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37877,
-				group_id: 4359,
+				groupId: 4359,
 				number: 3,
 				opponent1: {
 					id: 17280,
 					position: 4,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17697,
 					position: 13,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37878,
-				group_id: 4359,
+				groupId: 4359,
 				number: 4,
 				opponent1: {
 					id: 17155,
 					position: 5,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17710,
 					position: 12,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37879,
-				group_id: 4359,
+				groupId: 4359,
 				number: 5,
 				opponent1: {
 					id: 17561,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17768,
 					position: 15,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37880,
-				group_id: 4359,
+				groupId: 4359,
 				number: 6,
 				opponent1: {
 					id: 17067,
 					position: 7,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17713,
 					position: 10,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37881,
-				group_id: 4359,
+				groupId: 4359,
 				number: 7,
 				opponent1: {
 					id: 17168,
 					position: 3,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16974,
 					position: 14,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37882,
-				group_id: 4359,
+				groupId: 4359,
 				number: 8,
 				opponent1: {
 					id: 17457,
 					position: 6,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17650,
 					position: 11,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13452,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13452,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37883,
-				group_id: 4359,
+				groupId: 4359,
 				number: 1,
 				opponent1: {
 					id: 16984,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17208,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13453,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13453,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37884,
-				group_id: 4359,
+				groupId: 4359,
 				number: 2,
 				opponent1: {
 					id: 17280,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17710,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13453,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13453,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37885,
-				group_id: 4359,
+				groupId: 4359,
 				number: 3,
 				opponent1: {
 					id: 17561,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17713,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13453,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13453,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37886,
-				group_id: 4359,
+				groupId: 4359,
 				number: 4,
 				opponent1: {
 					id: 17168,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17457,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13453,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13453,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37887,
-				group_id: 4359,
+				groupId: 4359,
 				number: 1,
 				opponent1: {
 					id: 16984,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17710,
 					score: 2,
-					result: "loss",
 				},
-				round_id: 13454,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13454,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37888,
-				group_id: 4359,
+				groupId: 4359,
 				number: 2,
 				opponent1: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17168,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13454,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13454,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37889,
-				group_id: 4359,
+				groupId: 4359,
 				number: 1,
 				opponent1: {
 					id: 16984,
 					score: 2,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13455,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13455,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37890,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 17749,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17659,
 					position: 2,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13456,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13456,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37891,
-				group_id: 4360,
+				groupId: 4360,
 				number: 2,
 				opponent1: {
 					id: 17697,
 					position: 3,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17155,
 					position: 4,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13456,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13456,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37892,
-				group_id: 4360,
+				groupId: 4360,
 				number: 3,
 				opponent1: {
 					id: 17768,
 					position: 5,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17067,
 					position: 6,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13456,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13456,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37893,
-				group_id: 4360,
+				groupId: 4360,
 				number: 4,
 				opponent1: {
 					id: 16974,
 					position: 7,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17650,
 					position: 8,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13456,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13456,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37894,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 17280,
 					position: 2,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17749,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13457,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13457,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37895,
-				group_id: 4360,
+				groupId: 4360,
 				number: 2,
 				opponent1: {
 					id: 17208,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17155,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13457,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13457,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37896,
-				group_id: 4360,
+				groupId: 4360,
 				number: 3,
 				opponent1: {
 					id: 17457,
 					position: 4,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17067,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13457,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13457,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37897,
-				group_id: 4360,
+				groupId: 4360,
 				number: 4,
 				opponent1: {
 					id: 17713,
 					position: 3,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16974,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13457,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13457,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37898,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 17749,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17208,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13458,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13458,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37899,
-				group_id: 4360,
+				groupId: 4360,
 				number: 2,
 				opponent1: {
 					id: 17067,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16974,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13458,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13458,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37900,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 17168,
 					position: 2,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17749,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13459,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13459,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37901,
-				group_id: 4360,
+				groupId: 4360,
 				number: 2,
 				opponent1: {
 					id: 17710,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16974,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13459,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13459,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37902,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 17749,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17710,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13460,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13460,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37903,
-				group_id: 4360,
+				groupId: 4360,
 				number: 1,
 				opponent1: {
 					id: 16984,
 					position: 1,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17710,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13461,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13461,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37904,
-				group_id: 4361,
+				groupId: 4361,
 				number: 1,
 				opponent1: {
 					id: 17561,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16984,
 					position: 1,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13462,
-				stage_id: 1429,
-				status: 4,
+				roundId: 13462,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37905,
-				group_id: 4361,
+				groupId: 4361,
 				number: 1,
 				opponent1: {
 					id: null,
@@ -5581,1252 +5036,1128 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
 				opponent2: {
 					id: null,
 				},
-				round_id: 13463,
-				stage_id: 1429,
-				status: 0,
+				roundId: 13463,
+				stageId: 1429,
 				startedAt: null,
+				winnerSide: null,
 			},
 			{
 				id: 37906,
-				group_id: 4362,
+				groupId: 4362,
 				number: 1,
 				opponent1: {
 					id: 16828,
 					position: 1,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17188,
 					position: 16,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37907,
-				group_id: 4362,
+				groupId: 4362,
 				number: 2,
 				opponent1: {
 					id: 16887,
 					position: 8,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17505,
 					position: 9,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37908,
-				group_id: 4362,
+				groupId: 4362,
 				number: 3,
 				opponent1: {
 					id: 16829,
 					position: 4,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16872,
 					position: 13,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37909,
-				group_id: 4362,
+				groupId: 4362,
 				number: 4,
 				opponent1: {
 					id: 17292,
 					position: 5,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17423,
 					position: 12,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37910,
-				group_id: 4362,
+				groupId: 4362,
 				number: 5,
 				opponent1: {
 					id: 16806,
 					position: 2,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16803,
 					position: 15,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37911,
-				group_id: 4362,
+				groupId: 4362,
 				number: 6,
 				opponent1: {
 					id: 16825,
 					position: 7,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17513,
 					position: 10,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37912,
-				group_id: 4362,
+				groupId: 4362,
 				number: 7,
 				opponent1: {
 					id: 16910,
 					position: 3,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17434,
 					position: 14,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37913,
-				group_id: 4362,
+				groupId: 4362,
 				number: 8,
 				opponent1: {
 					id: 16830,
 					position: 6,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16996,
 					position: 11,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13464,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13464,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37914,
-				group_id: 4362,
+				groupId: 4362,
 				number: 1,
 				opponent1: {
 					id: 17188,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16887,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13465,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13465,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37915,
-				group_id: 4362,
+				groupId: 4362,
 				number: 2,
 				opponent1: {
 					id: 16829,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17423,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13465,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13465,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37916,
-				group_id: 4362,
+				groupId: 4362,
 				number: 3,
 				opponent1: {
 					id: 16803,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16825,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13465,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13465,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37917,
-				group_id: 4362,
+				groupId: 4362,
 				number: 4,
 				opponent1: {
 					id: 16910,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16830,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13465,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13465,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37918,
-				group_id: 4362,
+				groupId: 4362,
 				number: 1,
 				opponent1: {
 					id: 16887,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16829,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13466,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13466,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37919,
-				group_id: 4362,
+				groupId: 4362,
 				number: 2,
 				opponent1: {
 					id: 16803,
 					score: 2,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13466,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13466,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37920,
-				group_id: 4362,
+				groupId: 4362,
 				number: 1,
 				opponent1: {
 					id: 16829,
 					score: 2,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13467,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13467,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37921,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 16828,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17505,
 					position: 2,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13468,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13468,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37922,
-				group_id: 4363,
+				groupId: 4363,
 				number: 2,
 				opponent1: {
 					id: 16872,
 					position: 3,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					position: 4,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13468,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13468,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37923,
-				group_id: 4363,
+				groupId: 4363,
 				number: 3,
 				opponent1: {
 					id: 16806,
 					position: 5,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17513,
 					position: 6,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13468,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13468,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37924,
-				group_id: 4363,
+				groupId: 4363,
 				number: 4,
 				opponent1: {
 					id: 17434,
 					position: 7,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16996,
 					position: 8,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13468,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13468,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37925,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 17423,
 					position: 2,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16828,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13469,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13469,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37926,
-				group_id: 4363,
+				groupId: 4363,
 				number: 2,
 				opponent1: {
 					id: 17188,
 					position: 1,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13469,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13469,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37927,
-				group_id: 4363,
+				groupId: 4363,
 				number: 3,
 				opponent1: {
 					id: 16830,
 					position: 4,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16806,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13469,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13469,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37928,
-				group_id: 4363,
+				groupId: 4363,
 				number: 4,
 				opponent1: {
 					id: 16825,
 					position: 3,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16996,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13469,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13469,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37929,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 16828,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17292,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13470,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13470,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37930,
-				group_id: 4363,
+				groupId: 4363,
 				number: 2,
 				opponent1: {
 					id: 16830,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16996,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13470,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13470,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37931,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 16803,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17292,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13471,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13471,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37932,
-				group_id: 4363,
+				groupId: 4363,
 				number: 2,
 				opponent1: {
 					id: 16887,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16996,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13471,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13471,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37933,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 16803,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16887,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13472,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13472,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37934,
-				group_id: 4363,
+				groupId: 4363,
 				number: 1,
 				opponent1: {
 					id: 16829,
 					position: 1,
 					score: 2,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16803,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13473,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13473,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37935,
-				group_id: 4364,
+				groupId: 4364,
 				number: 1,
 				opponent1: {
 					id: 16910,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16803,
 					position: 1,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13474,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13474,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37936,
-				group_id: 4364,
+				groupId: 4364,
 				number: 1,
 				opponent1: {
 					id: 16910,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 16803,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13475,
-				stage_id: 1430,
-				status: 4,
+				roundId: 13475,
+				stageId: 1430,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37937,
-				group_id: 4365,
+				groupId: 4365,
 				number: 1,
 				opponent1: {
 					id: 17368,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16821,
 					position: 16,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37938,
-				group_id: 4365,
+				groupId: 4365,
 				number: 2,
 				opponent1: {
 					id: 17500,
 					position: 8,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17634,
 					position: 9,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37939,
-				group_id: 4365,
+				groupId: 4365,
 				number: 3,
 				opponent1: {
 					id: 17609,
 					position: 4,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17529,
 					position: 13,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37940,
-				group_id: 4365,
+				groupId: 4365,
 				number: 4,
 				opponent1: {
 					id: 17769,
 					position: 5,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17411,
 					position: 12,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37941,
-				group_id: 4365,
+				groupId: 4365,
 				number: 5,
 				opponent1: {
 					id: 17354,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16805,
 					position: 15,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37942,
-				group_id: 4365,
+				groupId: 4365,
 				number: 6,
 				opponent1: {
 					id: 17698,
 					position: 7,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16870,
 					position: 10,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37943,
-				group_id: 4365,
+				groupId: 4365,
 				number: 7,
 				opponent1: {
 					id: 17765,
 					position: 3,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17138,
 					position: 14,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37944,
-				group_id: 4365,
+				groupId: 4365,
 				number: 8,
 				opponent1: {
 					id: 16802,
 					position: 6,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17202,
 					position: 11,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13476,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13476,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37945,
-				group_id: 4365,
+				groupId: 4365,
 				number: 1,
 				opponent1: {
 					id: 17368,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17634,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13477,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13477,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37946,
-				group_id: 4365,
+				groupId: 4365,
 				number: 2,
 				opponent1: {
 					id: 17529,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17769,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13477,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13477,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37947,
-				group_id: 4365,
+				groupId: 4365,
 				number: 3,
 				opponent1: {
 					id: 17354,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17698,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13477,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13477,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37948,
-				group_id: 4365,
+				groupId: 4365,
 				number: 4,
 				opponent1: {
 					id: 17765,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16802,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13477,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13477,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37949,
-				group_id: 4365,
+				groupId: 4365,
 				number: 1,
 				opponent1: {
 					id: 17634,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 17529,
 					score: 2,
-					result: "loss",
 				},
-				round_id: 13478,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13478,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37950,
-				group_id: 4365,
+				groupId: 4365,
 				number: 2,
 				opponent1: {
 					id: 17354,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17765,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13478,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13478,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37951,
-				group_id: 4365,
+				groupId: 4365,
 				number: 1,
 				opponent1: {
 					id: 17634,
 					score: 2,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17765,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13479,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13479,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37952,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 16821,
 					position: 1,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17500,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13480,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13480,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37953,
-				group_id: 4366,
+				groupId: 4366,
 				number: 2,
 				opponent1: {
 					id: 17609,
 					position: 3,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17411,
 					position: 4,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13480,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13480,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37954,
-				group_id: 4366,
+				groupId: 4366,
 				number: 3,
 				opponent1: {
 					id: 16805,
 					position: 5,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16870,
 					position: 6,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13480,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13480,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37955,
-				group_id: 4366,
+				groupId: 4366,
 				number: 4,
 				opponent1: {
 					id: 17138,
 					position: 7,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17202,
 					position: 8,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13480,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13480,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37956,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 17769,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17500,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13481,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13481,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37957,
-				group_id: 4366,
+				groupId: 4366,
 				number: 2,
 				opponent1: {
 					id: 17368,
 					position: 1,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17609,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13481,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13481,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37958,
-				group_id: 4366,
+				groupId: 4366,
 				number: 3,
 				opponent1: {
 					id: 16802,
 					position: 4,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 16805,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13481,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13481,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37959,
-				group_id: 4366,
+				groupId: 4366,
 				number: 4,
 				opponent1: {
 					id: 17698,
 					position: 3,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17202,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13481,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13481,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37960,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 17769,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17609,
 					score: 2,
-					result: "win",
 				},
-				round_id: 13482,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13482,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37961,
-				group_id: 4366,
+				groupId: 4366,
 				number: 2,
 				opponent1: {
 					id: 16805,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17698,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13482,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13482,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37962,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 17354,
 					position: 2,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17609,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13483,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13483,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37963,
-				group_id: 4366,
+				groupId: 4366,
 				number: 2,
 				opponent1: {
 					id: 17529,
 					position: 1,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 16805,
 					score: 1,
-					result: "loss",
 				},
-				round_id: 13483,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13483,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37964,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 17354,
 					score: 2,
-					result: "win",
 				},
 				opponent2: {
 					id: 17529,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13484,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13484,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 37965,
-				group_id: 4366,
+				groupId: 4366,
 				number: 1,
 				opponent1: {
 					id: 17634,
 					position: 1,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17354,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13485,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13485,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37966,
-				group_id: 4367,
+				groupId: 4367,
 				number: 1,
 				opponent1: {
 					id: 17765,
 					score: 1,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17354,
 					position: 1,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13486,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13486,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 37967,
-				group_id: 4367,
+				groupId: 4367,
 				number: 1,
 				opponent1: {
 					id: 17765,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 17354,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13487,
-				stage_id: 1431,
-				status: 4,
+				roundId: 13487,
+				stageId: 1431,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 		],
 	},
diff --git a/app/features/tournament-bracket/core/tests/mocks-sos.ts b/app/features/tournament-bracket/core/tests/mocks-sos.ts
index 8c6f248fc..766b6e8a3 100644
--- a/app/features/tournament-bracket/core/tests/mocks-sos.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-sos.ts
@@ -12,11 +12,7 @@ export const SWIM_OR_SINK_167 = (
 				number: 1,
 				settings: {
 					groupCount: 11,
-					seedOrdering: ["groups.seed_optimized"],
-					roundRobinMode: "simple",
-					size: 44,
 				},
-				tournament_id: 672,
 				type: "round_robin",
 				createdAt: 1730941256,
 			},
@@ -25,65 +21,65 @@ export const SWIM_OR_SINK_167 = (
 			{
 				id: 3508,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3509,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3510,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3511,
 				number: 4,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3512,
 				number: 5,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3513,
 				number: 6,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3514,
 				number: 7,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3515,
 				number: 8,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3516,
 				number: 9,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3517,
 				number: 10,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 			{
 				id: 3518,
 				number: 11,
-				stage_id: 1118,
+				stageId: 1118,
 			},
 		],
 		round: [
 			{
 				id: 10930,
-				group_id: 3508,
+				groupId: 3508,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -91,9 +87,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10931,
-				group_id: 3508,
+				groupId: 3508,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -101,9 +97,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10932,
-				group_id: 3508,
+				groupId: 3508,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -111,9 +107,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10933,
-				group_id: 3509,
+				groupId: 3509,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -121,9 +117,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10934,
-				group_id: 3509,
+				groupId: 3509,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -131,9 +127,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10935,
-				group_id: 3509,
+				groupId: 3509,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -141,9 +137,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10936,
-				group_id: 3510,
+				groupId: 3510,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -151,9 +147,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10937,
-				group_id: 3510,
+				groupId: 3510,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -161,9 +157,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10938,
-				group_id: 3510,
+				groupId: 3510,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -171,9 +167,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10939,
-				group_id: 3511,
+				groupId: 3511,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -181,9 +177,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10940,
-				group_id: 3511,
+				groupId: 3511,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -191,9 +187,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10941,
-				group_id: 3511,
+				groupId: 3511,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -201,9 +197,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10942,
-				group_id: 3512,
+				groupId: 3512,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -211,9 +207,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10943,
-				group_id: 3512,
+				groupId: 3512,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -221,9 +217,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10944,
-				group_id: 3512,
+				groupId: 3512,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -231,9 +227,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10945,
-				group_id: 3513,
+				groupId: 3513,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -241,9 +237,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10946,
-				group_id: 3513,
+				groupId: 3513,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -251,9 +247,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10947,
-				group_id: 3513,
+				groupId: 3513,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -261,9 +257,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10948,
-				group_id: 3514,
+				groupId: 3514,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -271,9 +267,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10949,
-				group_id: 3514,
+				groupId: 3514,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -281,9 +277,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10950,
-				group_id: 3514,
+				groupId: 3514,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -291,9 +287,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10951,
-				group_id: 3515,
+				groupId: 3515,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -301,9 +297,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10952,
-				group_id: 3515,
+				groupId: 3515,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -311,9 +307,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10953,
-				group_id: 3515,
+				groupId: 3515,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -321,9 +317,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10954,
-				group_id: 3516,
+				groupId: 3516,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -331,9 +327,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10955,
-				group_id: 3516,
+				groupId: 3516,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -341,9 +337,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10956,
-				group_id: 3516,
+				groupId: 3516,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -351,9 +347,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10957,
-				group_id: 3517,
+				groupId: 3517,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -361,9 +357,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10958,
-				group_id: 3517,
+				groupId: 3517,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -371,9 +367,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10959,
-				group_id: 3517,
+				groupId: 3517,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -381,9 +377,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10960,
-				group_id: 3518,
+				groupId: 3518,
 				number: 1,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -391,9 +387,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10961,
-				group_id: 3518,
+				groupId: 3518,
 				number: 2,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -401,9 +397,9 @@ export const SWIM_OR_SINK_167 = (
 			},
 			{
 				id: 10962,
-				group_id: 3518,
+				groupId: 3518,
 				number: 3,
-				stage_id: 1118,
+				stageId: 1118,
 				maps: {
 					count: 3,
 					type: "BEST_OF",
@@ -413,1521 +409,1257 @@ export const SWIM_OR_SINK_167 = (
 		match: [
 			{
 				id: 31409,
-				group_id: 3508,
+				groupId: 3508,
 				number: 1,
 				opponent1: {
 					id: 14657,
 					position: 1,
 					score: 2,
-					result: "win",
-					totalPoints: 101,
 				},
 				opponent2: {
 					id: 14607,
 					position: 44,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10930,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10930,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31410,
-				group_id: 3508,
+				groupId: 3508,
 				number: 2,
 				opponent1: {
 					id: 14809,
 					position: 23,
 					score: 2,
-					result: "win",
-					totalPoints: 166,
 				},
 				opponent2: {
 					id: 14797,
 					position: 22,
 					score: 0,
-					result: "loss",
-					totalPoints: 53,
 				},
-				round_id: 10930,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10930,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31411,
-				group_id: 3508,
+				groupId: 3508,
 				number: 1,
 				opponent1: {
 					id: 14797,
 					position: 22,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14607,
 					position: 44,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10931,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10931,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31412,
-				group_id: 3508,
+				groupId: 3508,
 				number: 2,
 				opponent1: {
 					id: 14657,
 					position: 1,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14809,
 					position: 23,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10931,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10931,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31413,
-				group_id: 3508,
+				groupId: 3508,
 				number: 1,
 				opponent1: {
 					id: 14809,
 					position: 23,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14607,
 					position: 44,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10932,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10932,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31414,
-				group_id: 3508,
+				groupId: 3508,
 				number: 2,
 				opponent1: {
 					id: 14797,
 					position: 22,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14657,
 					position: 1,
 					score: 2,
-					result: "win",
-					totalPoints: 101,
 				},
-				round_id: 10932,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10932,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31415,
-				group_id: 3509,
+				groupId: 3509,
 				number: 1,
 				opponent1: {
 					id: 14800,
 					position: 2,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14739,
 					position: 43,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10933,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10933,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31416,
-				group_id: 3509,
+				groupId: 3509,
 				number: 2,
 				opponent1: {
 					id: 14709,
 					position: 24,
 					score: 2,
-					result: "win",
-					totalPoints: 171,
 				},
 				opponent2: {
 					id: 14796,
 					position: 21,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10933,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10933,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31417,
-				group_id: 3509,
+				groupId: 3509,
 				number: 1,
 				opponent1: {
 					id: 14796,
 					position: 21,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14739,
 					position: 43,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10934,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10934,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31418,
-				group_id: 3509,
+				groupId: 3509,
 				number: 2,
 				opponent1: {
 					id: 14800,
 					position: 2,
 					score: 2,
-					result: "win",
-					totalPoints: 177,
 				},
 				opponent2: {
 					id: 14709,
 					position: 24,
 					score: 1,
-					result: "loss",
-					totalPoints: 156,
 				},
-				round_id: 10934,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10934,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31419,
-				group_id: 3509,
+				groupId: 3509,
 				number: 1,
 				opponent1: {
 					id: 14709,
 					position: 24,
 					score: 2,
-					result: "win",
-					totalPoints: 268,
 				},
 				opponent2: {
 					id: 14739,
 					position: 43,
 					score: 1,
-					result: "loss",
-					totalPoints: 69,
 				},
-				round_id: 10935,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10935,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31420,
-				group_id: 3509,
+				groupId: 3509,
 				number: 2,
 				opponent1: {
 					id: 14796,
 					position: 21,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14800,
 					position: 2,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10935,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10935,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31421,
-				group_id: 3510,
+				groupId: 3510,
 				number: 1,
 				opponent1: {
 					id: 14743,
 					position: 3,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14737,
 					position: 42,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10936,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10936,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31422,
-				group_id: 3510,
+				groupId: 3510,
 				number: 2,
 				opponent1: {
 					id: 14702,
 					position: 25,
 					score: 1,
-					result: "loss",
-					totalPoints: 135,
 				},
 				opponent2: {
 					id: 14715,
 					position: 20,
 					score: 2,
-					result: "win",
-					totalPoints: 188,
 				},
-				round_id: 10936,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10936,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31423,
-				group_id: 3510,
+				groupId: 3510,
 				number: 1,
 				opponent1: {
 					id: 14715,
 					position: 20,
 					score: 2,
-					result: "win",
-					totalPoints: 180,
 				},
 				opponent2: {
 					id: 14737,
 					position: 42,
 					score: 0,
-					result: "loss",
-					totalPoints: 68,
 				},
-				round_id: 10937,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10937,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31424,
-				group_id: 3510,
+				groupId: 3510,
 				number: 2,
 				opponent1: {
 					id: 14743,
 					position: 3,
 					score: 2,
-					result: "win",
-					totalPoints: 196,
 				},
 				opponent2: {
 					id: 14702,
 					position: 25,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10937,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10937,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31425,
-				group_id: 3510,
+				groupId: 3510,
 				number: 1,
 				opponent1: {
 					id: 14702,
 					position: 25,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14737,
 					position: 42,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10938,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10938,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31426,
-				group_id: 3510,
+				groupId: 3510,
 				number: 2,
 				opponent1: {
 					id: 14715,
 					position: 20,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14743,
 					position: 3,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10938,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10938,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31427,
-				group_id: 3511,
+				groupId: 3511,
 				number: 1,
 				opponent1: {
 					id: 14801,
 					position: 4,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14620,
 					position: 41,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10939,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10939,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31428,
-				group_id: 3511,
+				groupId: 3511,
 				number: 2,
 				opponent1: {
 					id: 14735,
 					position: 26,
 					score: 2,
-					result: "win",
-					totalPoints: 196,
 				},
 				opponent2: {
 					id: 14708,
 					position: 19,
 					score: 0,
-					result: "loss",
-					totalPoints: 64,
 				},
-				round_id: 10939,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10939,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31429,
-				group_id: 3511,
+				groupId: 3511,
 				number: 1,
 				opponent1: {
 					id: 14708,
 					position: 19,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14620,
 					position: 41,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10940,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10940,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31430,
-				group_id: 3511,
+				groupId: 3511,
 				number: 2,
 				opponent1: {
 					id: 14801,
 					position: 4,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14735,
 					position: 26,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10940,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10940,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31431,
-				group_id: 3511,
+				groupId: 3511,
 				number: 1,
 				opponent1: {
 					id: 14735,
 					position: 26,
 					score: 2,
-					result: "win",
-					totalPoints: 180,
 				},
 				opponent2: {
 					id: 14620,
 					position: 41,
 					score: 0,
-					result: "loss",
-					totalPoints: 63,
 				},
-				round_id: 10941,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10941,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31432,
-				group_id: 3511,
+				groupId: 3511,
 				number: 2,
 				opponent1: {
 					id: 14708,
 					position: 19,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14801,
 					position: 4,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10941,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10941,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31433,
-				group_id: 3512,
+				groupId: 3512,
 				number: 1,
 				opponent1: {
 					id: 14792,
 					position: 5,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14808,
 					position: 40,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10942,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10942,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31434,
-				group_id: 3512,
+				groupId: 3512,
 				number: 2,
 				opponent1: {
 					id: 14798,
 					position: 27,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14653,
 					position: 18,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10942,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10942,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31435,
-				group_id: 3512,
+				groupId: 3512,
 				number: 1,
 				opponent1: {
 					id: 14653,
 					position: 18,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14808,
 					position: 40,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10943,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10943,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31436,
-				group_id: 3512,
+				groupId: 3512,
 				number: 2,
 				opponent1: {
 					id: 14792,
 					position: 5,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14798,
 					position: 27,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10943,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10943,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31437,
-				group_id: 3512,
+				groupId: 3512,
 				number: 1,
 				opponent1: {
 					id: 14798,
 					position: 27,
 					score: 2,
-					result: "win",
-					totalPoints: 222,
 				},
 				opponent2: {
 					id: 14808,
 					position: 40,
 					score: 1,
-					result: "loss",
-					totalPoints: 104,
 				},
-				round_id: 10944,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10944,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31438,
-				group_id: 3512,
+				groupId: 3512,
 				number: 2,
 				opponent1: {
 					id: 14653,
 					position: 18,
 					score: 0,
-					result: "loss",
-					totalPoints: 117,
 				},
 				opponent2: {
 					id: 14792,
 					position: 5,
 					score: 2,
-					result: "win",
-					totalPoints: 181,
 				},
-				round_id: 10944,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10944,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31439,
-				group_id: 3513,
+				groupId: 3513,
 				number: 1,
 				opponent1: {
 					id: 14670,
 					position: 6,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14696,
 					position: 39,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10945,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10945,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31440,
-				group_id: 3513,
+				groupId: 3513,
 				number: 2,
 				opponent1: {
 					id: 14663,
 					position: 28,
 					score: 1,
-					result: "loss",
-					totalPoints: 1,
 				},
 				opponent2: {
 					id: 14806,
 					position: 17,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10945,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10945,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31441,
-				group_id: 3513,
+				groupId: 3513,
 				number: 1,
 				opponent1: {
 					id: 14806,
 					position: 17,
 					score: 2,
-					result: "win",
-					totalPoints: 2,
 				},
 				opponent2: {
 					id: 14696,
 					position: 39,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10946,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10946,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31442,
-				group_id: 3513,
+				groupId: 3513,
 				number: 2,
 				opponent1: {
 					id: 14670,
 					position: 6,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14663,
 					position: 28,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10946,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10946,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31443,
-				group_id: 3513,
+				groupId: 3513,
 				number: 1,
 				opponent1: {
 					id: 14663,
 					position: 28,
 					score: 2,
-					result: "win",
-					totalPoints: 153,
 				},
 				opponent2: {
 					id: 14696,
 					position: 39,
 					score: 0,
-					result: "loss",
-					totalPoints: 38,
 				},
-				round_id: 10947,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10947,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31444,
-				group_id: 3513,
+				groupId: 3513,
 				number: 2,
 				opponent1: {
 					id: 14806,
 					position: 17,
 					score: 0,
-					result: "loss",
-					totalPoints: 17,
 				},
 				opponent2: {
 					id: 14670,
 					position: 6,
 					score: 2,
-					result: "win",
-					totalPoints: 181,
 				},
-				round_id: 10947,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10947,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31445,
-				group_id: 3514,
+				groupId: 3514,
 				number: 1,
 				opponent1: {
 					id: 14661,
 					position: 7,
 					score: 2,
-					result: "win",
-					totalPoints: 3,
 				},
 				opponent2: {
 					id: 14802,
 					position: 38,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10948,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10948,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31446,
-				group_id: 3514,
+				groupId: 3514,
 				number: 2,
 				opponent1: {
 					id: 14517,
 					position: 29,
 					score: 1,
-					result: "loss",
-					totalPoints: 100,
 				},
 				opponent2: {
 					id: 14805,
 					position: 16,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10948,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10948,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31447,
-				group_id: 3514,
+				groupId: 3514,
 				number: 1,
 				opponent1: {
 					id: 14805,
 					position: 16,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14802,
 					position: 38,
 					score: 1,
-					result: "loss",
-					totalPoints: 1,
 				},
-				round_id: 10949,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10949,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31448,
-				group_id: 3514,
+				groupId: 3514,
 				number: 2,
 				opponent1: {
 					id: 14661,
 					position: 7,
 					score: 2,
-					result: "win",
-					totalPoints: 148,
 				},
 				opponent2: {
 					id: 14517,
 					position: 29,
 					score: 0,
-					result: "loss",
-					totalPoints: 44,
 				},
-				round_id: 10949,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10949,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31449,
-				group_id: 3514,
+				groupId: 3514,
 				number: 1,
 				opponent1: {
 					id: 14517,
 					position: 29,
 					score: 2,
-					result: "win",
-					totalPoints: 154,
 				},
 				opponent2: {
 					id: 14802,
 					position: 38,
 					score: 0,
-					result: "loss",
-					totalPoints: 40,
 				},
-				round_id: 10950,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10950,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31450,
-				group_id: 3514,
+				groupId: 3514,
 				number: 2,
 				opponent1: {
 					id: 14805,
 					position: 16,
 					score: 0,
-					result: "loss",
-					totalPoints: 84,
 				},
 				opponent2: {
 					id: 14661,
 					position: 7,
 					score: 2,
-					result: "win",
-					totalPoints: 193,
 				},
-				round_id: 10950,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10950,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31451,
-				group_id: 3515,
+				groupId: 3515,
 				number: 1,
 				opponent1: {
 					id: 14804,
 					position: 8,
 					score: 2,
-					result: "win",
-					totalPoints: 185,
 				},
 				opponent2: {
 					id: 14764,
 					position: 37,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10951,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10951,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31452,
-				group_id: 3515,
+				groupId: 3515,
 				number: 2,
 				opponent1: {
 					id: 14741,
 					position: 30,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14777,
 					position: 15,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10951,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10951,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31453,
-				group_id: 3515,
+				groupId: 3515,
 				number: 1,
 				opponent1: {
 					id: 14777,
 					position: 15,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14764,
 					position: 37,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10952,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10952,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31454,
-				group_id: 3515,
+				groupId: 3515,
 				number: 2,
 				opponent1: {
 					id: 14804,
 					position: 8,
 					score: 2,
-					result: "win",
-					totalPoints: 102,
 				},
 				opponent2: {
 					id: 14741,
 					position: 30,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10952,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10952,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31455,
-				group_id: 3515,
+				groupId: 3515,
 				number: 1,
 				opponent1: {
 					id: 14741,
 					position: 30,
 					score: 2,
-					result: "win",
-					totalPoints: 3,
 				},
 				opponent2: {
 					id: 14764,
 					position: 37,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10953,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10953,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31456,
-				group_id: 3515,
+				groupId: 3515,
 				number: 2,
 				opponent1: {
 					id: 14777,
 					position: 15,
 					score: 2,
-					result: "win",
-					totalPoints: 153,
 				},
 				opponent2: {
 					id: 14804,
 					position: 8,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10953,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10953,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31457,
-				group_id: 3516,
+				groupId: 3516,
 				number: 1,
 				opponent1: {
 					id: 14732,
 					position: 9,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14742,
 					position: 36,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10954,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10954,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31458,
-				group_id: 3516,
+				groupId: 3516,
 				number: 2,
 				opponent1: {
 					id: 14655,
 					position: 31,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14445,
 					position: 14,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
-				round_id: 10954,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10954,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31459,
-				group_id: 3516,
+				groupId: 3516,
 				number: 1,
 				opponent1: {
 					id: 14445,
 					position: 14,
 					score: 2,
-					result: "win",
-					totalPoints: 102,
 				},
 				opponent2: {
 					id: 14742,
 					position: 36,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10955,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10955,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31460,
-				group_id: 3516,
+				groupId: 3516,
 				number: 2,
 				opponent1: {
 					id: 14732,
 					position: 9,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14655,
 					position: 31,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10955,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10955,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31461,
-				group_id: 3516,
+				groupId: 3516,
 				number: 1,
 				opponent1: {
 					id: 14655,
 					position: 31,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14742,
 					position: 36,
 					score: 2,
-					result: "win",
-					totalPoints: 101,
 				},
-				round_id: 10956,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10956,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31462,
-				group_id: 3516,
+				groupId: 3516,
 				number: 2,
 				opponent1: {
 					id: 14445,
 					position: 14,
 					score: 0,
-					result: "loss",
-					totalPoints: 40,
 				},
 				opponent2: {
 					id: 14732,
 					position: 9,
 					score: 2,
-					result: "win",
-					totalPoints: 155,
 				},
-				round_id: 10956,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10956,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31463,
-				group_id: 3517,
+				groupId: 3517,
 				number: 1,
 				opponent1: {
 					id: 14747,
 					position: 10,
 					score: 2,
-					result: "win",
-					totalPoints: 3,
 				},
 				opponent2: {
 					id: 14687,
 					position: 35,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10957,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10957,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31464,
-				group_id: 3517,
+				groupId: 3517,
 				number: 2,
 				opponent1: {
 					id: 14799,
 					position: 32,
 					score: 1,
-					result: "loss",
-					totalPoints: 172,
 				},
 				opponent2: {
 					id: 14795,
 					position: 13,
 					score: 2,
-					result: "win",
-					totalPoints: 186,
 				},
-				round_id: 10957,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10957,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31465,
-				group_id: 3517,
+				groupId: 3517,
 				number: 1,
 				opponent1: {
 					id: 14795,
 					position: 13,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14687,
 					position: 35,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10958,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10958,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31466,
-				group_id: 3517,
+				groupId: 3517,
 				number: 2,
 				opponent1: {
 					id: 14747,
 					position: 10,
 					score: 1,
-					result: "loss",
-					totalPoints: 2,
 				},
 				opponent2: {
 					id: 14799,
 					position: 32,
 					score: 2,
-					result: "win",
-					totalPoints: 3,
 				},
-				round_id: 10958,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10958,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31467,
-				group_id: 3517,
+				groupId: 3517,
 				number: 1,
 				opponent1: {
 					id: 14799,
 					position: 32,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14687,
 					position: 35,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10959,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10959,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31468,
-				group_id: 3517,
+				groupId: 3517,
 				number: 2,
 				opponent1: {
 					id: 14795,
 					position: 13,
 					score: 2,
-					result: "win",
-					totalPoints: 198,
 				},
 				opponent2: {
 					id: 14747,
 					position: 10,
 					score: 1,
-					result: "loss",
-					totalPoints: 189,
 				},
-				round_id: 10959,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10959,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31469,
-				group_id: 3518,
+				groupId: 3518,
 				number: 1,
 				opponent1: {
 					id: 14748,
 					position: 11,
 					score: 2,
-					result: "win",
-					totalPoints: 172,
 				},
 				opponent2: {
 					id: 14713,
 					position: 34,
 					score: 0,
-					result: "loss",
-					totalPoints: 32,
 				},
-				round_id: 10960,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10960,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31470,
-				group_id: 3518,
+				groupId: 3518,
 				number: 2,
 				opponent1: {
 					id: 14733,
 					position: 33,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
 				opponent2: {
 					id: 14803,
 					position: 12,
 					score: 2,
-					result: "win",
-					totalPoints: 160,
 				},
-				round_id: 10960,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10960,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 31471,
-				group_id: 3518,
+				groupId: 3518,
 				number: 1,
 				opponent1: {
 					id: 14803,
 					position: 12,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14713,
 					position: 34,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10961,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10961,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31472,
-				group_id: 3518,
+				groupId: 3518,
 				number: 2,
 				opponent1: {
 					id: 14748,
 					position: 11,
 					score: 2,
-					result: "win",
-					totalPoints: 200,
 				},
 				opponent2: {
 					id: 14733,
 					position: 33,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10961,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10961,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31473,
-				group_id: 3518,
+				groupId: 3518,
 				number: 1,
 				opponent1: {
 					id: 14733,
 					position: 33,
 					score: 2,
-					result: "win",
-					totalPoints: 161,
 				},
 				opponent2: {
 					id: 14713,
 					position: 34,
 					score: 0,
-					result: "loss",
-					totalPoints: 0,
 				},
-				round_id: 10962,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10962,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 31474,
-				group_id: 3518,
+				groupId: 3518,
 				number: 2,
 				opponent1: {
 					id: 14803,
 					position: 12,
 					score: 2,
-					result: "win",
-					totalPoints: 170,
 				},
 				opponent2: {
 					id: 14748,
 					position: 11,
 					score: 0,
-					result: "loss",
-					totalPoints: 65,
 				},
-				round_id: 10962,
-				stage_id: 1118,
-				status: 4,
+				roundId: 10962,
+				stageId: 1118,
 				startedAt: null,
+				winnerSide: "opponent1",
 			},
 		],
 	},
diff --git a/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts b/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
index d680142ef..7317f3ddc 100644
--- a/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
@@ -9,12 +9,9 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 				name: "Main Bracket",
 				number: 1,
 				settings: {
-					swiss: {
-						groupCount: 1,
-						roundCount: 4,
-					},
+					groupCount: 1,
+					roundCount: 4,
 				},
-				tournament_id: 891,
 				type: "swiss",
 				createdAt: 1734685232,
 			},
@@ -23,15 +20,15 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 			{
 				id: 4443,
 				number: 1,
-				stage_id: 1457,
+				stageId: 1457,
 			},
 		],
 		round: [
 			{
 				id: 13715,
-				group_id: 4443,
+				groupId: 4443,
 				number: 1,
-				stage_id: 1457,
+				stageId: 1457,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -40,9 +37,9 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 			},
 			{
 				id: 13716,
-				group_id: 4443,
+				groupId: 4443,
 				number: 2,
-				stage_id: 1457,
+				stageId: 1457,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -51,9 +48,9 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 			},
 			{
 				id: 13717,
-				group_id: 4443,
+				groupId: 4443,
 				number: 3,
-				stage_id: 1457,
+				stageId: 1457,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -62,9 +59,9 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 			},
 			{
 				id: 13718,
-				group_id: 4443,
+				groupId: 4443,
 				number: 4,
-				stage_id: 1457,
+				stageId: 1457,
 				maps: {
 					count: 5,
 					type: "BEST_OF",
@@ -75,213 +72,195 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
 		match: [
 			{
 				id: 38584,
-				group_id: 4443,
+				groupId: 4443,
 				number: 1,
 				opponent1: {
 					id: 18248,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18266,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13715,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13715,
+				stageId: 1457,
 				startedAt: 1734685232,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38585,
-				group_id: 4443,
+				groupId: 4443,
 				number: 2,
 				opponent1: {
 					id: 18037,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18212,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13715,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13715,
+				stageId: 1457,
 				startedAt: 1734685232,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38586,
-				group_id: 4443,
+				groupId: 4443,
 				number: 3,
 				opponent1: {
 					id: 18255,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18019,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13715,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13715,
+				stageId: 1457,
 				startedAt: 1734685232,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38587,
-				group_id: 4443,
+				groupId: 4443,
 				number: 4,
 				opponent1: {
 					id: 18210,
 				},
 				opponent2: null,
-				round_id: 13715,
-				stage_id: 1457,
-				status: 2,
+				roundId: 13715,
+				stageId: 1457,
 				startedAt: 1734685232,
+				winnerSide: null,
 			},
 			{
 				id: 38588,
-				group_id: 4443,
+				groupId: 4443,
 				number: 1,
 				opponent1: {
 					id: 18248,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18210,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13716,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13716,
+				stageId: 1457,
 				startedAt: 1734687519,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38589,
-				group_id: 4443,
+				groupId: 4443,
 				number: 2,
 				opponent1: {
 					id: 18037,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18255,
 					score: 2,
-					result: "loss",
 				},
-				round_id: 13716,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13716,
+				stageId: 1457,
 				startedAt: 1734687519,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38590,
-				group_id: 4443,
+				groupId: 4443,
 				number: 3,
 				opponent1: {
 					id: 18266,
 					score: 3,
-					result: "win",
 				},
 				opponent2: {
 					id: 18212,
 					score: 0,
-					result: "loss",
 				},
-				round_id: 13716,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13716,
+				stageId: 1457,
 				startedAt: 1734687519,
+				winnerSide: "opponent1",
 			},
 			{
 				id: 38591,
-				group_id: 4443,
+				groupId: 4443,
 				number: 4,
 				opponent1: {
 					id: 18019,
 				},
 				opponent2: null,
-				round_id: 13716,
-				stage_id: 1457,
-				status: 2,
+				roundId: 13716,
+				stageId: 1457,
 				startedAt: 1734687519,
+				winnerSide: null,
 			},
 			{
 				id: 38592,
-				group_id: 4443,
+				groupId: 4443,
 				number: 1,
 				opponent1: {
 					id: 18248,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 18037,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13717,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13717,
+				stageId: 1457,
 				startedAt: 1734689680,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 38593,
-				group_id: 4443,
+				groupId: 4443,
 				number: 2,
 				opponent1: {
 					id: 18019,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 18266,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13717,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13717,
+				stageId: 1457,
 				startedAt: 1734689680,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 38594,
-				group_id: 4443,
+				groupId: 4443,
 				number: 3,
 				opponent1: {
 					id: 18210,
 					score: 0,
-					result: "loss",
 				},
 				opponent2: {
 					id: 18255,
 					score: 3,
-					result: "win",
 				},
-				round_id: 13717,
-				stage_id: 1457,
-				status: 4,
+				roundId: 13717,
+				stageId: 1457,
 				startedAt: 1734689680,
+				winnerSide: "opponent2",
 			},
 			{
 				id: 38595,
-				group_id: 4443,
+				groupId: 4443,
 				number: 4,
 				opponent1: {
 					id: 18212,
 				},
 				opponent2: null,
-				round_id: 13717,
-				stage_id: 1457,
-				status: 2,
+				roundId: 13717,
+				stageId: 1457,
 				startedAt: 1734689680,
+				winnerSide: null,
 			},
 		],
 	},
diff --git a/app/features/tournament-bracket/core/tests/mocks.ts b/app/features/tournament-bracket/core/tests/mocks.ts
index 404eac822..a2af8955a 100644
--- a/app/features/tournament-bracket/core/tests/mocks.ts
+++ b/app/features/tournament-bracket/core/tests/mocks.ts
@@ -10,11 +10,7 @@ export const PADDLING_POOL_257 = () =>
 					number: 1,
 					settings: {
 						groupCount: 9,
-						seedOrdering: ["groups.seed_optimized"],
-						roundRobinMode: "simple",
-						size: 35,
 					},
-					tournament_id: 27,
 					type: "round_robin",
 				},
 			],
@@ -22,1374 +18,1170 @@ export const PADDLING_POOL_257 = () =>
 				{
 					id: 85,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 86,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 87,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 88,
 					number: 4,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 89,
 					number: 5,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 90,
 					number: 6,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 91,
 					number: 7,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 92,
 					number: 8,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 93,
 					number: 9,
-					stage_id: 28,
+					stageId: 28,
 				},
 			],
 			round: [
 				{
 					id: 386,
-					group_id: 85,
+					groupId: 85,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 387,
-					group_id: 85,
+					groupId: 85,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 388,
-					group_id: 85,
+					groupId: 85,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 389,
-					group_id: 86,
+					groupId: 86,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 390,
-					group_id: 86,
+					groupId: 86,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 391,
-					group_id: 86,
+					groupId: 86,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 392,
-					group_id: 87,
+					groupId: 87,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 393,
-					group_id: 87,
+					groupId: 87,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 394,
-					group_id: 87,
+					groupId: 87,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 395,
-					group_id: 88,
+					groupId: 88,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 396,
-					group_id: 88,
+					groupId: 88,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 397,
-					group_id: 88,
+					groupId: 88,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 398,
-					group_id: 89,
+					groupId: 89,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 399,
-					group_id: 89,
+					groupId: 89,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 400,
-					group_id: 89,
+					groupId: 89,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 401,
-					group_id: 90,
+					groupId: 90,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 402,
-					group_id: 90,
+					groupId: 90,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 403,
-					group_id: 90,
+					groupId: 90,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 404,
-					group_id: 91,
+					groupId: 91,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 405,
-					group_id: 91,
+					groupId: 91,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 406,
-					group_id: 91,
+					groupId: 91,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 407,
-					group_id: 92,
+					groupId: 92,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 408,
-					group_id: 92,
+					groupId: 92,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 409,
-					group_id: 92,
+					groupId: 92,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 410,
-					group_id: 93,
+					groupId: 93,
 					number: 1,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 411,
-					group_id: 93,
+					groupId: 93,
 					number: 2,
-					stage_id: 28,
+					stageId: 28,
 				},
 				{
 					id: 412,
-					group_id: 93,
+					groupId: 93,
 					number: 3,
-					stage_id: 28,
+					stageId: 28,
 				},
 			],
 			match: [
 				{
 					id: 1718,
-					group_id: 85,
+					groupId: 85,
 					number: 1,
 					opponent1: {
 						id: 892,
 						position: 1,
 					},
 					opponent2: null,
-					round_id: 386,
-					stage_id: 28,
-					status: 2,
+					roundId: 386,
+					stageId: 28,
+					winnerSide: null,
 				},
 				{
 					id: 1719,
-					group_id: 85,
+					groupId: 85,
 					number: 2,
 					opponent1: {
 						id: 902,
 						position: 19,
 						score: 1,
-						result: "loss",
-						totalPoints: 128,
 					},
 					opponent2: {
 						id: 882,
 						position: 18,
 						score: 2,
-						result: "win",
-						totalPoints: 232,
 					},
-					round_id: 386,
-					stage_id: 28,
-					status: 4,
+					roundId: 386,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1720,
-					group_id: 85,
+					groupId: 85,
 					number: 1,
 					opponent1: {
 						id: 882,
 						position: 18,
 					},
 					opponent2: null,
-					round_id: 387,
-					stage_id: 28,
-					status: 2,
+					roundId: 387,
+					stageId: 28,
+					winnerSide: null,
 				},
 				{
 					id: 1721,
-					group_id: 85,
+					groupId: 85,
 					number: 2,
 					opponent1: {
 						id: 892,
 						position: 1,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 902,
 						position: 19,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 387,
-					stage_id: 28,
-					status: 4,
+					roundId: 387,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1722,
-					group_id: 85,
+					groupId: 85,
 					number: 1,
 					opponent1: {
 						id: 902,
 						position: 19,
 					},
 					opponent2: null,
-					round_id: 388,
-					stage_id: 28,
-					status: 2,
+					roundId: 388,
+					stageId: 28,
+					winnerSide: null,
 				},
 				{
 					id: 1723,
-					group_id: 85,
+					groupId: 85,
 					number: 2,
 					opponent1: {
 						id: 882,
 						position: 18,
 						score: 0,
-						result: "loss",
-						totalPoints: 20,
 					},
 					opponent2: {
 						id: 892,
 						position: 1,
 						score: 2,
-						result: "win",
-						totalPoints: 143,
 					},
-					round_id: 388,
-					stage_id: 28,
-					status: 4,
+					roundId: 388,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1724,
-					group_id: 86,
+					groupId: 86,
 					number: 1,
 					opponent1: {
 						id: 881,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 838,
 						position: 35,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 389,
-					stage_id: 28,
-					status: 4,
+					roundId: 389,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1725,
-					group_id: 86,
+					groupId: 86,
 					number: 2,
 					opponent1: {
 						id: 898,
 						position: 20,
 						score: 2,
-						result: "win",
-						totalPoints: 160,
 					},
 					opponent2: {
 						id: 889,
 						position: 17,
 						score: 0,
-						result: "loss",
-						totalPoints: 36,
 					},
-					round_id: 389,
-					stage_id: 28,
-					status: 4,
+					roundId: 389,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1726,
-					group_id: 86,
+					groupId: 86,
 					number: 1,
 					opponent1: {
 						id: 889,
 						position: 17,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 838,
 						position: 35,
 						score: 1,
-						result: "loss",
-						totalPoints: 100,
 					},
-					round_id: 390,
-					stage_id: 28,
-					status: 4,
+					roundId: 390,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1727,
-					group_id: 86,
+					groupId: 86,
 					number: 2,
 					opponent1: {
 						id: 881,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 898,
 						position: 20,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 390,
-					stage_id: 28,
-					status: 4,
+					roundId: 390,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1728,
-					group_id: 86,
+					groupId: 86,
 					number: 1,
 					opponent1: {
 						id: 898,
 						position: 20,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
 					opponent2: {
 						id: 838,
 						position: 35,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 391,
-					stage_id: 28,
-					status: 4,
+					roundId: 391,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1729,
-					group_id: 86,
+					groupId: 86,
 					number: 2,
 					opponent1: {
 						id: 889,
 						position: 17,
 						score: 0,
-						result: "loss",
-						totalPoints: 43,
 					},
 					opponent2: {
 						id: 881,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 193,
 					},
-					round_id: 391,
-					stage_id: 28,
-					status: 4,
+					roundId: 391,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1730,
-					group_id: 87,
+					groupId: 87,
 					number: 1,
 					opponent1: {
 						id: 891,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 847,
 						position: 34,
 						score: 1,
-						result: "loss",
-						totalPoints: 1,
 					},
-					round_id: 392,
-					stage_id: 28,
-					status: 4,
+					roundId: 392,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1731,
-					group_id: 87,
+					groupId: 87,
 					number: 2,
 					opponent1: {
 						id: 874,
 						position: 21,
 						score: 2,
-						result: "win",
-						totalPoints: 117,
 					},
 					opponent2: {
 						id: 901,
 						position: 16,
 						score: 1,
-						result: "loss",
-						totalPoints: 188,
 					},
-					round_id: 392,
-					stage_id: 28,
-					status: 4,
+					roundId: 392,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1732,
-					group_id: 87,
+					groupId: 87,
 					number: 1,
 					opponent1: {
 						id: 901,
 						position: 16,
 						score: 2,
-						result: "win",
-						totalPoints: 157,
 					},
 					opponent2: {
 						id: 847,
 						position: 34,
 						score: 0,
-						result: "loss",
-						totalPoints: 53,
 					},
-					round_id: 393,
-					stage_id: 28,
-					status: 4,
+					roundId: 393,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1733,
-					group_id: 87,
+					groupId: 87,
 					number: 2,
 					opponent1: {
 						id: 891,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 150,
 					},
 					opponent2: {
 						id: 874,
 						position: 21,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 393,
-					stage_id: 28,
-					status: 4,
+					roundId: 393,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1734,
-					group_id: 87,
+					groupId: 87,
 					number: 1,
 					opponent1: {
 						id: 874,
 						position: 21,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
 					opponent2: {
 						id: 847,
 						position: 34,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 394,
-					stage_id: 28,
-					status: 4,
+					roundId: 394,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1735,
-					group_id: 87,
+					groupId: 87,
 					number: 2,
 					opponent1: {
 						id: 901,
 						position: 16,
 						score: 0,
-						result: "loss",
-						totalPoints: 71,
 					},
 					opponent2: {
 						id: 891,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 179,
 					},
-					round_id: 394,
-					stage_id: 28,
-					status: 4,
+					roundId: 394,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1736,
-					group_id: 88,
+					groupId: 88,
 					number: 1,
 					opponent1: {
 						id: 890,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 172,
 					},
 					opponent2: {
 						id: 896,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 61,
 					},
-					round_id: 395,
-					stage_id: 28,
-					status: 4,
+					roundId: 395,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1737,
-					group_id: 88,
+					groupId: 88,
 					number: 2,
 					opponent1: {
 						id: 869,
 						position: 22,
 						score: 2,
-						result: "win",
-						totalPoints: 175,
 					},
 					opponent2: {
 						id: 878,
 						position: 15,
 						score: 0,
-						result: "loss",
-						totalPoints: 46,
 					},
-					round_id: 395,
-					stage_id: 28,
-					status: 4,
+					roundId: 395,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1738,
-					group_id: 88,
+					groupId: 88,
 					number: 1,
 					opponent1: {
 						id: 878,
 						position: 15,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 896,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 396,
-					stage_id: 28,
-					status: 4,
+					roundId: 396,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1739,
-					group_id: 88,
+					groupId: 88,
 					number: 2,
 					opponent1: {
 						id: 890,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 182,
 					},
 					opponent2: {
 						id: 869,
 						position: 22,
 						score: 0,
-						result: "loss",
-						totalPoints: 72,
 					},
-					round_id: 396,
-					stage_id: 28,
-					status: 4,
+					roundId: 396,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1740,
-					group_id: 88,
+					groupId: 88,
 					number: 1,
 					opponent1: {
 						id: 869,
 						position: 22,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
 					opponent2: {
 						id: 896,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 397,
-					stage_id: 28,
-					status: 4,
+					roundId: 397,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1741,
-					group_id: 88,
+					groupId: 88,
 					number: 2,
 					opponent1: {
 						id: 878,
 						position: 15,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 890,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 397,
-					stage_id: 28,
-					status: 4,
+					roundId: 397,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1742,
-					group_id: 89,
+					groupId: 89,
 					number: 1,
 					opponent1: {
 						id: 886,
 						position: 5,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
 					opponent2: {
 						id: 819,
 						position: 32,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 398,
-					stage_id: 28,
-					status: 4,
+					roundId: 398,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1743,
-					group_id: 89,
+					groupId: 89,
 					number: 2,
 					opponent1: {
 						id: 843,
 						position: 23,
 						score: 0,
-						result: "loss",
-						totalPoints: 81,
 					},
 					opponent2: {
 						id: 845,
 						position: 14,
 						score: 2,
-						result: "win",
-						totalPoints: 103,
 					},
-					round_id: 398,
-					stage_id: 28,
-					status: 4,
+					roundId: 398,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1744,
-					group_id: 89,
+					groupId: 89,
 					number: 1,
 					opponent1: {
 						id: 845,
 						position: 14,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 819,
 						position: 32,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 399,
-					stage_id: 28,
-					status: 4,
+					roundId: 399,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1745,
-					group_id: 89,
+					groupId: 89,
 					number: 2,
 					opponent1: {
 						id: 886,
 						position: 5,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
 					opponent2: {
 						id: 843,
 						position: 23,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 399,
-					stage_id: 28,
-					status: 4,
+					roundId: 399,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1746,
-					group_id: 89,
+					groupId: 89,
 					number: 1,
 					opponent1: {
 						id: 843,
 						position: 23,
 						score: 2,
-						result: "win",
-						totalPoints: 199,
 					},
 					opponent2: {
 						id: 819,
 						position: 32,
 						score: 1,
-						result: "loss",
-						totalPoints: 135,
 					},
-					round_id: 400,
-					stage_id: 28,
-					status: 4,
+					roundId: 400,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1747,
-					group_id: 89,
+					groupId: 89,
 					number: 2,
 					opponent1: {
 						id: 845,
 						position: 14,
 						score: 1,
-						result: "loss",
-						totalPoints: 1,
 					},
 					opponent2: {
 						id: 886,
 						position: 5,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
-					round_id: 400,
-					stage_id: 28,
-					status: 4,
+					roundId: 400,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1748,
-					group_id: 90,
+					groupId: 90,
 					number: 1,
 					opponent1: {
 						id: 867,
 						position: 6,
 						score: 2,
-						result: "win",
-						totalPoints: 175,
 					},
 					opponent2: {
 						id: 872,
 						position: 31,
 						score: 0,
-						result: "loss",
-						totalPoints: 4,
 					},
-					round_id: 401,
-					stage_id: 28,
-					status: 4,
+					roundId: 401,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1749,
-					group_id: 90,
+					groupId: 90,
 					number: 2,
 					opponent1: {
 						id: 870,
 						position: 24,
 						score: 0,
-						result: "loss",
-						totalPoints: 37,
 					},
 					opponent2: {
 						id: 871,
 						position: 13,
 						score: 2,
-						result: "win",
-						totalPoints: 74,
 					},
-					round_id: 401,
-					stage_id: 28,
-					status: 4,
+					roundId: 401,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1750,
-					group_id: 90,
+					groupId: 90,
 					number: 1,
 					opponent1: {
 						id: 871,
 						position: 13,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
 					opponent2: {
 						id: 872,
 						position: 31,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 402,
-					stage_id: 28,
-					status: 4,
+					roundId: 402,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1751,
-					group_id: 90,
+					groupId: 90,
 					number: 2,
 					opponent1: {
 						id: 867,
 						position: 6,
 						score: 2,
-						result: "win",
-						totalPoints: 172,
 					},
 					opponent2: {
 						id: 870,
 						position: 24,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 402,
-					stage_id: 28,
-					status: 4,
+					roundId: 402,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1752,
-					group_id: 90,
+					groupId: 90,
 					number: 1,
 					opponent1: {
 						id: 870,
 						position: 24,
 						score: 0,
-						result: "loss",
-						totalPoints: 60,
 					},
 					opponent2: {
 						id: 872,
 						position: 31,
 						score: 2,
-						result: "win",
-						totalPoints: 188,
 					},
-					round_id: 403,
-					stage_id: 28,
-					status: 4,
+					roundId: 403,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1753,
-					group_id: 90,
+					groupId: 90,
 					number: 2,
 					opponent1: {
 						id: 871,
 						position: 13,
 						score: 1,
-						result: "loss",
-						totalPoints: 100,
 					},
 					opponent2: {
 						id: 867,
 						position: 6,
 						score: 2,
-						result: "win",
-						totalPoints: 132,
 					},
-					round_id: 403,
-					stage_id: 28,
-					status: 4,
+					roundId: 403,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1754,
-					group_id: 91,
+					groupId: 91,
 					number: 1,
 					opponent1: {
 						id: 884,
 						position: 7,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
 					opponent2: {
 						id: 897,
 						position: 30,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 404,
-					stage_id: 28,
-					status: 4,
+					roundId: 404,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1755,
-					group_id: 91,
+					groupId: 91,
 					number: 2,
 					opponent1: {
 						id: 893,
 						position: 25,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 828,
 						position: 12,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
-					round_id: 404,
-					stage_id: 28,
-					status: 4,
+					roundId: 404,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1756,
-					group_id: 91,
+					groupId: 91,
 					number: 1,
 					opponent1: {
 						id: 828,
 						position: 12,
 						score: 2,
-						result: "win",
-						totalPoints: 170,
 					},
 					opponent2: {
 						id: 897,
 						position: 30,
 						score: 0,
-						result: "loss",
-						totalPoints: 112,
 					},
-					round_id: 405,
-					stage_id: 28,
-					status: 4,
+					roundId: 405,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1757,
-					group_id: 91,
+					groupId: 91,
 					number: 2,
 					opponent1: {
 						id: 884,
 						position: 7,
 						score: 2,
-						result: "win",
-						totalPoints: 152,
 					},
 					opponent2: {
 						id: 893,
 						position: 25,
 						score: 0,
-						result: "loss",
-						totalPoints: 23,
 					},
-					round_id: 405,
-					stage_id: 28,
-					status: 4,
+					roundId: 405,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1758,
-					group_id: 91,
+					groupId: 91,
 					number: 1,
 					opponent1: {
 						id: 893,
 						position: 25,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 897,
 						position: 30,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
-					round_id: 406,
-					stage_id: 28,
-					status: 4,
+					roundId: 406,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1759,
-					group_id: 91,
+					groupId: 91,
 					number: 2,
 					opponent1: {
 						id: 828,
 						position: 12,
 						score: 2,
-						result: "win",
-						totalPoints: 160,
 					},
 					opponent2: {
 						id: 884,
 						position: 7,
 						score: 1,
-						result: "loss",
-						totalPoints: 218,
 					},
-					round_id: 406,
-					stage_id: 28,
-					status: 4,
+					roundId: 406,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1760,
-					group_id: 92,
+					groupId: 92,
 					number: 1,
 					opponent1: {
 						id: 879,
 						position: 8,
 						score: 2,
-						result: "win",
-						totalPoints: 199,
 					},
 					opponent2: {
 						id: 887,
 						position: 29,
 						score: 0,
-						result: "loss",
-						totalPoints: 52,
 					},
-					round_id: 407,
-					stage_id: 28,
-					status: 4,
+					roundId: 407,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1761,
-					group_id: 92,
+					groupId: 92,
 					number: 2,
 					opponent1: {
 						id: 883,
 						position: 26,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 900,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 407,
-					stage_id: 28,
-					status: 4,
+					roundId: 407,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1762,
-					group_id: 92,
+					groupId: 92,
 					number: 1,
 					opponent1: {
 						id: 900,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 887,
 						position: 29,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 408,
-					stage_id: 28,
-					status: 4,
+					roundId: 408,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1763,
-					group_id: 92,
+					groupId: 92,
 					number: 2,
 					opponent1: {
 						id: 879,
 						position: 8,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 883,
 						position: 26,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 408,
-					stage_id: 28,
-					status: 4,
+					roundId: 408,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1764,
-					group_id: 92,
+					groupId: 92,
 					number: 1,
 					opponent1: {
 						id: 883,
 						position: 26,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 887,
 						position: 29,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 409,
-					stage_id: 28,
-					status: 4,
+					roundId: 409,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1765,
-					group_id: 92,
+					groupId: 92,
 					number: 2,
 					opponent1: {
 						id: 900,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 149,
 					},
 					opponent2: {
 						id: 879,
 						position: 8,
 						score: 0,
-						result: "loss",
-						totalPoints: 40,
 					},
-					round_id: 409,
-					stage_id: 28,
-					status: 4,
+					roundId: 409,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1766,
-					group_id: 93,
+					groupId: 93,
 					number: 1,
 					opponent1: {
 						id: 888,
 						position: 9,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 873,
 						position: 28,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 410,
-					stage_id: 28,
-					status: 4,
+					roundId: 410,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1767,
-					group_id: 93,
+					groupId: 93,
 					number: 2,
 					opponent1: {
 						id: 839,
 						position: 27,
 						score: 1,
-						result: "loss",
-						totalPoints: 98,
 					},
 					opponent2: {
 						id: 875,
 						position: 10,
 						score: 2,
-						result: "win",
-						totalPoints: 174,
 					},
-					round_id: 410,
-					stage_id: 28,
-					status: 4,
+					roundId: 410,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1768,
-					group_id: 93,
+					groupId: 93,
 					number: 1,
 					opponent1: {
 						id: 875,
 						position: 10,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 873,
 						position: 28,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 411,
-					stage_id: 28,
-					status: 4,
+					roundId: 411,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1769,
-					group_id: 93,
+					groupId: 93,
 					number: 2,
 					opponent1: {
 						id: 888,
 						position: 9,
 						score: 2,
-						result: "win",
-						totalPoints: 191,
 					},
 					opponent2: {
 						id: 839,
 						position: 27,
 						score: 0,
-						result: "loss",
-						totalPoints: 19,
 					},
-					round_id: 411,
-					stage_id: 28,
-					status: 4,
+					roundId: 411,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1770,
-					group_id: 93,
+					groupId: 93,
 					number: 1,
 					opponent1: {
 						id: 839,
 						position: 27,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 873,
 						position: 28,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 412,
-					stage_id: 28,
-					status: 4,
+					roundId: 412,
+					stageId: 28,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1771,
-					group_id: 93,
+					groupId: 93,
 					number: 2,
 					opponent1: {
 						id: 875,
 						position: 10,
 						score: 1,
-						result: "loss",
-						totalPoints: 184,
 					},
 					opponent2: {
 						id: 888,
 						position: 9,
 						score: 2,
-						result: "win",
-						totalPoints: 117,
 					},
-					round_id: 412,
-					stage_id: 28,
-					status: 4,
+					roundId: 412,
+					stageId: 28,
+					winnerSide: "opponent2",
 				},
 			],
 		},
@@ -6926,11 +6718,7 @@ export const PADDLING_POOL_255 = () =>
 					number: 1,
 					settings: {
 						groupCount: 9,
-						seedOrdering: ["groups.seed_optimized"],
-						roundRobinMode: "simple",
-						size: 35,
 					},
-					tournament_id: 18,
 					type: "round_robin",
 					createdAt: 1708538411,
 				},
@@ -6939,1455 +6727,1251 @@ export const PADDLING_POOL_255 = () =>
 				{
 					id: 56,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 57,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 58,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 59,
 					number: 4,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 60,
 					number: 5,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 61,
 					number: 6,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 62,
 					number: 7,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 63,
 					number: 8,
-					stage_id: 20,
+					stageId: 20,
 				},
 				{
 					id: 64,
 					number: 9,
-					stage_id: 20,
+					stageId: 20,
 				},
 			],
 			round: [
 				{
 					id: 285,
-					group_id: 56,
+					groupId: 56,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 286,
-					group_id: 56,
+					groupId: 56,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 287,
-					group_id: 56,
+					groupId: 56,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 288,
-					group_id: 57,
+					groupId: 57,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 289,
-					group_id: 57,
+					groupId: 57,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 290,
-					group_id: 57,
+					groupId: 57,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 291,
-					group_id: 58,
+					groupId: 58,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 292,
-					group_id: 58,
+					groupId: 58,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 293,
-					group_id: 58,
+					groupId: 58,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 294,
-					group_id: 59,
+					groupId: 59,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 295,
-					group_id: 59,
+					groupId: 59,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 296,
-					group_id: 59,
+					groupId: 59,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 297,
-					group_id: 60,
+					groupId: 60,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 298,
-					group_id: 60,
+					groupId: 60,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 299,
-					group_id: 60,
+					groupId: 60,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 300,
-					group_id: 61,
+					groupId: 61,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 301,
-					group_id: 61,
+					groupId: 61,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 302,
-					group_id: 61,
+					groupId: 61,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 303,
-					group_id: 62,
+					groupId: 62,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 304,
-					group_id: 62,
+					groupId: 62,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 305,
-					group_id: 62,
+					groupId: 62,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 306,
-					group_id: 63,
+					groupId: 63,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 307,
-					group_id: 63,
+					groupId: 63,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 308,
-					group_id: 63,
+					groupId: 63,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 309,
-					group_id: 64,
+					groupId: 64,
 					number: 1,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 310,
-					group_id: 64,
+					groupId: 64,
 					number: 2,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 				{
 					id: 311,
-					group_id: 64,
+					groupId: 64,
 					number: 3,
-					stage_id: 20,
+					stageId: 20,
 					maps: null,
 				},
 			],
 			match: [
 				{
 					id: 1426,
-					group_id: 56,
+					groupId: 56,
 					number: 1,
 					opponent1: {
 						id: 698,
 						position: 1,
 					},
 					opponent2: null,
-					round_id: 285,
-					stage_id: 20,
-					status: 2,
+					roundId: 285,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: null,
 				},
 				{
 					id: 1427,
-					group_id: 56,
+					groupId: 56,
 					number: 2,
 					opponent1: {
 						id: 673,
 						position: 19,
 						score: 2,
-						result: "win",
-						totalPoints: 82,
 					},
 					opponent2: {
 						id: 707,
 						position: 18,
 						score: 0,
-						result: "loss",
-						totalPoints: 80,
 					},
-					round_id: 285,
-					stage_id: 20,
-					status: 4,
+					roundId: 285,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1428,
-					group_id: 56,
+					groupId: 56,
 					number: 1,
 					opponent1: {
 						id: 707,
 						position: 18,
 					},
 					opponent2: null,
-					round_id: 286,
-					stage_id: 20,
-					status: 2,
+					roundId: 286,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: null,
 				},
 				{
 					id: 1429,
-					group_id: 56,
+					groupId: 56,
 					number: 2,
 					opponent1: {
 						id: 698,
 						position: 1,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 673,
 						position: 19,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 286,
-					stage_id: 20,
-					status: 4,
+					roundId: 286,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1430,
-					group_id: 56,
+					groupId: 56,
 					number: 1,
 					opponent1: {
 						id: 673,
 						position: 19,
 					},
 					opponent2: null,
-					round_id: 287,
-					stage_id: 20,
-					status: 2,
+					roundId: 287,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: null,
 				},
 				{
 					id: 1431,
-					group_id: 56,
+					groupId: 56,
 					number: 2,
 					opponent1: {
 						id: 707,
 						position: 18,
 						score: 0,
-						result: "loss",
-						totalPoints: 55,
 					},
 					opponent2: {
 						id: 698,
 						position: 1,
 						score: 2,
-						result: "win",
-						totalPoints: 156,
 					},
-					round_id: 287,
-					stage_id: 20,
-					status: 4,
+					roundId: 287,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1432,
-					group_id: 57,
+					groupId: 57,
 					number: 1,
 					opponent1: {
 						id: 718,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 700,
 						position: 35,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 288,
-					stage_id: 20,
-					status: 4,
+					roundId: 288,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1433,
-					group_id: 57,
+					groupId: 57,
 					number: 2,
 					opponent1: {
 						id: 714,
 						position: 20,
 						score: 1,
-						result: "loss",
-						totalPoints: 119,
 					},
 					opponent2: {
 						id: 678,
 						position: 17,
 						score: 2,
-						result: "win",
-						totalPoints: 221,
 					},
-					round_id: 288,
-					stage_id: 20,
-					status: 4,
+					roundId: 288,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1434,
-					group_id: 57,
+					groupId: 57,
 					number: 1,
 					opponent1: {
 						id: 678,
 						position: 17,
 						score: 2,
-						result: "win",
-						totalPoints: 190,
 					},
 					opponent2: {
 						id: 700,
 						position: 35,
 						score: 0,
-						result: "loss",
-						totalPoints: 78,
 					},
-					round_id: 289,
-					stage_id: 20,
-					status: 4,
+					roundId: 289,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1435,
-					group_id: 57,
+					groupId: 57,
 					number: 2,
 					opponent1: {
 						id: 718,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 168,
 					},
 					opponent2: {
 						id: 714,
 						position: 20,
 						score: 0,
-						result: "loss",
-						totalPoints: 60,
 					},
-					round_id: 289,
-					stage_id: 20,
-					status: 4,
+					roundId: 289,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1436,
-					group_id: 57,
+					groupId: 57,
 					number: 1,
 					opponent1: {
 						id: 714,
 						position: 20,
 						score: 2,
-						result: "win",
-						totalPoints: 160,
 					},
 					opponent2: {
 						id: 700,
 						position: 35,
 						score: 0,
-						result: "loss",
-						totalPoints: 75,
 					},
-					round_id: 290,
-					stage_id: 20,
-					status: 4,
+					roundId: 290,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1437,
-					group_id: 57,
+					groupId: 57,
 					number: 2,
 					opponent1: {
 						id: 678,
 						position: 17,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 718,
 						position: 2,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 290,
-					stage_id: 20,
-					status: 4,
+					roundId: 290,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1438,
-					group_id: 58,
+					groupId: 58,
 					number: 1,
 					opponent1: {
 						id: 716,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 70,
 					},
 					opponent2: {
 						id: 710,
 						position: 34,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 291,
-					stage_id: 20,
-					status: 4,
+					roundId: 291,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1439,
-					group_id: 58,
+					groupId: 58,
 					number: 2,
 					opponent1: {
 						id: 672,
 						position: 21,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 702,
 						position: 16,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
-					round_id: 291,
-					stage_id: 20,
-					status: 4,
+					roundId: 291,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1440,
-					group_id: 58,
+					groupId: 58,
 					number: 1,
 					opponent1: {
 						id: 702,
 						position: 16,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
 					opponent2: {
 						id: 710,
 						position: 34,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 292,
-					stage_id: 20,
-					status: 4,
+					roundId: 292,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1441,
-					group_id: 58,
+					groupId: 58,
 					number: 2,
 					opponent1: {
 						id: 716,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 164,
 					},
 					opponent2: {
 						id: 672,
 						position: 21,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 292,
-					stage_id: 20,
-					status: 4,
+					roundId: 292,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1442,
-					group_id: 58,
+					groupId: 58,
 					number: 1,
 					opponent1: {
 						id: 672,
 						position: 21,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
 					opponent2: {
 						id: 710,
 						position: 34,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 293,
-					stage_id: 20,
-					status: 4,
+					roundId: 293,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1443,
-					group_id: 58,
+					groupId: 58,
 					number: 2,
 					opponent1: {
 						id: 702,
 						position: 16,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 716,
 						position: 3,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 293,
-					stage_id: 20,
-					status: 4,
+					roundId: 293,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1444,
-					group_id: 59,
+					groupId: 59,
 					number: 1,
 					opponent1: {
 						id: 724,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 175,
 					},
 					opponent2: {
 						id: 699,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 23,
 					},
-					round_id: 294,
-					stage_id: 20,
-					status: 4,
+					roundId: 294,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1445,
-					group_id: 59,
+					groupId: 59,
 					number: 2,
 					opponent1: {
 						id: 695,
 						position: 22,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 719,
 						position: 15,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 294,
-					stage_id: 20,
-					status: 4,
+					roundId: 294,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1446,
-					group_id: 59,
+					groupId: 59,
 					number: 1,
 					opponent1: {
 						id: 719,
 						position: 15,
 						score: 2,
-						result: "win",
-						totalPoints: 179,
 					},
 					opponent2: {
 						id: 699,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 26,
 					},
-					round_id: 295,
-					stage_id: 20,
-					status: 4,
+					roundId: 295,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1447,
-					group_id: 59,
+					groupId: 59,
 					number: 2,
 					opponent1: {
 						id: 724,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 199,
 					},
 					opponent2: {
 						id: 695,
 						position: 22,
 						score: 0,
-						result: "loss",
-						totalPoints: 72,
 					},
-					round_id: 295,
-					stage_id: 20,
-					status: 4,
+					roundId: 295,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1448,
-					group_id: 59,
+					groupId: 59,
 					number: 1,
 					opponent1: {
 						id: 695,
 						position: 22,
 						score: 2,
-						result: "win",
-						totalPoints: 191,
 					},
 					opponent2: {
 						id: 699,
 						position: 33,
 						score: 0,
-						result: "loss",
-						totalPoints: 58,
 					},
-					round_id: 296,
-					stage_id: 20,
-					status: 4,
+					roundId: 296,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1449,
-					group_id: 59,
+					groupId: 59,
 					number: 2,
 					opponent1: {
 						id: 719,
 						position: 15,
 						score: 1,
-						result: "loss",
-						totalPoints: 159,
 					},
 					opponent2: {
 						id: 724,
 						position: 4,
 						score: 2,
-						result: "win",
-						totalPoints: 160,
 					},
-					round_id: 296,
-					stage_id: 20,
-					status: 4,
+					roundId: 296,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1450,
-					group_id: 60,
+					groupId: 60,
 					number: 1,
 					opponent1: {
 						id: 715,
 						position: 5,
 						score: 2,
-						result: "win",
-						totalPoints: 106,
 					},
 					opponent2: {
 						id: 712,
 						position: 32,
 						score: 0,
-						result: "loss",
-						totalPoints: 53,
 					},
-					round_id: 297,
-					stage_id: 20,
-					status: 4,
+					roundId: 297,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1451,
-					group_id: 60,
+					groupId: 60,
 					number: 2,
 					opponent1: {
 						id: 705,
 						position: 23,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 713,
 						position: 14,
 						score: 2,
-						result: "win",
-						totalPoints: 102,
 					},
-					round_id: 297,
-					stage_id: 20,
-					status: 4,
+					roundId: 297,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1452,
-					group_id: 60,
+					groupId: 60,
 					number: 1,
 					opponent1: {
 						id: 713,
 						position: 14,
 						score: 2,
-						result: "win",
-						totalPoints: 72,
 					},
 					opponent2: {
 						id: 712,
 						position: 32,
 						score: 0,
-						result: "loss",
-						totalPoints: 33,
 					},
-					round_id: 298,
-					stage_id: 20,
-					status: 4,
+					roundId: 298,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1453,
-					group_id: 60,
+					groupId: 60,
 					number: 2,
 					opponent1: {
 						id: 715,
 						position: 5,
 						score: 2,
-						result: "win",
-						totalPoints: 183,
 					},
 					opponent2: {
 						id: 705,
 						position: 23,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 298,
-					stage_id: 20,
-					status: 4,
+					roundId: 298,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1454,
-					group_id: 60,
+					groupId: 60,
 					number: 1,
 					opponent1: {
 						id: 705,
 						position: 23,
 						score: 2,
-						result: "win",
-						totalPoints: 195,
 					},
 					opponent2: {
 						id: 712,
 						position: 32,
 						score: 0,
-						result: "loss",
-						totalPoints: 20,
 					},
-					round_id: 299,
-					stage_id: 20,
-					status: 4,
+					roundId: 299,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1455,
-					group_id: 60,
+					groupId: 60,
 					number: 2,
 					opponent1: {
 						id: 713,
 						position: 14,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
 					opponent2: {
 						id: 715,
 						position: 5,
 						score: 1,
-						result: "loss",
-						totalPoints: 1,
 					},
-					round_id: 299,
-					stage_id: 20,
-					status: 4,
+					roundId: 299,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1456,
-					group_id: 61,
+					groupId: 61,
 					number: 1,
 					opponent1: {
 						id: 676,
 						position: 6,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 717,
 						position: 31,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 300,
-					stage_id: 20,
-					status: 4,
+					roundId: 300,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1457,
-					group_id: 61,
+					groupId: 61,
 					number: 2,
 					opponent1: {
 						id: 720,
 						position: 24,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 677,
 						position: 13,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
-					round_id: 300,
-					stage_id: 20,
-					status: 4,
+					roundId: 300,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1458,
-					group_id: 61,
+					groupId: 61,
 					number: 1,
 					opponent1: {
 						id: 677,
 						position: 13,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
 					opponent2: {
 						id: 717,
 						position: 31,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 301,
-					stage_id: 20,
-					status: 4,
+					roundId: 301,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1459,
-					group_id: 61,
+					groupId: 61,
 					number: 2,
 					opponent1: {
 						id: 676,
 						position: 6,
 						score: 1,
-						result: "loss",
-						totalPoints: 266,
 					},
 					opponent2: {
 						id: 720,
 						position: 24,
 						score: 2,
-						result: "win",
-						totalPoints: 219,
 					},
-					round_id: 301,
-					stage_id: 20,
-					status: 4,
+					roundId: 301,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1460,
-					group_id: 61,
+					groupId: 61,
 					number: 1,
 					opponent1: {
 						id: 720,
 						position: 24,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
 					opponent2: {
 						id: 717,
 						position: 31,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 302,
-					stage_id: 20,
-					status: 4,
+					roundId: 302,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1461,
-					group_id: 61,
+					groupId: 61,
 					number: 2,
 					opponent1: {
 						id: 677,
 						position: 13,
 						score: 2,
-						result: "win",
-						totalPoints: 80,
 					},
 					opponent2: {
 						id: 676,
 						position: 6,
 						score: 1,
-						result: "loss",
-						totalPoints: 100,
 					},
-					round_id: 302,
-					stage_id: 20,
-					status: 4,
+					roundId: 302,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1462,
-					group_id: 62,
+					groupId: 62,
 					number: 1,
 					opponent1: {
 						id: 722,
 						position: 7,
 						score: 2,
-						result: "win",
-						totalPoints: 185,
 					},
 					opponent2: {
 						id: 704,
 						position: 30,
 						score: 0,
-						result: "loss",
-						totalPoints: 53,
 					},
-					round_id: 303,
-					stage_id: 20,
-					status: 4,
+					roundId: 303,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1463,
-					group_id: 62,
+					groupId: 62,
 					number: 2,
 					opponent1: {
 						id: 721,
 						position: 25,
 						score: 0,
-						result: "loss",
-						totalPoints: 72,
 					},
 					opponent2: {
 						id: 674,
 						position: 12,
 						score: 2,
-						result: "win",
-						totalPoints: 197,
 					},
-					round_id: 303,
-					stage_id: 20,
-					status: 4,
+					roundId: 303,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1464,
-					group_id: 62,
+					groupId: 62,
 					number: 1,
 					opponent1: {
 						id: 674,
 						position: 12,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 704,
 						position: 30,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 304,
-					stage_id: 20,
-					status: 4,
+					roundId: 304,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1465,
-					group_id: 62,
+					groupId: 62,
 					number: 2,
 					opponent1: {
 						id: 722,
 						position: 7,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
 					opponent2: {
 						id: 721,
 						position: 25,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 304,
-					stage_id: 20,
-					status: 4,
+					roundId: 304,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1466,
-					group_id: 62,
+					groupId: 62,
 					number: 1,
 					opponent1: {
 						id: 721,
 						position: 25,
 						score: 1,
-						result: "loss",
-						totalPoints: 1,
 					},
 					opponent2: {
 						id: 704,
 						position: 30,
 						score: 2,
-						result: "win",
-						totalPoints: 3,
 					},
-					round_id: 305,
-					stage_id: 20,
-					status: 4,
+					roundId: 305,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1467,
-					group_id: 62,
+					groupId: 62,
 					number: 2,
 					opponent1: {
 						id: 674,
 						position: 12,
 						score: 0,
-						result: "loss",
-						totalPoints: 83,
 					},
 					opponent2: {
 						id: 722,
 						position: 7,
 						score: 2,
-						result: "win",
-						totalPoints: 184,
 					},
-					round_id: 305,
-					stage_id: 20,
-					status: 4,
+					roundId: 305,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1468,
-					group_id: 63,
+					groupId: 63,
 					number: 1,
 					opponent1: {
 						id: 708,
 						position: 8,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 675,
 						position: 29,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 306,
-					stage_id: 20,
-					status: 4,
+					roundId: 306,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1469,
-					group_id: 63,
+					groupId: 63,
 					number: 2,
 					opponent1: {
 						id: 706,
 						position: 26,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 697,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
-					round_id: 306,
-					stage_id: 20,
-					status: 4,
+					roundId: 306,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1470,
-					group_id: 63,
+					groupId: 63,
 					number: 1,
 					opponent1: {
 						id: 697,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 675,
 						position: 29,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 307,
-					stage_id: 20,
-					status: 4,
+					roundId: 307,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1471,
-					group_id: 63,
+					groupId: 63,
 					number: 2,
 					opponent1: {
 						id: 708,
 						position: 8,
 						score: 1,
-						result: "loss",
-						totalPoints: 158,
 					},
 					opponent2: {
 						id: 706,
 						position: 26,
 						score: 2,
-						result: "win",
-						totalPoints: 235,
 					},
-					round_id: 307,
-					stage_id: 20,
-					status: 4,
+					roundId: 307,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1472,
-					group_id: 63,
+					groupId: 63,
 					number: 1,
 					opponent1: {
 						id: 706,
 						position: 26,
 						score: 2,
-						result: "win",
-						totalPoints: 259,
 					},
 					opponent2: {
 						id: 675,
 						position: 29,
 						score: 1,
-						result: "loss",
-						totalPoints: 162,
 					},
-					round_id: 308,
-					stage_id: 20,
-					status: 4,
+					roundId: 308,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1473,
-					group_id: 63,
+					groupId: 63,
 					number: 2,
 					opponent1: {
 						id: 697,
 						position: 11,
 						score: 2,
-						result: "win",
-						totalPoints: 200,
 					},
 					opponent2: {
 						id: 708,
 						position: 8,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 308,
-					stage_id: 20,
-					status: 4,
+					roundId: 308,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1474,
-					group_id: 64,
+					groupId: 64,
 					number: 1,
 					opponent1: {
 						id: 701,
 						position: 9,
 						score: 2,
-						result: "win",
-						totalPoints: 85,
 					},
 					opponent2: {
 						id: 725,
 						position: 28,
 						score: 1,
-						result: "loss",
-						totalPoints: 80,
 					},
-					round_id: 309,
-					stage_id: 20,
-					status: 4,
+					roundId: 309,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1475,
-					group_id: 64,
+					groupId: 64,
 					number: 2,
 					opponent1: {
 						id: 723,
 						position: 27,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
 					opponent2: {
 						id: 709,
 						position: 10,
 						score: 2,
-						result: "win",
-						totalPoints: 2,
 					},
-					round_id: 309,
-					stage_id: 20,
-					status: 4,
+					roundId: 309,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1476,
-					group_id: 64,
+					groupId: 64,
 					number: 1,
 					opponent1: {
 						id: 709,
 						position: 10,
 						score: 2,
-						result: "win",
-						totalPoints: 164,
 					},
 					opponent2: {
 						id: 725,
 						position: 28,
 						score: 0,
-						result: "loss",
-						totalPoints: 38,
 					},
-					round_id: 310,
-					stage_id: 20,
-					status: 4,
+					roundId: 310,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1477,
-					group_id: 64,
+					groupId: 64,
 					number: 2,
 					opponent1: {
 						id: 701,
 						position: 9,
 						score: 2,
-						result: "win",
-						totalPoints: 101,
 					},
 					opponent2: {
 						id: 723,
 						position: 27,
 						score: 0,
-						result: "loss",
-						totalPoints: 0,
 					},
-					round_id: 310,
-					stage_id: 20,
-					status: 4,
+					roundId: 310,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1478,
-					group_id: 64,
+					groupId: 64,
 					number: 1,
 					opponent1: {
 						id: 723,
 						position: 27,
 						score: 1,
-						result: "loss",
-						totalPoints: 110,
 					},
 					opponent2: {
 						id: 725,
 						position: 28,
 						score: 2,
-						result: "win",
-						totalPoints: 187,
 					},
-					round_id: 311,
-					stage_id: 20,
-					status: 4,
+					roundId: 311,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1479,
-					group_id: 64,
+					groupId: 64,
 					number: 2,
 					opponent1: {
 						id: 709,
 						position: 10,
 						score: 2,
-						result: "win",
-						totalPoints: 188,
 					},
 					opponent2: {
 						id: 701,
 						position: 9,
 						score: 0,
-						result: "loss",
-						totalPoints: 155,
 					},
-					round_id: 311,
-					stage_id: 20,
-					status: 4,
+					roundId: 311,
+					stageId: 20,
 					startedAt: null,
+					winnerSide: "opponent1",
 				},
 			],
 		},
@@ -13968,10 +13552,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 0,
 		number: 1,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 698,
 			position: 1,
@@ -13981,10 +13564,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 1,
 		number: 2,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 674,
 			position: 16,
@@ -13997,10 +13579,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 2,
 		number: 3,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 697,
 			position: 8,
@@ -14010,10 +13591,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 3,
 		number: 4,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 709,
 			position: 9,
@@ -14023,10 +13603,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 4,
 		number: 5,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 724,
 			position: 4,
@@ -14036,10 +13615,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 5,
 		number: 6,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 719,
 			position: 13,
@@ -14049,10 +13627,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 6,
 		number: 7,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 713,
 			position: 5,
@@ -14062,10 +13639,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 7,
 		number: 8,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 702,
 			position: 12,
@@ -14075,10 +13651,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 8,
 		number: 9,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 718,
 			position: 2,
@@ -14088,10 +13663,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 9,
 		number: 10,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 720,
 			position: 15,
@@ -14104,10 +13678,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 10,
 		number: 11,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 722,
 			position: 7,
@@ -14117,10 +13690,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 11,
 		number: 12,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 673,
 			position: 10,
@@ -14130,10 +13702,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 12,
 		number: 13,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 716,
 			position: 3,
@@ -14143,10 +13714,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 13,
 		number: 14,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 715,
 			position: 14,
@@ -14156,10 +13726,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 14,
 		number: 15,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 677,
 			position: 6,
@@ -14169,10 +13738,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 15,
 		number: 16,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 0,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 0,
 		opponent1: {
 			id: 678,
 			position: 11,
@@ -14182,10 +13750,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 16,
 		number: 1,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 1,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 698,
 		},
@@ -14196,10 +13763,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 17,
 		number: 2,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 697,
 		},
@@ -14210,10 +13776,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 18,
 		number: 3,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 724,
 		},
@@ -14224,10 +13789,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 19,
 		number: 4,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 713,
 		},
@@ -14238,10 +13802,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 20,
 		number: 5,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 1,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 718,
 		},
@@ -14252,10 +13815,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 21,
 		number: 6,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 722,
 		},
@@ -14266,10 +13828,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 22,
 		number: 7,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 716,
 		},
@@ -14280,10 +13841,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 23,
 		number: 8,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 1,
-		status: 2,
+		stageId: 0,
+		groupId: 0,
+		roundId: 1,
 		opponent1: {
 			id: 677,
 		},
@@ -14294,10 +13854,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 24,
 		number: 1,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 2,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 2,
 		opponent1: {
 			id: null,
 		},
@@ -14308,10 +13867,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 25,
 		number: 2,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 2,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 2,
 		opponent1: {
 			id: null,
 		},
@@ -14322,10 +13880,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 26,
 		number: 3,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 2,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 2,
 		opponent1: {
 			id: null,
 		},
@@ -14336,10 +13893,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 27,
 		number: 4,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 2,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 2,
 		opponent1: {
 			id: null,
 		},
@@ -14350,10 +13906,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 28,
 		number: 1,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 3,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 3,
 		opponent1: {
 			id: null,
 		},
@@ -14364,10 +13919,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 29,
 		number: 2,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 3,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 3,
 		opponent1: {
 			id: null,
 		},
@@ -14378,10 +13932,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 30,
 		number: 1,
-		stage_id: 0,
-		group_id: 0,
-		round_id: 4,
-		status: 0,
+		stageId: 0,
+		groupId: 0,
+		roundId: 4,
 		opponent1: {
 			id: null,
 		},
@@ -14392,10 +13945,9 @@ export const PADDLING_POOL_255_TOP_CUT_INITIAL_MATCHES = () => [
 	{
 		id: 31,
 		number: 1,
-		stage_id: 0,
-		group_id: 1,
-		round_id: 5,
-		status: 0,
+		stageId: 0,
+		groupId: 1,
+		roundId: 5,
 		opponent1: {
 			id: null,
 			position: 1,
@@ -14418,18 +13970,7 @@ export const IN_THE_ZONE_32 = ({
 					id: 16,
 					name: "Main bracket",
 					number: 1,
-					settings: {
-						grandFinal: "double",
-						size: 32,
-						seedOrdering: [
-							"space_between",
-							"natural",
-							"reverse",
-							"half_shift",
-							"natural",
-						],
-					},
-					tournament_id: 11,
+					settings: {},
 					type: "double_elimination",
 				},
 			],
@@ -14437,1295 +13978,1171 @@ export const IN_THE_ZONE_32 = ({
 				{
 					id: 46,
 					number: 1,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 47,
 					number: 2,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 48,
 					number: 3,
-					stage_id: 16,
+					stageId: 16,
 				},
 			],
 			round: [
 				{
 					id: 238,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 239,
-					group_id: 46,
+					groupId: 46,
 					number: 2,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 240,
-					group_id: 46,
+					groupId: 46,
 					number: 3,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 241,
-					group_id: 46,
+					groupId: 46,
 					number: 4,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 242,
-					group_id: 46,
+					groupId: 46,
 					number: 5,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 243,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 244,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 245,
-					group_id: 47,
+					groupId: 47,
 					number: 3,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 246,
-					group_id: 47,
+					groupId: 47,
 					number: 4,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 247,
-					group_id: 47,
+					groupId: 47,
 					number: 5,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 248,
-					group_id: 47,
+					groupId: 47,
 					number: 6,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 249,
-					group_id: 47,
+					groupId: 47,
 					number: 7,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 250,
-					group_id: 47,
+					groupId: 47,
 					number: 8,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 251,
-					group_id: 48,
+					groupId: 48,
 					number: 1,
-					stage_id: 16,
+					stageId: 16,
 				},
 				{
 					id: 252,
-					group_id: 48,
+					groupId: 48,
 					number: 2,
-					stage_id: 16,
+					stageId: 16,
 				},
 			],
 			match: [
 				{
 					id: 1234,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
 					opponent1: {
 						id: 552,
 						position: 1,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 605,
 						position: 32,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1235,
-					group_id: 46,
+					groupId: 46,
 					number: 2,
 					opponent1: {
 						id: 509,
 						position: 16,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 598,
 						position: 17,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1236,
-					group_id: 46,
+					groupId: 46,
 					number: 3,
 					opponent1: {
 						id: 592,
 						position: 8,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 551,
 						position: 25,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1237,
-					group_id: 46,
+					groupId: 46,
 					number: 4,
 					opponent1: {
 						id: 609,
 						position: 9,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 610,
 						position: 24,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1238,
-					group_id: 46,
+					groupId: 46,
 					number: 5,
 					opponent1: {
 						id: 547,
 						position: 4,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 611,
 						position: 29,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1239,
-					group_id: 46,
+					groupId: 46,
 					number: 6,
 					opponent1: {
 						id: 601,
 						position: 13,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 596,
 						position: 20,
 						score: 2,
-						result: "win",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1240,
-					group_id: 46,
+					groupId: 46,
 					number: 7,
 					opponent1: {
 						id: 507,
 						position: 5,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 612,
 						position: 28,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1241,
-					group_id: 46,
+					groupId: 46,
 					number: 8,
 					opponent1: {
 						id: 595,
 						position: 12,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 600,
 						position: 21,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1242,
-					group_id: 46,
+					groupId: 46,
 					number: 9,
 					opponent1: {
 						id: 548,
 						position: 2,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 608,
 						position: 31,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1243,
-					group_id: 46,
+					groupId: 46,
 					number: 10,
 					opponent1: {
 						id: 594,
 						position: 15,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 604,
 						position: 18,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1244,
-					group_id: 46,
+					groupId: 46,
 					number: 11,
 					opponent1: {
 						id: 591,
 						position: 7,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 597,
 						position: 26,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1245,
-					group_id: 46,
+					groupId: 46,
 					number: 12,
 					opponent1: {
 						id: 564,
 						position: 10,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 614,
 						position: 23,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1246,
-					group_id: 46,
+					groupId: 46,
 					number: 13,
 					opponent1: {
 						id: 499,
 						position: 3,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 606,
 						position: 30,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1247,
-					group_id: 46,
+					groupId: 46,
 					number: 14,
 					opponent1: {
 						id: 560,
 						position: 14,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 603,
 						position: 19,
 						score: 2,
-						result: "win",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1248,
-					group_id: 46,
+					groupId: 46,
 					number: 15,
 					opponent1: {
 						id: 546,
 						position: 6,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 589,
 						position: 27,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1249,
-					group_id: 46,
+					groupId: 46,
 					number: 16,
 					opponent1: {
 						id: 590,
 						position: 11,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 599,
 						position: 22,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 238,
-					stage_id: 16,
-					status: 4,
+					roundId: 238,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1250,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
 					opponent1: {
 						id: 552,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 509,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1251,
-					group_id: 46,
+					groupId: 46,
 					number: 2,
 					opponent1: {
 						id: 592,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 609,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1252,
-					group_id: 46,
+					groupId: 46,
 					number: 3,
 					opponent1: {
 						id: 547,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 596,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1253,
-					group_id: 46,
+					groupId: 46,
 					number: 4,
 					opponent1: {
 						id: 507,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 595,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1254,
-					group_id: 46,
+					groupId: 46,
 					number: 5,
 					opponent1: {
 						id: 548,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 594,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1255,
-					group_id: 46,
+					groupId: 46,
 					number: 6,
 					opponent1: {
 						id: 591,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 564,
 						score: 2,
-						result: "win",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1256,
-					group_id: 46,
+					groupId: 46,
 					number: 7,
 					opponent1: {
 						id: 499,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 603,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1257,
-					group_id: 46,
+					groupId: 46,
 					number: 8,
 					opponent1: {
 						id: 546,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 590,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 239,
-					stage_id: 16,
-					status: 4,
+					roundId: 239,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1258,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
 					opponent1: {
 						id: 552,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 592,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 240,
-					stage_id: 16,
-					status: 4,
+					roundId: 240,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1259,
-					group_id: 46,
+					groupId: 46,
 					number: 2,
 					opponent1: {
 						id: 547,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 507,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 240,
-					stage_id: 16,
-					status: 4,
+					roundId: 240,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1260,
-					group_id: 46,
+					groupId: 46,
 					number: 3,
 					opponent1: {
 						id: 548,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 564,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 240,
-					stage_id: 16,
-					status: 4,
+					roundId: 240,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1261,
-					group_id: 46,
+					groupId: 46,
 					number: 4,
 					opponent1: {
 						id: 499,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 546,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 240,
-					stage_id: 16,
-					status: 4,
+					roundId: 240,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1262,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
 					opponent1: {
 						id: 552,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 547,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 241,
-					stage_id: 16,
-					status: 4,
+					roundId: 241,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1263,
-					group_id: 46,
+					groupId: 46,
 					number: 2,
 					opponent1: {
 						id: 548,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 499,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 241,
-					stage_id: 16,
-					status: 4,
+					roundId: 241,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1264,
-					group_id: 46,
+					groupId: 46,
 					number: 1,
 					opponent1: {
 						id: 552,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 548,
 						score: 3,
-						result: "win",
 					},
-					round_id: 242,
-					stage_id: 16,
-					status: 4,
+					roundId: 242,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1265,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 605,
 						position: 1,
 						score: 0,
-						result: "loss",
 					},
 					opponent2: {
 						id: 598,
 						position: 2,
 						score: 2,
-						result: "win",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1266,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 551,
 						position: 3,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 610,
 						position: 4,
 						score: 2,
-						result: "win",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1267,
-					group_id: 47,
+					groupId: 47,
 					number: 3,
 					opponent1: {
 						id: 611,
 						position: 5,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 601,
 						position: 6,
 						score: 2,
-						result: "win",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1268,
-					group_id: 47,
+					groupId: 47,
 					number: 4,
 					opponent1: {
 						id: 612,
 						position: 7,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 600,
 						position: 8,
 						score: 2,
-						result: "win",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1269,
-					group_id: 47,
+					groupId: 47,
 					number: 5,
 					opponent1: {
 						id: 608,
 						position: 9,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 604,
 						position: 10,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1270,
-					group_id: 47,
+					groupId: 47,
 					number: 6,
 					opponent1: {
 						id: 597,
 						position: 11,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 614,
 						position: 12,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1271,
-					group_id: 47,
+					groupId: 47,
 					number: 7,
 					opponent1: {
 						id: 606,
 						position: 13,
 						score: 0,
-						result: "loss",
 					},
 					opponent2: {
 						id: 560,
 						position: 14,
 						score: 2,
-						result: "win",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1272,
-					group_id: 47,
+					groupId: 47,
 					number: 8,
 					opponent1: {
 						id: 589,
 						position: 15,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 599,
 						position: 16,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 243,
-					stage_id: 16,
-					status: 4,
+					roundId: 243,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1273,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 590,
 						position: 8,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 598,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1274,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 603,
 						position: 7,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 610,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1275,
-					group_id: 47,
+					groupId: 47,
 					number: 3,
 					opponent1: {
 						id: 591,
 						position: 6,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 601,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1276,
-					group_id: 47,
+					groupId: 47,
 					number: 4,
 					opponent1: {
 						id: 594,
 						position: 5,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 600,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1277,
-					group_id: 47,
+					groupId: 47,
 					number: 5,
 					opponent1: {
 						id: 595,
 						position: 4,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 608,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1278,
-					group_id: 47,
+					groupId: 47,
 					number: 6,
 					opponent1: {
 						id: 596,
 						position: 3,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 597,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1279,
-					group_id: 47,
+					groupId: 47,
 					number: 7,
 					opponent1: {
 						id: 609,
 						position: 2,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 560,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1280,
-					group_id: 47,
+					groupId: 47,
 					number: 8,
 					opponent1: {
 						id: 509,
 						position: 1,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 589,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 244,
-					stage_id: 16,
-					status: 4,
+					roundId: 244,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1281,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 590,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 603,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 245,
-					stage_id: 16,
-					status: 4,
+					roundId: 245,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1282,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 591,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 594,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 245,
-					stage_id: 16,
-					status: 4,
+					roundId: 245,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1283,
-					group_id: 47,
+					groupId: 47,
 					number: 3,
 					opponent1: {
 						id: 595,
 						score: 1,
-						result: "loss",
 					},
 					opponent2: {
 						id: 596,
 						score: 2,
-						result: "win",
 					},
-					round_id: 245,
-					stage_id: 16,
-					status: 4,
+					roundId: 245,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1284,
-					group_id: 47,
+					groupId: 47,
 					number: 4,
 					opponent1: {
 						id: 609,
 						score: 0,
-						result: "loss",
 					},
 					opponent2: {
 						id: 509,
 						score: 2,
-						result: "win",
 					},
-					round_id: 245,
-					stage_id: 16,
-					status: 4,
+					roundId: 245,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1285,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 564,
 						position: 3,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 590,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 246,
-					stage_id: 16,
-					status: 4,
+					roundId: 246,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1286,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 546,
 						position: 4,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 591,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 246,
-					stage_id: 16,
-					status: 4,
+					roundId: 246,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1287,
-					group_id: 47,
+					groupId: 47,
 					number: 3,
 					opponent1: {
 						id: 592,
 						position: 1,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 596,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 246,
-					stage_id: 16,
-					status: 4,
+					roundId: 246,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1288,
-					group_id: 47,
+					groupId: 47,
 					number: 4,
 					opponent1: {
 						id: 507,
 						position: 2,
 						score: 0,
-						result: "loss",
 					},
 					opponent2: {
 						id: 509,
 						score: 2,
-						result: "win",
 					},
-					round_id: 246,
-					stage_id: 16,
-					status: 4,
+					roundId: 246,
+					stageId: 16,
+					winnerSide: "opponent2",
 				},
 				{
 					id: 1289,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 564,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 546,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 247,
-					stage_id: 16,
-					status: 4,
+					roundId: 247,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1290,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 592,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 509,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 247,
-					stage_id: 16,
-					status: 4,
+					roundId: 247,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1291,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 547,
 						position: 1,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 564,
 						score: 0,
-						result: "loss",
 					},
-					round_id: 248,
-					stage_id: 16,
-					status: 4,
+					roundId: 248,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1292,
-					group_id: 47,
+					groupId: 47,
 					number: 2,
 					opponent1: {
 						id: 499,
 						position: 2,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 592,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 248,
-					stage_id: 16,
-					status: 4,
+					roundId: 248,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1293,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 547,
 						score: 2,
-						result: "win",
 					},
 					opponent2: {
 						id: 499,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 249,
-					stage_id: 16,
-					status: 4,
+					roundId: 249,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1294,
-					group_id: 47,
+					groupId: 47,
 					number: 1,
 					opponent1: {
 						id: 552,
 						position: 1,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 547,
 						score: 1,
-						result: "loss",
 					},
-					round_id: 250,
-					stage_id: 16,
-					status: 4,
+					roundId: 250,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1295,
-					group_id: 48,
+					groupId: 48,
 					number: 1,
 					opponent1: {
 						id: 548,
 						score: 3,
-						result: "win",
 					},
 					opponent2: {
 						id: 552,
 						position: 1,
 						score: 2,
-						result: "loss",
 					},
-					round_id: 251,
-					stage_id: 16,
-					status: 4,
+					roundId: 251,
+					stageId: 16,
+					winnerSide: "opponent1",
 				},
 				{
 					id: 1296,
-					group_id: 48,
+					groupId: 48,
 					number: 1,
 					opponent1: {
 						id: 548,
@@ -15733,9 +15150,9 @@ export const IN_THE_ZONE_32 = ({
 					opponent2: {
 						id: 552,
 					},
-					round_id: 252,
-					stage_id: 16,
-					status: 2,
+					roundId: 252,
+					stageId: 16,
+					winnerSide: null,
 				},
 			],
 		},
diff --git a/app/features/tournament-bracket/core/tests/test-utils.ts b/app/features/tournament-bracket/core/tests/test-utils.ts
index c4e837ca0..61455fb81 100644
--- a/app/features/tournament-bracket/core/tests/test-utils.ts
+++ b/app/features/tournament-bracket/core/tests/test-utils.ts
@@ -1,5 +1,5 @@
 import * as R from "remeda";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import type * as Progression from "../Progression";
 import { Tournament } from "../Tournament";
 import type { TournamentData } from "../Tournament.server";
@@ -47,7 +47,7 @@ export const testTournament = ({
 	},
 	ctx,
 }: {
-	data?: TournamentManagerDataSet;
+	data?: BracketData;
 	ctx?: Partial<TournamentData["ctx"]>;
 }) => {
 	const participant = R.pipe(
@@ -57,57 +57,120 @@ export const testTournament = ({
 		R.unique<number[]>,
 	);
 
-	return new Tournament({
-		data,
-		ctx: {
-			eventId: 1,
-			id: 1,
-			tags: null,
-			organization: null,
-			tier: null,
-			tentativeTier: null,
-			parentTournamentId: null,
-			parentTournamentName: null,
-			hasRules: false,
-			logoUrl: "/test.avif",
-			discordUrl: null,
-			startTime: 1705858842,
-			isFinalized: 0,
-			name: "test",
-			castTwitchAccounts: [],
-			bracketProgressionOverrides: [],
-			staff: [],
-			tieBreakerMapPool: [],
-			toSetMapPool: [],
-			participatedUsers: [],
-			castStreams: [],
-			mapPickingStyle: "AUTO_SZ",
-			settings: {
-				bracketProgression: [
-					{
-						name: "Main Bracket",
-						type: "double_elimination",
-						requiresCheckIn: false,
-						settings: {},
-					},
-				],
-			},
-			castedMatchesInfo: null,
-			teams: nTeams(participant.length, Math.min(...participant)),
-			author: {
-				customUrl: null,
-				customAvatarUrl: null,
-				discordAvatar: null,
-				discordId: "123",
-				username: "test",
-				pronouns: null,
-				id: 1,
-			},
-			...ctx,
+	const tournamentCtx: TournamentData["ctx"] = {
+		eventId: 1,
+		id: 1,
+		tags: null,
+		organization: null,
+		tier: null,
+		tentativeTier: null,
+		parentTournamentId: null,
+		parentTournamentName: null,
+		hasRules: false,
+		logoUrl: "/test.avif",
+		discordUrl: null,
+		startTime: 1705858842,
+		isFinalized: 0,
+		name: "test",
+		castTwitchAccounts: [],
+		bracketProgressionOverrides: [],
+		staff: [],
+		tieBreakerMapPool: [],
+		toSetMapPool: [],
+		participatedUsers: [],
+		castStreams: [],
+		mapPickingStyle: "AUTO_SZ",
+		settings: {
+			bracketProgression: [
+				{
+					name: "Main Bracket",
+					type: "double_elimination",
+					requiresCheckIn: false,
+					settings: {},
+				},
+			],
 		},
+		castedMatchesInfo: null,
+		teams: nTeams(participant.length, Math.min(...participant)),
+		author: {
+			customUrl: null,
+			customAvatarUrl: null,
+			discordAvatar: null,
+			discordId: "123",
+			username: "test",
+			pronouns: null,
+			id: 1,
+		},
+		...ctx,
+	};
+
+	return new Tournament({
+		// engine created data has no stage names, the database assigns them from the bracket progression
+		data: {
+			...data,
+			stage: data.stage.map((stage, stageIdx) => ({
+				...stage,
+				name:
+					stage.name ??
+					tournamentCtx.settings.bracketProgression[stageIdx]?.name,
+			})),
+		},
+		ctx: tournamentCtx,
 	});
 };
 
+/**
+ * Combines separately created brackets into the bracket data of one tournament,
+ * offsetting the local ids of every bracket after the first the same way the
+ * database does when a new stage is added to an existing tournament.
+ */
+export const mergeStages = (...brackets: BracketData[]): BracketData => {
+	const merged: BracketData = { stage: [], group: [], round: [], match: [] };
+
+	for (const bracket of brackets) {
+		const offsets = {
+			stage: merged.stage.length,
+			group: merged.group.length,
+			round: merged.round.length,
+			match: merged.match.length,
+		};
+
+		merged.stage.push(
+			...bracket.stage.map((stage) => ({
+				...stage,
+				id: stage.id + offsets.stage,
+				number: offsets.stage + 1,
+			})),
+		);
+		merged.group.push(
+			...bracket.group.map((group) => ({
+				...group,
+				id: group.id + offsets.group,
+				stageId: group.stageId + offsets.stage,
+			})),
+		);
+		merged.round.push(
+			...bracket.round.map((round) => ({
+				...round,
+				id: round.id + offsets.round,
+				stageId: round.stageId + offsets.stage,
+				groupId: round.groupId + offsets.group,
+			})),
+		);
+		merged.match.push(
+			...bracket.match.map((match) => ({
+				...match,
+				id: match.id + offsets.match,
+				stageId: match.stageId + offsets.stage,
+				groupId: match.groupId + offsets.group,
+				roundId: match.roundId + offsets.round,
+			})),
+		);
+	}
+
+	return merged;
+};
+
 const DEFAULT_PROGRESSION_ARGS = {
 	requiresCheckIn: false,
 	settings: {},
diff --git a/app/features/tournament-bracket/core/toMapList.ts b/app/features/tournament-bracket/core/toMapList.ts
index ab8a32b2e..d164dbe5e 100644
--- a/app/features/tournament-bracket/core/toMapList.ts
+++ b/app/features/tournament-bracket/core/toMapList.ts
@@ -3,13 +3,13 @@
 import type { Tables, TournamentRoundMaps } from "~/db/tables";
 import * as MapList from "~/features/map-list-generator/core/MapList";
 import { MapPool } from "~/features/map-list-generator/core/map-pool";
-import type { Round } from "~/modules/brackets-model";
+import type { RoundData } from "~/features/tournament-bracket/core/engine/types";
 import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
 import { logger } from "~/utils/logger";
 import { assertUnreachable } from "~/utils/types";
 
 export type BracketMapCounts = Map<
-	// round.group_id ->
+	// round.groupId ->
 	number,
 	// round.number ->
 	Map<number, { count: number; type: "BEST_OF" }>
@@ -17,7 +17,7 @@ export type BracketMapCounts = Map<
 
 export interface GenerateTournamentRoundMaplistArgs {
 	pool: Array<{ mode: ModeShort; stageId: StageId }>;
-	rounds: Round[];
+	rounds: RoundData[];
 	mapCounts: BracketMapCounts;
 	type: Tables["TournamentStage"]["type"];
 	roundsWithPickBan: Set<number>;
@@ -92,7 +92,7 @@ export function generateTournamentRoundMaplist(
 }
 
 function getFilteredRounds(
-	rounds: Round[],
+	rounds: RoundData[],
 	type: Tables["TournamentStage"]["type"],
 ) {
 	if (type !== "round_robin" && type !== "swiss") return rounds;
@@ -101,19 +101,19 @@ function getFilteredRounds(
 	// (e.g. groups of 3 and 2). Use the group with the most rounds: it covers
 	// every round number and its map list is shared with the smaller groups.
 	const fullestGroupId = fullestGroupIdByRounds(rounds);
-	return rounds.filter((x) => x.group_id === fullestGroupId);
+	return rounds.filter((x) => x.groupId === fullestGroupId);
 }
 
-function fullestGroupIdByRounds(rounds: Round[]) {
+function fullestGroupIdByRounds(rounds: RoundData[]) {
 	const roundCountByGroup = new Map<number, number>();
 	for (const round of rounds) {
 		roundCountByGroup.set(
-			round.group_id,
-			(roundCountByGroup.get(round.group_id) ?? 0) + 1,
+			round.groupId,
+			(roundCountByGroup.get(round.groupId) ?? 0) + 1,
 		);
 	}
 
-	let fullestGroupId = rounds[0].group_id;
+	let fullestGroupId = rounds[0].groupId;
 	for (const [groupId, count] of roundCountByGroup) {
 		if (count > roundCountByGroup.get(fullestGroupId)!)
 			fullestGroupId = groupId;
@@ -122,8 +122,11 @@ function fullestGroupIdByRounds(rounds: Round[]) {
 	return fullestGroupId;
 }
 
-function sortRounds(rounds: Round[], type: Tables["TournamentStage"]["type"]) {
-	const groupIds = rounds.map((x) => x.group_id);
+function sortRounds(
+	rounds: RoundData[],
+	type: Tables["TournamentStage"]["type"],
+) {
+	const groupIds = rounds.map((x) => x.groupId);
 	const minGroupId = Math.min(...groupIds);
 	const maxGroupId = Math.max(...groupIds);
 
@@ -137,13 +140,13 @@ function sortRounds(rounds: Round[], type: Tables["TournamentStage"]["type"]) {
 	return rounds.toSorted((a, b) => {
 		if (type === "double_elimination") {
 			const rankDiff =
-				doubleEliminationGroupRank(a.group_id) -
-				doubleEliminationGroupRank(b.group_id);
+				doubleEliminationGroupRank(a.groupId) -
+				doubleEliminationGroupRank(b.groupId);
 			if (rankDiff !== 0) return rankDiff;
 		}
 		if (type === "single_elimination") {
 			// finals and 3rd place match last
-			if (a.group_id !== b.group_id) return a.group_id - b.group_id;
+			if (a.groupId !== b.groupId) return a.groupId - b.groupId;
 		}
 
 		return a.number - b.number;
@@ -151,7 +154,7 @@ function sortRounds(rounds: Round[], type: Tables["TournamentStage"]["type"]) {
 }
 
 function resolveRoundMapCount(
-	round: Round,
+	round: RoundData,
 	counts: BracketMapCounts,
 	type: Tables["TournamentStage"]["type"],
 ) {
@@ -160,12 +163,12 @@ function resolveRoundMapCount(
 	const groupId =
 		type === "round_robin" || type === "swiss"
 			? fullestGroupIdByCounts(counts)
-			: round.group_id;
+			: round.groupId;
 
 	const count = counts.get(groupId)?.get(round.number)?.count;
 	if (typeof count === "undefined") {
 		logger.warn(
-			`No map count found for round ${round.number} (group ${round.group_id})`,
+			`No map count found for round ${round.number} (group ${round.groupId})`,
 		);
 		return 5;
 	}
diff --git a/app/features/tournament-bracket/queries/deletePickBanEvent.server.ts b/app/features/tournament-bracket/queries/deletePickBanEvent.server.ts
deleted file mode 100644
index e36da84d6..000000000
--- a/app/features/tournament-bracket/queries/deletePickBanEvent.server.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  delete from "TournamentMatchPickBanEvent"
-    where "matchId" = @matchId
-    and "number" = @number
-`);
-
-export function deletePickBanEvent({
-	matchId,
-	number,
-}: {
-	matchId: number;
-	number: number;
-}) {
-	return stm.run({ matchId, number });
-}
diff --git a/app/features/tournament-bracket/routes/to.$id.brackets.tsx b/app/features/tournament-bracket/routes/to.$id.brackets.tsx
index 18bd920f2..dc632524e 100644
--- a/app/features/tournament-bracket/routes/to.$id.brackets.tsx
+++ b/app/features/tournament-bracket/routes/to.$id.brackets.tsx
@@ -321,7 +321,7 @@ function getAbDivisionsStartError(
 		return null;
 	}
 
-	const groupCount = new Set(bracket.data.round.map((r) => r.group_id)).size;
+	const groupCount = new Set(bracket.data.round.map((r) => r.groupId)).size;
 	const abDivisionsBySeedOrder = bracket.seeding.map(
 		(teamId) => tournament.teamById(teamId)?.abDivision,
 	);
diff --git a/app/features/tournament-bracket/tournament-bracket-schemas.server.ts b/app/features/tournament-bracket/tournament-bracket-schemas.server.ts
index fb77cf096..d903b234d 100644
--- a/app/features/tournament-bracket/tournament-bracket-schemas.server.ts
+++ b/app/features/tournament-bracket/tournament-bracket-schemas.server.ts
@@ -31,36 +31,13 @@ const reportedMatchPosition = z.preprocess(
 		.max(Math.max(...TOURNAMENT.AVAILABLE_BEST_OF) - 1),
 );
 
-const point = z.number().int().min(0).max(100);
-const points = z.preprocess(
-	safeJSONParse,
-	z
-		.tuple([point, point])
-		.nullish()
-		.refine(
-			(val) => {
-				if (!val) return true;
-				const [p1, p2] = val;
-
-				// KO
-				if (p1 === 100 && p2 === 0) return true;
-				if (p2 === 100 && p1 === 0) return true;
-				// ...or no points sent at all (TODO: if we decide that this KO only approach is solid then we can do a proper data model migration)
-				if (p1 === 0 && p2 === 0) return true;
-
-				return false;
-			},
-			{
-				message: "Invalid points. Valid: 100-0, 0-100 or 0-0.",
-			},
-		),
-);
+const ko = z.preprocess(safeJSONParse, z.boolean().nullish());
 export const matchSchema = z.union([
 	z.object({
 		_action: _action("REPORT_SCORE"),
 		winnerTeamId: id,
 		position: reportedMatchPosition,
-		points,
+		ko,
 	}),
 	z.object({
 		_action: _action("SET_ACTIVE_ROSTER"),
@@ -80,7 +57,7 @@ export const matchSchema = z.union([
 		_action: _action("UPDATE_REPORTED_SCORE"),
 		rosters: bothTeamPlayerIds,
 		resultId: id,
-		points,
+		ko,
 	}),
 	z.object({
 		_action: _action("REOPEN_MATCH"),
diff --git a/app/features/tournament-bracket/tournament-bracket-utils.test.ts b/app/features/tournament-bracket/tournament-bracket-utils.test.ts
index 617ebc08a..7ab5d5665 100644
--- a/app/features/tournament-bracket/tournament-bracket-utils.test.ts
+++ b/app/features/tournament-bracket/tournament-bracket-utils.test.ts
@@ -1,34 +1,9 @@
 import { describe, expect, test } from "vitest";
 import {
-	fillWithNullTillPowerOfTwo,
 	groupNumberToLetters,
 	validateBadgeReceivers,
 } from "./tournament-bracket-utils";
 
-const powerOfTwoParamsToResults: [
-	amountOfTeams: number,
-	expectedNullCount: number,
-][] = [
-	[32, 0],
-	[16, 0],
-	[8, 0],
-	[31, 1],
-	[0, 0],
-	[17, 15],
-];
-
-describe("fillWithNullTillPowerOfTwo()", () => {
-	for (const [amountOfTeams, expectedNullCount] of powerOfTwoParamsToResults) {
-		test(`amountOfTeams=${amountOfTeams} -> ${expectedNullCount}`, () => {
-			expect(
-				fillWithNullTillPowerOfTwo(Array(amountOfTeams).fill("team")).filter(
-					(x) => x === null,
-				).length,
-			).toBe(expectedNullCount);
-		});
-	}
-});
-
 const groupNumberToLettersParamsToResult = [
 	{ groupNumber: 1, expected: "A" },
 	{ groupNumber: 26, expected: "Z" },
diff --git a/app/features/tournament-bracket/tournament-bracket-utils.ts b/app/features/tournament-bracket/tournament-bracket-utils.ts
index f45683015..77b009818 100644
--- a/app/features/tournament-bracket/tournament-bracket-utils.ts
+++ b/app/features/tournament-bracket/tournament-bracket-utils.ts
@@ -5,13 +5,6 @@ import type { Standing } from "./core/Bracket";
 export const tournamentWebsocketRoom = (tournamentId: number) =>
 	`tournament__${tournamentId}`;
 
-export function fillWithNullTillPowerOfTwo<T>(arr: T[]) {
-	const nextPowerOfTwo = 2 ** Math.ceil(Math.log2(arr.length));
-	const nullsToAdd = nextPowerOfTwo - arr.length;
-
-	return [...arr, ...new Array(nullsToAdd).fill(null)];
-}
-
 /**
  * Converts a group number to its corresponding letter representation.
  *
diff --git a/app/features/tournament-match/TournamentMatchRepository.server.test.ts b/app/features/tournament-match/TournamentMatchRepository.server.test.ts
index 2d90faac6..3aba95bf5 100644
--- a/app/features/tournament-match/TournamentMatchRepository.server.test.ts
+++ b/app/features/tournament-match/TournamentMatchRepository.server.test.ts
@@ -71,9 +71,15 @@ const createMatch = async (args: {
 			groupId: args.groupId,
 			roundId: args.roundId,
 			number: args.number,
-			status: 4,
-			opponentOne: JSON.stringify({ id: args.teamOneId, score: 2 }),
-			opponentTwo: JSON.stringify({ id: args.teamTwoId, score: 0 }),
+			opponentOne: JSON.stringify({
+				id: args.teamOneId,
+				score: 2,
+			}),
+			opponentTwo: JSON.stringify({
+				id: args.teamTwoId,
+				score: 0,
+			}),
+			winnerSide: "opponent1",
 		})
 		.returning("id")
 		.executeTakeFirstOrThrow();
diff --git a/app/features/tournament-match/TournamentMatchRepository.server.ts b/app/features/tournament-match/TournamentMatchRepository.server.ts
index 9c4fbae45..ccde5d55f 100644
--- a/app/features/tournament-match/TournamentMatchRepository.server.ts
+++ b/app/features/tournament-match/TournamentMatchRepository.server.ts
@@ -1,7 +1,8 @@
-import { sql } from "kysely";
+import { type Insertable, sql, type Transaction } from "kysely";
 import { jsonArrayFrom } from "kysely/helpers/sqlite";
 import { db } from "~/db/sql";
-import { TournamentMatchStatus, type TournamentRoundMaps } from "~/db/tables";
+import type { DB, TournamentRoundMaps } from "~/db/tables";
+import type { Side } from "~/features/tournament-bracket/core/engine/types";
 import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
 import invariant from "~/utils/invariant";
 import { customAvatarUrl } from "~/utils/kysely.server";
@@ -15,12 +16,6 @@ const opponentOneScore = sql<
 const opponentTwoScore = sql<
 	number | null
 >`"TournamentMatch"."opponentTwo" ->> '$.score'`;
-const opponentOneResult = sql<
-	"win" | "loss"
->`"TournamentMatch"."opponentOne" ->> '$.result'`;
-const opponentTwoResult = sql<
-	"win" | "loss"
->`"TournamentMatch"."opponentTwo" ->> '$.result'`;
 
 export type FindMatchById = NonNullable<Unwrapped<typeof findMatchById>>;
 export async function findMatchById(id: number) {
@@ -42,9 +37,9 @@ export async function findMatchById(id: number) {
 			"TournamentMatch.groupId",
 			"TournamentMatch.opponentOne",
 			"TournamentMatch.opponentTwo",
+			"TournamentMatch.winnerSide",
 			"TournamentMatch.chatCode",
 			"TournamentMatch.startedAt",
-			"TournamentMatch.status",
 			"Tournament.mapPickingStyle",
 			"TournamentRound.id as roundId",
 			"TournamentRound.maps as roundMaps",
@@ -91,26 +86,17 @@ export async function findMatchById(id: number) {
 
 	return {
 		...row,
-		opponentOne: normalizeOpponent(row.opponentOne),
-		opponentTwo: normalizeOpponent(row.opponentTwo),
 		bestOf: row.roundMaps.count,
 	};
 }
 
-// Kysely's ParseJSONResultsPlugin only parses strings starting with `[` or `{`,
-// so the JSON `null` stored for BYE opponents survives as the literal text "null".
-function normalizeOpponent<T>(value: T): T | null {
-	return (value as unknown) === "null" ? null : value;
-}
-
 export function findResultById(id: number) {
 	return db
 		.selectFrom("TournamentMatchGameResult")
 		.select([
 			"TournamentMatchGameResult.id",
 			"TournamentMatchGameResult.matchId",
-			"TournamentMatchGameResult.opponentOnePoints",
-			"TournamentMatchGameResult.opponentTwoPoints",
+			"TournamentMatchGameResult.ko",
 			"TournamentMatchGameResult.winnerTeamId",
 		])
 		.where("TournamentMatchGameResult.id", "=", id)
@@ -127,8 +113,7 @@ export function findResultsByMatchId(matchId: number) {
 			"TournamentMatchGameResult.mode",
 			"TournamentMatchGameResult.source",
 			"TournamentMatchGameResult.createdAt",
-			"TournamentMatchGameResult.opponentOnePoints",
-			"TournamentMatchGameResult.opponentTwoPoints",
+			"TournamentMatchGameResult.ko",
 			jsonArrayFrom(
 				eb
 					.selectFrom("TournamentMatchGameResultParticipant")
@@ -148,10 +133,97 @@ export function findResultsByMatchId(matchId: number) {
 		.execute();
 }
 
+/** Inserts a single game result, returning the id it was given. */
+export function insertResult(
+	args: Insertable<DB["TournamentMatchGameResult"]>,
+	trx?: Transaction<DB>,
+) {
+	return (trx ?? db)
+		.insertInto("TournamentMatchGameResult")
+		.values(args)
+		.returning("id")
+		.executeTakeFirstOrThrow();
+}
+
+/** Updates the KO status of a single game result. */
+export function updateResultKo(
+	args: { id: number; ko: boolean },
+	trx?: Transaction<DB>,
+) {
+	return (trx ?? db)
+		.updateTable("TournamentMatchGameResult")
+		.set({ ko: Number(args.ko) })
+		.where("TournamentMatchGameResult.id", "=", args.id)
+		.execute();
+}
+
+/** Sets the players who participated in a game result, replacing any existing ones. */
+export async function setParticipants(
+	args: {
+		resultId: number;
+		participants: Array<
+			Pick<
+				Insertable<DB["TournamentMatchGameResultParticipant"]>,
+				"userId" | "tournamentTeamId"
+			>
+		>;
+	},
+	trx: Transaction<DB>,
+) {
+	await trx
+		.deleteFrom("TournamentMatchGameResultParticipant")
+		.where(
+			"TournamentMatchGameResultParticipant.matchGameResultId",
+			"=",
+			args.resultId,
+		)
+		.execute();
+
+	await trx
+		.insertInto("TournamentMatchGameResultParticipant")
+		.values(
+			args.participants.map((participant) => ({
+				...participant,
+				matchGameResultId: args.resultId,
+			})),
+		)
+		.execute();
+}
+
+/** Deletes a single game result by its id. */
+export function deleteResultById(id: number, trx?: Transaction<DB>) {
+	return (trx ?? db)
+		.deleteFrom("TournamentMatchGameResult")
+		.where("TournamentMatchGameResult.id", "=", id)
+		.execute();
+}
+
+/** Deletes all pick/ban events belonging to a match. */
+export function deletePickBanEventsByMatchId(
+	matchId: number,
+	trx?: Transaction<DB>,
+) {
+	return (trx ?? db)
+		.deleteFrom("TournamentMatchPickBanEvent")
+		.where("TournamentMatchPickBanEvent.matchId", "=", matchId)
+		.execute();
+}
+
+/** Deletes a single pick/ban event by its match and event number. */
+export function deletePickBanEvent(
+	args: { matchId: number; number: number },
+	trx?: Transaction<DB>,
+) {
+	return (trx ?? db)
+		.deleteFrom("TournamentMatchPickBanEvent")
+		.where("TournamentMatchPickBanEvent.matchId", "=", args.matchId)
+		.where("TournamentMatchPickBanEvent.number", "=", args.number)
+		.execute();
+}
+
 interface AllMatchResultOpponent {
 	id: number;
 	score: number;
-	result: "win" | "loss";
 	droppedOut: boolean;
 	activeRosterUserIds: number[] | null;
 	memberUserIds: number[];
@@ -159,6 +231,7 @@ interface AllMatchResultOpponent {
 export interface AllMatchResult {
 	opponentOne: AllMatchResultOpponent;
 	opponentTwo: AllMatchResultOpponent;
+	winnerSide: Side;
 	roundMaps: TournamentRoundMaps;
 	maps: Array<{
 		stageId: StageId;
@@ -202,8 +275,7 @@ export async function allResultsByTournamentId(
 			sql<number>`"TournamentMatch"."opponentTwo" ->> '$.score'`.as(
 				"opponentTwoScore",
 			),
-			opponentOneResult.as("opponentOneResult"),
-			opponentTwoResult.as("opponentTwoResult"),
+			"TournamentMatch.winnerSide",
 			"TournamentRound.maps as roundMaps",
 			"Team1.droppedOut as opponentOneDroppedOut",
 			"Team2.droppedOut as opponentTwoDroppedOut",
@@ -251,7 +323,7 @@ export async function allResultsByTournamentId(
 			).as("maps"),
 		])
 		.where("TournamentStage.tournamentId", "=", tournamentId)
-		.where(opponentOneResult, "is not", null)
+		.where("TournamentMatch.winnerSide", "is not", null)
 		// strictly speaking the order by condition is not accurate, future improvement would be to add order conditions that match the tournament structure
 		.orderBy("TournamentMatch.id", "asc")
 		.execute();
@@ -260,7 +332,6 @@ export async function allResultsByTournamentId(
 		const opponentOne: AllMatchResultOpponent = {
 			id: row.opponentOneId,
 			score: row.opponentOneScore,
-			result: row.opponentOneResult,
 			droppedOut: row.opponentOneDroppedOut === 1,
 			activeRosterUserIds: row.opponentOneActiveRoster,
 			memberUserIds: row.opponentOneMembers.map((member) => member.userId),
@@ -268,15 +339,17 @@ export async function allResultsByTournamentId(
 		const opponentTwo: AllMatchResultOpponent = {
 			id: row.opponentTwoId,
 			score: row.opponentTwoScore,
-			result: row.opponentTwoResult,
 			droppedOut: row.opponentTwoDroppedOut === 1,
 			activeRosterUserIds: row.opponentTwoActiveRoster,
 			memberUserIds: row.opponentTwoMembers.map((member) => member.userId),
 		};
 
+		invariant(row.winnerSide, "Match has no winner");
+
 		return {
 			opponentOne,
 			opponentTwo,
+			winnerSide: row.winnerSide,
 			roundMaps: row.roundMaps,
 			maps: row.maps.map((map) => {
 				invariant(map.participants.length > 0, "No participants found");
@@ -429,7 +502,7 @@ export function findByTournamentTeamId(tournamentTeamId: number) {
 				eb(opponentTwoId, "=", tournamentTeamId),
 			]),
 		)
-		.where("TournamentMatch.status", ">=", TournamentMatchStatus.Completed)
+		.where("TournamentMatch.winnerSide", "is not", null)
 		.where((eb) =>
 			eb.exists(
 				eb
diff --git a/app/features/tournament-match/actions/to.$id.matches.$mid.server.ts b/app/features/tournament-match/actions/to.$id.matches.$mid.server.ts
index 944836ed4..26a09810d 100644
--- a/app/features/tournament-match/actions/to.$id.matches.$mid.server.ts
+++ b/app/features/tournament-match/actions/to.$id.matches.$mid.server.ts
@@ -1,20 +1,22 @@
+import type { Transaction } from "kysely";
 import type { ActionFunction } from "react-router";
-import { sql } from "~/db/sql";
-import { TournamentMatchStatus } from "~/db/tables";
+import { db } from "~/db/sql";
+import type { DB } from "~/db/tables";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
 import * as ReportedWeaponRepository from "~/features/sendouq-match/ReportedWeaponRepository.server";
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
 import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
 import { endDroppedTeamMatches } from "~/features/tournament/tournament-utils.server";
-import { getServerTournamentManager } from "~/features/tournament-bracket/core/brackets-manager/manager.server";
+import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
+import * as Engine from "~/features/tournament-bracket/core/engine";
 import * as PickBan from "~/features/tournament-bracket/core/PickBan";
+import type { Tournament } from "~/features/tournament-bracket/core/Tournament";
 import {
 	clearTournamentDataCache,
 	type TournamentDataTeam,
 	tournamentFromDB,
 } from "~/features/tournament-bracket/core/Tournament.server";
-import { deletePickBanEvent } from "~/features/tournament-bracket/queries/deletePickBanEvent.server";
 import {
 	matchPageParamsSchema,
 	matchSchema,
@@ -37,16 +39,8 @@ import { errorIsSqliteUniqueConstraintFailure } from "~/utils/sql";
 import { assertUnreachable } from "~/utils/types";
 import { executeRoll } from "../core/executeRoll.server";
 import { resolveMapList } from "../core/mapList.server";
-import { deleteMatchPickBanEvents } from "../queries/deleteMatchPickBanEvents.server";
-import { deleteParticipantsByMatchGameResultId } from "../queries/deleteParticipantsByMatchGameResultId.server";
-import { deleteTournamentMatchGameResultById } from "../queries/deleteTournamentMatchGameResultById.server";
-import { insertTournamentMatchGameResult } from "../queries/insertTournamentMatchGameResult.server";
-import { insertTournamentMatchGameResultParticipant } from "../queries/insertTournamentMatchGameResultParticipant.server";
-import { updateMatchGameResultPoints } from "../queries/updateMatchGameResultPoints.server";
 import type { FindMatchById } from "../TournamentMatchRepository.server";
 import {
-	isSetOverByScore,
-	matchEndedEarly,
 	matchIsLocked,
 	tournamentMatchWebsocketRoom,
 } from "../tournament-match-utils";
@@ -78,8 +72,7 @@ export const action: ActionFunction = async ({ params, request }) => {
 		);
 
 		errorToastIfFalsy(
-			match.status !== TournamentMatchStatus.Locked &&
-				match.status !== TournamentMatchStatus.Waiting,
+			tournament.matchStatusById(match.id) !== "PENDING",
 			"Match is locked, waiting for teams to finish their previous matches",
 		);
 
@@ -93,8 +86,6 @@ export const action: ActionFunction = async ({ params, request }) => {
 		);
 	};
 
-	const manager = getServerTournamentManager();
-
 	const scores: [number, number] = [
 		match.opponentOne?.score ?? 0,
 		match.opponentTwo?.score ?? 0,
@@ -162,37 +153,14 @@ export const action: ActionFunction = async ({ params, request }) => {
 			];
 			invariant(currentMap, "Can't resolve current map");
 
-			const scoreToIncrement = () => {
-				if (data.winnerTeamId === match.opponentOne?.id) return 0;
-				if (data.winnerTeamId === match.opponentTwo?.id) return 1;
-
-				errorToastIfFalsy(false, "Winner team id is invalid");
-			};
-
-			errorToastIfFalsy(
-				!data.points ||
-					data.points[0] === data.points[1] ||
-					(scoreToIncrement() === 0 && data.points[0] > data.points[1]) ||
-					(scoreToIncrement() === 1 && data.points[1] > data.points[0]),
-				"Points are invalid (winner must have more points than loser)",
-			);
-
 			const bracket = tournament.bracketByIdx(
 				tournament.matchIdToBracketIdx(match.id)!,
 			)!;
 			errorToastIfFalsy(
-				!bracket.collectResultsWithPoints || data.points,
-				"Points are required for this bracket",
+				!bracket.collectsKos || typeof data.ko === "boolean",
+				"KO status is required for this bracket",
 			);
 
-			scores[scoreToIncrement()]++;
-
-			const setOver = isSetOverByScore({
-				count: match.roundMaps?.count ?? match.bestOf,
-				countType: match.roundMaps?.type ?? "BEST_OF",
-				scores,
-			});
-
 			const teamOneRoster = tournamentTeamToActiveRosterUserIds(
 				tournament.teamById(match.opponentOne.id!)!,
 				tournament.minMembersPerTeam,
@@ -212,53 +180,51 @@ export const action: ActionFunction = async ({ params, request }) => {
 			);
 
 			try {
-				sql.transaction(() => {
-					manager.update.match({
-						id: match.id,
-						opponent1: {
-							score: scores[0],
-							result: setOver && scores[0] > scores[1] ? "win" : undefined,
-						},
-						opponent2: {
-							score: scores[1],
-							result: setOver && scores[1] > scores[0] ? "win" : undefined,
+				const { result: reported, endedMatchIds } =
+					await executeBracketOperation({
+						tournamentId,
+						tournament,
+						operation: (bracketData) =>
+							Engine.reportGameResult(bracketData, {
+								matchId: match.id,
+								winnerTeamId: data.winnerTeamId,
+							}),
+						endDroppedTeams: (result) => result.setOver,
+						inTransaction: async (_result, trx) => {
+							const result = await TournamentMatchRepository.insertResult(
+								{
+									matchId: match.id,
+									mode: currentMap.mode,
+									stageId: currentMap.stageId,
+									reporterId: user.id,
+									winnerTeamId: data.winnerTeamId,
+									number: data.position + 1,
+									source: String(currentMap.source),
+									ko: bracket.collectsKos ? Number(Boolean(data.ko)) : null,
+								},
+								trx,
+							);
+
+							await TournamentMatchRepository.setParticipants(
+								{
+									resultId: result.id,
+									participants: [
+										...teamOneRoster.map((userId) => ({
+											userId,
+											tournamentTeamId: match.opponentOne!.id!,
+										})),
+										...teamTwoRoster.map((userId) => ({
+											userId,
+											tournamentTeamId: match.opponentTwo!.id!,
+										})),
+									],
+								},
+								trx,
+							);
 						},
 					});
-
-					const result = insertTournamentMatchGameResult({
-						matchId: match.id,
-						mode: currentMap.mode,
-						stageId: currentMap.stageId,
-						reporterId: user.id,
-						winnerTeamId: data.winnerTeamId,
-						number: data.position + 1,
-						source: String(currentMap.source),
-						opponentOnePoints: data.points?.[0] ?? null,
-						opponentTwoPoints: data.points?.[1] ?? null,
-					});
-
-					for (const userId of teamOneRoster) {
-						insertTournamentMatchGameResultParticipant({
-							matchGameResultId: result.id,
-							userId,
-							tournamentTeamId: match.opponentOne!.id!,
-						});
-					}
-					for (const userId of teamTwoRoster) {
-						insertTournamentMatchGameResultParticipant({
-							matchGameResultId: result.id,
-							userId,
-							tournamentTeamId: match.opponentTwo!.id!,
-						});
-					}
-
-					if (setOver) {
-						endedDroppedMatchIds = endDroppedTeamMatches({
-							tournament,
-							manager,
-						});
-					}
-				})();
+				endedDroppedMatchIds = endedMatchIds;
+				setIsOver = reported.setOver;
 			} catch (error) {
 				// another request already reported this game in the race window,
 				// let their page refresh to pick up the already-recorded result
@@ -268,7 +234,7 @@ export const action: ActionFunction = async ({ params, request }) => {
 				throw error;
 			}
 
-			if (setOver) {
+			if (setIsOver) {
 				// the set ended, so weapons reported in advance for map indexes
 				// beyond the games actually played are trimmed
 				await ReportedWeaponRepository.deleteExtraByTournamentMatchId({
@@ -279,7 +245,6 @@ export const action: ActionFunction = async ({ params, request }) => {
 
 			emitMatchUpdate = true;
 			emitTournamentUpdate = true;
-			setIsOver = setOver;
 
 			break;
 		}
@@ -324,14 +289,6 @@ export const action: ActionFunction = async ({ params, request }) => {
 			const lastResult = results[results.length - 1];
 			invariant(lastResult, "Last result is missing");
 
-			const shouldReset = results.length === 1;
-
-			if (lastResult.winnerTeamId === match.opponentOne?.id) {
-				scores[0]--;
-			} else {
-				scores[1]--;
-			}
-
 			logger.info(
 				`Undoing score: Position: ${data.position}; User ID: ${user.id}; Match ID: ${match.id}`,
 			);
@@ -370,27 +327,26 @@ export const action: ActionFunction = async ({ params, request }) => {
 				return unplayedPicks[0] ? [unplayedPicks[0].number] : [];
 			})();
 
-			sql.transaction(() => {
-				deleteTournamentMatchGameResultById(lastResult.id);
+			await executeBracketOperation({
+				tournamentId,
+				tournament,
+				operation: (bracketData) =>
+					Engine.undoGameResult(bracketData, {
+						matchId: match.id,
+						lastGameWinnerTeamId: lastResult.winnerTeamId,
+					}),
+				endDroppedTeams: false,
+				inTransaction: async (_result, trx) => {
+					await TournamentMatchRepository.deleteResultById(lastResult.id, trx);
 
-				manager.update.match({
-					id: match.id,
-					opponent1: {
-						score: shouldReset ? undefined : scores[0],
-					},
-					opponent2: {
-						score: shouldReset ? undefined : scores[1],
-					},
-				});
-
-				if (shouldReset) {
-					manager.reset.matchResults(match.id);
-				}
-
-				for (const number of pickBanEventNumbersToDelete) {
-					deletePickBanEvent({ matchId, number });
-				}
-			})();
+					for (const number of pickBanEventNumbersToDelete) {
+						await TournamentMatchRepository.deletePickBanEvent(
+							{ matchId, number },
+							trx,
+						);
+					}
+				},
+			});
 
 			emitMatchUpdate = true;
 			emitTournamentUpdate = true;
@@ -427,61 +383,48 @@ export const action: ActionFunction = async ({ params, request }) => {
 				"Invalid roster",
 			);
 
-			const hadPoints = typeof result.opponentOnePoints === "number";
-			const willHavePoints = typeof data.points?.[0] === "number";
+			const bracket = tournament.bracketByIdx(
+				tournament.matchIdToBracketIdx(match.id)!,
+			)!;
 			errorToastIfFalsy(
-				(hadPoints && willHavePoints) || (!hadPoints && !willHavePoints),
-				"Points mismatch",
+				!bracket.collectsKos || typeof data.ko === "boolean",
+				"KO status is required for this bracket",
 			);
 
-			if (data.points) {
-				if (data.points[0] !== result.opponentOnePoints) {
-					// changing points at this point could retroactively change who advanced from the group
-					errorToastIfFalsy(
-						tournament.matchCanBeReopened(match.id),
-						"Bracket has progressed",
-					);
-				}
-
-				if (data.points[0] === 100) {
-					errorToastIfFalsy(
-						result.winnerTeamId === match.opponentOne!.id,
-						"KO winner must match the result winner",
-					);
-				} else if (data.points[1] === 100) {
-					errorToastIfFalsy(
-						result.winnerTeamId === match.opponentTwo!.id,
-						"KO winner must match the result winner",
-					);
-				}
+			const wasKo = Boolean(result.ko);
+			if (typeof data.ko === "boolean" && data.ko !== wasKo) {
+				// changing the KO status at this point could retroactively change who advanced from the group
+				errorToastIfFalsy(
+					tournament.matchCanBeReopened(match.id),
+					"Bracket has progressed",
+				);
 			}
 
-			sql.transaction(() => {
-				if (data.points) {
-					updateMatchGameResultPoints({
-						matchGameResultId: result.id,
-						opponentOnePoints: data.points[0],
-						opponentTwoPoints: data.points[1],
-					});
+			await db.transaction().execute(async (trx) => {
+				if (typeof data.ko === "boolean") {
+					await TournamentMatchRepository.updateResultKo(
+						{ id: result.id, ko: data.ko },
+						trx,
+					);
 				}
 
-				deleteParticipantsByMatchGameResultId(result.id);
-
-				for (const userId of data.rosters[0]) {
-					insertTournamentMatchGameResultParticipant({
-						matchGameResultId: result.id,
-						userId,
-						tournamentTeamId: match.opponentOne!.id!,
-					});
-				}
-				for (const userId of data.rosters[1]) {
-					insertTournamentMatchGameResultParticipant({
-						matchGameResultId: result.id,
-						userId,
-						tournamentTeamId: match.opponentTwo!.id!,
-					});
-				}
-			})();
+				await TournamentMatchRepository.setParticipants(
+					{
+						resultId: result.id,
+						participants: [
+							...data.rosters[0].map((userId) => ({
+								userId,
+								tournamentTeamId: match.opponentOne!.id!,
+							})),
+							...data.rosters[1].map((userId) => ({
+								userId,
+								tournamentTeamId: match.opponentTwo!.id!,
+							})),
+						],
+					},
+					trx,
+				);
+			});
 
 			emitMatchUpdate = true;
 			emitTournamentUpdate = true;
@@ -633,11 +576,6 @@ export const action: ActionFunction = async ({ params, request }) => {
 			break;
 		}
 		case "REOPEN_MATCH": {
-			const scoreOne = match.opponentOne?.score ?? 0;
-			const scoreTwo = match.opponentTwo?.score ?? 0;
-			invariant(typeof scoreOne === "number", "Score one is missing");
-			invariant(typeof scoreTwo === "number", "Score two is missing");
-
 			errorToastIfFalsy(tournament.isOrganizer(user), "Not an organizer");
 			errorToastIfFalsy(
 				tournament.matchCanBeReopened(match.id),
@@ -648,59 +586,42 @@ export const action: ActionFunction = async ({ params, request }) => {
 				await TournamentMatchRepository.findResultsByMatchId(matchId);
 			const lastResult = results[results.length - 1];
 
-			const endedEarly = matchEndedEarly({
-				opponentOne: { score: scoreOne, result: match.opponentOne?.result },
-				opponentTwo: { score: scoreTwo, result: match.opponentTwo?.result },
-				count: match.roundMaps.count,
-				countType: match.roundMaps.type,
-			});
-
-			if (!endedEarly) {
-				invariant(scoreOne !== scoreTwo, "Scores are equal");
-				invariant(lastResult, "Last result is missing");
-
-				if (lastResult.winnerTeamId === match.opponentOne?.id) {
-					scores[0]--;
-				} else {
-					scores[1]--;
-				}
-			}
-
-			logger.info(
-				`Reopening match: User ID: ${user.id}; Match ID: ${match.id}; Ended early: ${endedEarly}`,
-			);
-
 			const followingMatches = tournament.followingMatches(match.id);
 			const bracketFormat = tournament.bracketByIdx(
 				tournament.matchIdToBracketIdx(match.id)!,
 			)!.type;
-			sql.transaction(() => {
-				// edge case but for round robin we can just leave the match as is, lock it then unlock later to continue where they left off (should not really ever happen)
-				if (bracketFormat !== "round_robin") {
-					for (const followingMatch of followingMatches) {
-						deleteMatchPickBanEvents(followingMatch.id);
+			const { result: reopened } = await executeBracketOperation({
+				tournamentId,
+				tournament,
+				operation: (bracketData) => Engine.reopenMatch(bracketData, match.id),
+				endDroppedTeams: false,
+				inTransaction: async (result, trx) => {
+					// edge case but for round robin we can just leave the match as is, lock it then unlock later to continue where they left off (should not really ever happen)
+					if (bracketFormat !== "round_robin") {
+						for (const followingMatch of followingMatches) {
+							await TournamentMatchRepository.deletePickBanEventsByMatchId(
+								followingMatch.id,
+								trx,
+							);
+						}
 					}
-				}
 
-				// when the set was force-ended early no extra result was inserted for
-				// the forced win, so the last result is a genuinely played game and must
-				// be kept to avoid desyncing the score from the results
-				if (!endedEarly && lastResult) {
-					deleteTournamentMatchGameResultById(lastResult.id);
-				}
+					// when the set was force-ended early no extra result was inserted for
+					// the forced win, so the last result is a genuinely played game and must
+					// be kept to avoid desyncing the score from the results
+					if (!result.endedEarly) {
+						invariant(lastResult, "Last result is missing");
+						await TournamentMatchRepository.deleteResultById(
+							lastResult.id,
+							trx,
+						);
+					}
+				},
+			});
 
-				manager.update.match({
-					id: match.id,
-					opponent1: {
-						score: endedEarly ? scoreOne : scores[0],
-						result: undefined,
-					},
-					opponent2: {
-						score: endedEarly ? scoreTwo : scores[1],
-						result: undefined,
-					},
-				});
-			})();
+			logger.info(
+				`Reopening match: User ID: ${user.id}; Match ID: ${match.id}; Ended early: ${reopened.endedEarly}`,
+			);
 
 			// the teams advanced into following matches are being pulled back out,
 			// so those "waiting for teams" pages need to revalidate too
@@ -744,11 +665,8 @@ export const action: ActionFunction = async ({ params, request }) => {
 				"Invalid Twitch account",
 			);
 
-			// can't lock if match status is not Locked or Waiting (team(s) busy with previous match), let's update their view to reflect that
-			if (
-				match.status !== TournamentMatchStatus.Locked &&
-				match.status !== TournamentMatchStatus.Waiting
-			) {
+			// can't lock if the match can already be played, let's update their view to reflect that
+			if (tournament.matchStatusById(match.id) !== "PENDING") {
 				return null;
 			}
 
@@ -783,11 +701,7 @@ export const action: ActionFunction = async ({ params, request }) => {
 				match.opponentOne?.id && match.opponentTwo?.id,
 				"Teams are missing",
 			);
-			errorToastIfFalsy(
-				match.opponentOne?.result !== "win" &&
-					match.opponentTwo?.result !== "win",
-				"Match is already over",
-			);
+			errorToastIfFalsy(!match.winnerSide, "Match is already over");
 
 			// Determine winner (random if not specified)
 			const winnerTeamId = (() => {
@@ -810,24 +724,17 @@ export const action: ActionFunction = async ({ params, request }) => {
 				`Ending set by organizer: User ID: ${user.id}; Match ID: ${match.id}; Winner: ${winnerTeamId}; Random: ${!data.winnerTeamId}`,
 			);
 
-			sql.transaction(() => {
-				manager.update.match({
-					id: match.id,
-					opponent1: {
-						score: match.opponentOne?.score,
-						result: winnerTeamId === match.opponentOne!.id ? "win" : "loss",
-					},
-					opponent2: {
-						score: match.opponentTwo?.score,
-						result: winnerTeamId === match.opponentTwo!.id ? "win" : "loss",
-					},
-				});
-
-				endedDroppedMatchIds = endDroppedTeamMatches({
-					tournament,
-					manager,
-				});
-			})();
+			const { endedMatchIds } = await executeBracketOperation({
+				tournamentId,
+				tournament,
+				operation: (bracketData) =>
+					Engine.endSet(bracketData, {
+						matchId: match.id,
+						winnerTeamId,
+					}),
+				endDroppedTeams: true,
+			});
+			endedDroppedMatchIds = endedMatchIds;
 
 			// the set ended early so no further games will be played; trim weapons
 			// reported in advance for map indexes beyond the games actually played
@@ -938,8 +845,66 @@ function canReportTournamentScore({
 	isMemberOfATeamInTheMatch: boolean;
 	isOrganizer: boolean;
 }) {
-	const matchIsOver =
-		match.opponentOne?.result === "win" || match.opponentTwo?.result === "win";
-
-	return !matchIsOver && (isMemberOfATeamInTheMatch || isOrganizer);
+	return !match.winnerSide && (isMemberOfATeamInTheMatch || isOrganizer);
+}
+
+/**
+ * Runs an engine operation against freshly hydrated bracket data and persists
+ * the resulting match changes, all in one transaction: hydrate → operate →
+ * (end dropped teams' matches) → apply changes → extra statements.
+ */
+async function executeBracketOperation<T extends Engine.EngineResult>({
+	tournamentId,
+	tournament,
+	operation,
+	endDroppedTeams,
+	inTransaction,
+}: {
+	tournamentId: number;
+	tournament: Tournament;
+	operation: (bracketData: Engine.BracketData) => T;
+	/** Whether unfinished matches of dropped out teams should be ended after the operation (resolved from its result when given a function). */
+	endDroppedTeams: boolean | ((result: T) => boolean);
+	/** Extra statements to run inside the same transaction, after the match changes have been applied. */
+	inTransaction?: (result: T, trx: Transaction<DB>) => void | Promise<void>;
+}): Promise<{ result: T; endedMatchIds: number[] }> {
+	let result!: T;
+	let endedMatchIds: number[] = [];
+
+	await db.transaction().execute(async (trx) => {
+		const bracketData = await BracketRepository.findByTournamentId(
+			tournamentId,
+			trx,
+		);
+		result = operation(bracketData);
+
+		let applied: Engine.EngineResult = result;
+
+		const shouldEndDroppedTeamMatches =
+			typeof endDroppedTeams === "function"
+				? endDroppedTeams(result)
+				: endDroppedTeams;
+		if (shouldEndDroppedTeamMatches) {
+			const droppedResult = endDroppedTeamMatches({
+				tournament,
+				data: result.data,
+			});
+			endedMatchIds = droppedResult.endedMatchIds;
+			applied = {
+				data: droppedResult.data,
+				changedMatches: [
+					...result.changedMatches,
+					...droppedResult.changedMatches,
+				],
+			};
+		}
+
+		await BracketRepository.applyMatchChanges(
+			{ previousData: bracketData, result: applied },
+			trx,
+		);
+		await inTransaction?.(result, trx);
+	});
+
+	return { result, endedMatchIds };
 }
diff --git a/app/features/tournament-match/components/TournamentMatchActionTab.tsx b/app/features/tournament-match/components/TournamentMatchActionTab.tsx
index 5300cbfde..bc5602414 100644
--- a/app/features/tournament-match/components/TournamentMatchActionTab.tsx
+++ b/app/features/tournament-match/components/TournamentMatchActionTab.tsx
@@ -9,11 +9,11 @@ import { useMatchWeaponReport } from "~/components/match-page/useMatchWeaponRepo
 import { WeaponReporter } from "~/components/match-page/WeaponReporter";
 import { useUser } from "~/features/auth/core/user";
 import { useTournament } from "~/features/tournament/routes/to.$id";
+import { isSetOverByScore } from "~/features/tournament-bracket/core/engine";
 import { databaseTimestampToJavascriptTimestamp } from "~/utils/dates";
 import type { CommonUser } from "~/utils/kysely.server";
 import type { TournamentMatchLoaderData } from "../loaders/to.$id.matches.$mid.server";
 import { useMatch } from "../match-page-context";
-import { isSetOverByScore } from "../tournament-match-utils";
 
 export function TournamentMatchActionTab({
 	data,
@@ -54,9 +54,9 @@ export function TournamentMatchActionTab({
 
 	if (!teamOne || !teamTwo) return null;
 
-	const withPoints = tournament.bracketByIdxOrDefault(
+	const withKo = tournament.bracketByIdxOrDefault(
 		tournament.matchIdToBracketIdx(data.match.id) ?? 0,
-	).collectResultsWithPoints;
+	).collectsKos;
 
 	const count = data.match.roundMaps.count;
 	const countType = data.match.roundMaps.type;
@@ -113,16 +113,16 @@ export function TournamentMatchActionTab({
 			ownTeamId={ownTeamId}
 			stageId={currentMap.stageId}
 			mode={currentMap.mode}
-			withPoints={withPoints}
+			withKo={withKo}
 			setEnding={setEnding}
 			isSubmitting={reportFetcher.state !== "idle"}
-			onSubmit={({ winnerId, points }) => {
+			onSubmit={({ winnerId, ko }) => {
 				reportFetcher.submit(
 					{
 						_action: "REPORT_SCORE",
 						winnerTeamId: String(winnerId),
 						position: String(scoreSum),
-						...(points ? { points: JSON.stringify(points) } : {}),
+						...(typeof ko === "boolean" ? { ko: String(ko) } : {}),
 					},
 					{ method: "post" },
 				);
@@ -271,13 +271,7 @@ function buildSetEndingData({
 				alpha: alphaParticipants,
 				bravo: bravoParticipants,
 			},
-			points:
-				result.opponentOnePoints != null && result.opponentTwoPoints != null
-					? ([result.opponentOnePoints, result.opponentTwoPoints] as [
-							number,
-							number,
-						])
-					: undefined,
+			ko: result.ko != null ? Boolean(result.ko) : undefined,
 		};
 	});
 
diff --git a/app/features/tournament-match/components/TournamentMatchAdminTab.tsx b/app/features/tournament-match/components/TournamentMatchAdminTab.tsx
index 9f15ea4c1..7a5dff5f4 100644
--- a/app/features/tournament-match/components/TournamentMatchAdminTab.tsx
+++ b/app/features/tournament-match/components/TournamentMatchAdminTab.tsx
@@ -14,9 +14,9 @@ import { InfoPopover } from "~/components/InfoPopover";
 import { Label } from "~/components/Label";
 import { TAB_KEYS } from "~/components/match-page/MatchTabs";
 import { SubmitButton } from "~/components/SubmitButton";
-import { TournamentMatchStatus } from "~/db/tables";
 import { useUser } from "~/features/auth/core/user";
 import { useTournament } from "~/features/tournament/routes/to.$id";
+import type { MatchStatus } from "~/features/tournament-bracket/core/engine";
 import type { TournamentDataTeam } from "~/features/tournament-bracket/core/Tournament.server";
 import type { TournamentMatchLoaderData } from "../loaders/to.$id.matches.$mid.server";
 import { useMatch } from "../match-page-context";
@@ -78,7 +78,7 @@ function AdminCastSection({
 	matchStatus,
 }: {
 	matchId: number;
-	matchStatus: number;
+	matchStatus: MatchStatus;
 }) {
 	const { t } = useTranslation(["tournament"]);
 	const tournament = useTournament();
@@ -95,10 +95,7 @@ function AdminCastSection({
 		castedMatchesInfo?.lockedMatches?.some((lm) => lm.matchId === matchId) ??
 		false;
 
-	const canLock =
-		(matchStatus === TournamentMatchStatus.Locked ||
-			matchStatus === TournamentMatchStatus.Waiting) &&
-		!isLocked;
+	const canLock = matchStatus === "PENDING" && !isLocked;
 	const canUnlock = !isMatchStarted && isLocked;
 
 	return (
@@ -349,9 +346,9 @@ function EditReportedScoresSection({
 	const { t } = useTranslation(["tournament"]);
 	const tournament = useTournament();
 
-	const withPoints = tournament.bracketByIdxOrDefault(
+	const withKo = tournament.bracketByIdxOrDefault(
 		tournament.matchIdToBracketIdx(data.match.id) ?? 0,
-	).collectResultsWithPoints;
+	).collectsKos;
 
 	return (
 		<div className={styles.editSection}>
@@ -363,7 +360,7 @@ function EditReportedScoresSection({
 						index={index}
 						result={result}
 						teams={teams}
-						withPoints={withPoints}
+						withKo={withKo}
 					/>
 				))}
 			</div>
@@ -375,12 +372,12 @@ function EditReportedScoreRow({
 	index,
 	result,
 	teams,
-	withPoints,
+	withKo,
 }: {
 	index: number;
 	result: TournamentMatchLoaderData["results"][number];
 	teams: [TournamentDataTeam, TournamentDataTeam];
-	withPoints: boolean;
+	withKo: boolean;
 }) {
 	const { t } = useTranslation(["common", "game-misc", "tournament"]);
 	const tournament = useTournament();
@@ -399,8 +396,7 @@ function EditReportedScoreRow({
 		previousFetcherStateRef.current = fetcher.state;
 	}, [fetcher.state, fetcher.data]);
 
-	const isKo =
-		result.opponentOnePoints === 100 || result.opponentTwoPoints === 100;
+	const isKo = Boolean(result.ko);
 
 	if (!editing) {
 		return (
@@ -433,7 +429,7 @@ function EditReportedScoreRow({
 			fetcher={fetcher}
 			result={result}
 			teams={teams}
-			withPoints={withPoints}
+			withKo={withKo}
 			minMembersPerTeam={tournament.minMembersPerTeam}
 			onCancel={() => setEditing(false)}
 			index={index}
@@ -445,7 +441,7 @@ function EditReportedScoreForm({
 	fetcher,
 	result,
 	teams,
-	withPoints,
+	withKo,
 	minMembersPerTeam,
 	onCancel,
 	index,
@@ -453,7 +449,7 @@ function EditReportedScoreForm({
 	fetcher: ReturnType<typeof useFetcher>;
 	result: TournamentMatchLoaderData["results"][number];
 	teams: [TournamentDataTeam, TournamentDataTeam];
-	withPoints: boolean;
+	withKo: boolean;
 	minMembersPerTeam: number;
 	onCancel: () => void;
 	index: number;
@@ -471,16 +467,7 @@ function EditReportedScoreForm({
 				.map((p) => p.userId),
 		];
 	});
-	const [isKO, setIsKO] = React.useState(
-		result.opponentOnePoints === 100 || result.opponentTwoPoints === 100,
-	);
-
-	const team0Won = result.winnerTeamId === teams[0].id;
-	const points: [number, number] = isKO
-		? team0Won
-			? [100, 0]
-			: [0, 100]
-		: [0, 0];
+	const [isKO, setIsKO] = React.useState(Boolean(result.ko));
 
 	const formValid = checkedPlayers.every(
 		(team) => team.length === minMembersPerTeam,
@@ -536,9 +523,9 @@ function EditReportedScoreForm({
 				name="rosters"
 				value={JSON.stringify(checkedPlayers)}
 			/>
-			{withPoints ? (
+			{withKo ? (
 				<>
-					<input type="hidden" name="points" value={JSON.stringify(points)} />
+					<input type="hidden" name="ko" value={String(isKO)} />
 					<label className="stack horizontal sm items-center mx-auto">
 						<input
 							type="checkbox"
diff --git a/app/features/tournament-match/components/TournamentMatchBanner.tsx b/app/features/tournament-match/components/TournamentMatchBanner.tsx
index d49c3f913..30c993c66 100644
--- a/app/features/tournament-match/components/TournamentMatchBanner.tsx
+++ b/app/features/tournament-match/components/TournamentMatchBanner.tsx
@@ -256,9 +256,7 @@ function TournamentMatchBannerTopRow({
 			score={{
 				alpha: scores[0],
 				bravo: scores[1],
-				isFinal:
-					data.match.opponentOne?.result === "win" ||
-					data.match.opponentTwo?.result === "win",
+				isFinal: Boolean(data.match.winnerSide),
 				count: data.match.roundMaps.count,
 				bestOf: data.match.roundMaps.type === "BEST_OF",
 			}}
@@ -529,10 +527,10 @@ function resolveDroppedOutTeamName({
 	if (!data.matchIsOver || data.results.length > 0) return null;
 
 	const droppedOutId =
-		data.match.opponentOne?.result === "loss"
-			? data.match.opponentOne.id
-			: data.match.opponentTwo?.result === "loss"
-				? data.match.opponentTwo.id
+		data.match.winnerSide === "opponent2"
+			? data.match.opponentOne?.id
+			: data.match.winnerSide === "opponent1"
+				? data.match.opponentTwo?.id
 				: null;
 	if (!droppedOutId) return null;
 
diff --git a/app/features/tournament-match/components/TournamentMatchTabs.tsx b/app/features/tournament-match/components/TournamentMatchTabs.tsx
index 2ad98bf0e..8d1f28790 100644
--- a/app/features/tournament-match/components/TournamentMatchTabs.tsx
+++ b/app/features/tournament-match/components/TournamentMatchTabs.tsx
@@ -153,9 +153,6 @@ function resolveTimelineMaps(
 			}));
 
 	return data.results.map((result, mapIndex) => {
-		const hasPoints =
-			result.opponentOnePoints !== null && result.opponentTwoPoints !== null;
-
 		const alphaRoster = resolveRoster(result.participants, opponentOneId);
 		const bravoRoster = resolveRoster(result.participants, opponentTwoId);
 
@@ -185,12 +182,7 @@ function resolveTimelineMaps(
 			weapons: hasAnyWeapon
 				? { alpha: alphaWeapons, bravo: bravoWeapons }
 				: undefined,
-			points: hasPoints
-				? ([result.opponentOnePoints, result.opponentTwoPoints] as [
-						number,
-						number,
-					])
-				: undefined,
+			ko: result.ko != null ? Boolean(result.ko) : undefined,
 		};
 	});
 }
diff --git a/app/features/tournament-match/core/mapList.server.ts b/app/features/tournament-match/core/mapList.server.ts
index 7e1b04fa2..ec106d7c7 100644
--- a/app/features/tournament-match/core/mapList.server.ts
+++ b/app/features/tournament-match/core/mapList.server.ts
@@ -1,9 +1,7 @@
 import type { Tables, TournamentRoundMaps } from "~/db/tables";
 import { MapPool } from "~/features/map-list-generator/core/map-pool";
 import { mapPickingStyleToModes } from "~/features/tournament/tournament-utils";
-import type { Bracket } from "~/features/tournament-bracket/core/Bracket";
 import type * as PickBan from "~/features/tournament-bracket/core/PickBan";
-import type { Round } from "~/modules/brackets-model";
 import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
 import { generateBalancedMapList } from "~/modules/tournament-map-list-generator/balanced-map-list";
 import { starterMap } from "~/modules/tournament-map-list-generator/starter-map";
@@ -12,7 +10,6 @@ import type {
 	TournamentMaplistSource,
 } from "~/modules/tournament-map-list-generator/types";
 import { syncCached } from "~/utils/cache.server";
-import invariant from "~/utils/invariant";
 import { logger } from "~/utils/logger";
 import { assertUnreachable } from "~/utils/types";
 
@@ -240,76 +237,3 @@ function resolveFreshTeamPickedMapList(
 		});
 	}
 }
-
-export function roundMapsFromInput({
-	roundsFromDB,
-	virtualRounds,
-	maps,
-	bracket,
-}: {
-	roundsFromDB: Round[];
-	virtualRounds: Round[];
-	maps: (TournamentRoundMaps & { roundId: number })[];
-	bracket: Bracket;
-}) {
-	const expandedMaps =
-		bracket.type === "round_robin" || bracket.type === "swiss"
-			? expandMaps({ maps, virtualRounds })
-			: maps;
-
-	const virtualGroupIdToReal = (virtualGroupId: number) => {
-		const minRealGroupId = Math.min(...roundsFromDB.map((r) => r.group_id));
-		const minVirtualGroupId = Math.min(...virtualRounds.map((r) => r.group_id));
-
-		return virtualGroupId - minVirtualGroupId + minRealGroupId;
-	};
-
-	return expandedMaps.map((map) => {
-		const virtualRound = virtualRounds.find((r) => r.id === map.roundId);
-		invariant(
-			virtualRound,
-			`No virtual round found for map with round id: ${map.roundId}`,
-		);
-
-		const realRoundId = roundsFromDB.find(
-			(r) =>
-				r.number === virtualRound.number &&
-				r.group_id === virtualGroupIdToReal(virtualRound.group_id),
-		)?.id;
-		invariant(realRoundId, "No real round found for virtual round");
-
-		return { ...map, roundId: realRoundId };
-	});
-}
-
-function expandMaps({
-	virtualRounds,
-	maps,
-}: {
-	virtualRounds: Round[];
-	maps: (TournamentRoundMaps & { roundId: number })[];
-}) {
-	const result: typeof maps = [];
-
-	const mapsByNumber = maps.reduce(
-		(acc, map) => {
-			const number = virtualRounds.find((r) => r.id === map.roundId)?.number;
-			invariant(number, "No number found for round id");
-
-			acc.set(number, map);
-			return acc;
-		},
-		new Map() as Map<number, (typeof maps)[number]>,
-	);
-	for (const round of virtualRounds) {
-		const maps = mapsByNumber.get(round.number);
-		invariant(maps, "No maps found for round number");
-
-		result.push({
-			...maps,
-			roundId: round.id,
-		});
-	}
-
-	return result;
-}
diff --git a/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts b/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
index d618f6a79..bf47b936d 100644
--- a/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
+++ b/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
@@ -7,13 +7,13 @@ import * as ReportedWeaponRepository from "~/features/sendouq-match/ReportedWeap
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
 import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
 import { isLeagueRoundLocked } from "~/features/tournament/tournament-utils";
+import { matchEndedEarly } from "~/features/tournament-bracket/core/engine";
 import * as PickBan from "~/features/tournament-bracket/core/PickBan";
 import { tournamentFromDBCached } from "~/features/tournament-bracket/core/Tournament.server";
 import { matchPageParamsSchema } from "~/features/tournament-bracket/tournament-bracket-schemas.server";
 import { tournamentTeamToActiveRosterUserIds } from "~/features/tournament-bracket/tournament-bracket-utils";
 import * as UserCardRepository from "~/features/user-card/UserCardRepository.server";
 import * as UserRepository from "~/features/user-page/UserRepository.server";
-import { Status } from "~/modules/brackets-model";
 import { cache, IN_MILLISECONDS, ttl } from "~/utils/cache.server";
 import { IS_E2E_TEST_RUN } from "~/utils/e2e";
 import { logger } from "~/utils/logger";
@@ -23,7 +23,6 @@ import { tournamentMatchPage } from "~/utils/urls";
 import { executeRoll } from "../core/executeRoll.server";
 import { mapListFromResults, resolveMapList } from "../core/mapList.server";
 import * as TournamentMatchRepository from "../TournamentMatchRepository.server";
-import { matchEndedEarly } from "../tournament-match-utils";
 
 export type TournamentMatchLoaderData = SerializeFrom<typeof loader>;
 
@@ -60,8 +59,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 	const reportedWeapons =
 		await ReportedWeaponRepository.findByTournamentMatchId(matchId);
 
-	const matchIsOver =
-		match.opponentOne?.result === "win" || match.opponentTwo?.result === "win";
+	const matchIsOver = Boolean(match.winnerSide);
 
 	if (
 		!matchIsOver &&
@@ -143,25 +141,22 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 
 	const endedEarly = matchIsOver
 		? matchEndedEarly({
-				opponentOne: {
-					score: match.opponentOne?.score,
-					result: match.opponentOne?.result,
-				},
-				opponentTwo: {
-					score: match.opponentTwo?.score,
-					result: match.opponentTwo?.result,
-				},
+				opponentOne: match.opponentOne,
+				opponentTwo: match.opponentTwo,
+				winnerSide: match.winnerSide,
 				count: match.roundMaps.count,
 				countType: match.roundMaps.type,
 			})
 		: false;
 
+	const status = tournament.matchStatusById(matchId);
+
 	if (
 		match.chatCode &&
 		!matchIsOver &&
 		match.opponentOne?.id &&
 		match.opponentTwo?.id &&
-		match.status > Status.Locked
+		status !== "PENDING"
 	) {
 		// only add global chat for active roster (or all if not yet set i.e. first match)
 		// if roster changed mid-set the subs can still see the chat on the match page
@@ -225,7 +220,11 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 				friendCode: isParticipant || isSiteStaff || isTournamentStaff,
 			},
 		})),
-		match: hasPermsToSeeChat ? match : { ...match, chatCode: undefined },
+		match: {
+			...match,
+			status,
+			chatCode: hasPermsToSeeChat ? match.chatCode : undefined,
+		},
 		results,
 		reportedWeapons,
 		mapList,
diff --git a/app/features/tournament-match/match-page-context.tsx b/app/features/tournament-match/match-page-context.tsx
index a5d931a41..7d4f45245 100644
--- a/app/features/tournament-match/match-page-context.tsx
+++ b/app/features/tournament-match/match-page-context.tsx
@@ -1,7 +1,6 @@
 import * as React from "react";
 import { TAB_KEYS } from "~/components/match-page/MatchTabs";
 import { resolveRoomPass } from "~/components/match-page/utils";
-import { TournamentMatchStatus } from "~/db/tables";
 import { useUser } from "~/features/auth/core/user";
 import { useTournament } from "~/features/tournament/routes/to.$id";
 import { isLeagueRoundLocked } from "~/features/tournament/tournament-utils";
@@ -102,9 +101,7 @@ export function MatchPageProvider({
 		scores,
 	});
 
-	const waitingForPreviousMatch =
-		data.match.status === TournamentMatchStatus.Locked ||
-		data.match.status === TournamentMatchStatus.Waiting;
+	const waitingForPreviousMatch = data.match.status === "PENDING";
 
 	const joinInfo = resolveJoinInfo({ tournament, data, teams });
 
@@ -263,9 +260,7 @@ function resolveJoinInfo({
 	);
 	const bracket = tournament.brackets[bracketIdx];
 	const bracketMatch = bracket?.data.match.find((m) => m.id === data.match.id);
-	const group = bracket?.data.group.find(
-		(g) => g.id === bracketMatch?.group_id,
-	);
+	const group = bracket?.data.group.find((g) => g.id === bracketMatch?.groupId);
 
 	const poolCode = tournament.resolvePoolCode({
 		hostingTeamId: hostingTeam.id,
diff --git a/app/features/tournament-match/queries/deleteMatchPickBanEvents.server.ts b/app/features/tournament-match/queries/deleteMatchPickBanEvents.server.ts
deleted file mode 100644
index f56acdf14..000000000
--- a/app/features/tournament-match/queries/deleteMatchPickBanEvents.server.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  delete from "TournamentMatchPickBanEvent"
-    where "matchId" = @matchId
-`);
-
-export function deleteMatchPickBanEvents(matchId: number) {
-	return stm.run({ matchId });
-}
diff --git a/app/features/tournament-match/queries/deleteParticipantsByMatchGameResultId.server.ts b/app/features/tournament-match/queries/deleteParticipantsByMatchGameResultId.server.ts
deleted file mode 100644
index 01c762ea7..000000000
--- a/app/features/tournament-match/queries/deleteParticipantsByMatchGameResultId.server.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  delete from "TournamentMatchGameResultParticipant"
-  where "matchGameResultId" = @matchGameResultId
-`);
-
-export function deleteParticipantsByMatchGameResultId(
-	matchGameResultId: number,
-) {
-	stm.run({ matchGameResultId });
-}
diff --git a/app/features/tournament-match/queries/deleteTournamentMatchGameResultById.server.ts b/app/features/tournament-match/queries/deleteTournamentMatchGameResultById.server.ts
deleted file mode 100644
index 177aabb43..000000000
--- a/app/features/tournament-match/queries/deleteTournamentMatchGameResultById.server.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  delete from "TournamentMatchGameResult"
-  where "TournamentMatchGameResult"."id" = @id
-`);
-
-export function deleteTournamentMatchGameResultById(id: number) {
-	stm.run({ id });
-}
diff --git a/app/features/tournament-match/queries/insertTournamentMatchGameResult.server.ts b/app/features/tournament-match/queries/insertTournamentMatchGameResult.server.ts
deleted file mode 100644
index d2cf4f5ad..000000000
--- a/app/features/tournament-match/queries/insertTournamentMatchGameResult.server.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-
-const stm = sql.prepare(/* sql */ `
-  insert into "TournamentMatchGameResult"
-    ("matchId", "stageId", "mode", "winnerTeamId", "reporterId", "number", "source", "opponentOnePoints", "opponentTwoPoints")
-  values
-    (@matchId, @stageId, @mode, @winnerTeamId, @reporterId, @number, @source, @opponentOnePoints, @opponentTwoPoints)
-  returning *
-`);
-
-export function insertTournamentMatchGameResult(
-	args: Omit<Tables["TournamentMatchGameResult"], "id" | "createdAt">,
-) {
-	return stm.get(args) as Tables["TournamentMatchGameResult"];
-}
diff --git a/app/features/tournament-match/queries/insertTournamentMatchGameResultParticipant.server.ts b/app/features/tournament-match/queries/insertTournamentMatchGameResultParticipant.server.ts
deleted file mode 100644
index 4149fce42..000000000
--- a/app/features/tournament-match/queries/insertTournamentMatchGameResultParticipant.server.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  insert into "TournamentMatchGameResultParticipant"
-    ("matchGameResultId", "userId", "tournamentTeamId")
-  values
-    (@matchGameResultId, @userId, @tournamentTeamId)
-`);
-
-export function insertTournamentMatchGameResultParticipant(args: {
-	matchGameResultId: number;
-	userId: number;
-	tournamentTeamId: number;
-}) {
-	stm.run(args);
-}
diff --git a/app/features/tournament-match/queries/updateMatchGameResultPoints.server.ts b/app/features/tournament-match/queries/updateMatchGameResultPoints.server.ts
deleted file mode 100644
index ac009f2fa..000000000
--- a/app/features/tournament-match/queries/updateMatchGameResultPoints.server.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
-  update "TournamentMatchGameResult"
-  set "opponentOnePoints" = @opponentOnePoints,
-      "opponentTwoPoints" = @opponentTwoPoints
-  where "id" = @id
-`);
-
-export function updateMatchGameResultPoints({
-	matchGameResultId,
-	opponentOnePoints,
-	opponentTwoPoints,
-}: {
-	matchGameResultId: number;
-	opponentOnePoints: number;
-	opponentTwoPoints: number;
-}) {
-	stm.run({ id: matchGameResultId, opponentOnePoints, opponentTwoPoints });
-}
diff --git a/app/features/tournament-match/routes/to.$id.matches.$mid.test.ts b/app/features/tournament-match/routes/to.$id.matches.$mid.test.ts
index 503f3dfd7..4278c4ec4 100644
--- a/app/features/tournament-match/routes/to.$id.matches.$mid.test.ts
+++ b/app/features/tournament-match/routes/to.$id.matches.$mid.test.ts
@@ -130,8 +130,7 @@ describe("Tournament match page", () => {
 				),
 				"Result participants should only include active roster user ids",
 			).toBeTruthy();
-			expect(result.opponentOnePoints).toBe(null);
-			expect(result.opponentTwoPoints).toBe(null);
+			expect(result.ko).toBe(null);
 			expect(result.winnerTeamId).toBe(1);
 		});
 
@@ -251,7 +250,7 @@ describe("Tournament match page", () => {
 			await setActiveRosterAction();
 			await db
 				.updateTable("TournamentMatch")
-				.set({ status: 0 })
+				.set({ opponentOne: JSON.stringify({ id: null }) })
 				.where("id", "=", 1)
 				.execute();
 
@@ -265,7 +264,7 @@ describe("Tournament match page", () => {
 		it("should 404 when accessing a BYE match", async () => {
 			await db
 				.updateTable("TournamentMatch")
-				.set({ opponentTwo: JSON.stringify(null) })
+				.set({ opponentTwo: null })
 				.where("id", "=", 1)
 				.execute();
 
diff --git a/app/features/tournament-match/tournament-match-utils.test.ts b/app/features/tournament-match/tournament-match-utils.test.ts
index a80e0d5e4..e884be5ab 100644
--- a/app/features/tournament-match/tournament-match-utils.test.ts
+++ b/app/features/tournament-match/tournament-match-utils.test.ts
@@ -1,8 +1,5 @@
 import { describe, expect, test } from "vitest";
-import {
-	mapCountPlayedInSetWithCertainty,
-	matchEndedEarly,
-} from "./tournament-match-utils";
+import { mapCountPlayedInSetWithCertainty } from "./tournament-match-utils";
 
 const mapCountParamsToResult: {
 	bestOf: number;
@@ -29,93 +26,3 @@ describe("mapCountPlayedInSetWithCertainty()", () => {
 		});
 	}
 });
-
-describe("matchEndedEarly", () => {
-	test("returns false when no winner", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 1 },
-				opponentTwo: { score: 1 },
-				count: 3,
-				countType: "BEST_OF",
-			}),
-		).toBe(false);
-	});
-
-	test("returns false when match completed normally (best of 3)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 2, result: "win" },
-				opponentTwo: { score: 1, result: "loss" },
-				count: 3,
-				countType: "BEST_OF",
-			}),
-		).toBe(false);
-	});
-
-	test("returns true when match ended early (best of 3)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 1, result: "win" },
-				opponentTwo: { score: 0, result: "loss" },
-				count: 3,
-				countType: "BEST_OF",
-			}),
-		).toBe(true);
-	});
-
-	test("returns true when match ended early (best of 5)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 2, result: "win" },
-				opponentTwo: { score: 1, result: "loss" },
-				count: 5,
-				countType: "BEST_OF",
-			}),
-		).toBe(true);
-	});
-
-	test("returns false when match completed normally (best of 5)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 3, result: "win" },
-				opponentTwo: { score: 2, result: "loss" },
-				count: 5,
-				countType: "BEST_OF",
-			}),
-		).toBe(false);
-	});
-
-	test("returns false when all maps played (play all)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 2, result: "win" },
-				opponentTwo: { score: 1, result: "loss" },
-				count: 3,
-				countType: "PLAY_ALL",
-			}),
-		).toBe(false);
-	});
-
-	test("returns true when not all maps played (play all)", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { score: 2, result: "win" },
-				opponentTwo: { score: 0, result: "loss" },
-				count: 3,
-				countType: "PLAY_ALL",
-			}),
-		).toBe(true);
-	});
-
-	test("handles missing scores as 0", () => {
-		expect(
-			matchEndedEarly({
-				opponentOne: { result: "win" },
-				opponentTwo: { result: "loss" },
-				count: 3,
-				countType: "BEST_OF",
-			}),
-		).toBe(true);
-	});
-});
diff --git a/app/features/tournament-match/tournament-match-utils.ts b/app/features/tournament-match/tournament-match-utils.ts
index 7a9e9df17..2b25d8903 100644
--- a/app/features/tournament-match/tournament-match-utils.ts
+++ b/app/features/tournament-match/tournament-match-utils.ts
@@ -108,43 +108,3 @@ export function isSetOverByResults({
 	// best of
 	return maxWins >= Math.ceil(count / 2);
 }
-
-export function isSetOverByScore({
-	scores,
-	count,
-	countType,
-}: {
-	scores: [number, number];
-	count: number;
-	countType: TournamentRoundMaps["type"];
-}) {
-	if (countType === "PLAY_ALL") {
-		return R.sum(scores) === count;
-	}
-
-	const matchOverAtXWins = Math.ceil(count / 2);
-	return scores[0] === matchOverAtXWins || scores[1] === matchOverAtXWins;
-}
-
-export function matchEndedEarly({
-	opponentOne,
-	opponentTwo,
-	count,
-	countType,
-}: {
-	opponentOne: { score?: number; result?: "win" | "loss" };
-	opponentTwo: { score?: number; result?: "win" | "loss" };
-	count: number;
-	countType: TournamentRoundMaps["type"];
-}) {
-	if (opponentOne.result !== "win" && opponentTwo.result !== "win") {
-		return false;
-	}
-
-	const scores: [number, number] = [
-		opponentOne.score ?? 0,
-		opponentTwo.score ?? 0,
-	];
-
-	return !isSetOverByScore({ scores, count, countType });
-}
diff --git a/app/features/tournament-organization/test-utils.ts b/app/features/tournament-organization/test-utils.ts
index 5fa92fadc..ab9cdd3b2 100644
--- a/app/features/tournament-organization/test-utils.ts
+++ b/app/features/tournament-organization/test-utils.ts
@@ -106,7 +106,6 @@ export async function seedOrgEventWithParticipants({
 			groupId: group.id,
 			roundId: round.id,
 			number: 1,
-			status: 4,
 			opponentOne: JSON.stringify({ id: team.id, score: 1 }),
 			opponentTwo: JSON.stringify({ id: team.id, score: 0 }),
 		})
diff --git a/app/features/tournament/TournamentRepository.server.ts b/app/features/tournament/TournamentRepository.server.ts
index cff891526..a16664124 100644
--- a/app/features/tournament/TournamentRepository.server.ts
+++ b/app/features/tournament/TournamentRepository.server.ts
@@ -15,11 +15,9 @@ import { identifierToUserIds } from "~/features/mmr/mmr-utils";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
 import type { TournamentSummary } from "~/features/tournament-bracket/core/summarizer.server";
 import type { TournamentBadgeReceivers } from "~/features/tournament-bracket/tournament-bracket-schemas.server";
-import { Status } from "~/modules/brackets-model";
 import { modesShort } from "~/modules/in-game-lists/modes";
 import { nullFilledArray, nullifyingAvg } from "~/utils/arrays";
 import { databaseTimestampNow, dateToDatabaseTimestamp } from "~/utils/dates";
-import { shortNanoid } from "~/utils/id";
 import invariant from "~/utils/invariant";
 import {
 	commonUserSelect,
@@ -1049,30 +1047,6 @@ export function addPickBanEvent(
 	return db.insertInto("TournamentMatchPickBanEvent").values(values).execute();
 }
 
-export function resetBracket(tournamentStageId: number) {
-	return db.transaction().execute(async (trx) => {
-		await trx
-			.deleteFrom("TournamentMatch")
-			.where("stageId", "=", tournamentStageId)
-			.execute();
-
-		await trx
-			.deleteFrom("TournamentRound")
-			.where("stageId", "=", tournamentStageId)
-			.execute();
-
-		await trx
-			.deleteFrom("TournamentGroup")
-			.where("stageId", "=", tournamentStageId)
-			.execute();
-
-		await trx
-			.deleteFrom("TournamentStage")
-			.where("id", "=", tournamentStageId)
-			.execute();
-	});
-}
-
 export function reopenTournament(tournamentId: number) {
 	return db.transaction().execute(async (trx) => {
 		await trx
@@ -1309,49 +1283,6 @@ export function finalizeWithoutSummary(tournamentId: number) {
 		.execute();
 }
 
-export type TournamentRepositoryInsertableMatch = Omit<
-	Insertable<DB["TournamentMatch"]>,
-	"status" | "chatCode"
->;
-
-export function insertSwissMatches(
-	matches: TournamentRepositoryInsertableMatch[],
-) {
-	if (matches.length === 0) {
-		throw new Error("No matches to insert");
-	}
-
-	return db
-		.insertInto("TournamentMatch")
-		.values(
-			matches.map((match) => ({
-				groupId: match.groupId,
-				number: match.number,
-				opponentOne: match.opponentOne,
-				opponentTwo: match.opponentTwo,
-				roundId: match.roundId,
-				stageId: match.stageId,
-				status: Status.Ready,
-				chatCode: shortNanoid(),
-			})),
-		)
-		.execute();
-}
-
-export function deleteSwissMatches({
-	groupId,
-	roundId,
-}: {
-	groupId: number;
-	roundId: number;
-}) {
-	return db
-		.deleteFrom("TournamentMatch")
-		.where("groupId", "=", groupId)
-		.where("roundId", "=", roundId)
-		.execute();
-}
-
 export async function searchByName({
 	query,
 	limit,
diff --git a/app/features/tournament/core/Standings.test.ts b/app/features/tournament/core/Standings.test.ts
index ae6fc0ad2..7c19766e6 100644
--- a/app/features/tournament/core/Standings.test.ts
+++ b/app/features/tournament/core/Standings.test.ts
@@ -1,11 +1,13 @@
 import { describe, expect, it } from "vitest";
+import * as Engine from "~/features/tournament-bracket/core/engine";
+import { createResolved } from "~/features/tournament-bracket/core/engine/create";
+import type { BracketData } from "~/features/tournament-bracket/core/engine/types";
 import {
+	mergeStages,
 	progressions,
 	testTournament,
 	tournamentCtxTeam,
 } from "~/features/tournament-bracket/core/tests/test-utils";
-import { BracketsManager } from "~/modules/brackets-manager";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
 import invariant from "~/utils/invariant";
 import {
 	matchesPlayed,
@@ -158,44 +160,20 @@ describe("matchesPlayed", () => {
 });
 
 function roundRobinToSingleEliminationTournament() {
-	const storage = new InMemoryDatabase();
-	const manager = new BracketsManager(storage);
-
-	manager.create({
-		name: "Main Bracket",
-		tournamentId: 1,
-		type: "round_robin",
-		seeding: [1, 2, 3, 4],
-		settings: { groupCount: 1, seedOrdering: ["groups.seed_optimized"] },
-	});
-	manager.create({
-		name: "B1",
-		tournamentId: 1,
-		type: "single_elimination",
-		seeding: [1, 2],
-		settings: { seedOrdering: ["natural"] },
-	});
-
-	// play every match across both brackets, lower id always wins
-	while (true) {
-		const pending = storage
-			.select<any>("match")!
-			.find(
-				(m) =>
-					typeof m.opponent1?.id === "number" &&
-					typeof m.opponent2?.id === "number" &&
-					m.opponent1.result !== "win" &&
-					m.opponent2.result !== "win",
-			);
-		if (!pending) break;
-
-		const winnerIsOpp1 = pending.opponent1.id < pending.opponent2.id;
-		manager.update.match({
-			id: pending.id,
-			opponent1: winnerIsOpp1 ? { score: 2, result: "win" } : { score: 0 },
-			opponent2: winnerIsOpp1 ? { score: 0 } : { score: 2, result: "win" },
-		});
-	}
+	const data = playOutLowerIdWins(
+		mergeStages(
+			createResolved({
+				type: "round_robin",
+				seeding: [1, 2, 3, 4],
+				settings: { groupCount: 1 },
+			}),
+			createResolved({
+				type: "single_elimination",
+				seeding: [1, 2],
+				settings: {},
+			}),
+		),
+	);
 
 	return testTournament({
 		ctx: {
@@ -209,41 +187,18 @@ function roundRobinToSingleEliminationTournament() {
 				tournamentCtxTeam(4, { startingBracketIdx: 0, seed: 4 }),
 			],
 		},
-		data: manager.get.tournamentData(1),
+		data,
 	});
 }
 
 function singleEliminationTournament() {
-	const storage = new InMemoryDatabase();
-	const manager = new BracketsManager(storage);
-
-	manager.create({
-		name: "Main Bracket",
-		tournamentId: 1,
-		type: "single_elimination",
-		seeding: [1, 2, 3, 4],
-		settings: { seedOrdering: ["natural"] },
-	});
-
-	while (true) {
-		const pending = storage
-			.select<any>("match")!
-			.find(
-				(m) =>
-					typeof m.opponent1?.id === "number" &&
-					typeof m.opponent2?.id === "number" &&
-					m.opponent1.result !== "win" &&
-					m.opponent2.result !== "win",
-			);
-		if (!pending) break;
-
-		const winnerIsOpp1 = pending.opponent1.id < pending.opponent2.id;
-		manager.update.match({
-			id: pending.id,
-			opponent1: winnerIsOpp1 ? { score: 2, result: "win" } : { score: 0 },
-			opponent2: winnerIsOpp1 ? { score: 0 } : { score: 2, result: "win" },
-		});
-	}
+	const data = playOutLowerIdWins(
+		createResolved({
+			type: "single_elimination",
+			seeding: [1, 2, 3, 4],
+			settings: {},
+		}),
+	);
 
 	return testTournament({
 		ctx: {
@@ -257,24 +212,18 @@ function singleEliminationTournament() {
 				tournamentCtxTeam(4, { seed: 4 }),
 			],
 		},
-		data: manager.get.tournamentData(1),
+		data,
 	});
 }
 
 function abDivisionsTournament() {
-	const storage = new InMemoryDatabase();
-	const manager = new BracketsManager(storage);
-
-	manager.create({
-		name: "AB RR",
-		tournamentId: 1,
+	let data = createResolved({
 		type: "round_robin",
 		seeding: [1, 2, 3, 4],
 		abDivisions: [0, 1, 0, 1],
 		settings: {
 			groupCount: 1,
 			hasAbDivisions: true,
-			seedOrdering: ["groups.seed_optimized"],
 		},
 	});
 
@@ -284,27 +233,21 @@ function abDivisionsTournament() {
 		"2-3": 2,
 		"3-4": 3,
 	};
-	for (const match of storage.select<any>("match")!) {
-		const a = match.opponent1.id as number;
-		const b = match.opponent2.id as number;
+	for (const match of data.match) {
+		const a = match.opponent1!.id as number;
+		const b = match.opponent2!.id as number;
 		const key = a < b ? `${a}-${b}` : `${b}-${a}`;
 		const winnerId = winnerByMatchup[key];
 		invariant(winnerId, `unexpected matchup ${key}`);
 		const loserScore = key === "2-3" || key === "3-4" ? 1 : 0;
-		const winnerIsOpp1 = match.opponent1.id === winnerId;
-		manager.update.match({
-			id: match.id,
-			opponent1: winnerIsOpp1
-				? { score: 2, result: "win" }
-				: { score: loserScore },
-			opponent2: winnerIsOpp1
-				? { score: loserScore }
-				: { score: 2, result: "win" },
-		});
+		const winnerIsOpp1 = match.opponent1!.id === winnerId;
+		data = Engine.reportResult(data, {
+			matchId: match.id,
+			scores: [winnerIsOpp1 ? 2 : loserScore, winnerIsOpp1 ? loserScore : 2],
+			winnerSide: winnerIsOpp1 ? "opponent1" : "opponent2",
+		}).data;
 	}
 
-	const data = manager.get.tournamentData(1);
-
 	return testTournament({
 		ctx: {
 			settings: {
@@ -327,3 +270,27 @@ function abDivisionsTournament() {
 		data,
 	});
 }
+
+/** Plays every match of the bracket data, the lower team id always winning. */
+function playOutLowerIdWins(data: BracketData) {
+	let played = data;
+
+	while (true) {
+		const pending = played.match.find(
+			(match) =>
+				typeof match.opponent1?.id === "number" &&
+				typeof match.opponent2?.id === "number" &&
+				!match.winnerSide,
+		);
+		if (!pending) break;
+
+		const winnerIsOpp1 = pending.opponent1!.id! < pending.opponent2!.id!;
+		played = Engine.reportResult(played, {
+			matchId: pending.id,
+			scores: [winnerIsOpp1 ? 2 : 0, winnerIsOpp1 ? 0 : 2],
+			winnerSide: winnerIsOpp1 ? "opponent1" : "opponent2",
+		}).data;
+	}
+
+	return played;
+}
diff --git a/app/features/tournament/core/Standings.ts b/app/features/tournament/core/Standings.ts
index e2a710144..44155254a 100644
--- a/app/features/tournament/core/Standings.ts
+++ b/app/features/tournament/core/Standings.ts
@@ -126,8 +126,7 @@ export function matchesPlayed({
 					match.opponent1 &&
 					match.opponent2 &&
 					(match.opponent1?.id === teamId || match.opponent2?.id === teamId) &&
-					(match.opponent1.result === "win" ||
-						match.opponent2?.result === "win"),
+					match.winnerSide,
 			)
 			.map((match) => ({
 				...match,
@@ -141,17 +140,15 @@ export function matchesPlayed({
 		)!;
 		const team = tournament.teamById(opponentId);
 
-		const result =
-			match.opponent1?.id === teamId
-				? match.opponent1.result
-				: match.opponent2?.result;
+		const teamSide = match.opponent1?.id === teamId ? "opponent1" : "opponent2";
+		const result: "win" | "loss" =
+			match.winnerSide === teamSide ? "win" : "loss";
 
 		return {
 			id: match.id,
 			// defensive fallback
 			vsSeed: team?.seed ?? 0,
-			// defensive fallback
-			result: result ?? "win",
+			result,
 			bracketIdx: match.bracketIdx,
 		};
 	});
diff --git a/app/features/tournament/loaders/to.$id.teams.$tid.server.ts b/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
index 875e166f9..19074f6d4 100644
--- a/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
+++ b/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
@@ -26,9 +26,10 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 	const setHistory =
 		await TournamentMatchRepository.findByTournamentTeamId(tournamentTeamId);
 	const allRounds: AllRoundsItem[] = tournament.data.round.map((round) => {
-		const stage = tournament.data.stage.find((s) => s.id === round.stage_id);
-		const group = tournament.data.group.find((g) => g.id === round.group_id);
+		const stage = tournament.data.stage.find((s) => s.id === round.stageId);
+		const group = tournament.data.group.find((g) => g.id === round.groupId);
 		invariant(stage && group, "Stage or group not found for round");
+		invariant(stage.name, "Stage from the database is missing a name");
 
 		return {
 			stageId: stage.id,
diff --git a/app/features/tournament/queries/createSwissBracketInTransaction.server.ts b/app/features/tournament/queries/createSwissBracketInTransaction.server.ts
deleted file mode 100644
index 3a9a1441e..000000000
--- a/app/features/tournament/queries/createSwissBracketInTransaction.server.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
-import { databaseTimestampNow } from "~/utils/dates";
-import { shortNanoid } from "~/utils/id";
-import invariant from "~/utils/invariant";
-
-const createTournamentStageStm = sql.prepare(/* sql */ `
-  insert into "TournamentStage" (
-    "tournamentId",
-    "type",
-    "createdAt",
-    "settings",
-    "number",
-    "name"
-  ) values (
-    @tournamentId,
-    @type,
-    @createdAt,
-    @settings,
-    (select coalesce(max("number"), 0) + 1 from "TournamentStage" where "tournamentId" = @tournamentId),
-    @name
-  ) returning *
-`);
-
-const createTournamentGroupStm = sql.prepare(/* sql */ `
-  insert into "TournamentGroup" (
-    "number",
-    "stageId"
-  ) values (
-    @number,
-    @stageId
-  ) returning *
-`);
-
-const createTournamentRoundStm = sql.prepare(/* sql */ `
-  insert into "TournamentRound" (
-    "groupId",
-    "number",
-    "stageId"
-  ) values (
-    @groupId,
-    @number,
-    @stageId
-  ) returning *
-`);
-
-const createTournamentMatchStm = sql.prepare(/* sql */ `
-  insert into "TournamentMatch" (
-    "chatCode",
-    "groupId",
-    "number",
-    "opponentOne",
-    "opponentTwo",
-    "roundId",
-    "stageId",
-    "status"
-  ) values (
-    @chatCode,
-    @groupId,
-    @number,
-    @opponentOne,
-    @opponentTwo,
-    @roundId,
-    @stageId,
-    @status
-  )
-`);
-
-export function createSwissBracketInTransaction(
-	input: TournamentManagerDataSet,
-) {
-	const stageInput = input.stage[0];
-	invariant(stageInput, "Stage input is required");
-	invariant(stageInput.type === "swiss", "Invalid stage type");
-
-	const stageFromDB = createTournamentStageStm.get({
-		tournamentId: stageInput.tournament_id,
-		type: stageInput.type,
-		createdAt: databaseTimestampNow(),
-		settings: JSON.stringify(stageInput.settings),
-		name: stageInput.name,
-	}) as Tables["TournamentStage"];
-
-	for (const group of input.group) {
-		const groupFromDB = createTournamentGroupStm.get({
-			number: group.number,
-			stageId: stageFromDB.id,
-		}) as Tables["TournamentGroup"];
-
-		for (const round of input.round) {
-			if (round.group_id !== group.id) {
-				continue;
-			}
-
-			const roundFromDB = createTournamentRoundStm.get({
-				groupId: groupFromDB.id,
-				number: round.number,
-				stageId: stageFromDB.id,
-			}) as Tables["TournamentRound"];
-
-			for (const match of input.match) {
-				if (match.round_id !== round.id) {
-					continue;
-				}
-
-				createTournamentMatchStm.run({
-					chatCode: shortNanoid(),
-					groupId: groupFromDB.id,
-					number: match.number,
-					opponentOne: match.opponent1
-						? JSON.stringify(match.opponent1)
-						: "null",
-					opponentTwo: match.opponent2
-						? JSON.stringify(match.opponent2)
-						: "null",
-					roundId: roundFromDB.id,
-					stageId: stageFromDB.id,
-					status: match.status,
-				});
-			}
-		}
-	}
-
-	return stageFromDB;
-}
diff --git a/app/features/tournament/queries/updateRoundMaps.server.ts b/app/features/tournament/queries/updateRoundMaps.server.ts
deleted file mode 100644
index 92e215579..000000000
--- a/app/features/tournament/queries/updateRoundMaps.server.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { sql } from "~/db/sql";
-import type { TournamentRoundMaps } from "~/db/tables";
-
-const stm = sql.prepare(/*sql*/ `
-  update "TournamentRound"
-  set "maps" = @maps
-  where "id" = @roundId
-`);
-
-export function updateRoundMaps(
-	args: (TournamentRoundMaps & { roundId: number })[],
-) {
-	for (const { roundId, ...rest } of args) {
-		stm.run({
-			maps: JSON.stringify(rest),
-			roundId,
-		});
-	}
-}
diff --git a/app/features/tournament/tournament-test-utils.ts b/app/features/tournament/tournament-test-utils.ts
index 2b6206579..9062a0dbd 100644
--- a/app/features/tournament/tournament-test-utils.ts
+++ b/app/features/tournament/tournament-test-utils.ts
@@ -2,9 +2,9 @@ import * as CalendarRepository from "~/features/calendar/CalendarRepository.serv
 import { databaseTimestampNow } from "~/utils/dates";
 import invariant from "~/utils/invariant";
 import { withUserId } from "~/utils/Test";
-import { getServerTournamentManager } from "../tournament-bracket/core/brackets-manager/manager.server";
+import * as BracketRepository from "../tournament-bracket/BracketRepository.server";
+import * as Engine from "../tournament-bracket/core/engine";
 import { tournamentFromDB } from "../tournament-bracket/core/Tournament.server";
-import { updateRoundMaps } from "./queries/updateRoundMaps.server";
 import * as TournamentTeamRepository from "./TournamentTeamRepository.server";
 
 /**
@@ -96,11 +96,9 @@ export async function dbInsertTournamentTeam({
 
 /**
  * Starts a tournament with the given seeding and tournament ID.
- * Assumes that the tournament has only one bracket and one round.
+ * Assumes that the tournament has only one bracket.
  */
 export async function dbStartTournament(seeding: number[], tournamentId = 1) {
-	const manager = getServerTournamentManager();
-
 	const tournament = await tournamentFromDB({
 		tournamentId,
 		user: undefined,
@@ -112,34 +110,26 @@ export async function dbStartTournament(seeding: number[], tournamentId = 1) {
 
 	const bracket = tournament.bracketByIdx(0)!;
 
-	const settings = tournament.bracketManagerSettings(
-		bracket.settings,
-		bracket.type,
-		seeding.length,
-	);
-
-	manager.create({
-		tournamentId: tournament.ctx.id,
-		name: bracket.name,
+	const createInput: Engine.CreateBracketInput = {
 		type: bracket.type,
 		seeding,
-		settings,
-	});
+		settings: bracket.settings,
+	};
 
-	// assuming here every tournament has only one round
-	const roundId = tournamentId === 1 ? 1 : 2;
-
-	updateRoundMaps([
-		{
-			count: 3,
-			roundId,
-			type: "BEST_OF",
-			list: ([1, 2, 3] as const).map((stageId) => ({
-				pickBan: false,
-				mode: "SZ",
-				stageId,
-				source: "TO",
+	await BracketRepository.insertBracket({
+		tournamentId: tournament.ctx.id,
+		name: bracket.name,
+		bracket: Engine.create({
+			...createInput,
+			maps: Engine.create(createInput).round.map((round) => ({
+				roundId: round.id,
+				count: 3,
+				type: "BEST_OF",
+				list: ([1, 2, 3] as const).map((stageId) => ({
+					mode: "SZ",
+					stageId,
+				})),
 			})),
-		},
-	]);
+		}),
+	});
 }
diff --git a/app/features/tournament/tournament-utils.server.ts b/app/features/tournament/tournament-utils.server.ts
index 2a2e1263c..86cbdeed2 100644
--- a/app/features/tournament/tournament-utils.server.ts
+++ b/app/features/tournament/tournament-utils.server.ts
@@ -1,5 +1,5 @@
 import * as LeaderboardRepository from "~/features/leaderboards/LeaderboardRepository.server";
-import type { getServerTournamentManager } from "~/features/tournament-bracket/core/brackets-manager/manager.server";
+import * as Engine from "~/features/tournament-bracket/core/engine";
 import * as TournamentOrganizationRepository from "~/features/tournament-organization/TournamentOrganizationRepository.server";
 import { logger } from "~/utils/logger";
 import { errorToast, errorToastIfFalsy } from "~/utils/remix.server";
@@ -69,68 +69,35 @@ export async function requireSendouQParticipationIfNeeded({
 
 /**
  * Ends all unfinished matches involving dropped teams by awarding wins to their opponents.
- * If both teams in a match have dropped, a random winner is selected.
+ * If both teams in a match have dropped, a random winner is selected. Pure over the given
+ * bracket data — the caller persists the returned changedMatches.
  *
  * @param tournament - The tournament instance
- * @param manager - The bracket manager instance used to update matches
+ * @param data - The bracket data to end matches in (fresh rows or the previous engine result)
  * @param droppedTeamId - Optional team ID to filter matches for a specific dropped team.
  *                        If omitted, processes all matches with any dropped team.
  */
 export function endDroppedTeamMatches({
 	tournament,
-	manager,
+	data,
 	droppedTeamId,
 }: {
 	tournament: Tournament;
-	manager: ReturnType<typeof getServerTournamentManager>;
+	data: Engine.BracketData;
 	droppedTeamId?: number;
 }) {
-	const stageData = manager.get.tournamentData(tournament.ctx.id);
+	const droppedTeamIds = tournament.ctx.teams
+		.filter((team) => team.droppedOut)
+		.map((team) => team.id);
+	if (typeof droppedTeamId === "number") droppedTeamIds.push(droppedTeamId);
 
-	const endedMatchIds: number[] = [];
-
-	for (const match of stageData.match) {
-		if (!match.opponent1?.id || !match.opponent2?.id) continue;
-		if (match.opponent1.result === "win" || match.opponent2.result === "win")
-			continue;
-
-		const team1 = tournament.teamById(match.opponent1.id);
-		const team2 = tournament.teamById(match.opponent2.id);
-
-		const team1Dropped =
-			team1?.droppedOut || match.opponent1.id === droppedTeamId;
-		const team2Dropped =
-			team2?.droppedOut || match.opponent2.id === droppedTeamId;
-
-		if (!team1Dropped && !team2Dropped) continue;
-
-		const winnerTeamId = (() => {
-			if (team1Dropped && !team2Dropped) return match.opponent2.id;
-			if (!team1Dropped && team2Dropped) return match.opponent1.id;
-			return Math.random() < 0.5 ? match.opponent1.id : match.opponent2.id;
-		})();
+	const result = Engine.endDroppedTeamMatches(data, droppedTeamIds);
 
+	for (const matchId of result.endedMatchIds) {
 		logger.info(
-			`Ending match with dropped team: Match ID: ${match.id}; Team1 dropped: ${team1Dropped}; Team2 dropped: ${team2Dropped}; Winner: ${winnerTeamId}`,
+			`Ending match with dropped team: Match ID: ${matchId}; Dropped team ids: ${droppedTeamIds.join(", ")}`,
 		);
-
-		manager.update.match(
-			{
-				id: match.id,
-				opponent1: {
-					score: match.opponent1.score,
-					result: winnerTeamId === match.opponent1.id ? "win" : "loss",
-				},
-				opponent2: {
-					score: match.opponent2.score,
-					result: winnerTeamId === match.opponent2.id ? "win" : "loss",
-				},
-			},
-			true,
-		);
-
-		endedMatchIds.push(match.id);
 	}
 
-	return endedMatchIds;
+	return result;
 }
diff --git a/app/features/tournament/tournament-utils.ts b/app/features/tournament/tournament-utils.ts
index d205e48f5..34ed5144b 100644
--- a/app/features/tournament/tournament-utils.ts
+++ b/app/features/tournament/tournament-utils.ts
@@ -203,7 +203,7 @@ export function resolveLeagueRoundStartDate(
 
 	const round = bracket?.data.round.find((r) => r.id === roundId);
 	const onlyRelevantRounds = bracket?.data.round.filter(
-		(r) => r.group_id === round?.group_id,
+		(r) => r.groupId === round?.groupId,
 	);
 
 	const roundIdx = onlyRelevantRounds?.findIndex((r) => r.id === roundId);
diff --git a/app/modules/brackets-manager/README.md b/app/modules/brackets-manager/README.md
deleted file mode 100644
index 8a6975699..000000000
--- a/app/modules/brackets-manager/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Taken from https://github.com/Drarig29/brackets-manager.js
diff --git a/app/modules/brackets-manager/base/getter.ts b/app/modules/brackets-manager/base/getter.ts
deleted file mode 100644
index dcb2918f1..000000000
--- a/app/modules/brackets-manager/base/getter.ts
+++ /dev/null
@@ -1,678 +0,0 @@
-import type {
-	Group,
-	GroupType,
-	Match,
-	Round,
-	Stage,
-	StageType,
-} from "~/modules/brackets-model";
-import * as helpers from "../helpers";
-import type { RoundPositionalInfo, Storage } from "../types";
-
-export class BaseGetter {
-	protected readonly storage: Storage;
-
-	/**
-	 * Creates an instance of a Storage getter.
-	 *
-	 * @param storage The implementation of Storage.
-	 */
-	constructor(storage: Storage) {
-		this.storage = storage;
-	}
-
-	/**
-	 * Gets all the rounds that contain ordered participants.
-	 *
-	 * @param stage The stage to get rounds from.
-	 */
-	protected getOrderedRounds(stage: Stage): Round[] {
-		if (!stage?.settings.size) throw Error("The stage has no size.");
-
-		if (stage.type === "single_elimination")
-			return this.getOrderedRoundsSingleElimination(stage.id);
-
-		return this.getOrderedRoundsDoubleElimination(stage.id);
-	}
-
-	/**
-	 * Gets all the rounds that contain ordered participants in a single elimination stage.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	private getOrderedRoundsSingleElimination(stageId: number): Round[] {
-		return [this.getUpperBracketFirstRound(stageId)];
-	}
-
-	/**
-	 * Gets all the rounds that contain ordered participants in a double elimination stage.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	private getOrderedRoundsDoubleElimination(stageId: number): Round[] {
-		// Getting all rounds instead of cherry-picking them is the least expensive.
-		const rounds = this.storage.select("round", { stage_id: stageId });
-		if (!rounds) throw Error("Error getting rounds.");
-
-		const loserBracket = this.getLoserBracket(stageId);
-		if (!loserBracket) throw Error("Loser bracket not found.");
-
-		const firstRoundWB = rounds[0];
-
-		const roundsLB = rounds.filter((r) => r.group_id === loserBracket.id);
-		const orderedRoundsLB = roundsLB.filter((r) =>
-			helpers.isOrderingSupportedLoserBracket(r.number, roundsLB.length),
-		);
-
-		return [firstRoundWB, ...orderedRoundsLB];
-	}
-
-	/**
-	 * Gets the positional information (number in group and total number of rounds in group) of a round based on its id.
-	 *
-	 * @param roundId ID of the round.
-	 */
-	protected getRoundPositionalInfo(roundId: number): RoundPositionalInfo {
-		const round = this.storage.select("round", roundId);
-		if (!round) throw Error("Round not found.");
-
-		const rounds = this.storage.select("round", {
-			group_id: round.group_id,
-		});
-		if (!rounds) throw Error("Error getting rounds.");
-
-		return {
-			roundNumber: round.number,
-			roundCount: rounds.length,
-		};
-	}
-
-	/**
-	 * Gets the matches leading to the given match.
-	 *
-	 * @param match The current match.
-	 * @param matchLocation Location of the current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the round.
-	 */
-	protected getPreviousMatches(
-		match: Match,
-		matchLocation: GroupType,
-		stage: Stage,
-		roundNumber: number,
-	): Match[] {
-		if (matchLocation === "loser_bracket")
-			return this.getPreviousMatchesLB(match, stage, roundNumber);
-
-		if (matchLocation === "final_group")
-			return this.getPreviousMatchesFinal(match, stage, roundNumber);
-
-		if (roundNumber === 1) return []; // The match is in the first round of an upper bracket.
-
-		return this.getMatchesBeforeMajorRound(match, roundNumber);
-	}
-
-	/**
-	 * Gets the matches leading to the given match, which is in a final group (consolation final or grand final).
-	 *
-	 * @param match The current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the current round.
-	 */
-	private getPreviousMatchesFinal(
-		match: Match,
-		stage: Stage,
-		roundNumber: number,
-	): Match[] {
-		if (stage.type === "single_elimination")
-			return this.getPreviousMatchesFinalSingleElimination(match, stage);
-
-		return this.getPreviousMatchesFinalDoubleElimination(match, roundNumber);
-	}
-
-	/**
-	 * Gets the matches leading to the given match, which is in a final group (consolation final).
-	 *
-	 * @param match The current match.
-	 * @param stage The parent stage.
-	 */
-	private getPreviousMatchesFinalSingleElimination(
-		match: Match,
-		stage: Stage,
-	): Match[] {
-		const upperBracket = this.getUpperBracket(match.stage_id);
-		const upperBracketRoundCount = helpers.getUpperBracketRoundCount(
-			stage.settings.size!,
-		);
-
-		const semiFinalsRound = this.storage.selectFirst("round", {
-			group_id: upperBracket.id,
-			number: upperBracketRoundCount - 1, // Second to last round
-		});
-
-		if (!semiFinalsRound) throw Error("Semi finals round not found.");
-
-		const semiFinalMatches = this.storage.select("match", {
-			round_id: semiFinalsRound.id,
-		});
-
-		if (!semiFinalMatches) throw Error("Error getting semi final matches.");
-
-		// In single elimination, both the final and consolation final have the same previous matches.
-		return semiFinalMatches;
-	}
-
-	/**
-	 * Gets the matches leading to the given match, which is in a final group (grand final).
-	 *
-	 * @param match The current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the current round.
-	 */
-	private getPreviousMatchesFinalDoubleElimination(
-		match: Match,
-		roundNumber: number,
-	): Match[] {
-		if (roundNumber > 1)
-			// Double grand final
-			return [this.findMatch(match.group_id, roundNumber - 1, 1)];
-
-		const winnerBracket = this.getUpperBracket(match.stage_id);
-		const lastRoundWB = this.getLastRound(winnerBracket.id);
-
-		const winnerBracketFinalMatch = this.storage.selectFirst("match", {
-			round_id: lastRoundWB.id,
-			number: 1,
-		});
-
-		if (!winnerBracketFinalMatch) throw Error("Match not found.");
-
-		const loserBracket = this.getLoserBracket(match.stage_id);
-		if (!loserBracket) throw Error("Loser bracket not found.");
-
-		const lastRoundLB = this.getLastRound(loserBracket.id);
-		const loserBracketFinalMatch = this.storage.selectFirst("match", {
-			round_id: lastRoundLB.id,
-			number: 1,
-		});
-
-		if (!loserBracketFinalMatch) throw Error("Match not found.");
-
-		return [winnerBracketFinalMatch, loserBracketFinalMatch];
-	}
-
-	/**
-	 * Gets the matches leading to a given match from the loser bracket.
-	 *
-	 * @param match The current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the round.
-	 */
-	private getPreviousMatchesLB(
-		match: Match,
-		stage: Stage,
-		roundNumber: number,
-	): Match[] {
-		if (stage.settings.skipFirstRound && roundNumber === 1) return [];
-
-		if (helpers.hasBye(match)) return []; // Shortcut because we are coming from propagateByes().
-
-		const winnerBracket = this.getUpperBracket(match.stage_id);
-		const actualRoundNumberWB = Math.ceil((roundNumber + 1) / 2);
-
-		const roundNumberWB = stage.settings.skipFirstRound
-			? actualRoundNumberWB - 1
-			: actualRoundNumberWB;
-
-		if (roundNumber === 1)
-			return this.getMatchesBeforeFirstRoundLB(
-				match,
-				winnerBracket.id,
-				roundNumberWB,
-			);
-
-		if (roundNumber % 2 === 0)
-			return this.getMatchesBeforeMinorRoundLB(
-				match,
-				winnerBracket.id,
-				roundNumber,
-				roundNumberWB,
-			);
-
-		return this.getMatchesBeforeMajorRound(match, roundNumber);
-	}
-
-	/**
-	 * Gets the matches leading to a given match in a major round (every round of upper bracket or specific ones in lower bracket).
-	 *
-	 * @param match The current match.
-	 * @param roundNumber Number of the round.
-	 */
-	private getMatchesBeforeMajorRound(
-		match: Match,
-		roundNumber: number,
-	): Match[] {
-		return [
-			this.findMatch(match.group_id, roundNumber - 1, match.number * 2 - 1),
-			this.findMatch(match.group_id, roundNumber - 1, match.number * 2),
-		];
-	}
-
-	/**
-	 * Gets the matches leading to a given match in the first round of the loser bracket.
-	 *
-	 * @param match The current match.
-	 * @param winnerBracketId ID of the winner bracket.
-	 * @param roundNumberWB The number of the previous round in the winner bracket.
-	 */
-	private getMatchesBeforeFirstRoundLB(
-		match: Match,
-		winnerBracketId: number,
-		roundNumberWB: number,
-	): Match[] {
-		return [
-			this.findMatch(
-				winnerBracketId,
-				roundNumberWB,
-				helpers.getOriginPosition(match, "opponent1"),
-			),
-			this.findMatch(
-				winnerBracketId,
-				roundNumberWB,
-				helpers.getOriginPosition(match, "opponent2"),
-			),
-		];
-	}
-
-	/**
-	 * Gets the matches leading to a given match in a minor round of the loser bracket.
-	 *
-	 * @param match The current match.
-	 * @param winnerBracketId ID of the winner bracket.
-	 * @param roundNumber Number of the current round.
-	 * @param roundNumberWB The number of the previous round in the winner bracket.
-	 */
-	private getMatchesBeforeMinorRoundLB(
-		match: Match,
-		winnerBracketId: number,
-		roundNumber: number,
-		roundNumberWB: number,
-	): Match[] {
-		const matchNumber = helpers.getOriginPosition(match, "opponent1");
-
-		return [
-			this.findMatch(winnerBracketId, roundNumberWB, matchNumber),
-			this.findMatch(match.group_id, roundNumber - 1, match.number),
-		];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match will go just after.
-	 *
-	 * @param match The current match.
-	 * @param matchLocation Location of the current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount Count of rounds.
-	 */
-	protected getNextMatches(
-		match: Match,
-		matchLocation: GroupType,
-		stage: Stage,
-		roundNumber: number,
-		roundCount: number,
-	): (Match | null)[] {
-		switch (matchLocation) {
-			case "single_bracket":
-				return this.getNextMatchesUpperBracket(
-					match,
-					stage.type,
-					roundNumber,
-					roundCount,
-				);
-			case "winner_bracket":
-				return this.getNextMatchesWB(match, stage, roundNumber, roundCount);
-			case "loser_bracket":
-				return this.getNextMatchesLB(
-					match,
-					stage.type,
-					roundNumber,
-					roundCount,
-				);
-			case "final_group":
-				return this.getNextMatchesFinal(match, roundNumber, roundCount);
-			default:
-				throw Error("Unknown bracket kind.");
-		}
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of winner bracket will go just after.
-	 *
-	 * @param match The current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount Count of rounds.
-	 */
-	private getNextMatchesWB(
-		match: Match,
-		stage: Stage,
-		roundNumber: number,
-		roundCount: number,
-	): (Match | null)[] {
-		const loserBracket = this.getLoserBracket(match.stage_id);
-		if (loserBracket === null)
-			// Only one match in the stage, there is no loser bracket.
-			return [];
-
-		const actualRoundNumber = stage.settings.skipFirstRound
-			? roundNumber + 1
-			: roundNumber;
-		const roundNumberLB =
-			actualRoundNumber > 1 ? (actualRoundNumber - 1) * 2 : 1;
-
-		const participantCount = stage.settings.size!;
-		const method = helpers.getLoserOrdering(
-			stage.settings.seedOrdering!,
-			roundNumberLB,
-		);
-		const actualMatchNumberLB = helpers.findLoserMatchNumber(
-			participantCount,
-			roundNumberLB,
-			match.number,
-			method,
-		);
-
-		return [
-			...this.getNextMatchesUpperBracket(
-				match,
-				stage.type,
-				roundNumber,
-				roundCount,
-			),
-			this.findMatch(loserBracket.id, roundNumberLB, actualMatchNumberLB),
-		];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of an upper bracket will go just after.
-	 *
-	 * @param match The current match.
-	 * @param stageType Type of the stage.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount Count of rounds.
-	 */
-	private getNextMatchesUpperBracket(
-		match: Match,
-		stageType: StageType,
-		roundNumber: number,
-		roundCount: number,
-	): (Match | null)[] {
-		if (stageType === "single_elimination")
-			return this.getNextMatchesUpperBracketSingleElimination(
-				match,
-				stageType,
-				roundNumber,
-				roundCount,
-			);
-
-		if (stageType === "double_elimination" && roundNumber === roundCount)
-			return [this.getFirstMatchFinal(match, stageType)];
-
-		return [this.getDiagonalMatch(match.group_id, roundNumber, match.number)];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of the unique bracket of a single elimination will go just after.
-	 *
-	 * @param match The current match.
-	 * @param stageType Type of the stage.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount Count of rounds.
-	 */
-	private getNextMatchesUpperBracketSingleElimination(
-		match: Match,
-		stageType: StageType,
-		roundNumber: number,
-		roundCount: number,
-	): Match[] {
-		if (roundNumber === roundCount - 1) {
-			const final = this.getFirstMatchFinal(match, stageType);
-			return [
-				this.getDiagonalMatch(match.group_id, roundNumber, match.number),
-				...(final ? [final] : []),
-			];
-		}
-
-		if (roundNumber === roundCount) return [];
-
-		return [this.getDiagonalMatch(match.group_id, roundNumber, match.number)];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of loser bracket will go just after.
-	 *
-	 * @param match The current match.
-	 * @param stageType Type of the stage.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount Count of rounds.
-	 */
-	private getNextMatchesLB(
-		match: Match,
-		stageType: StageType,
-		roundNumber: number,
-		roundCount: number,
-	): Match[] {
-		if (roundNumber === roundCount) {
-			const final = this.getFirstMatchFinal(match, stageType);
-			return final ? [final] : [];
-		}
-
-		if (roundNumber % 2 === 1)
-			return this.getMatchAfterMajorRoundLB(match, roundNumber);
-
-		return this.getMatchAfterMinorRoundLB(match, roundNumber);
-	}
-
-	/**
-	 * Gets the first match of the final group (consolation final or grand final).
-	 *
-	 * @param match The current match.
-	 * @param stageType Type of the stage.
-	 */
-	private getFirstMatchFinal(match: Match, stageType: StageType): Match | null {
-		const finalGroupId = this.getFinalGroupId(match.stage_id, stageType);
-		if (finalGroupId === null) return null;
-
-		return this.findMatch(finalGroupId, 1, 1);
-	}
-
-	/**
-	 * Gets the matches following the current match, which is in the final group (consolation final or grand final).
-	 *
-	 * @param match The current match.
-	 * @param roundNumber The number of the current round.
-	 * @param roundCount The count of rounds.
-	 */
-	private getNextMatchesFinal(
-		match: Match,
-		roundNumber: number,
-		roundCount: number,
-	): Match[] {
-		if (
-			roundNumber === roundCount ||
-			// avoid putting teams to bracket reset if tournament is over
-			match.opponent1?.result === "win"
-		) {
-			return [];
-		}
-
-		return [this.findMatch(match.group_id, roundNumber + 1, 1)];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of a winner bracket's major round will go just after.
-	 *
-	 * @param match The current match.
-	 * @param roundNumber The number of the current round.
-	 */
-	private getMatchAfterMajorRoundLB(
-		match: Match,
-		roundNumber: number,
-	): Match[] {
-		return [this.getParallelMatch(match.group_id, roundNumber, match.number)];
-	}
-
-	/**
-	 * Gets the match(es) where the opponents of the current match of a winner bracket's minor round will go just after.
-	 *
-	 * @param match The current match.
-	 * @param roundNumber The number of the current round.
-	 */
-	private getMatchAfterMinorRoundLB(
-		match: Match,
-		roundNumber: number,
-	): Match[] {
-		return [this.getDiagonalMatch(match.group_id, roundNumber, match.number)];
-	}
-
-	/**
-	 * Gets the first round of the upper bracket.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	private getUpperBracketFirstRound(stageId: number): Round {
-		// Considering the database is ordered, this round will always be the first round of the upper bracket.
-		const firstRound = this.storage.selectFirst("round", {
-			stage_id: stageId,
-			number: 1,
-		});
-		if (!firstRound) throw Error("Round not found.");
-		return firstRound;
-	}
-
-	/**
-	 * Gets the last round of a group.
-	 *
-	 * @param groupId ID of the group.
-	 */
-	private getLastRound(groupId: number): Round {
-		const round = this.storage.selectLast("round", { group_id: groupId });
-		if (!round) throw Error("Error getting rounds.");
-		return round;
-	}
-
-	/**
-	 * Returns the id of the final group (consolation final or grand final).
-	 *
-	 * @param stageId ID of the stage.
-	 * @param stageType Type of the stage.
-	 */
-	private getFinalGroupId(
-		stageId: number,
-		stageType: StageType,
-	): number | null {
-		const groupNumber =
-			stageType === "single_elimination"
-				? 2 /* Consolation final */
-				: 3; /* Grand final */
-		const finalGroup = this.storage.selectFirst("group", {
-			stage_id: stageId,
-			number: groupNumber,
-		});
-		if (!finalGroup) return null;
-		return finalGroup.id;
-	}
-
-	/**
-	 * Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	protected getUpperBracket(stageId: number): Group {
-		const winnerBracket = this.storage.selectFirst("group", {
-			stage_id: stageId,
-			number: 1,
-		});
-		if (!winnerBracket) throw Error("Winner bracket not found.");
-		return winnerBracket;
-	}
-
-	/**
-	 * Gets the loser bracket.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	protected getLoserBracket(stageId: number): Group | null {
-		return this.storage.selectFirst("group", { stage_id: stageId, number: 2 });
-	}
-
-	/**
-	 * Gets the corresponding match in the next round ("diagonal match") the usual way.
-	 *
-	 * Just like from Round 1 to Round 2 in a single elimination stage.
-	 *
-	 * @param groupId ID of the group.
-	 * @param roundNumber Number of the round in its parent group.
-	 * @param matchNumber Number of the match in its parent round.
-	 */
-	private getDiagonalMatch(
-		groupId: number,
-		roundNumber: number,
-		matchNumber: number,
-	): Match {
-		return this.findMatch(
-			groupId,
-			roundNumber + 1,
-			helpers.getDiagonalMatchNumber(matchNumber),
-		);
-	}
-
-	/**
-	 * Gets the corresponding match in the next round ("parallel match") the "major round to minor round" way.
-	 *
-	 * Just like from Round 1 to Round 2 in the loser bracket of a double elimination stage.
-	 *
-	 * @param groupId ID of the group.
-	 * @param roundNumber Number of the round in its parent group.
-	 * @param matchNumber Number of the match in its parent round.
-	 */
-	private getParallelMatch(
-		groupId: number,
-		roundNumber: number,
-		matchNumber: number,
-	): Match {
-		return this.findMatch(groupId, roundNumber + 1, matchNumber);
-	}
-
-	/**
-	 * Finds a match in a given group. The match must have the given number in a round of which the number in group is given.
-	 *
-	 * **Example:** In group of id 1, give me the 4th match in the 3rd round.
-	 *
-	 * @param groupId ID of the group.
-	 * @param roundNumber Number of the round in its parent group.
-	 * @param matchNumber Number of the match in its parent round.
-	 */
-	protected findMatch(
-		groupId: number,
-		roundNumber: number,
-		matchNumber: number,
-	): Match {
-		const round = this.storage.selectFirst("round", {
-			group_id: groupId,
-			number: roundNumber,
-		});
-
-		if (!round) throw Error("Round not found.");
-
-		const match = this.storage.selectFirst("match", {
-			round_id: round.id,
-			number: matchNumber,
-		});
-
-		if (!match) throw Error("Match not found.");
-
-		return match;
-	}
-}
diff --git a/app/modules/brackets-manager/base/updater.ts b/app/modules/brackets-manager/base/updater.ts
deleted file mode 100644
index 31135535d..000000000
--- a/app/modules/brackets-manager/base/updater.ts
+++ /dev/null
@@ -1,331 +0,0 @@
-import type { GroupType, Match, Stage } from "~/modules/brackets-model";
-import { Status } from "~/modules/brackets-model";
-import type { SetNextOpponent } from "../helpers";
-import * as helpers from "../helpers";
-import type { DeepPartial, Side } from "../types";
-import { BaseGetter } from "./getter";
-
-export class BaseUpdater extends BaseGetter {
-	/**
-	 * Updates the matches related (previous and next) to a match.
-	 *
-	 * @param match A match.
-	 * @param updatePrevious Whether to update the previous matches.
-	 * @param updateNext Whether to update the next matches.
-	 */
-	protected updateRelatedMatches(
-		match: Match,
-		updatePrevious: boolean,
-		updateNext: boolean,
-	): void {
-		const { roundNumber, roundCount } = this.getRoundPositionalInfo(
-			match.round_id,
-		);
-
-		const stage = this.storage.select("stage", match.stage_id);
-		if (!stage) throw Error("Stage not found.");
-
-		const group = this.storage.select("group", match.group_id);
-		if (!group) throw Error("Group not found.");
-
-		const matchLocation = helpers.getMatchLocation(stage.type, group.number);
-
-		updatePrevious &&
-			this.updatePrevious(match, matchLocation, stage, roundNumber);
-		updateNext &&
-			this.updateNext(match, matchLocation, stage, roundNumber, roundCount);
-	}
-
-	/**
-	 * Updates a match based on a partial match.
-	 *
-	 * @param stored A reference to what will be updated in the storage.
-	 * @param match Input of the update.
-	 * @param force Whether to force update locked matches.
-	 */
-	protected updateMatch(
-		stored: Match,
-		match: DeepPartial<Match>,
-		force?: boolean,
-	): void {
-		if (!force && helpers.isMatchUpdateLocked(stored))
-			throw Error("The match is locked.");
-
-		const stage = this.storage.select("stage", stored.stage_id);
-		if (!stage) throw Error("Stage not found.");
-
-		const { statusChanged, resultChanged } = helpers.setMatchResults(
-			stored,
-			match,
-		);
-		this.applyMatchUpdate(stored);
-
-		// Don't update related matches if it's a simple score update.
-		if (!statusChanged && !resultChanged) return;
-
-		if (!helpers.isRoundRobin(stage) && !helpers.isSwiss(stage)) {
-			this.updateRelatedMatches(stored, statusChanged, resultChanged);
-		} else if (helpers.isRoundRobin(stage) && resultChanged) {
-			this.unlockNextRoundRobinRound(stored);
-		}
-	}
-
-	/**
-	 * Updates the opponents and status of a match and its child games.
-	 *
-	 * @param match A match.
-	 */
-	protected applyMatchUpdate(match: Match): void {
-		if (!this.storage.update("match", match.id, match))
-			throw Error("Could not update the match.");
-	}
-
-	/**
-	 * Updates the match(es) leading to the current match based on this match results.
-	 *
-	 * @param match Input of the update.
-	 * @param matchLocation Location of the current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the round.
-	 */
-	protected updatePrevious(
-		match: Match,
-		matchLocation: GroupType,
-		stage: Stage,
-		roundNumber: number,
-	): void {
-		const previousMatches = this.getPreviousMatches(
-			match,
-			matchLocation,
-			stage,
-			roundNumber,
-		);
-		if (previousMatches.length === 0) return;
-
-		if (match.status < Status.Running) {
-			this.resetMatchesStatus(previousMatches);
-		}
-	}
-
-	/**
-	 * Resets the status of a list of matches to what it should currently be.
-	 *
-	 * @param matches The matches to update.
-	 */
-	protected resetMatchesStatus(matches: Match[]): void {
-		for (const match of matches) {
-			match.status = helpers.getMatchStatus(match);
-			this.applyMatchUpdate(match);
-		}
-	}
-
-	/**
-	 * Updates the match(es) following the current match based on this match results.
-	 *
-	 * @param match Input of the update.
-	 * @param matchLocation Location of the current match.
-	 * @param stage The parent stage.
-	 * @param roundNumber Number of the round.
-	 * @param roundCount Count of rounds.
-	 */
-	protected updateNext(
-		match: Match,
-		matchLocation: GroupType,
-		stage: Stage,
-		roundNumber: number,
-		roundCount: number,
-	): void {
-		const nextMatches = this.getNextMatches(
-			match,
-			matchLocation,
-			stage,
-			roundNumber,
-			roundCount,
-		);
-		if (nextMatches.length === 0) {
-			return;
-		}
-
-		const winnerSide = helpers.getMatchResult(match);
-		const actualRoundNumber =
-			stage.settings.skipFirstRound && matchLocation === "winner_bracket"
-				? roundNumber + 1
-				: roundNumber;
-
-		if (winnerSide)
-			this.applyToNextMatches(
-				helpers.setNextOpponent,
-				match,
-				matchLocation,
-				actualRoundNumber,
-				roundCount,
-				nextMatches,
-				winnerSide,
-			);
-		else
-			this.applyToNextMatches(
-				helpers.resetNextOpponent,
-				match,
-				matchLocation,
-				actualRoundNumber,
-				roundCount,
-				nextMatches,
-			);
-	}
-
-	/**
-	 * Applies a SetNextOpponent function to matches following the current match.
-	 *
-	 * @param setNextOpponent The SetNextOpponent function.
-	 * @param match The current match.
-	 * @param matchLocation Location of the current match.
-	 * @param roundNumber Number of the current round.
-	 * @param roundCount Count of rounds.
-	 * @param nextMatches The matches following the current match.
-	 * @param winnerSide Side of the winner in the current match.
-	 */
-	protected applyToNextMatches(
-		setNextOpponent: SetNextOpponent,
-		match: Match,
-		matchLocation: GroupType,
-		roundNumber: number,
-		roundCount: number,
-		nextMatches: (Match | null)[],
-		winnerSide?: Side,
-	): void {
-		if (matchLocation === "final_group") {
-			if (!nextMatches[0]) throw Error("First next match is null.");
-			setNextOpponent(nextMatches[0], "opponent1", match, "opponent1");
-			setNextOpponent(nextMatches[0], "opponent2", match, "opponent2");
-			this.applyMatchUpdate(nextMatches[0]);
-			return;
-		}
-
-		const nextSide = helpers.getNextSide(
-			match.number,
-			roundNumber,
-			roundCount,
-			matchLocation,
-		);
-
-		if (nextMatches[0]) {
-			setNextOpponent(nextMatches[0], nextSide, match, winnerSide);
-			this.propagateByeWinners(nextMatches[0]);
-		}
-
-		if (nextMatches.length !== 2) return;
-		if (!nextMatches[1]) throw Error("Second next match is null.");
-
-		// The second match is either the consolation final (single elimination) or a loser bracket match (double elimination).
-
-		if (matchLocation === "single_bracket") {
-			setNextOpponent(
-				nextMatches[1],
-				nextSide,
-				match,
-				winnerSide && helpers.getOtherSide(winnerSide),
-			);
-			this.applyMatchUpdate(nextMatches[1]);
-		} else {
-			const nextSideLB = helpers.getNextSideLoserBracket(
-				match.number,
-				nextMatches[1],
-				roundNumber,
-			);
-			setNextOpponent(
-				nextMatches[1],
-				nextSideLB,
-				match,
-				winnerSide && helpers.getOtherSide(winnerSide),
-			);
-			this.propagateByeWinners(nextMatches[1]);
-		}
-	}
-
-	/**
-	 * Propagates winner against BYEs in related matches.
-	 *
-	 * @param match The current match.
-	 */
-	protected propagateByeWinners(match: Match): void {
-		helpers.setMatchResults(match, match); // BYE propagation is only in non round-robin stages.
-		this.applyMatchUpdate(match);
-
-		if (helpers.hasBye(match)) this.updateRelatedMatches(match, true, true);
-	}
-
-	/**
-	 * Unlocks matches in the next round of a round-robin group if both participants are ready.
-	 *
-	 * @param match The match that was just completed.
-	 */
-	protected unlockNextRoundRobinRound(match: Match): void {
-		const round = this.storage.select("round", match.round_id);
-		if (!round) throw Error("Round not found.");
-
-		const nextRound = this.storage.selectFirst("round", {
-			group_id: round.group_id,
-			number: round.number + 1,
-		});
-		if (!nextRound) return;
-
-		const currentRoundMatches = this.storage.select("match", {
-			round_id: round.id,
-		});
-		if (!currentRoundMatches) return;
-
-		const nextRoundMatches = this.storage.select("match", {
-			round_id: nextRound.id,
-		});
-		if (!nextRoundMatches) return;
-
-		for (const nextMatch of nextRoundMatches) {
-			if (nextMatch.status !== Status.Locked) continue;
-
-			const participant1Id = nextMatch.opponent1?.id;
-			const participant2Id = nextMatch.opponent2?.id;
-
-			if (!participant1Id || !participant2Id) continue;
-
-			const participant1Ready = this.isParticipantReadyForNextRound(
-				participant1Id,
-				currentRoundMatches,
-			);
-			const participant2Ready = this.isParticipantReadyForNextRound(
-				participant2Id,
-				currentRoundMatches,
-			);
-
-			if (participant1Ready && participant2Ready) {
-				nextMatch.status = Status.Ready;
-				this.applyMatchUpdate(nextMatch);
-			}
-		}
-	}
-
-	/**
-	 * Checks if a participant has completed their match in the current round.
-	 *
-	 * @param participantId The participant to check.
-	 * @param roundMatches All matches in the round.
-	 */
-	protected isParticipantReadyForNextRound(
-		participantId: number,
-		roundMatches: Match[],
-	): boolean {
-		const participantMatch = roundMatches.find(
-			(m) =>
-				m.opponent1?.id === participantId || m.opponent2?.id === participantId,
-		);
-
-		// If the participant doesn't have a match in this round, they had a bye/didn't play
-		// and are considered ready
-		if (!participantMatch) return true;
-
-		// If the match has a BYE (one opponent is null), it's considered completed
-		if (!participantMatch.opponent1?.id || !participantMatch.opponent2?.id)
-			return true;
-
-		return participantMatch.status >= Status.Completed;
-	}
-}
diff --git a/app/modules/brackets-manager/create.ts b/app/modules/brackets-manager/create.ts
deleted file mode 100644
index 124a99046..000000000
--- a/app/modules/brackets-manager/create.ts
+++ /dev/null
@@ -1,975 +0,0 @@
-import {
-	type Group,
-	type InputStage,
-	type Match,
-	type Round,
-	type Seeding,
-	type SeedOrdering,
-	type Stage,
-	Status,
-} from "~/modules/brackets-model";
-import type { BracketsManager } from ".";
-import * as helpers from "./helpers";
-import { defaultMinorOrdering, ordering } from "./ordering";
-import type {
-	Duel,
-	OmitId,
-	ParticipantSlot,
-	StandardBracketResults,
-	Storage,
-} from "./types";
-
-/**
- * Creates a stage.
- *
- * @param this Instance of BracketsManager.
- * @param stage The stage to create.
- */
-export function create(this: BracketsManager, stage: InputStage): Stage {
-	const instance = new Create(this.storage, stage);
-	return instance.run();
-}
-
-class Create {
-	private storage: Storage;
-	private stage: InputStage;
-	private readonly seedOrdering: SeedOrdering[];
-	private enableByesInUpdate: boolean;
-
-	/**
-	 * Creates an instance of Create, which will handle the creation of the stage.
-	 *
-	 * @param storage The implementation of Storage.
-	 * @param stage The stage to create.
-	 */
-	constructor(storage: Storage, stage: InputStage) {
-		this.storage = storage;
-		this.stage = stage;
-		this.stage.settings = this.stage.settings || {};
-		this.seedOrdering = this.stage.settings.seedOrdering || [];
-		this.enableByesInUpdate = false;
-
-		if (!this.stage.name) throw Error("You must provide a name for the stage.");
-
-		if (!Number.isInteger(this.stage.tournamentId))
-			throw Error("You must provide a tournament id for the stage.");
-
-		if (stage.type === "round_robin")
-			this.stage.settings.roundRobinMode =
-				this.stage.settings.roundRobinMode || "simple";
-
-		if (stage.type === "single_elimination")
-			this.stage.settings.consolationFinal =
-				this.stage.settings.consolationFinal || false;
-
-		if (stage.type === "double_elimination")
-			this.stage.settings.grandFinal = this.stage.settings.grandFinal || "none";
-	}
-
-	/**
-	 * Run the creation process.
-	 */
-	public run(): Stage {
-		let stage: Stage;
-
-		switch (this.stage.type) {
-			case "round_robin":
-				stage = this.roundRobin();
-				break;
-			case "single_elimination":
-				stage = this.singleElimination();
-				break;
-			case "double_elimination":
-				stage = this.doubleElimination();
-				break;
-			default:
-				throw Error("Unknown stage type.");
-		}
-
-		if (stage.id === -1)
-			throw Error("Something went wrong when creating the stage.");
-
-		this.ensureSeedOrdering(stage.id);
-
-		return stage;
-	}
-
-	/**
-	 * Creates a round-robin stage.
-	 *
-	 * Group count must be given. It will distribute participants in groups and rounds.
-	 */
-	private roundRobin(): Stage {
-		if (this.stage.settings?.hasAbDivisions) return this.abDivisionRoundRobin();
-
-		const groups = this.getRoundRobinGroups();
-		const stage = this.createStage();
-
-		for (let i = 0; i < groups.length; i++)
-			this.createRoundRobinGroup(stage.id, i + 1, groups[i]);
-
-		return stage;
-	}
-
-	/**
-	 * Creates a bipartite (A/B divisions) round-robin stage.
-	 *
-	 * Participants are partitioned into two pools by `abDivisions` (parallel to the seeding).
-	 * Each group receives equal A and B teams, and matches only pair A against B.
-	 */
-	private abDivisionRoundRobin(): Stage {
-		const groups = this.getAbDivisionGroups();
-		const stage = this.createStage();
-
-		for (let i = 0; i < groups.length; i++)
-			this.createAbDivisionRoundRobinGroup(
-				stage.id,
-				i + 1,
-				groups[i].a,
-				groups[i].b,
-			);
-
-		return stage;
-	}
-
-	/**
-	 * Creates a single elimination stage.
-	 *
-	 * One bracket and optionally a consolation final between semi-final losers.
-	 */
-	private singleElimination(): Stage {
-		if (
-			Array.isArray(this.stage.settings?.seedOrdering) &&
-			this.stage.settings?.seedOrdering.length !== 1
-		)
-			throw Error("You must specify one seed ordering method.");
-
-		const slots = this.getSlots();
-		const stage = this.createStage();
-		const method = this.getStandardBracketFirstRoundOrdering();
-		const ordered = ordering[method](slots);
-
-		const { losers } = this.createStandardBracket(stage.id, 1, ordered);
-		this.createConsolationFinal(stage.id, losers);
-
-		return stage;
-	}
-
-	/**
-	 * Creates a double elimination stage.
-	 *
-	 * One upper bracket (winner bracket, WB), one lower bracket (loser bracket, LB) and optionally a grand final
-	 * between the winner of both bracket, which can be simple or double.
-	 */
-	private doubleElimination(): Stage {
-		if (
-			this.stage.settings &&
-			Array.isArray(this.stage.settings.seedOrdering) &&
-			this.stage.settings.seedOrdering.length < 1
-		)
-			throw Error("You must specify at least one seed ordering method.");
-
-		const slots = this.getSlots();
-		const stage = this.createStage();
-		const method = this.getStandardBracketFirstRoundOrdering();
-		const ordered = ordering[method](slots);
-
-		if (this.stage.settings?.skipFirstRound)
-			this.createDoubleEliminationSkipFirstRound(stage.id, ordered);
-		else this.createDoubleElimination(stage.id, ordered);
-
-		return stage;
-	}
-
-	/**
-	 * Creates a double elimination stage with skip first round option.
-	 *
-	 * @param stageId ID of the stage.
-	 * @param slots A list of slots.
-	 */
-	private createDoubleEliminationSkipFirstRound(
-		stageId: number,
-		slots: ParticipantSlot[],
-	): void {
-		const { even: directInWb, odd: directInLb } = helpers.splitByParity(slots);
-		const { losers: losersWb, winner: winnerWb } = this.createStandardBracket(
-			stageId,
-			1,
-			directInWb,
-		);
-
-		// biome-ignore lint/suspicious/noNonNullAssertedOptionalChain: Biome 2.3.1 upgrade
-		if (helpers.isDoubleEliminationNecessary(this.stage.settings?.size!)) {
-			const winnerLb = this.createLowerBracket(stageId, 2, [
-				directInLb,
-				...losersWb,
-			]);
-			this.createGrandFinal(stageId, winnerWb, winnerLb);
-		}
-	}
-
-	/**
-	 * Creates a double elimination stage.
-	 *
-	 * @param stageId ID of the stage.
-	 * @param slots A list of slots.
-	 */
-	private createDoubleElimination(
-		stageId: number,
-		slots: ParticipantSlot[],
-	): void {
-		const { losers: losersWb, winner: winnerWb } = this.createStandardBracket(
-			stageId,
-			1,
-			slots,
-		);
-
-		// biome-ignore lint/suspicious/noNonNullAssertedOptionalChain: Biome 2.3.1 upgrade
-		if (helpers.isDoubleEliminationNecessary(this.stage.settings?.size!)) {
-			const winnerLb = this.createLowerBracket(stageId, 2, losersWb);
-			this.createGrandFinal(stageId, winnerWb, winnerLb);
-		}
-	}
-
-	/**
-	 * Creates a round-robin group.
-	 *
-	 * This will make as many rounds as needed to let each participant match every other once.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param number Number in the stage.
-	 * @param slots A list of slots.
-	 */
-	private createRoundRobinGroup(
-		stageId: number,
-		number: number,
-		slots: ParticipantSlot[],
-	): void {
-		const groupId = this.insertGroup({
-			stage_id: stageId,
-			number,
-		});
-
-		if (groupId === -1) throw Error("Could not insert the group.");
-
-		// Groups can be padded with empty slots when teams don't divide evenly
-		// (`null`) or by the seed ordering (`undefined`). An empty slot is just an
-		// absent team, so drop it to round-robin only the present teams — otherwise
-		// the padding becomes BYE rounds that strand real matches in later rounds.
-		// TBD slots (`{ id: null }`) are kept; only nullish placeholders are removed.
-		const presentSlots = slots.filter(
-			(slot) => slot !== null && slot !== undefined,
-		);
-
-		const rounds = helpers.makeRoundRobinMatches(
-			presentSlots,
-			this.stage.settings?.roundRobinMode,
-		);
-
-		for (let i = 0; i < rounds.length; i++)
-			this.createRound(stageId, groupId, i + 1, rounds[0].length, rounds[i]);
-	}
-
-	/**
-	 * Creates a bipartite round-robin group where every A team plays every B team exactly once.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param number Number in the stage.
-	 * @param slotsA Slots in division A (ordered by seed).
-	 * @param slotsB Slots in division B (ordered by seed).
-	 */
-	private createAbDivisionRoundRobinGroup(
-		stageId: number,
-		number: number,
-		slotsA: ParticipantSlot[],
-		slotsB: ParticipantSlot[],
-	): void {
-		const groupId = this.insertGroup({
-			stage_id: stageId,
-			number,
-		});
-
-		if (groupId === -1) throw Error("Could not insert the group.");
-
-		const rounds = helpers.makeAbDivisionRoundRobinMatches(slotsA, slotsB);
-
-		for (let i = 0; i < rounds.length; i++)
-			this.createRound(stageId, groupId, i + 1, rounds[0].length, rounds[i]);
-	}
-
-	/**
-	 * Creates a standard bracket, which is the only one in single elimination and the upper one in double elimination.
-	 *
-	 * This will make as many rounds as needed to end with one winner.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param number Number in the stage.
-	 * @param slots A list of slots.
-	 */
-	private createStandardBracket(
-		stageId: number,
-		number: number,
-		slots: ParticipantSlot[],
-	): StandardBracketResults {
-		const roundCount = helpers.getUpperBracketRoundCount(slots.length);
-		const groupId = this.insertGroup({
-			stage_id: stageId,
-			number,
-		});
-
-		if (groupId === -1) throw Error("Could not insert the group.");
-
-		let duels = helpers.makePairs(slots);
-		let roundNumber = 1;
-
-		const losers: ParticipantSlot[][] = [];
-
-		for (let i = roundCount - 1; i >= 0; i--) {
-			const matchCount = 2 ** i;
-			duels = this.getCurrentDuels(duels, matchCount);
-			losers.push(duels.map(helpers.byeLoser));
-			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
-		}
-
-		return { losers, winner: helpers.byeWinner(duels[0]) };
-	}
-
-	/**
-	 * Creates a lower bracket, alternating between major and minor rounds.
-	 *
-	 * - A major round is a regular round.
-	 * - A minor round matches the previous (major) round's winners against upper bracket losers of the corresponding round.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param number Number in the stage.
-	 * @param losers One list of losers per upper bracket round.
-	 */
-	private createLowerBracket(
-		stageId: number,
-		number: number,
-		losers: ParticipantSlot[][],
-	): ParticipantSlot {
-		// biome-ignore lint/suspicious/noNonNullAssertedOptionalChain: Biome 2.3.1 upgrade
-		const participantCount = this.stage.settings?.size!;
-		const roundPairCount = helpers.getRoundPairCount(participantCount);
-
-		let losersId = 0;
-
-		const method = this.getMajorOrdering(participantCount);
-		const ordered = ordering[method](losers[losersId++]);
-
-		const groupId = this.insertGroup({
-			stage_id: stageId,
-			number,
-		});
-
-		if (groupId === -1) throw Error("Could not insert the group.");
-
-		let duels = helpers.makePairs(ordered);
-		let roundNumber = 1;
-
-		for (let i = 0; i < roundPairCount; i++) {
-			const matchCount = 2 ** (roundPairCount - i - 1);
-
-			// Major round.
-			duels = this.getCurrentDuels(duels, matchCount, true);
-			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
-
-			// Minor round.
-			const minorOrdering = this.getMinorOrdering(
-				participantCount,
-				i,
-				roundPairCount,
-			);
-			duels = this.getCurrentDuels(
-				duels,
-				matchCount,
-				false,
-				losers[losersId++],
-				minorOrdering,
-			);
-			this.createRound(stageId, groupId, roundNumber++, matchCount, duels);
-		}
-
-		return helpers.byeWinnerToGrandFinal(duels[0]);
-	}
-
-	/**
-	 * Creates a bracket with rounds that only have 1 match each. Used for finals.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param number Number in the stage.
-	 * @param duels A list of duels.
-	 */
-	private createUniqueMatchBracket(
-		stageId: number,
-		number: number,
-		duels: Duel[],
-	): void {
-		const groupId = this.insertGroup({
-			stage_id: stageId,
-			number,
-		});
-
-		if (groupId === -1) throw Error("Could not insert the group.");
-
-		for (let i = 0; i < duels.length; i++)
-			this.createRound(stageId, groupId, i + 1, 1, [duels[i]]);
-	}
-
-	/**
-	 * Creates a round, which contain matches.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param groupId ID of the parent group.
-	 * @param roundNumber Number in the group.
-	 * @param matchCount Duel/match count.
-	 * @param duels A list of duels.
-	 */
-	private createRound(
-		stageId: number,
-		groupId: number,
-		roundNumber: number,
-		matchCount: number,
-		duels: Duel[],
-	): void {
-		const roundId = this.insertRound({
-			number: roundNumber,
-			stage_id: stageId,
-			group_id: groupId,
-		});
-
-		if (roundId === -1) throw Error("Could not insert the round.");
-
-		for (let i = 0; i < matchCount; i++) {
-			this.createMatch(stageId, groupId, roundId, i + 1, roundNumber, duels[i]);
-		}
-	}
-
-	/**
-	 * Creates a match, possibly with match games.
-	 *
-	 * @param stageId ID of the parent stage.
-	 * @param groupId ID of the parent group.
-	 * @param roundId ID of the parent round.
-	 * @param matchNumber Number in the round.
-	 * @param opponents The two opponents matching against each other.
-	 */
-	private createMatch(
-		stageId: number,
-		groupId: number,
-		roundId: number,
-		matchNumber: number,
-		roundNumber: number,
-		opponents: Duel,
-	): void {
-		const opponent1 = helpers.toResultWithPosition(opponents[0]);
-		const opponent2 = helpers.toResultWithPosition(opponents[1]);
-
-		// Round-robin matches can easily be removed. Prevent BYE vs. BYE matches.
-		if (
-			this.stage.type === "round_robin" &&
-			opponent1 === null &&
-			opponent2 === null
-		)
-			return;
-
-		let status = helpers.getMatchStatus(opponents);
-
-		// In round-robin, only the first round is ready to play at the beginning.
-		// other matches have teams set but they are busy playing the first round.
-		if (
-			this.stage.type === "round_robin" &&
-			roundNumber > 1 &&
-			!this.stage.settings?.independentRounds
-		) {
-			status = Status.Locked;
-		}
-
-		const parentId = this.insertMatch(
-			{
-				number: matchNumber,
-				stage_id: stageId,
-				group_id: groupId,
-				round_id: roundId,
-				status,
-				opponent1,
-				opponent2,
-			},
-			null,
-		);
-
-		if (parentId === -1) throw Error("Could not insert the match.");
-	}
-
-	/**
-	 * Gets the duels for the current round based on the previous one. No ordering is done, it must be done beforehand for the first round.
-	 *
-	 * @param previousDuels Duels of the previous round.
-	 * @param currentDuelCount Count of duels (matches) in the current round.
-	 */
-	private getCurrentDuels(
-		previousDuels: Duel[],
-		currentDuelCount: number,
-	): Duel[];
-
-	/**
-	 * Gets the duels for a major round in the LB. No ordering is done, it must be done beforehand for the first round.
-	 *
-	 * @param previousDuels Duels of the previous round.
-	 * @param currentDuelCount Count of duels (matches) in the current round.
-	 * @param major Indicates that the round is a major round in the LB.
-	 */
-	private getCurrentDuels(
-		previousDuels: Duel[],
-		currentDuelCount: number,
-		major: true,
-	): Duel[];
-
-	/**
-	 * Gets the duels for a minor round in the LB. Ordering is done.
-	 *
-	 * @param previousDuels Duels of the previous round.
-	 * @param currentDuelCount Count of duels (matches) in the current round.
-	 * @param major Indicates that the round is a minor round in the LB.
-	 * @param losers The losers going from the WB.
-	 * @param method The ordering method to apply to the losers.
-	 */
-	private getCurrentDuels(
-		previousDuels: Duel[],
-		currentDuelCount: number,
-		major: false,
-		losers: ParticipantSlot[],
-		method?: SeedOrdering,
-	): Duel[];
-
-	/**
-	 * Generic implementation.
-	 *
-	 * @param previousDuels Always given.
-	 * @param currentDuelCount Always given.
-	 * @param major Only for loser bracket.
-	 * @param losers Only for minor rounds of loser bracket.
-	 * @param method Only for minor rounds. Ordering method for the losers.
-	 */
-	private getCurrentDuels(
-		previousDuels: Duel[],
-		currentDuelCount: number,
-		major?: boolean,
-		losers?: ParticipantSlot[],
-		method?: SeedOrdering,
-	): Duel[] {
-		if (
-			(major === undefined || major) &&
-			previousDuels.length === currentDuelCount
-		) {
-			// First round.
-			return previousDuels;
-		}
-
-		if (major === undefined || major) {
-			// From major to major (WB) or minor to major (LB).
-			return helpers.transitionToMajor(previousDuels);
-		}
-
-		// From major to minor (LB).
-		// Losers and method won't be undefined.
-		return helpers.transitionToMinor(previousDuels, losers!, method);
-	}
-
-	/**
-	 * Returns a list of slots.
-	 * - If `seeding` was given, inserts them in the storage.
-	 * - If `size` was given, only returns a list of empty slots.
-	 *
-	 * @param positions An optional list of positions (seeds) for a manual ordering.
-	 */
-	public getSlots(positions?: number[]): ParticipantSlot[] {
-		const size = this.stage.settings?.size || this.stage.seeding?.length || 0;
-		helpers.ensureValidSize(this.stage.type, size);
-
-		if (size && !this.stage.seeding)
-			return Array.from(Array(size), (_: ParticipantSlot, i) => ({
-				id: null,
-				position: i + 1,
-			}));
-
-		if (!this.stage.seeding)
-			throw Error("Either size or seeding must be given.");
-
-		this.stage.settings = {
-			...this.stage.settings,
-			size, // Always set the size.
-		};
-
-		helpers.ensureNoDuplicates(this.stage.seeding);
-		this.stage.seeding = helpers.fixSeeding(this.stage.seeding, size);
-
-		if (this.stage.type !== "round_robin" && this.stage.settings.balanceByes)
-			this.stage.seeding = helpers.balanceByes(
-				this.stage.seeding,
-				this.stage.settings.size,
-			);
-
-		return this.getSlotsUsingIds(this.stage.seeding, positions);
-	}
-
-	/**
-	 * Returns the list of slots with a seeding containing IDs. No database mutation.
-	 *
-	 * @param seeding The seeding (IDs).
-	 * @param positions An optional list of positions (seeds) for a manual ordering.
-	 */
-	private getSlotsUsingIds(
-		seeding: Seeding,
-		positions?: number[],
-	): ParticipantSlot[] {
-		if (positions && positions.length !== seeding.length) {
-			throw Error(
-				"Not enough seeds in at least one group of the manual ordering.",
-			);
-		}
-
-		const slots = seeding.map((slot, i) => {
-			if (slot === null) return null; // BYE.
-
-			return { id: slot, position: i + 1 };
-		});
-
-		if (!positions) return slots;
-
-		return positions.map((position) => slots[position - 1]);
-	}
-
-	/**
-	 * Gets the current stage number based on existing stages.
-	 */
-	private getStageNumber(): number {
-		const stages = this.storage.select("stage", {
-			tournament_id: this.stage.tournamentId,
-		});
-		const stageNumbers = stages?.map((stage) => stage.number);
-
-		if (this.stage.number !== undefined) {
-			if (stageNumbers?.includes(this.stage.number))
-				throw Error("The given stage number already exists.");
-
-			return this.stage.number;
-		}
-
-		if (!stageNumbers?.length) return 1;
-
-		const maxNumber = Math.max(...stageNumbers);
-		return maxNumber + 1;
-	}
-
-	/**
-	 * Safely gets an ordering by its index in the stage input settings.
-	 *
-	 * @param orderingIndex Index of the ordering.
-	 * @param stageType A value indicating if the method should be a group method or not.
-	 * @param defaultMethod The default method to use if not given.
-	 */
-	private getOrdering(
-		orderingIndex: number,
-		stageType: "elimination" | "groups",
-		defaultMethod: SeedOrdering,
-	): SeedOrdering {
-		if (!this.stage.settings?.seedOrdering) {
-			this.seedOrdering.push(defaultMethod);
-			return defaultMethod;
-		}
-
-		const method = this.stage.settings.seedOrdering[orderingIndex];
-		if (!method) {
-			this.seedOrdering.push(defaultMethod);
-			return defaultMethod;
-		}
-
-		if (stageType === "elimination" && method.match(/^groups\./))
-			throw Error(
-				"You must specify a seed ordering method without a 'groups' prefix",
-			);
-
-		if (
-			stageType === "groups" &&
-			method !== "natural" &&
-			!method.match(/^groups\./)
-		)
-			throw Error(
-				"You must specify a seed ordering method with a 'groups' prefix",
-			);
-
-		return method;
-	}
-
-	/**
-	 * Gets the duels in groups for a round-robin stage.
-	 */
-	private getRoundRobinGroups(): ParticipantSlot[][] {
-		if (
-			this.stage.settings?.groupCount === undefined ||
-			!Number.isInteger(this.stage.settings.groupCount)
-		)
-			throw Error("You must specify a group count for round-robin stages.");
-
-		if (this.stage.settings.groupCount <= 0)
-			throw Error("You must provide a strictly positive group count.");
-
-		if (this.stage.settings?.manualOrdering) {
-			if (
-				this.stage.settings?.manualOrdering.length !==
-				this.stage.settings?.groupCount
-			)
-				throw Error(
-					"Group count in the manual ordering does not correspond to the given group count.",
-				);
-
-			const positions = this.stage.settings?.manualOrdering.flat();
-			const slots = this.getSlots(positions);
-
-			return helpers.makeGroups(slots, this.stage.settings.groupCount);
-		}
-
-		if (
-			Array.isArray(this.stage.settings.seedOrdering) &&
-			this.stage.settings.seedOrdering.length !== 1
-		)
-			throw Error("You must specify one seed ordering method.");
-
-		const method = this.getRoundRobinOrdering();
-		const slots = this.getSlots();
-		const ordered = ordering[method](slots, this.stage.settings.groupCount);
-		return helpers.makeGroups(ordered, this.stage.settings.groupCount);
-	}
-
-	/**
-	 * Partitions the seeded slots into A and B pools then distributes them into groups
-	 * such that each group has an equal number of A and B participants.
-	 */
-	private getAbDivisionGroups(): {
-		a: ParticipantSlot[];
-		b: ParticipantSlot[];
-	}[] {
-		if (
-			this.stage.settings?.groupCount === undefined ||
-			!Number.isInteger(this.stage.settings.groupCount)
-		)
-			throw Error("You must specify a group count for round-robin stages.");
-
-		if (this.stage.settings.groupCount <= 0)
-			throw Error("You must provide a strictly positive group count.");
-
-		const abDivisions = this.stage.abDivisions;
-		if (!abDivisions)
-			throw Error(
-				"abDivisions must be provided when hasAbDivisions is enabled.",
-			);
-
-		const slots = this.getSlots();
-
-		if (abDivisions.length !== slots.length)
-			throw Error("abDivisions length must match the seeding length.");
-
-		const divisionA: ParticipantSlot[] = [];
-		const divisionB: ParticipantSlot[] = [];
-
-		for (let i = 0; i < slots.length; i++) {
-			const slot = slots[i];
-			if (slot === null)
-				throw Error("BYEs are not supported with A/B divisions.");
-
-			const division = abDivisions[i];
-			if (division === 0) divisionA.push(slot);
-			else if (division === 1) divisionB.push(slot);
-			else
-				throw Error(
-					`Participant at seed ${i + 1} is missing an A/B division assignment.`,
-				);
-		}
-
-		return helpers.makeAbDivisionGroups(
-			divisionA,
-			divisionB,
-			this.stage.settings.groupCount,
-		);
-	}
-
-	/**
-	 * Returns the ordering method for the groups in a round-robin stage.
-	 */
-	public getRoundRobinOrdering(): SeedOrdering {
-		return this.getOrdering(0, "groups", "groups.effort_balanced");
-	}
-
-	/**
-	 * Returns the ordering method for the first round of the upper bracket of an elimination stage.
-	 */
-	public getStandardBracketFirstRoundOrdering(): SeedOrdering {
-		return this.getOrdering(0, "elimination", "space_between");
-	}
-
-	/**
-	 * Safely gets the only major ordering for the lower bracket.
-	 *
-	 * @param participantCount Number of participants in the stage.
-	 */
-	private getMajorOrdering(participantCount: number): SeedOrdering {
-		return this.getOrdering(
-			1,
-			"elimination",
-			defaultMinorOrdering[participantCount]?.[0] || "natural",
-		);
-	}
-
-	/**
-	 * Safely gets a minor ordering for the lower bracket by its index.
-	 *
-	 * @param participantCount Number of participants in the stage.
-	 * @param index Index of the minor round.
-	 * @param minorRoundCount Number of minor rounds.
-	 */
-	private getMinorOrdering(
-		participantCount: number,
-		index: number,
-		minorRoundCount: number,
-	): SeedOrdering | undefined {
-		// No ordering for the last minor round. There is only one participant to order.
-		if (index === minorRoundCount - 1) return undefined;
-
-		return this.getOrdering(
-			2 + index,
-			"elimination",
-			defaultMinorOrdering[participantCount]?.[1 + index] || "natural",
-		);
-	}
-
-	/**
-	 * Inserts a stage or finds an existing one.
-	 *
-	 * @param stage The stage to insert.
-	 */
-	private insertStage(stage: OmitId<Stage>): number {
-		return this.storage.insert("stage", stage);
-	}
-
-	/**
-	 * Inserts a group or finds an existing one.
-	 *
-	 * @param group The group to insert.
-	 */
-	private insertGroup(group: OmitId<Group>): number {
-		return this.storage.insert("group", group);
-	}
-
-	/**
-	 * Inserts a round or finds an existing one.
-	 *
-	 * @param round The round to insert.
-	 */
-	private insertRound(round: OmitId<Round>): number {
-		return this.storage.insert("round", round);
-	}
-
-	/**
-	 * Inserts a match or updates an existing one.
-	 *
-	 * @param match The match to insert.
-	 * @param existing An existing match corresponding to the current one.
-	 */
-	private insertMatch(match: OmitId<Match>, existing: Match | null): number {
-		if (!existing) return this.storage.insert("match", match);
-
-		const updated = helpers.getUpdatedMatchResults(
-			match,
-			existing,
-			this.enableByesInUpdate,
-		) as Match;
-		if (!this.storage.update("match", existing.id, updated))
-			throw Error("Could not update the match.");
-
-		return existing.id;
-	}
-
-	/**
-	 * Creates a new stage.
-	 */
-	private createStage(): Stage {
-		const number = this.getStageNumber();
-		const stage: OmitId<Stage> = {
-			tournament_id: this.stage.tournamentId,
-			name: this.stage.name,
-			type: this.stage.type,
-			number: number,
-			settings: this.stage.settings || {},
-		};
-
-		const stageId = this.insertStage(stage);
-
-		if (stageId === -1) throw Error("Could not insert the stage.");
-
-		return { ...stage, id: stageId };
-	}
-
-	/**
-	 * Creates a consolation final for the semi final losers of a single elimination stage.
-	 *
-	 * @param stageId ID of the stage.
-	 * @param losers The semi final losers who will play the consolation final.
-	 */
-	private createConsolationFinal(
-		stageId: number,
-		losers: ParticipantSlot[][],
-	): void {
-		if (!this.stage.settings?.consolationFinal) return;
-
-		const semiFinalLosers = losers[losers.length - 2] as Duel;
-		this.createUniqueMatchBracket(stageId, 2, [semiFinalLosers]);
-	}
-
-	/**
-	 * Creates a grand final (none, simple or double) for winners of both bracket in a double elimination stage.
-	 *
-	 * @param stageId ID of the stage.
-	 * @param winnerWb The winner of the winner bracket.
-	 * @param winnerLb The winner of the loser bracket.
-	 */
-	private createGrandFinal(
-		stageId: number,
-		winnerWb: ParticipantSlot,
-		winnerLb: ParticipantSlot,
-	): void {
-		// No Grand Final by default.
-		const grandFinal = this.stage.settings?.grandFinal;
-		if (grandFinal === "none") return;
-
-		// One duel by default.
-		const finalDuels: Duel[] = [[winnerWb, winnerLb]];
-
-		// Second duel.
-		if (grandFinal === "double") finalDuels.push([{ id: null }, { id: null }]);
-
-		this.createUniqueMatchBracket(stageId, 3, finalDuels);
-	}
-
-	/**
-	 * Ensures that the seed ordering list is stored even if it was not given in the first place.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	private ensureSeedOrdering(stageId: number): void {
-		if (this.stage.settings?.seedOrdering?.length === this.seedOrdering.length)
-			return;
-
-		const stage = this.storage.select("stage", stageId);
-		if (!stage) throw Error(`Stage not found. (stageId: ${stageId})`);
-
-		stage.settings = {
-			...stage.settings,
-			seedOrdering: this.seedOrdering,
-		};
-
-		if (!this.storage.update("stage", stageId, stage))
-			throw Error("Could not update the stage.");
-	}
-}
diff --git a/app/modules/brackets-manager/get.ts b/app/modules/brackets-manager/get.ts
deleted file mode 100644
index 5ce1c8b19..000000000
--- a/app/modules/brackets-manager/get.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import type { Group, Match, Round, Stage } from "~/modules/brackets-model";
-import { BaseGetter } from "./base/getter";
-import type { Database } from "./types";
-
-export class Get extends BaseGetter {
-	/**
-	 * Returns the data needed to display a stage.
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	public stageData(stageId: number): Database {
-		const stageData = this.getStageSpecificData(stageId);
-
-		return {
-			stage: [stageData.stage],
-			group: stageData.groups,
-			round: stageData.rounds,
-			match: stageData.matches,
-		};
-	}
-
-	/**
-	 * Returns the data needed to display a whole tournament with all its stages.
-	 *
-	 * @param tournamentId ID of the tournament.
-	 */
-	public tournamentData(tournamentId: number): Database {
-		const stages = this.storage.select("stage", {
-			tournament_id: tournamentId,
-		});
-		if (!stages) throw Error("Error getting stages.");
-
-		const stagesData = stages.map((stage) =>
-			this.getStageSpecificData(stage.id),
-		);
-
-		return {
-			stage: stages,
-			group: stagesData.flatMap((data) => data.groups),
-			round: stagesData.flatMap((data) => data.rounds),
-			match: stagesData.flatMap((data) => data.matches),
-		};
-	}
-
-	/**
-	 * Returns only the data specific to the given stage (without the participants).
-	 *
-	 * @param stageId ID of the stage.
-	 */
-	private getStageSpecificData(stageId: number): {
-		stage: Stage;
-		groups: Group[];
-		rounds: Round[];
-		matches: Match[];
-	} {
-		const stage = this.storage.select("stage", stageId);
-		if (!stage) throw Error("Stage not found.");
-
-		const groups = this.storage.select("group", { stage_id: stageId });
-		if (!groups) throw Error("Error getting groups.");
-
-		const rounds = this.storage.select("round", { stage_id: stageId });
-		if (!rounds) throw Error("Error getting rounds.");
-
-		const matches = this.storage.select("match", { stage_id: stageId });
-		if (!matches) throw Error("Error getting matches.");
-
-		return {
-			stage,
-			groups,
-			rounds,
-			matches,
-		};
-	}
-}
diff --git a/app/modules/brackets-manager/helpers.ts b/app/modules/brackets-manager/helpers.ts
deleted file mode 100644
index f77801cbd..000000000
--- a/app/modules/brackets-manager/helpers.ts
+++ /dev/null
@@ -1,1376 +0,0 @@
-import type {
-	GroupType,
-	Match,
-	MatchResults,
-	ParticipantResult,
-	Result,
-	RoundRobinMode,
-	Seeding,
-	SeedOrdering,
-	Stage,
-	StageType,
-} from "~/modules/brackets-model";
-import { Status } from "~/modules/brackets-model";
-
-import { ordering } from "./ordering";
-import type {
-	Database,
-	DeepPartial,
-	Duel,
-	IdMapping,
-	Nullable,
-	ParitySplit,
-	ParticipantSlot,
-	Side,
-} from "./types";
-
-/**
- * Splits an array in two parts: one with even indices and the other with odd indices.
- *
- * @param array The array to split.
- */
-export function splitByParity<T>(array: T[]): ParitySplit<T> {
-	return {
-		even: array.filter((_, i) => i % 2 === 0),
-		odd: array.filter((_, i) => i % 2 === 1),
-	};
-}
-
-/**
- * Makes a list of rounds containing the matches of a round-robin group.
- *
- * @param participants The participants to distribute.
- * @param mode The round-robin mode.
- */
-export function makeRoundRobinMatches<T>(
-	participants: T[],
-	mode: RoundRobinMode = "simple",
-): [T, T][][] {
-	const distribution = makeRoundRobinDistribution(participants);
-
-	if (mode === "simple") return distribution;
-
-	// Reverse rounds and their content.
-	const symmetry = distribution.map((round) => [...round].reverse()).reverse();
-
-	return [...distribution, ...symmetry];
-}
-
-/**
- * Makes a list of rounds containing the matches of a bipartite (A/B divisions) round-robin group.
- *
- * Every A team plays every B team exactly once; there are no A-vs-A or B-vs-B matches.
- * Round 1 is cross-seeded (strongest A vs weakest B), and B is rotated cyclically downward
- * in each subsequent round.
- *
- * When the divisions have different sizes, the shorter side is padded with bye slots so the
- * rotation still works. Those bye pairings are filtered out of the output, so each round has
- * exactly `min(|A|, |B|)` real matches and the total is `|A| * |B|`.
- *
- * @param divisionA Participants in division A, ordered by seed.
- * @param divisionB Participants in division B, ordered by seed.
- */
-export function makeAbDivisionRoundRobinMatches<T>(
-	divisionA: T[],
-	divisionB: T[],
-): [T, T][][] {
-	const n = Math.max(divisionA.length, divisionB.length);
-	const paddedA: (T | null)[] = [
-		...divisionA,
-		...Array(n - divisionA.length).fill(null),
-	];
-	const paddedB: (T | null)[] = [
-		...divisionB,
-		...Array(n - divisionB.length).fill(null),
-	];
-	const rounds: [T, T][][] = [];
-
-	for (let roundIdx = 0; roundIdx < n; roundIdx++) {
-		const matches: [T, T][] = [];
-
-		for (let i = 0; i < n; i++) {
-			const bIdx = (((n - 1 - i - roundIdx) % n) + n) % n;
-			const a = paddedA[i];
-			const b = paddedB[bIdx];
-			if (a === null || b === null) continue;
-			matches.push([a, b]);
-		}
-
-		rounds.push(matches);
-	}
-
-	return rounds;
-}
-
-/**
- * Distributes A/B division participants into groups such that each group has an
- * equal number of A and B participants.
- *
- * The snake ordering used by `groups.seed_optimized` is applied independently to
- * each pool, so that relative seed order within each pool is preserved within
- * every group.
- *
- * @param divisionA Participants in division A, ordered by seed.
- * @param divisionB Participants in division B, ordered by seed.
- * @param groupCount Number of groups to distribute into.
- */
-export function makeAbDivisionGroups<T>(
-	divisionA: T[],
-	divisionB: T[],
-	groupCount: number,
-): { a: T[]; b: T[] }[] {
-	if (groupCount <= 0) throw Error("Group count must be strictly positive.");
-
-	if (divisionA.length !== divisionB.length) {
-		if (groupCount !== 1)
-			throw Error(
-				"Uneven A/B divisions are only supported with a single group.",
-			);
-
-		return [{ a: divisionA, b: divisionB }];
-	}
-
-	if (divisionA.length % groupCount !== 0)
-		throw Error("Pool size must be divisible by group count.");
-
-	const aOrdered = ordering["groups.seed_optimized"](divisionA, groupCount);
-	const bOrdered = ordering["groups.seed_optimized"](divisionB, groupCount);
-
-	const perPoolGroupSize = divisionA.length / groupCount;
-	const groups: { a: T[]; b: T[] }[] = [];
-
-	for (let i = 0; i < groupCount; i++) {
-		groups.push({
-			a: aOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
-			b: bOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
-		});
-	}
-
-	return groups;
-}
-
-/**
- * Distributes participants in rounds for a round-robin group.
- *
- * Conditions:
- * - Each participant plays each other once.
- * - Each participant plays once in each round.
- *
- * @param participants The participants to distribute.
- */
-function makeRoundRobinDistribution<T>(participants: T[]): [T, T][][] {
-	const n = participants.length;
-	const n1 = n % 2 === 0 ? n : n + 1;
-	const roundCount = n1 - 1;
-	const matchPerRound = n1 / 2;
-
-	const rounds: [T, T][][] = [];
-
-	for (let roundId = 0; roundId < roundCount; roundId++) {
-		const matches: [T, T][] = [];
-
-		for (let matchId = 0; matchId < matchPerRound; matchId++) {
-			if (matchId === 0 && n % 2 === 1) continue;
-
-			const opponentsIds = [
-				(roundId - matchId - 1 + n1) % (n1 - 1),
-				matchId === 0 ? n1 - 1 : (roundId + matchId) % (n1 - 1),
-			];
-
-			matches.push([
-				participants[opponentsIds[0]],
-				participants[opponentsIds[1]],
-			]);
-		}
-
-		rounds.push(matches);
-	}
-
-	return rounds;
-}
-
-/**
- * A helper to assert our generated round-robin is correct.
- *
- * @param input The input seeding.
- * @param output The resulting distribution of seeds in groups.
- */
-export function assertRoundRobin(
-	input: number[],
-	output: [number, number][][],
-): void {
-	const n = input.length;
-	const matchPerRound = Math.floor(n / 2);
-	const roundCount = n % 2 === 0 ? n - 1 : n;
-
-	if (output.length !== roundCount) throw Error("Round count is wrong");
-	if (!output.every((round) => round.length === matchPerRound))
-		throw Error("Not every round has the good number of matches");
-
-	const checkAllOpponents = Object.fromEntries(
-		input.map((element) => [element, new Set<number>()]),
-	) as Record<number, Set<number>>;
-
-	for (const round of output) {
-		const checkUnique = new Set<number>();
-
-		for (const match of round) {
-			if (match.length !== 2) throw Error("One match is not a pair");
-
-			if (checkUnique.has(match[0]))
-				throw Error("This team is already playing");
-			checkUnique.add(match[0]);
-
-			if (checkUnique.has(match[1]))
-				throw Error("This team is already playing");
-			checkUnique.add(match[1]);
-
-			if (checkAllOpponents[match[0]].has(match[1]))
-				throw Error("The team has already matched this team");
-			checkAllOpponents[match[0]].add(match[1]);
-
-			if (checkAllOpponents[match[1]].has(match[0]))
-				throw Error("The team has already matched this team");
-			checkAllOpponents[match[1]].add(match[0]);
-		}
-	}
-}
-
-/**
- * A helper to assert our generated bipartite round-robin is correct.
- *
- * @param divisionA Seeds in division A (ordered by seed).
- * @param divisionB Seeds in division B (ordered by seed).
- * @param output The resulting rounds of matches.
- */
-export function assertAbDivisionRoundRobin(
-	divisionA: number[],
-	divisionB: number[],
-	output: [number, number][][],
-): void {
-	const roundCount = Math.max(divisionA.length, divisionB.length);
-	const matchesPerRound = Math.min(divisionA.length, divisionB.length);
-
-	if (output.length !== roundCount) throw Error("Round count is wrong");
-	if (!output.every((round) => round.length === matchesPerRound))
-		throw Error("Not every round has the good number of matches");
-
-	const aSet = new Set(divisionA);
-	const bSet = new Set(divisionB);
-	const seenPairings = new Set<string>();
-
-	for (const round of output) {
-		const playingInRound = new Set<number>();
-
-		for (const match of round) {
-			if (match.length !== 2) throw Error("One match is not a pair");
-
-			const [a, b] = match;
-
-			if (!aSet.has(a)) throw Error(`${a} is not a division A participant`);
-			if (!bSet.has(b)) throw Error(`${b} is not a division B participant`);
-
-			if (playingInRound.has(a)) throw Error("This team is already playing");
-			playingInRound.add(a);
-
-			if (playingInRound.has(b)) throw Error("This team is already playing");
-			playingInRound.add(b);
-
-			const pairingKey = `${a}-${b}`;
-			if (seenPairings.has(pairingKey))
-				throw Error("The teams have already been paired");
-			seenPairings.add(pairingKey);
-		}
-	}
-
-	if (seenPairings.size !== divisionA.length * divisionB.length)
-		throw Error("Not every A vs B pairing was generated");
-}
-
-/**
- * Distributes elements in groups of equal size.
- *
- * @param elements A list of elements to distribute in groups.
- * @param groupCount The group count.
- */
-export function makeGroups<T>(elements: T[], groupCount: number): T[][] {
-	const groupSize = Math.ceil(elements.length / groupCount);
-	const result: T[][] = [];
-
-	for (let i = 0; i < elements.length; i++) {
-		if (i % groupSize === 0) result.push([]);
-
-		result[result.length - 1].push(elements[i]);
-	}
-
-	return result;
-}
-
-/**
- * Balances BYEs to prevents having BYE against BYE in matches.
- *
- * @param seeding The seeding of the stage.
- * @param participantCount The number of participants in the stage.
- */
-export function balanceByes(
-	seeding: Seeding,
-	participantCount?: number,
-): Seeding {
-	// biome-ignore lint/style/noParameterAssign: biome migration
-	seeding = seeding.filter((v) => v !== null);
-
-	// biome-ignore lint/style/noParameterAssign: biome migration
-	participantCount = participantCount || getNearestPowerOfTwo(seeding.length);
-
-	if (seeding.length < participantCount / 2) {
-		const flat = seeding.flatMap((v) => [v, null]);
-		return setArraySize(flat, participantCount, null);
-	}
-
-	const nonNullCount = seeding.length;
-	const nullCount = participantCount - nonNullCount;
-	const againstEachOther = seeding
-		.slice(0, nonNullCount - nullCount)
-		.filter((_, i) => i % 2 === 0)
-		.map((_, i) => [seeding[2 * i], seeding[2 * i + 1]]);
-	const againstNull = seeding
-		.slice(nonNullCount - nullCount, nonNullCount)
-		.map((v) => [v, null]);
-	const flat = [...againstEachOther.flat(), ...againstNull.flat()];
-
-	return setArraySize(flat, participantCount, null);
-}
-
-/**
- * Normalizes IDs in a database.
- *
- * All IDs (and references to them) are remapped to consecutive IDs starting from 0.
- *
- * @param data Data to normalize.
- */
-export function normalizeIds(data: Database): Database {
-	const mappings = {
-		stage: makeNormalizedIdMapping(data.stage),
-		group: makeNormalizedIdMapping(data.group),
-		round: makeNormalizedIdMapping(data.round),
-		match: makeNormalizedIdMapping(data.match),
-	};
-
-	return {
-		stage: data.stage.map((value) => ({
-			...value,
-			id: mappings.stage[value.id],
-		})),
-		group: data.group.map((value) => ({
-			...value,
-			id: mappings.group[value.id],
-			stage_id: mappings.stage[value.stage_id],
-		})),
-		round: data.round.map((value) => ({
-			...value,
-			id: mappings.round[value.id],
-			stage_id: mappings.stage[value.stage_id],
-			group_id: mappings.group[value.group_id],
-		})),
-		match: data.match.map((value) => ({
-			...value,
-			id: mappings.match[value.id],
-			stage_id: mappings.stage[value.stage_id],
-			group_id: mappings.group[value.group_id],
-			round_id: mappings.round[value.round_id],
-			opponent1: value.opponent1,
-			opponent2: value.opponent2,
-		})),
-	};
-}
-
-/**
- * Makes a mapping between old IDs and new normalized IDs.
- *
- * @param elements A list of elements with IDs.
- */
-function makeNormalizedIdMapping(elements: { id: number }[]): IdMapping {
-	let currentId = 0;
-
-	return elements.reduce(
-		(acc, current) => ({
-			// biome-ignore lint/performance/noAccumulatingSpread: biome migration
-			...acc,
-			[current.id]: currentId++,
-		}),
-		{},
-	) as IdMapping;
-}
-
-/**
- * Sets the size of an array with a placeholder if the size is bigger.
- *
- * @param array The original array.
- * @param length The new length.
- * @param placeholder A placeholder to use to fill the empty space.
- */
-function setArraySize<T>(array: T[], length: number, placeholder: T): T[] {
-	return Array.from(Array(length), (_, i) => array[i] || placeholder);
-}
-
-/**
- * Makes pairs with each element and its next one.
- *
- * @example [1, 2, 3, 4] --> [[1, 2], [3, 4]]
- * @param array A list of elements.
- */
-export function makePairs<T>(array: T[]): [T, T][] {
-	return array
-		.map((_, i) => (i % 2 === 0 ? [array[i], array[i + 1]] : []))
-		.filter((v): v is [T, T] => v.length === 2);
-}
-
-/**
- * Ensures there are no duplicates in a list of elements.
- *
- * @param array A list of elements.
- */
-export function ensureNoDuplicates<T>(array: Nullable<T>[]): void {
-	const nonNull = getNonNull(array);
-	const unique = nonNull.filter((item, index) => {
-		const stringifiedItem = JSON.stringify(item);
-		return (
-			nonNull.findIndex((obj) => JSON.stringify(obj) === stringifiedItem) ===
-			index
-		);
-	});
-
-	if (unique.length < nonNull.length)
-		throw new Error("The seeding has a duplicate participant.");
-}
-
-/**
- * Fixes the seeding by enlarging it if it's not complete.
- *
- * @param seeding The seeding of the stage.
- * @param participantCount The number of participants in the stage.
- */
-export function fixSeeding(
-	seeding: Seeding,
-	participantCount: number,
-): Seeding {
-	if (seeding.length > participantCount)
-		throw Error(
-			"The seeding has more participants than the size of the stage.",
-		);
-
-	if (seeding.length < participantCount)
-		return setArraySize(seeding, participantCount, null);
-
-	return seeding;
-}
-
-/**
- * Ensures that the participant count is valid.
- *
- * @param stageType Type of the stage to test.
- * @param participantCount The number to test.
- */
-export function ensureValidSize(
-	stageType: StageType,
-	participantCount: number,
-): void {
-	if (participantCount === 0)
-		throw Error(
-			"Impossible to create an empty stage. If you want an empty seeding, just set the size of the stage.",
-		);
-
-	if (participantCount < 2)
-		throw Error("Impossible to create a stage with less than 2 participants.");
-
-	if (stageType === "round_robin") {
-		// Round robin supports any number of participants.
-		return;
-	}
-
-	if (!Number.isInteger(Math.log2(participantCount)))
-		throw Error(
-			"The library only supports a participant count which is a power of two.",
-		);
-}
-
-/**
- * Converts a participant slot to a result stored in storage, with the position the participant is coming from.
- *
- * @param slot A participant slot.
- */
-export function toResultWithPosition(slot: ParticipantSlot): ParticipantSlot {
-	return (
-		slot && {
-			id: slot.id,
-			position: slot.position,
-		}
-	);
-}
-
-/**
- * Returns the pre-computed winner for a match because of BYEs.
- *
- * @param opponents Two opponents.
- */
-export function byeWinner(opponents: Duel): ParticipantSlot {
-	if (opponents[0] === null && opponents[1] === null)
-		// Double BYE.
-		return null; // BYE.
-
-	if (opponents[0] === null && opponents[1] !== null)
-		// opponent1 BYE.
-		return { id: opponents[1].id }; // opponent2.
-
-	if (opponents[0] !== null && opponents[1] === null)
-		// opponent2 BYE.
-		return { id: opponents[0].id }; // opponent1.
-
-	return { id: null }; // Normal.
-}
-
-/**
- * Returns the pre-computed winner for a match because of BYEs in a lower bracket.
- *
- * @param opponents Two opponents.
- */
-export function byeWinnerToGrandFinal(opponents: Duel): ParticipantSlot {
-	const winner = byeWinner(opponents);
-	if (winner) winner.position = 1;
-	return winner;
-}
-
-/**
- * Returns the pre-computed loser for a match because of BYEs.
- *
- * Only used for loser bracket.
- *
- * @param opponents Two opponents.
- * @param index The index of the duel in the round.
- */
-export function byeLoser(opponents: Duel, index: number): ParticipantSlot {
-	if (opponents[0] === null || opponents[1] === null)
-		// At least one BYE.
-		return null; // BYE.
-
-	return { id: null, position: index + 1 }; // Normal.
-}
-
-/**
- * Returns the winner side or `null` if no winner.
- *
- * @param match A match's results.
- */
-export function getMatchResult(match: MatchResults): Side | null {
-	if (!isMatchCompleted(match)) return null;
-
-	if (match.opponent1 === null && match.opponent2 === null) return null;
-
-	let winner: Side | null = null;
-
-	if (match.opponent1?.result === "win" || match.opponent2 === null)
-		winner = "opponent1";
-
-	if (match.opponent2?.result === "win" || match.opponent1 === null) {
-		if (winner !== null) throw Error("There are two winners.");
-		winner = "opponent2";
-	}
-
-	return winner;
-}
-
-/**
- * Gets the side where the winner of the given match will go in the next match.
- *
- * @param matchNumber Number of the match.
- */
-function getSide(matchNumber: number): Side {
-	return matchNumber % 2 === 1 ? "opponent1" : "opponent2";
-}
-
-/**
- * Gets the other side of a match.
- *
- * @param side The side that we don't want.
- */
-export function getOtherSide(side: Side): Side {
-	return side === "opponent1" ? "opponent2" : "opponent1";
-}
-
-/**
- * Checks if a match is started.
- *
- * @param match Partial match results.
- */
-function isMatchStarted(match: DeepPartial<MatchResults>): boolean {
-	return (
-		match.opponent1?.score !== undefined || match.opponent2?.score !== undefined
-	);
-}
-
-/**
- * Checks if a match is completed.
- *
- * @param match Partial match results.
- */
-function isMatchCompleted(match: DeepPartial<MatchResults>): boolean {
-	return isMatchByeCompleted(match) || isMatchResultCompleted(match);
-}
-
-/**
- * Checks if a match is completed because of a either a draw or a win.
- *
- * @param match Partial match results.
- */
-function isMatchResultCompleted(match: DeepPartial<MatchResults>): boolean {
-	return isMatchWinCompleted(match);
-}
-
-/**
- * Checks if a match is completed because of a win.
- *
- * @param match Partial match results.
- */
-function isMatchWinCompleted(match: DeepPartial<MatchResults>): boolean {
-	return (
-		match.opponent1?.result === "win" ||
-		match.opponent2?.result === "win" ||
-		match.opponent1?.result === "loss" ||
-		match.opponent2?.result === "loss"
-	);
-}
-
-/**
- * Checks if a match is completed because of at least one BYE.
- *
- * A match "BYE vs. TBD" isn't considered completed yet.
- *
- * @param match Partial match results.
- */
-export function isMatchByeCompleted(match: DeepPartial<MatchResults>): boolean {
-	return (
-		(match.opponent1 === null && match.opponent2?.id !== null) || // BYE vs. someone
-		(match.opponent2 === null && match.opponent1?.id !== null) || // someone vs. BYE
-		(match.opponent1 === null && match.opponent2 === null)
-	); // BYE vs. BYE
-}
-
-/**
- * Checks if a match's results can't be updated.
- *
- * @param match The match to check.
- */
-export function isMatchUpdateLocked(match: MatchResults): boolean {
-	return match.status === Status.Locked || match.status === Status.Waiting;
-}
-
-/**
- * Indicates whether a match has at least one BYE or not.
- *
- * @param match Partial match results.
- */
-export function hasBye(match: DeepPartial<MatchResults>): boolean {
-	return match.opponent1 === null || match.opponent2 === null;
-}
-
-/**
- * Returns the status of a match based on the opponents of a match.
- *
- * @param opponents The opponents of a match.
- */
-export function getMatchStatus(opponents: Duel): Status;
-
-/**
- * Returns the status of a match based on the results of a match.
- *
- * @param match Partial match results.
- */
-export function getMatchStatus(match: MatchResults): Status;
-
-/**
- * Returns the status of a match based on information about it.
- *
- * @param arg The opponents or partial results of the match.
- */
-export function getMatchStatus(arg: Duel | MatchResults): Status {
-	const match = Array.isArray(arg)
-		? {
-				opponent1: arg[0],
-				opponent2: arg[1],
-			}
-		: arg;
-
-	if (hasBye(match))
-		// At least one BYE.
-		return Status.Locked;
-
-	if (match.opponent1?.id === null && match.opponent2?.id === null)
-		// Two TBD opponents.
-		return Status.Locked;
-
-	if (match.opponent1?.id === null || match.opponent2?.id === null)
-		// One TBD opponent.
-		return Status.Waiting;
-
-	if (isMatchCompleted(match)) return Status.Completed;
-
-	if (isMatchStarted(match)) return Status.Running;
-
-	return Status.Ready;
-}
-
-/**
- * Updates a match results based on an input.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- * @param inRoundRobin Indicates whether the match is in a round-robin stage.
- */
-export function setMatchResults(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-): {
-	statusChanged: boolean;
-	resultChanged: boolean;
-} {
-	const completed = isMatchCompleted(match);
-	const currentlyCompleted = isMatchCompleted(stored);
-
-	setExtraFields(stored, match);
-	handleOpponentsInversion(stored, match);
-
-	const statusChanged = setScores(stored, match);
-
-	if (completed && currentlyCompleted) {
-		// Ensure everything is good.
-		setCompleted(stored, match);
-		return { statusChanged: false, resultChanged: true };
-	}
-
-	if (completed && !currentlyCompleted) {
-		setCompleted(stored, match);
-		return { statusChanged: true, resultChanged: true };
-	}
-
-	if (!completed && currentlyCompleted) {
-		resetMatchResults(stored);
-		return { statusChanged: true, resultChanged: true };
-	}
-
-	return { statusChanged, resultChanged: false };
-}
-
-/**
- * Resets the results of a match. (status, forfeit, result)
- *
- * @param stored A reference to what will be updated in the storage.
- */
-export function resetMatchResults(stored: MatchResults): void {
-	if (stored.opponent1) {
-		stored.opponent1.result = undefined;
-	}
-
-	if (stored.opponent2) {
-		stored.opponent2.result = undefined;
-	}
-
-	stored.status = getMatchStatus(stored);
-}
-
-/**
- * Passes user-defined extra fields to the stored match.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- */
-function setExtraFields(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-): void {
-	const partialAssign = (
-		target: unknown,
-		update: unknown,
-		ignoredKeys: string[],
-	): void => {
-		if (!target || !update) return;
-
-		const retainedKeys = Object.keys(update).filter(
-			(key) => !ignoredKeys.includes(key),
-		);
-
-		for (const key of retainedKeys) {
-			(target as Record<string, unknown>)[key] = (
-				update as Record<string, unknown>
-			)[key];
-		}
-	};
-
-	const ignoredKeys: Array<keyof Match> = [
-		"id",
-		"number",
-		"stage_id",
-		"group_id",
-		"round_id",
-		"status",
-		"opponent1",
-		"opponent2",
-	];
-
-	const ignoredOpponentKeys: Array<keyof ParticipantResult> = [
-		"id",
-		"score",
-		"position",
-		"forfeit",
-		"result",
-	];
-
-	partialAssign(stored, match, ignoredKeys);
-	partialAssign(stored.opponent1, match.opponent1, ignoredOpponentKeys);
-	partialAssign(stored.opponent2, match.opponent2, ignoredOpponentKeys);
-}
-
-/**
- * Gets the id of the opponent at the given side of the given match.
- *
- * @param match The match to get the opponent from.
- * @param side The side where to get the opponent from.
- */
-function getOpponentId(match: MatchResults, side: Side): number | null {
-	const opponent = match[side];
-	return opponent?.id ?? null;
-}
-
-/**
- * Gets the origin position of a side of a match.
- *
- * @param match The match.
- * @param side The side.
- */
-export function getOriginPosition(match: Match, side: Side): number {
-	const matchNumber = match[side]?.position;
-	if (matchNumber === undefined) throw Error("Position is undefined.");
-
-	return matchNumber;
-}
-
-/**
- * Gets the side the winner of the current match will go to in the next match.
- *
- * @param matchNumber Number of the current match.
- * @param roundNumber Number of the current round.
- * @param roundCount Count of rounds.
- * @param matchLocation Location of the current match.
- */
-export function getNextSide(
-	matchNumber: number,
-	roundNumber: number,
-	roundCount: number,
-	matchLocation: GroupType,
-): Side {
-	// The nextSide comes from the same bracket.
-	if (matchLocation === "loser_bracket" && roundNumber % 2 === 1)
-		return "opponent2";
-
-	// The nextSide comes from the loser bracket to the final group.
-	if (matchLocation === "loser_bracket" && roundNumber === roundCount)
-		return "opponent2";
-
-	return getSide(matchNumber);
-}
-
-/**
- * Gets the side the winner of the current match in loser bracket will go in the next match.
- *
- * @param matchNumber Number of the match.
- * @param nextMatch The next match.
- * @param roundNumber Number of the current round.
- */
-export function getNextSideLoserBracket(
-	matchNumber: number,
-	nextMatch: Match,
-	roundNumber: number,
-): Side {
-	// The nextSide comes from the WB.
-	if (roundNumber > 1) return "opponent1";
-
-	// The nextSide comes from the WB round 1.
-	if (nextMatch.opponent1?.position === matchNumber) return "opponent1";
-
-	return "opponent2";
-}
-
-export type SetNextOpponent = (
-	nextMatch: Match,
-	nextSide: Side,
-	match?: Match,
-	currentSide?: Side,
-) => void;
-
-/**
- * Sets an opponent in the next match he has to go.
- *
- * @param nextMatch A match which follows the current one.
- * @param nextSide The side the opponent will be on in the next match.
- * @param match The current match.
- * @param currentSide The side the opponent is currently on.
- */
-export function setNextOpponent(
-	nextMatch: Match,
-	nextSide: Side,
-	match?: Match,
-	currentSide?: Side,
-): void {
-	nextMatch[nextSide] = match![currentSide!] && {
-		// Keep BYE.
-		id: getOpponentId(match!, currentSide!), // This implementation of SetNextOpponent always has those arguments.
-		position: nextMatch[nextSide]?.position, // Keep position.
-	};
-
-	nextMatch.status = getMatchStatus(nextMatch);
-}
-
-/**
- * Resets an opponent in the match following the current one.
- *
- * @param nextMatch A match which follows the current one.
- * @param nextSide The side the opponent will be on in the next match.
- */
-export function resetNextOpponent(nextMatch: Match, nextSide: Side): void {
-	nextMatch[nextSide] = nextMatch[nextSide] && {
-		// Keep BYE.
-		id: null,
-		position: nextMatch[nextSide]?.position, // Keep position.
-	};
-
-	nextMatch.status = Status.Locked;
-}
-
-/**
- * Inverts opponents if requested by the input.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- */
-function handleOpponentsInversion(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-): void {
-	const id1 = match.opponent1?.id;
-	const id2 = match.opponent2?.id;
-
-	const storedId1 = stored.opponent1?.id;
-	const storedId2 = stored.opponent2?.id;
-
-	if (Number.isInteger(id1) && id1 !== storedId1 && id1 !== storedId2)
-		throw Error("The given opponent1 ID does not exist in this match.");
-
-	if (Number.isInteger(id2) && id2 !== storedId1 && id2 !== storedId2)
-		throw Error("The given opponent2 ID does not exist in this match.");
-
-	if (
-		(Number.isInteger(id1) && id1 === storedId2) ||
-		(Number.isInteger(id2) && id2 === storedId1)
-	)
-		invertOpponents(match);
-}
-
-/**
- * Inverts `opponent1` and `opponent2` in a match.
- *
- * @param match A match to update.
- */
-function invertOpponents(match: DeepPartial<MatchResults>): void {
-	[match.opponent1, match.opponent2] = [match.opponent2, match.opponent1];
-}
-
-/**
- * Updates the scores of a match.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- * @returns `true` if the status of the match changed, `false` otherwise.
- */
-function setScores(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-): boolean {
-	// Skip if no score update.
-	if (
-		match.opponent1?.score === stored.opponent1?.score &&
-		match.opponent2?.score === stored.opponent2?.score
-	)
-		return false;
-
-	const oldStatus = stored.status;
-	stored.status = Status.Running;
-
-	if (match.opponent1 && stored.opponent1)
-		stored.opponent1.score = match.opponent1.score;
-
-	if (match.opponent2 && stored.opponent2)
-		stored.opponent2.score = match.opponent2.score;
-
-	return stored.status !== oldStatus;
-}
-
-/**
- * Completes a match and handles results and forfeits.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- */
-function setCompleted(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-): void {
-	stored.status = Status.Completed;
-
-	setResults(stored, match, "win", "loss");
-	setResults(stored, match, "loss", "win");
-
-	if (stored.opponent1 && !stored.opponent2) stored.opponent1.result = "win"; // Win against opponent 2 BYE.
-
-	if (!stored.opponent1 && stored.opponent2) stored.opponent2.result = "win"; // Win against opponent 1 BYE.
-}
-
-/**
- * Enforces the symmetry between opponents.
- *
- * Sets an opponent's result to something, based on the result on the other opponent.
- *
- * @param stored A reference to what will be updated in the storage.
- * @param match Input of the update.
- * @param check A result to check in each opponent.
- * @param change A result to set in each other opponent if `check` is correct.
- */
-function setResults(
-	stored: MatchResults,
-	match: DeepPartial<MatchResults>,
-	check: Result,
-	change: Result,
-): void {
-	if (match.opponent1 && match.opponent2) {
-		if (match.opponent1.result === "win" && match.opponent2.result === "win")
-			throw Error("There are two winners.");
-
-		if (match.opponent1.result === "loss" && match.opponent2.result === "loss")
-			throw Error("There are two losers.");
-	}
-
-	if (match.opponent1?.result === check) {
-		if (stored.opponent1) stored.opponent1.result = check;
-		else stored.opponent1 = { id: null, result: check };
-
-		if (stored.opponent2) stored.opponent2.result = change;
-		else stored.opponent2 = { id: null, result: change };
-	}
-
-	if (match.opponent2?.result === check) {
-		if (stored.opponent2) stored.opponent2.result = check;
-		else stored.opponent2 = { id: null, result: check };
-
-		if (stored.opponent1) stored.opponent1.result = change;
-		else stored.opponent1 = { id: null, result: change };
-	}
-}
-
-/**
- * Returns only the non null elements.
- *
- * @param array The array to process.
- */
-function getNonNull<T>(array: Nullable<T>[]): T[] {
-	// Use a TS type guard to exclude null from the resulting type.
-	const nonNull = array.filter((element): element is T => element !== null);
-	return nonNull;
-}
-
-/**
- * Makes the transition to a major round for duels of the previous round. The duel count is divided by 2.
- *
- * @param previousDuels The previous duels to transition from.
- */
-export function transitionToMajor(previousDuels: Duel[]): Duel[] {
-	const currentDuelCount = previousDuels.length / 2;
-	const currentDuels: Duel[] = [];
-
-	for (let duelIndex = 0; duelIndex < currentDuelCount; duelIndex++) {
-		const prevDuelId = duelIndex * 2;
-		currentDuels.push([
-			byeWinner(previousDuels[prevDuelId]),
-			byeWinner(previousDuels[prevDuelId + 1]),
-		]);
-	}
-
-	return currentDuels;
-}
-
-/**
- * Makes the transition to a minor round for duels of the previous round. The duel count stays the same.
- *
- * @param previousDuels The previous duels to transition from.
- * @param losers Losers from the previous major round.
- * @param method The ordering method for the losers.
- */
-export function transitionToMinor(
-	previousDuels: Duel[],
-	losers: ParticipantSlot[],
-	method?: SeedOrdering,
-): Duel[] {
-	const orderedLosers = method ? ordering[method](losers) : losers;
-	const currentDuelCount = previousDuels.length;
-	const currentDuels: Duel[] = [];
-
-	for (let duelIndex = 0; duelIndex < currentDuelCount; duelIndex++) {
-		const prevDuelId = duelIndex;
-		currentDuels.push([
-			orderedLosers[prevDuelId],
-			byeWinner(previousDuels[prevDuelId]),
-		]);
-	}
-
-	return currentDuels;
-}
-
-/**
- * Gets the values which need to be updated in a match when it's updated on insertion.
- *
- * @param match The up to date match.
- * @param existing The base match.
- * @param enableByes Whether to use BYEs or TBDs for `null` values in an input seeding.
- */
-export function getUpdatedMatchResults<T extends MatchResults>(
-	match: T,
-	existing: T,
-	enableByes: boolean,
-): T {
-	return {
-		...existing,
-		...match,
-		...(enableByes
-			? {
-					opponent1:
-						match.opponent1 === null
-							? null
-							: { ...existing.opponent1, ...match.opponent1 },
-					opponent2:
-						match.opponent2 === null
-							? null
-							: { ...existing.opponent2, ...match.opponent2 },
-				}
-			: {
-					opponent1:
-						match.opponent1 === null
-							? { id: null }
-							: { ...existing.opponent1, ...match.opponent1 },
-					opponent2:
-						match.opponent2 === null
-							? { id: null }
-							: { ...existing.opponent2, ...match.opponent2 },
-				}),
-	};
-}
-
-/**
- * Indicates whether the ordering is supported in loser bracket, given the round number.
- *
- * @param roundNumber The number of the round.
- * @param roundCount The count of rounds.
- */
-export function isOrderingSupportedLoserBracket(
-	roundNumber: number,
-	roundCount: number,
-): boolean {
-	return (
-		roundNumber === 1 || (roundNumber % 2 === 0 && roundNumber < roundCount)
-	);
-}
-
-/**
- * Returns the number of rounds an upper bracket has given the number of participants in the stage.
- *
- * @param participantCount The number of participants in the stage.
- */
-export function getUpperBracketRoundCount(participantCount: number): number {
-	return Math.log2(participantCount);
-}
-
-/**
- * Returns the count of round pairs (major & minor) in a loser bracket.
- *
- * @param participantCount The number of participants in the stage.
- */
-export function getRoundPairCount(participantCount: number): number {
-	return getUpperBracketRoundCount(participantCount) - 1;
-}
-
-/**
- * Determines whether a double elimination stage is really necessary.
- *
- * If the size is only two (less is impossible), then a lower bracket and a grand final are not necessary.
- *
- * @param participantCount The number of participants in the stage.
- */
-export function isDoubleEliminationNecessary(
-	participantCount: number,
-): boolean {
-	return participantCount > 2;
-}
-
-/**
- * Returns the real (because of loser ordering) number of a match in a loser bracket.
- *
- * @param participantCount The number of participants in a stage.
- * @param roundNumber Number of the round.
- * @param matchNumber Number of the match.
- * @param method The method used for the round.
- */
-export function findLoserMatchNumber(
-	participantCount: number,
-	roundNumber: number,
-	matchNumber: number,
-	method?: SeedOrdering,
-): number {
-	const loserCount = getLoserRoundLoserCount(participantCount, roundNumber);
-	const losers = Array.from(Array(loserCount), (_, i) => i + 1);
-	const ordered = method ? ordering[method](losers) : losers;
-	const matchNumberLB = ordered.indexOf(matchNumber) + 1;
-
-	// For LB round 1, the list of losers is spread over the matches 2 by 2.
-	if (roundNumber === 1) return Math.ceil(matchNumberLB / 2);
-
-	return matchNumberLB;
-}
-
-/**
- * Returns the count of matches in a round of a loser bracket.
- *
- * @param participantCount The number of participants in a stage.
- * @param roundNumber Number of the round.
- */
-function getLoserRoundMatchCount(
-	participantCount: number,
-	roundNumber: number,
-): number {
-	const roundPairIndex = Math.ceil(roundNumber / 2) - 1;
-	const roundPairCount = getRoundPairCount(participantCount);
-	const matchCount = 2 ** (roundPairCount - roundPairIndex - 1);
-	return matchCount;
-}
-
-/**
- * Returns the count of losers in a round of a loser bracket.
- *
- * @param participantCount The number of participants in a stage.
- * @param roundNumber Number of the round.
- */
-function getLoserRoundLoserCount(
-	participantCount: number,
-	roundNumber: number,
-): number {
-	const matchCount = getLoserRoundMatchCount(participantCount, roundNumber);
-
-	// Two per match for LB round 1 (losers coming from WB round 1).
-	if (roundNumber === 1) return matchCount * 2;
-
-	return matchCount; // One per match for LB minor rounds.
-}
-
-/**
- * Returns the ordering method of a round of a loser bracket.
- *
- * @param seedOrdering The list of seed orderings.
- * @param roundNumber Number of the round.
- */
-export function getLoserOrdering(
-	seedOrdering: SeedOrdering[],
-	roundNumber: number,
-): SeedOrdering | undefined {
-	const orderingIndex = 1 + Math.floor(roundNumber / 2);
-	return seedOrdering[orderingIndex];
-}
-
-/**
- * Returns the match number of the corresponding match in the next round by dividing by two.
- *
- * @param matchNumber The current match number.
- */
-export function getDiagonalMatchNumber(matchNumber: number): number {
-	return Math.ceil(matchNumber / 2);
-}
-
-/**
- * Returns the nearest power of two **greater than** or equal to the given number.
- *
- * @param input The input number.
- */
-function getNearestPowerOfTwo(input: number): number {
-	return 2 ** Math.ceil(Math.log2(input));
-}
-
-/**
- * Checks if a stage is a round-robin stage.
- *
- * @param stage The stage to check.
- */
-export function isRoundRobin(stage: Stage): boolean {
-	return stage.type === "round_robin";
-}
-
-export function isSwiss(stage: Stage): boolean {
-	return stage.type === "swiss";
-}
-
-/**
- * Checks if a group is a winner bracket.
- *
- * It's not always the opposite of `inLoserBracket()`: it could be the only bracket of a single elimination stage.
- *
- * @param stageType Type of the stage.
- * @param groupNumber Number of the group.
- */
-function isWinnerBracket(stageType: StageType, groupNumber: number): boolean {
-	return stageType === "double_elimination" && groupNumber === 1;
-}
-
-/**
- * Checks if a group is a loser bracket.
- *
- * @param stageType Type of the stage.
- * @param groupNumber Number of the group.
- */
-function isLoserBracket(stageType: StageType, groupNumber: number): boolean {
-	return stageType === "double_elimination" && groupNumber === 2;
-}
-
-/**
- * Checks if a group is a final group (consolation final or grand final).
- *
- * @param stageType Type of the stage.
- * @param groupNumber Number of the group.
- */
-function isFinalGroup(stageType: StageType, groupNumber: number): boolean {
-	return (
-		(stageType === "single_elimination" && groupNumber === 2) ||
-		(stageType === "double_elimination" && groupNumber === 3)
-	);
-}
-
-/**
- * Returns the type of group the match is located into.
- *
- * @param stageType Type of the stage.
- * @param groupNumber Number of the group.
- */
-export function getMatchLocation(
-	stageType: StageType,
-	groupNumber: number,
-): GroupType {
-	if (isWinnerBracket(stageType, groupNumber)) return "winner_bracket";
-
-	if (isLoserBracket(stageType, groupNumber)) return "loser_bracket";
-
-	if (isFinalGroup(stageType, groupNumber)) return "final_group";
-
-	return "single_bracket";
-}
diff --git a/app/modules/brackets-manager/index.ts b/app/modules/brackets-manager/index.ts
deleted file mode 100644
index 3cc3935c8..000000000
--- a/app/modules/brackets-manager/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { BracketsManager } from "./manager";
-
-import type { CrudInterface, Database, OmitId, Table } from "./types";
-
-export {
-	BracketsManager,
-	type CrudInterface,
-	type Database,
-	type OmitId,
-	type Table,
-};
diff --git a/app/modules/brackets-manager/manager.ts b/app/modules/brackets-manager/manager.ts
deleted file mode 100644
index b5a45146b..000000000
--- a/app/modules/brackets-manager/manager.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import type { InputStage, Stage } from "~/modules/brackets-model";
-import { create } from "./create";
-import { Get } from "./get";
-import * as helpers from "./helpers";
-import { Reset } from "./reset";
-import type {
-	CrudInterface,
-	Database,
-	DataTypes,
-	Storage,
-	Table,
-} from "./types";
-import { Update } from "./update";
-
-/**
- * A class to handle tournament management at those levels: `stage`, `group`, `round` and `match`.
- */
-export class BracketsManager {
-	public storage: Storage;
-
-	public get: Get;
-	public update: Update;
-	public reset: Reset;
-
-	/**
-	 * Creates an instance of BracketsManager, which will handle all the stuff from the library.
-	 *
-	 * @param storageInterface An implementation of CrudInterface.
-	 */
-	constructor(storageInterface: CrudInterface) {
-		const storage = storageInterface as Storage;
-
-		storage.selectFirst = <T extends Table>(
-			table: T,
-			filter: Partial<DataTypes[T]>,
-		): DataTypes[T] | null => {
-			const results = this.storage.select<T>(table, filter);
-			if (!results || results.length === 0) return null;
-			return results[0];
-		};
-
-		storage.selectLast = <T extends Table>(
-			table: T,
-			filter: Partial<DataTypes[T]>,
-		): DataTypes[T] | null => {
-			const results = this.storage.select<T>(table, filter);
-			if (!results || results.length === 0) return null;
-			return results[results.length - 1];
-		};
-
-		this.storage = storage;
-		this.get = new Get(this.storage);
-		this.update = new Update(this.storage);
-		this.reset = new Reset(this.storage);
-	}
-
-	/**
-	 * Creates a stage for an existing tournament. The tournament won't be created.
-	 *
-	 * @param stage A stage to create.
-	 */
-	public create(stage: InputStage): Stage {
-		return create.call(this, stage);
-	}
-
-	/**
-	 * Imports data in the database.
-	 *
-	 * @param data Data to import.
-	 * @param normalizeIds Enable ID normalization: all IDs (and references to them) are remapped to consecutive IDs starting from 0.
-	 */
-	public importData(rawData: Database, normalizeIds = false): void {
-		const data = normalizeIds ? helpers.normalizeIds(rawData) : rawData;
-
-		if (!this.storage.delete("stage"))
-			throw Error("Could not empty the stage table.");
-		if (!this.storage.insert("stage", data.stage))
-			throw Error("Could not import stages.");
-
-		if (!this.storage.delete("group"))
-			throw Error("Could not empty the group table.");
-		if (!this.storage.insert("group", data.group))
-			throw Error("Could not import groups.");
-
-		if (!this.storage.delete("round"))
-			throw Error("Could not empty the round table.");
-		if (!this.storage.insert("round", data.round))
-			throw Error("Could not import rounds.");
-
-		if (!this.storage.delete("match"))
-			throw Error("Could not empty the match table.");
-		if (!this.storage.insert("match", data.match))
-			throw Error("Could not import matches.");
-	}
-
-	/**
-	 * Exports data from the database.
-	 */
-	public export(): Database {
-		const stages = this.storage.select("stage");
-		if (!stages) throw Error("Error getting stages.");
-
-		const groups = this.storage.select("group");
-		if (!groups) throw Error("Error getting groups.");
-
-		const rounds = this.storage.select("round");
-		if (!rounds) throw Error("Error getting rounds.");
-
-		const matches = this.storage.select("match");
-		if (!matches) throw Error("Error getting matches.");
-
-		return {
-			stage: stages,
-			group: groups,
-			round: rounds,
-			match: matches,
-		};
-	}
-}
diff --git a/app/modules/brackets-manager/reset.ts b/app/modules/brackets-manager/reset.ts
deleted file mode 100644
index 0cf246a6f..000000000
--- a/app/modules/brackets-manager/reset.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { Status } from "~/modules/brackets-model";
-import { BaseUpdater } from "./base/updater";
-import * as helpers from "./helpers";
-
-export class Reset extends BaseUpdater {
-	/**
-	 * Resets the results of a match.
-	 *
-	 * This will update related matches accordingly.
-	 *
-	 * @param matchId ID of the match.
-	 */
-	public matchResults(matchId: number): void {
-		const stored = this.storage.select("match", matchId);
-		if (!stored) throw Error("Match not found.");
-
-		const stage = this.storage.select("stage", stored.stage_id);
-		if (!stage) throw Error("Stage not found.");
-
-		const group = this.storage.select("group", stored.group_id);
-		if (!group) throw Error("Group not found.");
-
-		const { roundNumber, roundCount } = this.getRoundPositionalInfo(
-			stored.round_id,
-		);
-		const matchLocation = helpers.getMatchLocation(stage.type, group.number);
-		const nextMatches =
-			stage.type !== "round_robin" && stage.type !== "swiss"
-				? this.getNextMatches(
-						stored,
-						matchLocation,
-						stage,
-						roundNumber,
-						roundCount,
-					)
-				: [];
-
-		if (
-			nextMatches.some(
-				(match) =>
-					match &&
-					match.status >= Status.Running &&
-					!helpers.isMatchByeCompleted(match),
-			)
-		)
-			throw Error("The match is locked.");
-
-		helpers.resetMatchResults(stored);
-		this.applyMatchUpdate(stored);
-
-		if (!helpers.isRoundRobin(stage) && !helpers.isSwiss(stage))
-			this.updateRelatedMatches(stored, true, true);
-	}
-}
diff --git a/app/modules/brackets-manager/test/double-elimination.test.ts b/app/modules/brackets-manager/test/double-elimination.test.ts
deleted file mode 100644
index ab668c710..000000000
--- a/app/modules/brackets-manager/test/double-elimination.test.ts
+++ /dev/null
@@ -1,391 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { TournamentMatchStatus } from "~/db/tables";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-import { BracketsManager } from "../manager";
-
-const storage = new InMemoryDatabase();
-const manager = new BracketsManager(storage);
-
-describe("Delete stage", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should create a double elimination stage", () => {
-		manager.create({
-			name: "Amateur",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: { seedOrdering: ["natural"], grandFinal: "simple" },
-		});
-
-		const stage = storage.select<any>("stage", 0);
-		expect(stage.name).toBe("Amateur");
-		expect(stage.type).toBe("double_elimination");
-
-		expect(storage.select<any>("group")!.length).toBe(3);
-		expect(storage.select<any>("round")!.length).toBe(4 + 6 + 1);
-		expect(storage.select<any>("match")!.length).toBe(30);
-	});
-
-	test("should create a tournament with 256+ tournaments", () => {
-		manager.create({
-			name: "Example with 256 participants",
-			tournamentId: 0,
-			type: "double_elimination",
-			settings: { size: 256 },
-		});
-	});
-
-	test("should create a tournament with a double grand final", () => {
-		manager.create({
-			name: "Example with double grand final",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: { grandFinal: "double", seedOrdering: ["natural"] },
-		});
-
-		expect(storage.select<any>("group")!.length).toBe(3);
-		expect(storage.select<any>("round")!.length).toBe(3 + 4 + 2);
-		expect(storage.select<any>("match")!.length).toBe(15);
-	});
-});
-
-describe("Previous and next match update in double elimination stage", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should end a match and determine next matches", () => {
-		manager.create({
-			name: "Amateur",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: { seedOrdering: ["natural"], grandFinal: "simple" },
-		});
-
-		const before = storage.select<any>("match", 8); // First match of WB round 2
-		expect(before.opponent2.id).toBeNull();
-
-		manager.update.match({
-			id: 0, // First match of WB round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1, // Second match of WB round 1
-			opponent1: { score: 13 },
-			opponent2: { score: 16, result: "win" },
-		});
-
-		manager.update.match({
-			id: 15, // First match of LB round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 10 },
-		});
-
-		expect(
-			storage.select<any>("match", 8).opponent1.id, // Determined opponent for WB round 2
-		).toBe(storage.select<any>("match", 0).opponent1.id); // Winner of first match round 1
-
-		expect(
-			storage.select<any>("match", 8).opponent2.id, // Determined opponent for WB round 2
-		).toBe(storage.select<any>("match", 1).opponent2.id); // Winner of second match round 1
-
-		expect(
-			storage.select<any>("match", 15).opponent2.id, // Determined opponent for LB round 1
-		).toBe(storage.select<any>("match", 1).opponent1.id); // Loser of second match round 1
-
-		expect(
-			storage.select<any>("match", 19).opponent2.id, // Determined opponent for LB round 2
-		).toBe(storage.select<any>("match", 0).opponent2.id); // Loser of first match round 1
-	});
-
-	test("should propagate winner when BYE is already in next match in loser bracket", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, null],
-			settings: { grandFinal: "simple" },
-		});
-
-		manager.update.match({
-			id: 1, // Second match of WB round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		const loserId = storage.select<any>("match", 1).opponent2.id;
-		let matchSemiLB = storage.select<any>("match", 3);
-
-		expect(matchSemiLB.opponent2.id).toBe(loserId);
-		expect(matchSemiLB.opponent2.result).toBe("win");
-		expect(matchSemiLB.status).toBe(TournamentMatchStatus.Completed);
-
-		expect(
-			storage.select<any>("match", 4).opponent2.id, // Propagated winner in LB Final because of the BYE.
-		).toBe(loserId);
-
-		manager.reset.matchResults(1); // Second match of WB round 1
-
-		matchSemiLB = storage.select<any>("match", 3);
-		expect(matchSemiLB.opponent2.id).toBeNull();
-		expect(matchSemiLB.opponent2.result).toBeUndefined();
-		expect(matchSemiLB.status).toBe(TournamentMatchStatus.Locked);
-
-		expect(storage.select<any>("match", 4).opponent2.id).toBeNull(); // Propagated winner is removed.
-	});
-
-	test("should determine matches in grand final", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: { grandFinal: "double" },
-		});
-
-		manager.update.match({
-			id: 0, // First match of WB round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1, // Second match of WB round 1
-			opponent1: { score: 13 },
-			opponent2: { score: 16, result: "win" },
-		});
-
-		manager.update.match({
-			id: 2, // WB Final
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 9 },
-		});
-
-		expect(
-			storage.select<any>("match", 5).opponent1.id, // Determined opponent for the grand final (round 1)
-		).toBe(storage.select<any>("match", 0).opponent1.id); // Winner of WB Final
-
-		manager.update.match({
-			id: 3, // Only match of LB round 1
-			opponent1: { score: 12, result: "win" }, // Team 4
-			opponent2: { score: 8 },
-		});
-
-		manager.update.match({
-			id: 4, // LB Final
-			opponent1: { score: 14, result: "win" }, // Team 3
-			opponent2: { score: 7 },
-		});
-
-		expect(
-			storage.select<any>("match", 5).opponent2.id, // Determined opponent for the grand final (round 1)
-		).toBe(storage.select<any>("match", 1).opponent2.id); // Winner of LB Final
-
-		manager.update.match({
-			id: 5, // Grand Final round 1
-			opponent1: { score: 10 },
-			opponent2: { score: 16, result: "win" }, // Team 3
-		});
-
-		expect(
-			storage.select<any>("match", 6).opponent2.id, // Determined opponent for the grand final (round 2)
-		).toBe(storage.select<any>("match", 1).opponent2.id); // Winner of LB Final
-
-		expect(storage.select<any>("match", 5).status).toBe(
-			TournamentMatchStatus.Completed,
-		); // Grand final (round 1)
-		expect(storage.select<any>("match", 6).status).toBe(
-			TournamentMatchStatus.Ready,
-		); // Grand final (round 2)
-
-		manager.update.match({
-			id: 6, // Grand Final round 2
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 10 },
-		});
-	});
-
-	test("should determine next matches and reset them", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: { grandFinal: "double" },
-		});
-
-		manager.update.match({
-			id: 0, // First match of WB round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		const beforeReset = storage.select<any>("match", 3); // Determined opponent for LB round 1
-		expect(beforeReset.opponent1.id).toBe(
-			storage.select<any>("match", 0).opponent2.id,
-		);
-		expect(beforeReset.opponent1.position).toBe(1); // Must be set.
-
-		manager.reset.matchResults(0); // First match of WB round 1
-
-		const afterReset = storage.select<any>("match", 3); // Determined opponent for LB round 1
-		expect(afterReset.opponent1.id).toBeNull();
-		expect(afterReset.opponent1.position).toBe(1); // It must stay.
-	});
-
-	test("should choose the correct previous and next matches based on losers ordering", () => {
-		manager.create({
-			name: "Amateur",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: {
-				seedOrdering: ["natural", "reverse", "reverse"],
-				grandFinal: "simple",
-			},
-		});
-
-		manager.update.match({ id: 0, opponent1: { result: "win" } }); // WB 1.1
-		expect(
-			storage.select<any>("match", 18).opponent2.id, // Determined opponent for last match of LB round 1 (reverse ordering for losers)
-		).toBe(storage.select<any>("match", 0).opponent2.id); // Loser of first match round 1
-
-		manager.update.match({ id: 1, opponent1: { result: "win" } }); // WB 1.2
-		expect(
-			storage.select<any>("match", 18).opponent1.id, // Determined opponent for last match of LB round 1 (reverse ordering for losers)
-		).toBe(storage.select<any>("match", 1).opponent2.id); // Loser of second match round 1
-
-		manager.update.match({ id: 8, opponent1: { result: "win" } }); // WB 2.1
-		expect(
-			storage.select<any>("match", 22).opponent1.id, // Determined opponent for last match of LB round 2 (reverse ordering for losers)
-		).toBe(storage.select<any>("match", 8).opponent2.id); // Loser of first match round 2
-
-		manager.update.match({ id: 6, opponent1: { result: "win" } }); // WB 1.7
-		manager.update.match({ id: 7, opponent1: { result: "win" } }); // WB 1.8
-		manager.update.match({ id: 11, opponent1: { result: "win" } }); // WB 2.4
-		manager.update.match({ id: 15, opponent1: { result: "win" } }); // LB 1.1
-		manager.update.match({ id: 19, opponent1: { result: "win" } }); // LB 2.1
-
-		expect(storage.select<any>("match", 8).status).toBe(
-			TournamentMatchStatus.Completed,
-		); // WB 2.1
-	});
-
-	test("should send the losers to the right LB matches in round 1", () => {
-		manager.create({
-			name: "Example with inner_outer loser ordering",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: {
-				seedOrdering: ["inner_outer", "inner_outer"],
-			},
-		});
-
-		expect(storage.select<any>("match", 7).opponent1.position).toBe(1);
-		expect(storage.select<any>("match", 7).opponent2.position).toBe(4);
-		expect(storage.select<any>("match", 8).opponent1.position).toBe(2);
-		expect(storage.select<any>("match", 8).opponent2.position).toBe(3);
-
-		// Match of position 1.
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" }, // Loser id: 7.
-		});
-
-		expect(storage.select<any>("match", 7).opponent1.id).toBe(8);
-
-		// Match of position 2.
-		manager.update.match({
-			id: 1,
-			opponent1: { result: "win" }, // Loser id: 4.
-		});
-
-		expect(storage.select<any>("match", 8).opponent1.id).toBe(5);
-
-		// Match of position 3.
-		manager.update.match({
-			id: 2,
-			opponent1: { result: "win" }, // Loser id: 6.
-		});
-
-		expect(storage.select<any>("match", 8).opponent2.id).toBe(7);
-
-		// Match of position 4.
-		manager.update.match({
-			id: 3,
-			opponent1: { result: "win" }, // Loser id: 5.
-		});
-
-		expect(storage.select<any>("match", 7).opponent2.id).toBe(6);
-	});
-});
-
-describe("Skip first round", () => {
-	beforeEach(() => {
-		storage.reset();
-
-		manager.create({
-			name: "Example with double grand final",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: {
-				seedOrdering: ["natural"],
-				skipFirstRound: true,
-				grandFinal: "double",
-			},
-		});
-	});
-
-	test("should create a double elimination stage with skip first round option", () => {
-		expect(storage.select<any>("group")!.length).toBe(3);
-		expect(storage.select<any>("round")!.length).toBe(3 + 6 + 2); // One round less in WB.
-		expect(storage.select<any>("match")!.length).toBe(
-			4 + 2 + 1 + (4 + 4 + 2 + 2 + 1 + 1) + (1 + 1),
-		);
-
-		expect(storage.select<any>("round", 0).number).toBe(1); // Even though the "real" first round is skipped, the stored first round's number should be 1.
-
-		expect(storage.select<any>("match", 0).opponent1.id).toBe(1); // First match of WB.
-		expect(storage.select<any>("match", 7).opponent1.id).toBe(2); // First match of LB.
-	});
-
-	test("should choose the correct previous and next matches", () => {
-		manager.update.match({ id: 0, opponent1: { result: "win" } });
-		expect(storage.select<any>("match", 7).opponent1.id).toBe(2); // First match of LB Round 1 (must stay).
-		expect(storage.select<any>("match", 12).opponent1.id).toBe(3); // First match of LB Round 2 (must be updated).
-
-		manager.update.match({ id: 1, opponent1: { result: "win" } });
-		expect(storage.select<any>("match", 7).opponent2.id).toBe(4); // First match of LB Round 1 (must stay).
-		expect(storage.select<any>("match", 11).opponent1.id).toBe(7); // Second match of LB Round 2 (must be updated).
-
-		manager.update.match({ id: 4, opponent1: { result: "win" } }); // First match of WB Round 2.
-		expect(storage.select<any>("match", 18).opponent1.id).toBe(5); // First match of LB Round 4.
-
-		manager.update.match({ id: 7, opponent1: { result: "win" } }); // First match of LB Round 1.
-		expect(storage.select<any>("match", 11).opponent2.id).toBe(2); // First match of LB Round 2.
-
-		for (let i = 2; i < 21; i++)
-			manager.update.match({ id: i, opponent1: { result: "win" } });
-
-		expect(storage.select<any>("match", 15).opponent1.id).toBe(7); // First match of LB Round 3.
-
-		expect(storage.select<any>("match", 21).opponent1.id).toBe(1); // GF Round 1.
-		expect(storage.select<any>("match", 21).opponent2.id).toBe(9); // GF Round 1.
-
-		manager.update.match({ id: 21, opponent2: { result: "win" } });
-
-		expect(storage.select<any>("match", 21).opponent1.id).toBe(1); // GF Round 2.
-		expect(storage.select<any>("match", 22).opponent2.id).toBe(9); // GF Round 2.
-
-		manager.update.match({ id: 22, opponent2: { result: "win" } });
-	});
-});
diff --git a/app/modules/brackets-manager/test/general.test.ts b/app/modules/brackets-manager/test/general.test.ts
deleted file mode 100644
index 0492c6a15..000000000
--- a/app/modules/brackets-manager/test/general.test.ts
+++ /dev/null
@@ -1,389 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-import { BracketsManager } from "../manager";
-
-const storage = new InMemoryDatabase();
-const manager = new BracketsManager(storage);
-
-describe("BYE handling", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should propagate BYEs through the brackets", () => {
-		manager.create({
-			name: "Example with BYEs",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, null, null, null],
-			settings: { seedOrdering: ["natural"], grandFinal: "simple" },
-		});
-
-		expect(storage.select<any>("match", 2).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 2).opponent2).toBe(null);
-
-		expect(storage.select<any>("match", 3).opponent1).toBe(null);
-		expect(storage.select<any>("match", 3).opponent2).toBe(null);
-
-		expect(storage.select<any>("match", 4).opponent1).toBe(null);
-		expect(storage.select<any>("match", 4).opponent2).toBe(null);
-
-		expect(storage.select<any>("match", 5).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 5).opponent2).toBe(null);
-	});
-
-	test("should handle incomplete seeding during creation", () => {
-		manager.create({
-			name: "Example with BYEs",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2],
-			settings: {
-				seedOrdering: ["natural"],
-				balanceByes: false, // Default value.
-				size: 4,
-			},
-		});
-
-		expect(storage.select<any>("match", 0).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 0).opponent2.id).toBe(2);
-
-		expect(storage.select<any>("match", 1).opponent1).toBe(null);
-		expect(storage.select<any>("match", 1).opponent2).toBe(null);
-	});
-
-	test("should balance BYEs in the seeding", () => {
-		manager.create({
-			name: "Example with BYEs",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2],
-			settings: {
-				seedOrdering: ["natural"],
-				balanceByes: true,
-				size: 4,
-			},
-		});
-
-		expect(storage.select<any>("match", 0).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 0).opponent2).toBe(null);
-
-		expect(storage.select<any>("match", 1).opponent1.id).toBe(2);
-		expect(storage.select<any>("match", 1).opponent2).toBe(null);
-	});
-});
-
-describe("Position checks", () => {
-	beforeEach(() => {
-		storage.reset();
-
-		manager.create({
-			name: "Example with double grand final",
-			tournamentId: 0,
-			type: "double_elimination",
-			settings: {
-				size: 8,
-				grandFinal: "simple",
-				seedOrdering: ["natural"],
-			},
-		});
-	});
-
-	test("should not have a position when we don't need the origin of a participant", () => {
-		const matchFromWbRound2 = storage.select<any>("match", 4);
-		expect(matchFromWbRound2.opponent1.position).toBe(undefined);
-		expect(matchFromWbRound2.opponent2.position).toBe(undefined);
-
-		const matchFromLbRound2 = storage.select<any>("match", 9);
-		expect(matchFromLbRound2.opponent2.position).toBe(undefined);
-
-		const matchFromGrandFinal = storage.select<any>("match", 13);
-		expect(matchFromGrandFinal.opponent1.position).toBe(undefined);
-	});
-
-	test("should have a position where we need the origin of a participant", () => {
-		const matchFromWbRound1 = storage.select<any>("match", 0);
-		expect(matchFromWbRound1.opponent1.position).toBe(1);
-		expect(matchFromWbRound1.opponent2.position).toBe(2);
-
-		const matchFromLbRound1 = storage.select<any>("match", 7);
-		expect(matchFromLbRound1.opponent1.position).toBe(1);
-		expect(matchFromLbRound1.opponent2.position).toBe(2);
-
-		const matchFromLbRound2 = storage.select<any>("match", 9);
-		expect(matchFromLbRound2.opponent1.position).toBe(2);
-
-		const matchFromGrandFinal = storage.select<any>("match", 13);
-		expect(matchFromGrandFinal.opponent2.position).toBe(1);
-	});
-});
-
-describe("Special cases", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should throw if the name of the stage is not provided", () => {
-		expect(() =>
-			// @ts-expect-error testing throwing
-			manager.create({
-				tournamentId: 0,
-				type: "single_elimination",
-			}),
-		).toThrow("You must provide a name for the stage.");
-	});
-
-	test("should throw if the tournament id of the stage is not provided", () => {
-		expect(() =>
-			// @ts-expect-error testing throwing
-			manager.create({
-				name: "Example",
-				type: "single_elimination",
-			}),
-		).toThrow("You must provide a tournament id for the stage.");
-	});
-
-	test("should throw if the participant count of a stage is not a power of two", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "single_elimination",
-				seeding: [1, 2, 3, 4, 5, 6, 7],
-			}),
-		).toThrow(
-			"The library only supports a participant count which is a power of two.",
-		);
-
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "single_elimination",
-				settings: { size: 3 },
-			}),
-		).toThrow(
-			"The library only supports a participant count which is a power of two.",
-		);
-	});
-
-	test("should throw if the participant count of a stage is less than two", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "single_elimination",
-				settings: { size: 0 },
-			}),
-		).toThrow(
-			"Impossible to create an empty stage. If you want an empty seeding, just set the size of the stage.",
-		);
-
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "single_elimination",
-				settings: { size: 1 },
-			}),
-		).toThrow("Impossible to create a stage with less than 2 participants.");
-	});
-});
-
-describe("Seeding and ordering in elimination", () => {
-	beforeEach(() => {
-		storage.reset();
-
-		manager.create({
-			name: "Amateur",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: {
-				seedOrdering: [
-					"inner_outer",
-					"reverse",
-					"pair_flip",
-					"half_shift",
-					"reverse",
-				],
-			},
-		});
-	});
-
-	test("should have the good orderings everywhere", () => {
-		const firstRoundMatchWB = storage.select<any>("match", 0);
-		expect(firstRoundMatchWB.opponent1.position).toBe(1);
-		expect(firstRoundMatchWB.opponent2.position).toBe(16);
-
-		const firstRoundMatchLB = storage.select<any>("match", 15);
-		expect(firstRoundMatchLB.opponent1.position).toBe(8);
-		expect(firstRoundMatchLB.opponent2.position).toBe(7);
-
-		const secondRoundMatchLB = storage.select<any>("match", 19);
-		expect(secondRoundMatchLB.opponent1.position).toBe(2);
-
-		const secondRoundSecondMatchLB = storage.select<any>("match", 20);
-		expect(secondRoundSecondMatchLB.opponent1.position).toBe(1);
-
-		const fourthRoundMatchLB = storage.select<any>("match", 25);
-		expect(fourthRoundMatchLB.opponent1.position).toBe(2);
-
-		const finalRoundMatchLB = storage.select<any>("match", 28);
-		expect(finalRoundMatchLB.opponent1.position).toBe(1);
-	});
-});
-
-describe("Reset match and match games", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should reset results of a match", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2],
-			settings: {
-				seedOrdering: ["natural"],
-				size: 8,
-			},
-		});
-
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		let match = storage.select<any>("match", 0);
-		expect(match.opponent1.score).toBe(16);
-		expect(match.opponent2.score).toBe(12);
-		expect(match.opponent1.result).toBe("win");
-
-		let semi1 = storage.select<any>("match", 4);
-		expect(semi1.opponent1.result).toBe("win");
-		expect(semi1.opponent2).toBe(null);
-
-		let final = storage.select<any>("match", 6);
-		expect(final.opponent1.result).toBe("win");
-		expect(final.opponent2).toBe(null);
-
-		manager.reset.matchResults(0); // Score stays as is.
-
-		match = storage.select<any>("match", 0);
-		expect(match.opponent1.score).toBe(16);
-		expect(match.opponent2.score).toBe(12);
-		expect(match.opponent1.result).toBe(undefined);
-
-		semi1 = storage.select<any>("match", 4);
-		expect(semi1.opponent1.result).toBe(undefined);
-		expect(semi1.opponent2).toBe(null);
-
-		final = storage.select<any>("match", 6);
-		expect(final.opponent1.result).toBe(undefined);
-		expect(final.opponent2).toBe(null);
-	});
-
-	test("should throw when at least one of the following match is locked", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: {
-				seedOrdering: ["natural"],
-			},
-		});
-
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 2,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		expect(() => manager.reset.matchResults(0)).toThrow("The match is locked.");
-	});
-});
-
-describe("Import / export", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should import data in the storage", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: {
-				seedOrdering: ["natural"],
-			},
-		});
-
-		const initialData = manager.get.stageData(0);
-
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 2,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		expect(storage.select<any>("match", 0).opponent1.result).toBe("win");
-		expect(storage.select<any>("match", 1).opponent1.result).toBe("win");
-
-		manager.importData(initialData);
-
-		expect(storage.select<any>("match", 0).opponent1.result).toBe(undefined);
-		expect(storage.select<any>("match", 1).opponent1.result).toBe(undefined);
-	});
-
-	test("should export data from the storage", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: {
-				seedOrdering: ["natural"],
-			},
-		});
-
-		const data = manager.export();
-
-		for (const key of ["stage", "group", "round", "match"]) {
-			expect(Object.keys(data).includes(key)).toBe(true);
-		}
-
-		expect(storage.select<any>("stage")).toEqual(data.stage);
-		expect(storage.select<any>("group")).toEqual(data.group);
-		expect(storage.select<any>("round")).toEqual(data.round);
-		expect(storage.select<any>("match")).toEqual(data.match);
-	});
-});
diff --git a/app/modules/brackets-manager/test/round-robin.test.ts b/app/modules/brackets-manager/test/round-robin.test.ts
deleted file mode 100644
index 981424570..000000000
--- a/app/modules/brackets-manager/test/round-robin.test.ts
+++ /dev/null
@@ -1,511 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-import { BracketsManager } from "../manager";
-
-const storage = new InMemoryDatabase();
-const manager = new BracketsManager(storage);
-
-describe("Create a round-robin stage", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should create a round-robin stage", () => {
-		const example = {
-			name: "Example",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: { groupCount: 2 },
-		} as any;
-
-		manager.create(example);
-
-		const stage = storage.select<any>("stage", 0)!;
-		expect(stage.name).toBe(example.name);
-		expect(stage.type).toBe(example.type);
-
-		expect(storage.select("group")!.length).toBe(2);
-		expect(storage.select("round")!.length).toBe(6);
-		expect(storage.select("match")!.length).toBe(12);
-	});
-
-	test("should create a round-robin stage with a manual seeding", () => {
-		const example = {
-			name: "Example",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: {
-				groupCount: 2,
-				manualOrdering: [
-					[1, 4, 6, 7],
-					[2, 3, 5, 8],
-				],
-			},
-		} as any;
-
-		manager.create(example);
-
-		for (let groupIndex = 0; groupIndex < 2; groupIndex++) {
-			const matches = storage.select<any>("match", { group_id: groupIndex })!;
-			const participants = [
-				matches[0].opponent1.position,
-				matches[1].opponent2.position,
-				matches[1].opponent1.position,
-				matches[0].opponent2.position,
-			];
-
-			expect(participants).toEqual(example.settings.manualOrdering[groupIndex]);
-		}
-	});
-
-	test("should throw if manual ordering has invalid counts", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "round_robin",
-				seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-				settings: {
-					groupCount: 2,
-					manualOrdering: [[1, 4, 6, 7]],
-				},
-			}),
-		).toThrow(
-			"Group count in the manual ordering does not correspond to the given group count.",
-		);
-
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "round_robin",
-				seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-				settings: {
-					groupCount: 2,
-					manualOrdering: [
-						[1, 4],
-						[2, 3],
-					],
-				},
-			}),
-		).toThrow("Not enough seeds in at least one group of the manual ordering.");
-	});
-
-	test("should drop empty slots instead of creating BYE matches", () => {
-		const example = {
-			name: "Example",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4, 5, null, null, null],
-			settings: { groupCount: 2 },
-		} as any;
-
-		manager.create(example);
-
-		// 5 teams in 2 groups -> groups of 3 and 2 with no BYE matches at all.
-		const matches = storage.select<any>("match")!;
-		expect(matches.length).toBe(4);
-		for (const match of matches) {
-			expect(match.opponent1?.id).not.toBeNull();
-			expect(match.opponent2?.id).not.toBeNull();
-		}
-	});
-
-	test("should not pad a short group with empty rounds when teams divide unevenly", () => {
-		// 5 teams in 2 groups -> groups of 3 and 2. The 2-team group must be a
-		// clean single-round single-match group, not padded with BYE-only rounds
-		// that strand the real match in a later round.
-		manager.create({
-			name: "Uneven groups",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4, 5],
-			settings: { groupCount: 2, seedOrdering: ["groups.seed_optimized"] },
-		} as any);
-
-		const isRealMatch = (match: any) =>
-			match.opponent1?.id != null && match.opponent2?.id != null;
-
-		const shortGroup = storage.select<any>("group")!.find((group: any) => {
-			const matches = storage.select<any>("match", { group_id: group.id })!;
-			return matches.filter(isRealMatch).length === 1;
-		})!;
-
-		const rounds = storage.select<any>("round", {
-			group_id: shortGroup.id,
-		})!;
-		const matches = storage.select<any>("match", {
-			group_id: shortGroup.id,
-		})!;
-		const realMatch = matches.find(isRealMatch)!;
-		const realMatchRound = rounds.find(
-			(round: any) => round.id === realMatch.round_id,
-		)!;
-
-		// No BYE matches and no empty rounds, just the single match in round 1.
-		expect(matches.length).toBe(1);
-		expect(rounds.length).toBe(1);
-		expect(realMatchRound.number).toBe(1);
-	});
-
-	test("should create a round-robin stage with to be determined participants", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "round_robin",
-			settings: {
-				groupCount: 4,
-				size: 16,
-			},
-		});
-
-		expect(storage.select("group")!.length).toBe(4);
-		expect(storage.select("round")!.length).toBe(4 * 3);
-		expect(storage.select("match")!.length).toBe(4 * 3 * 2);
-	});
-
-	test("should create a round-robin stage with effort balanced", () => {
-		manager.create({
-			name: "Example with effort balanced",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: {
-				groupCount: 2,
-				seedOrdering: ["groups.seed_optimized"],
-			},
-		});
-
-		expect(storage.select<any>("match", 0).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 0).opponent2.id).toBe(8);
-	});
-
-	test("should throw if no group count given", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "round_robin",
-			}),
-		).toThrow("You must specify a group count for round-robin stages.");
-	});
-
-	test("should throw if the group count is not strictly positive", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "round_robin",
-				settings: {
-					groupCount: 0,
-					size: 4,
-					seedOrdering: ["groups.seed_optimized"],
-				},
-			}),
-		).toThrow("You must provide a strictly positive group count.");
-	});
-
-	test("creates an A/B divisions round-robin where every A team plays every B team once", () => {
-		const seeding = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
-		// alternate A (0) / B (1) so that seed order 1..12 gives A=[1,3,5,7,9,11], B=[2,4,6,8,10,12]
-		const abDivisions = seeding.map((_, i) => (i % 2 === 0 ? 0 : 1));
-
-		manager.create({
-			name: "AB Example",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding,
-			abDivisions: abDivisions as (0 | 1)[],
-			settings: {
-				groupCount: 1,
-				hasAbDivisions: true,
-				seedOrdering: ["groups.seed_optimized"],
-			},
-		});
-
-		expect(storage.select("group")!.length).toBe(1);
-		expect(storage.select("round")!.length).toBe(6);
-		expect(storage.select("match")!.length).toBe(36);
-
-		const divisionAIds = new Set([1, 3, 5, 7, 9, 11]);
-		const divisionBIds = new Set([2, 4, 6, 8, 10, 12]);
-		const pairings = new Set<string>();
-
-		for (const match of storage.select<any>("match")!) {
-			const aId: number = match.opponent1.id;
-			const bId: number = match.opponent2.id;
-
-			expect(divisionAIds.has(aId)).toBe(true);
-			expect(divisionBIds.has(bId)).toBe(true);
-
-			const key = `${aId}-${bId}`;
-			expect(pairings.has(key)).toBe(false);
-			pairings.add(key);
-		}
-
-		expect(pairings.size).toBe(36);
-	});
-
-	test("throws when A/B divisions are requested but abDivisions is missing", () => {
-		expect(() =>
-			manager.create({
-				name: "Missing AB",
-				tournamentId: 0,
-				type: "round_robin",
-				seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-				settings: {
-					groupCount: 1,
-					hasAbDivisions: true,
-				},
-			}),
-		).toThrow("abDivisions must be provided when hasAbDivisions is enabled.");
-	});
-
-	test("creates an A/B divisions round-robin with uneven (±1) divisions and a single group", () => {
-		const seeding = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-		manager.create({
-			name: "Uneven AB",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding,
-			abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
-			settings: {
-				groupCount: 1,
-				hasAbDivisions: true,
-				seedOrdering: ["groups.seed_optimized"],
-			},
-		});
-
-		expect(storage.select("group")!.length).toBe(1);
-		expect(storage.select("round")!.length).toBe(6);
-		expect(storage.select("match")!.length).toBe(30);
-	});
-
-	test("throws when A/B divisions are uneven with multiple groups", () => {
-		expect(() =>
-			manager.create({
-				name: "Uneven AB multi-group",
-				tournamentId: 0,
-				type: "round_robin",
-				seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-				abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
-				settings: {
-					groupCount: 2,
-					hasAbDivisions: true,
-				},
-			}),
-		).toThrow("Uneven A/B divisions are only supported with a single group.");
-	});
-});
-
-describe("Update scores in a round-robin stage", () => {
-	beforeEach(() => {
-		storage.reset();
-		manager.create({
-			name: "Example scores",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4],
-			settings: { groupCount: 1 },
-		});
-	});
-
-	describe("Example use-case", () => {
-		beforeEach(() => {
-			storage.reset();
-			manager.create({
-				name: "Example scores",
-				tournamentId: 0,
-				type: "round_robin",
-				seeding: [1, 2, 3, 4],
-				settings: { groupCount: 1 },
-			});
-		});
-
-		test("should set all the scores", () => {
-			manager.update.match({
-				id: 0,
-				opponent1: { score: 16, result: "win" }, // POCEBLO
-				opponent2: { score: 9 }, // AQUELLEHEURE?!
-			});
-
-			manager.update.match({
-				id: 1,
-				opponent1: { score: 3 }, // Ballec Squad
-				opponent2: { score: 16, result: "win" }, // twitch.tv/mrs_fly
-			});
-
-			manager.update.match({
-				id: 2,
-				opponent1: { score: 16, result: "win" }, // twitch.tv/mrs_fly
-				opponent2: { score: 0 }, // AQUELLEHEURE?!
-			});
-
-			manager.update.match({
-				id: 3,
-				opponent1: { score: 16, result: "win" }, // POCEBLO
-				opponent2: { score: 2 }, // Ballec Squad
-			});
-
-			manager.update.match({
-				id: 4,
-				opponent1: { score: 16, result: "win" }, // Ballec Squad
-				opponent2: { score: 12 }, // AQUELLEHEURE?!
-			});
-
-			manager.update.match({
-				id: 5,
-				opponent1: { score: 4 }, // twitch.tv/mrs_fly
-				opponent2: { score: 16, result: "win" }, // POCEBLO
-			});
-		});
-	});
-
-	test("should unlock next round matches as soon as both participants are ready", () => {
-		// Round robin with 4 teams: [1, 2, 3, 4]
-		// Round 1: Match 0 (1 vs 2), Match 1 (3 vs 4)
-		// Round 2: Match 2 (1 vs 3), Match 3 (2 vs 4)
-		// Round 3: Match 4 (1 vs 4), Match 5 (2 vs 3)
-
-		const round1Match1 = storage.select<any>("match", 0)!;
-		const round1Match2 = storage.select<any>("match", 1)!;
-		const round2Match1 = storage.select<any>("match", 2)!;
-		const round2Match2 = storage.select<any>("match", 3)!;
-
-		// Initially, only round 1 matches should be ready
-		expect(round1Match1.status).toBe(2); // Ready (1 vs 2)
-		expect(round1Match2.status).toBe(2); // Ready (3 vs 4)
-		expect(round2Match1.status).toBe(0); // Locked (1 vs 3)
-		expect(round2Match2.status).toBe(0); // Locked (2 vs 4)
-
-		// Complete first match of round 1 (1 vs 2)
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 16, result: "win" }, // Team 1 wins
-			opponent2: { score: 9 }, // Team 2 loses
-		});
-
-		// Round 2 Match 1 (1 vs 3) should still be locked because team 3 hasn't finished
-		// Round 2 Match 2 (2 vs 4) should still be locked because team 4 hasn't finished
-		let round2Match1After = storage.select<any>("match", 2)!;
-		let round2Match2After = storage.select<any>("match", 3)!;
-		expect(round2Match1After.status).toBe(0); // Still Locked
-		expect(round2Match2After.status).toBe(0); // Still Locked
-
-		// Complete second match of round 1 (3 vs 4)
-		manager.update.match({
-			id: 1,
-			opponent1: { score: 3 }, // Team 3 loses
-			opponent2: { score: 16, result: "win" }, // Team 4 wins
-		});
-
-		// Now both matches in round 2 should be unlocked
-		// Match 2 (1 vs 3): both team 1 and team 3 have finished round 1
-		// Match 3 (2 vs 4): both team 2 and team 4 have finished round 1
-		round2Match1After = storage.select<any>("match", 2)!;
-		round2Match2After = storage.select<any>("match", 3)!;
-		expect(round2Match1After.status).toBe(2); // Ready
-		expect(round2Match2After.status).toBe(2); // Ready
-	});
-
-	test("should leave every match Ready when independentRounds is set", () => {
-		storage.reset();
-		manager.create({
-			name: "Independent rounds",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3, 4],
-			settings: { groupCount: 1, independentRounds: true },
-		});
-
-		const matches = storage.select<any>("match")!;
-		for (const match of matches) {
-			expect(match.status).toBe(2);
-		}
-
-		// reporting a round-2 match before round-1 finishes must not throw
-		const round2Match = storage.select<any>("match", 2)!;
-		expect(() =>
-			manager.update.match({
-				id: round2Match.id,
-				opponent1: { score: 16, result: "win" },
-				opponent2: { score: 4 },
-			}),
-		).not.toThrow();
-	});
-
-	test("should let the only real match be played in a group with fewer teams than slots", () => {
-		storage.reset();
-		// Group sized for 3 but only 2 teams placed (the 3rd slot is a BYE).
-		// The two real teams only meet in round 3, preceded by two BYE rounds
-		// that can never be reported. The real match must still be playable.
-		manager.create({
-			name: "Two teams in a three-slot group",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, null],
-			settings: { groupCount: 1 },
-		} as any);
-
-		const realMatch = storage
-			.select<any>("match")!
-			.find((m: any) => m.opponent1?.id && m.opponent2?.id)!;
-
-		expect(realMatch.status).toBe(2); // Ready
-
-		expect(() =>
-			manager.update.match({
-				id: realMatch.id,
-				opponent1: { score: 16, result: "win" },
-				opponent2: { score: 9 },
-			}),
-		).not.toThrow();
-	});
-
-	test("should unlock next round matches with BYE participants", () => {
-		storage.reset();
-		// Create a round robin with 3 teams (odd number creates rounds where one team doesn't play)
-		manager.create({
-			name: "Example with BYEs",
-			tournamentId: 0,
-			type: "round_robin",
-			seeding: [1, 2, 3],
-			settings: { groupCount: 1 },
-		});
-
-		// With 3 teams, the rounds look like:
-		// Round 1: Match (teams 3 vs 2) - Team 1 doesn't play
-		// Round 2: Match (teams 1 vs 3) - Team 2 doesn't play
-		// Round 3: Match (teams 2 vs 1) - Team 3 doesn't play
-
-		const allMatches = storage.select<any>("match")!;
-		const allRounds = storage.select<any>("round")!;
-
-		// Find the actual match (not BYE vs BYE which doesn't exist)
-		const round1RealMatch = allMatches.find(
-			(m: any) => m.round_id === allRounds[0].id && m.opponent1 && m.opponent2,
-		)!;
-		const round2RealMatch = allMatches.find(
-			(m: any) => m.round_id === allRounds[1].id && m.opponent1 && m.opponent2,
-		)!;
-
-		expect(round1RealMatch.status).toBe(2); // Ready
-		expect(round2RealMatch.status).toBe(0); // Locked initially
-
-		// Complete the only real match in round 1 (teams 3 vs 2)
-		// Team 1 didn't play in round 1
-		manager.update.match({
-			id: round1RealMatch.id,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 9 },
-		});
-
-		// The real match in round 2 (teams 1 vs 3) should now be unlocked
-		// because team 1 didn't play in round 1 (considered ready)
-		// and team 3 just finished their match
-		const round2AfterUpdate = storage.select<any>("match", round2RealMatch.id)!;
-		expect(round2AfterUpdate.status).toBe(2); // Ready
-	});
-});
diff --git a/app/modules/brackets-manager/test/single-elimination.test.ts b/app/modules/brackets-manager/test/single-elimination.test.ts
deleted file mode 100644
index 5ee96a1e9..000000000
--- a/app/modules/brackets-manager/test/single-elimination.test.ts
+++ /dev/null
@@ -1,234 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { TournamentMatchStatus } from "~/db/tables";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-import { BracketsManager } from "../manager";
-
-const storage = new InMemoryDatabase();
-const manager = new BracketsManager(storage);
-
-describe("Create single elimination stage", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should create a single elimination stage", () => {
-		const example = {
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-			settings: { seedOrdering: ["natural"] },
-		} as any;
-
-		manager.create(example);
-
-		const stage = storage.select<any>("stage", 0);
-		expect(stage.name).toBe(example.name);
-		expect(stage.type).toBe(example.type);
-
-		expect(storage.select<any>("group")!.length).toBe(1);
-		expect(storage.select<any>("round")!.length).toBe(4);
-		expect(storage.select<any>("match")!.length).toBe(15);
-	});
-
-	test("should create a single elimination stage with BYEs", () => {
-		manager.create({
-			name: "Example with BYEs",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, null, 3, 4, null, null, 7, 8],
-			settings: { seedOrdering: ["natural"] },
-		});
-
-		expect(storage.select<any>("match", 4).opponent1.id).toBe(1);
-		expect(storage.select<any>("match", 4).opponent2.id).toBe(null);
-		expect(storage.select<any>("match", 5).opponent1).toBe(null);
-		expect(storage.select<any>("match", 5).opponent2.id).toBe(null);
-	});
-
-	test("should create a single elimination stage with consolation final", () => {
-		manager.create({
-			name: "Example with consolation final",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: { consolationFinal: true, seedOrdering: ["natural"] },
-		});
-
-		expect(storage.select<any>("group")!.length).toBe(2);
-		expect(storage.select<any>("round")!.length).toBe(4);
-		expect(storage.select<any>("match")!.length).toBe(8);
-	});
-
-	test("should create a single elimination stage with consolation final and BYEs", () => {
-		manager.create({
-			name: "Example with consolation final and BYEs",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [null, null, null, 4, 5, 6, 7, 8],
-			settings: { consolationFinal: true, seedOrdering: ["natural"] },
-		});
-
-		expect(storage.select<any>("match", 4).opponent1).toBe(null);
-		expect(storage.select<any>("match", 4).opponent2.id).toBe(4);
-
-		// Consolation final
-		expect(storage.select<any>("match", 7).opponent1).toBe(null);
-		expect(storage.select<any>("match", 7).opponent2.id).toBe(null);
-	});
-
-	test("should create a single elimination stage with Bo3 matches", () => {
-		manager.create({
-			name: "Example with Bo3 matches",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4, 5, 6, 7, 8],
-			settings: { seedOrdering: ["natural"] },
-		});
-
-		expect(storage.select<any>("group")!.length).toBe(1);
-		expect(storage.select<any>("round")!.length).toBe(3);
-		expect(storage.select<any>("match")!.length).toBe(7);
-	});
-
-	test("should throw if the given number property already exists", () => {
-		manager.create({
-			name: "Stage 1",
-			tournamentId: 0,
-			type: "single_elimination",
-			number: 1,
-			settings: { size: 2 },
-		});
-
-		expect(() =>
-			manager.create({
-				name: "Stage 1",
-				tournamentId: 0,
-				type: "single_elimination",
-				number: 1, // Duplicate
-				settings: { size: 2 },
-			}),
-		).toThrow("The given stage number already exists.");
-	});
-
-	test("should throw if the seeding has duplicate participants", () => {
-		expect(() =>
-			manager.create({
-				name: "Example",
-				tournamentId: 0,
-				type: "single_elimination",
-				seeding: [
-					1,
-					1, // Duplicate
-					3,
-					4,
-				],
-			}),
-		).toThrow("The seeding has a duplicate participant.");
-	});
-});
-
-describe("Previous and next match update", () => {
-	beforeEach(() => {
-		storage.reset();
-	});
-
-	test("should determine matches in consolation final", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: { consolationFinal: true },
-		});
-
-		manager.update.match({
-			id: 0, // First match of round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1, // Second match of round 1
-			opponent1: { score: 13 },
-			opponent2: { score: 16, result: "win" },
-		});
-
-		expect(storage.select<any>("match", 3).opponent1.id).toBe(
-			storage.select<any>("match", 0).opponent2.id,
-		);
-		expect(storage.select<any>("match", 3).opponent2.id).toBe(
-			storage.select<any>("match", 1).opponent1.id,
-		);
-		expect(storage.select<any>("match", 2).status).toBe(
-			TournamentMatchStatus.Ready,
-		);
-		expect(storage.select<any>("match", 3).status).toBe(
-			TournamentMatchStatus.Ready,
-		);
-	});
-
-	test("should play both the final and consolation final in parallel", () => {
-		manager.create({
-			name: "Example",
-			tournamentId: 0,
-			type: "single_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: { consolationFinal: true },
-		});
-
-		manager.update.match({
-			id: 0, // First match of round 1
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12 },
-		});
-
-		manager.update.match({
-			id: 1, // Second match of round 1
-			opponent1: { score: 13 },
-			opponent2: { score: 16, result: "win" },
-		});
-
-		manager.update.match({
-			id: 2, // Final
-			opponent1: { score: 12 },
-			opponent2: { score: 9 },
-		});
-
-		expect(storage.select<any>("match", 2).status).toBe(
-			TournamentMatchStatus.Running,
-		);
-		expect(storage.select<any>("match", 3).status).toBe(
-			TournamentMatchStatus.Ready,
-		);
-
-		manager.update.match({
-			id: 3, // Consolation final
-			opponent1: { score: 12 },
-			opponent2: { score: 9 },
-		});
-
-		expect(storage.select<any>("match", 2).status).toBe(
-			TournamentMatchStatus.Running,
-		);
-		expect(storage.select<any>("match", 3).status).toBe(
-			TournamentMatchStatus.Running,
-		);
-
-		manager.update.match({
-			id: 3, // Consolation final
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 9 },
-		});
-
-		expect(storage.select<any>("match", 2).status).toBe(
-			TournamentMatchStatus.Running,
-		);
-
-		manager.update.match({
-			id: 2, // Final
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 9 },
-		});
-	});
-});
diff --git a/app/modules/brackets-manager/test/update.test.ts b/app/modules/brackets-manager/test/update.test.ts
deleted file mode 100644
index 5dce89d92..000000000
--- a/app/modules/brackets-manager/test/update.test.ts
+++ /dev/null
@@ -1,289 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { TournamentMatchStatus } from "~/db/tables";
-import { InMemoryDatabase } from "~/modules/brackets-memory-db";
-import { BracketsManager } from "../manager";
-
-const storage = new InMemoryDatabase();
-const manager = new BracketsManager(storage);
-
-const example = {
-	name: "Amateur",
-	tournamentId: 0,
-	type: "double_elimination",
-	seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-	settings: { seedOrdering: ["natural"] },
-} as any;
-
-describe("Update matches", () => {
-	beforeEach(() => {
-		storage.reset();
-		manager.create(example);
-	});
-
-	test("should start a match", () => {
-		const before = storage.select<any>("match", 0);
-		expect(before.status).toBe(TournamentMatchStatus.Ready);
-
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 0 },
-			opponent2: { score: 0 },
-		});
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Running);
-	});
-
-	test("should update the scores for a match and set it to running", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 2 },
-			opponent2: { score: 1 },
-		});
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Running);
-		expect(after.opponent1.score).toBe(2);
-
-		// Name should stay. It shouldn't be overwritten.
-		expect(after.opponent1.id).toBe(1);
-	});
-
-	test("should end the match by only setting the winner", () => {
-		const before = storage.select<any>("match", 0);
-		expect(before.opponent1.result).toBeFalsy();
-
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" },
-		});
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Completed);
-		expect(after.opponent1.result).toBe("win");
-		expect(after.opponent2.result).toBe("loss");
-	});
-
-	test("should change the winner of the match and update in the next match", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" },
-		});
-
-		expect(storage.select<any>("match", 8).opponent1.id).toBe(1);
-
-		manager.update.match({
-			id: 0,
-			opponent2: { result: "win" },
-		});
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Completed);
-		expect(after.opponent1.result).toBe("loss");
-		expect(after.opponent2.result).toBe("win");
-
-		const nextMatch = storage.select<any>("match", 8);
-		expect(nextMatch.status).toBe(TournamentMatchStatus.Waiting);
-		expect(nextMatch.opponent1.id).toBe(2);
-	});
-
-	test("should update the status of the next match", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" },
-		});
-
-		expect(storage.select<any>("match", 8).status).toBe(
-			TournamentMatchStatus.Waiting,
-		);
-
-		manager.update.match({
-			id: 1,
-			opponent1: { result: "win" },
-		});
-
-		expect(storage.select<any>("match", 8).status).toBe(
-			TournamentMatchStatus.Ready,
-		);
-	});
-
-	test("should end the match by setting winner and loser", () => {
-		manager.update.match({
-			id: 0,
-			status: TournamentMatchStatus.Running,
-		});
-
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" },
-			opponent2: { result: "loss" },
-		});
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Completed);
-		expect(after.opponent1.result).toBe("win");
-		expect(after.opponent2.result).toBe("loss");
-	});
-
-	test("should remove results from a match without score", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: { result: "win" },
-			opponent2: { result: "loss" },
-		});
-
-		manager.reset.matchResults(0);
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Ready);
-		expect(after.opponent1.result).toBeFalsy();
-		expect(after.opponent2.result).toBeFalsy();
-	});
-
-	test("should remove results from a match with score", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: { score: 16, result: "win" },
-			opponent2: { score: 12, result: "loss" },
-		});
-
-		manager.reset.matchResults(0);
-
-		const after = storage.select<any>("match", 0);
-		expect(after.status).toBe(TournamentMatchStatus.Running);
-		expect(after.opponent1.result).toBeFalsy();
-		expect(after.opponent2.result).toBeFalsy();
-	});
-
-	test("should not set the other score to 0 if only one given", () => {
-		// It shouldn't be our decision to set the other score to 0.
-
-		manager.update.match({
-			id: 1,
-			opponent1: { score: 1 },
-		});
-
-		const after = storage.select<any>("match", 1);
-		expect(after.status).toBe(TournamentMatchStatus.Running);
-		expect(after.opponent1.score).toBe(1);
-		expect(after.opponent2.score).toBeFalsy();
-	});
-
-	test("should end the match by setting the winner and the scores", () => {
-		manager.update.match({
-			id: 1,
-			opponent1: { score: 6 },
-			opponent2: { result: "win", score: 3 },
-		});
-
-		const after = storage.select<any>("match", 1);
-		expect(after.status).toBe(TournamentMatchStatus.Completed);
-
-		expect(after.opponent1.result).toBe("loss");
-		expect(after.opponent1.score).toBe(6);
-
-		expect(after.opponent2.result).toBe("win");
-		expect(after.opponent2.score).toBe(3);
-	});
-
-	test("should throw if two winners", () => {
-		expect(() =>
-			manager.update.match({
-				id: 3,
-				opponent1: { result: "win" },
-				opponent2: { result: "win" },
-			}),
-		).toThrow("There are two winners.");
-
-		expect(() =>
-			manager.update.match({
-				id: 3,
-				opponent1: { result: "loss" },
-				opponent2: { result: "loss" },
-			}),
-		).toThrow("There are two losers.");
-	});
-});
-
-describe("Give opponent IDs when updating", () => {
-	beforeEach(() => {
-		storage.reset();
-
-		manager.create({
-			name: "Amateur",
-			tournamentId: 0,
-			type: "double_elimination",
-			seeding: [1, 2, 3, 4],
-			settings: { seedOrdering: ["natural"] },
-		});
-	});
-
-	test("should update the right opponents based on their IDs", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: {
-				id: 2,
-				score: 10,
-			},
-			opponent2: {
-				id: 1,
-				score: 5,
-			},
-		});
-
-		// Actual results must be inverted.
-		const after = storage.select<any>("match", 0);
-		expect(after.opponent1.score).toBe(5);
-		expect(after.opponent2.score).toBe(10);
-	});
-
-	test("should update the right opponent based on its ID, the other one is the remaining one", () => {
-		manager.update.match({
-			id: 0,
-			opponent1: {
-				id: 2,
-				score: 10,
-			},
-		});
-
-		// Actual results must be inverted.
-		const after = storage.select<any>("match", 0);
-		expect(after.opponent1.score).toBeFalsy();
-		expect(after.opponent2.score).toBe(10);
-	});
-
-	test("should throw when the given opponent ID does not exist in the match", () => {
-		expect(() =>
-			manager.update.match({
-				id: 0,
-				opponent1: {
-					id: 3, // Belongs to match id 1.
-					score: 10,
-				},
-			}),
-		).toThrow(/The given opponent[12] ID does not exist in this match./);
-	});
-});
-
-describe("Locked matches", () => {
-	beforeEach(() => {
-		storage.reset();
-		manager.create(example);
-	});
-
-	test("should throw when the matches leading to the match have not been completed yet", () => {
-		manager.update.match({ id: 0 }); // No problem when no previous match.
-		expect(() => manager.update.match({ id: 8 })).toThrow(
-			"The match is locked.",
-		); // First match of WB Round 2.
-		expect(() => manager.update.match({ id: 15 })).toThrow(
-			"The match is locked.",
-		); // First match of LB Round 1.
-		expect(() => manager.update.match({ id: 19 })).toThrow(
-			"The match is locked.",
-		); // First match of LB Round 1.
-		expect(() => manager.update.match({ id: 23 })).toThrow(
-			"The match is locked.",
-		); // First match of LB Round 3.
-	});
-});
diff --git a/app/modules/brackets-manager/types.ts b/app/modules/brackets-manager/types.ts
deleted file mode 100644
index 39ced56ba..000000000
--- a/app/modules/brackets-manager/types.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-import type {
-	Group,
-	Match,
-	Round,
-	SeedOrdering,
-	Stage,
-} from "~/modules/brackets-model";
-
-/**
- * Type of an object implementing every ordering method.
- */
-export type OrderingMap = Record<
-	SeedOrdering,
-	<T>(array: T[], ...args: number[]) => T[]
->;
-
-/**
- * Omits the `id` property of a type.
- */
-export type OmitId<T> = Omit<T, "id">;
-
-/**
- * Defines a T which can be null.
- */
-export type Nullable<T> = T | null;
-
-/**
- * An object which maps an ID to another ID.
- */
-export type IdMapping = Record<number, number>;
-
-/**
- * Used by the library to handle placements. Is `null` if is a BYE. Has a `null` name if it's yet to be determined.
- */
-export type ParticipantSlot = { id: number | null; position?: number } | null;
-
-/**
- * The library only handles duels. It's one participant versus another participant.
- */
-export type Duel = [ParticipantSlot, ParticipantSlot];
-
-/**
- * The side of an opponent.
- */
-export type Side = "opponent1" | "opponent2";
-
-/**
- * Positional information about a round.
- */
-export type RoundPositionalInfo = {
-	roundNumber: number;
-	roundCount: number;
-};
-
-/**
- * The result of an array which was split by parity.
- */
-export interface ParitySplit<T> {
-	even: T[];
-	odd: T[];
-}
-
-/**
- * Makes an object type deeply partial.
- */
-export type DeepPartial<T> = T extends object
-	? {
-			[P in keyof T]?: DeepPartial<T[P]>;
-		}
-	: T;
-
-/**
- * Converts all value types to array types.
- */
-export type ValueToArray<T> = {
-	[K in keyof T]: Array<T[K]>;
-};
-
-/**
- * Data type associated to each database table.
- */
-export interface DataTypes {
-	stage: Stage;
-	group: Group;
-	round: Round;
-	match: Match;
-}
-
-/**
- * The types of table in the storage.
- */
-export type Table = keyof DataTypes;
-
-/**
- * Format of the data in a database.
- */
-export type Database = ValueToArray<DataTypes>;
-
-export type TournamentManagerDataSet = Database;
-
-/**
- * Contains the losers and the winner of the bracket.
- */
-export interface StandardBracketResults {
-	/**
-	 * The list of losers for each round of the bracket.
-	 */
-	losers: ParticipantSlot[][];
-
-	/**
-	 * The winner of the bracket.
-	 */
-	winner: ParticipantSlot;
-}
-
-/**
- * This CRUD interface is used by the manager to abstract storage.
- */
-export interface CrudInterface {
-	/**
-	 * Inserts a value in the database and returns its id.
-	 *
-	 * @param table Where to insert.
-	 * @param value What to insert.
-	 */
-	insert<T extends Table>(table: T, value: OmitId<DataTypes[T]>): number;
-
-	/**
-	 * Inserts multiple values in the database.
-	 *
-	 * @param table Where to insert.
-	 * @param values What to insert.
-	 */
-	insert<T extends Table>(table: T, values: OmitId<DataTypes[T]>[]): boolean;
-
-	/**
-	 * Gets all data from a table in the database.
-	 *
-	 * @param table Where to get from.
-	 */
-	select<T extends Table>(table: T): Array<DataTypes[T]> | null;
-
-	/**
-	 * Gets specific data from a table in the database.
-	 *
-	 * @param table Where to get from.
-	 * @param id What to get.
-	 */
-	select<T extends Table>(table: T, id: number): DataTypes[T] | null;
-
-	/**
-	 * Gets data from a table in the database with a filter.
-	 *
-	 * @param table Where to get from.
-	 * @param filter An object to filter data.
-	 */
-	select<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-	): Array<DataTypes[T]> | null;
-
-	/**
-	 * Updates data in a table.
-	 *
-	 * @param table Where to update.
-	 * @param id What to update.
-	 * @param value How to update.
-	 */
-	update<T extends Table>(table: T, id: number, value: DataTypes[T]): boolean;
-
-	/**
-	 * Updates data in a table.
-	 *
-	 * @param table Where to update.
-	 * @param filter An object to filter data.
-	 * @param value How to update.
-	 */
-	update<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-		value: Partial<DataTypes[T]>,
-	): boolean;
-
-	/**
-	 * Empties a table completely.
-	 *
-	 * @param table Where to delete everything.
-	 */
-	delete<T extends Table>(table: T): boolean;
-
-	/**
-	 * Delete data in a table, based on a filter.
-	 *
-	 * @param table Where to delete in.
-	 * @param filter An object to filter data.
-	 */
-	delete<T extends Table>(table: T, filter: Partial<DataTypes[T]>): boolean;
-}
-
-export interface Storage extends CrudInterface {
-	selectFirst<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-	): DataTypes[T] | null;
-	selectLast<T extends Table>(
-		table: T,
-		filter: Partial<DataTypes[T]>,
-	): DataTypes[T] | null;
-}
diff --git a/app/modules/brackets-manager/update.ts b/app/modules/brackets-manager/update.ts
deleted file mode 100644
index 20b661715..000000000
--- a/app/modules/brackets-manager/update.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import type { Match } from "~/modules/brackets-model";
-import { BaseUpdater } from "./base/updater";
-import type { DeepPartial } from "./types";
-
-export class Update extends BaseUpdater {
-	/**
-	 * Updates partial information of a match. Its id must be given.
-	 *
-	 * This will update related matches accordingly.
-	 *
-	 * @param match Values to change in a match.
-	 * @param force If true, bypasses the locked match check.
-	 */
-	public match<M extends Match = Match>(
-		match: DeepPartial<M>,
-		force?: boolean,
-	): void {
-		if (match.id === undefined) throw Error("No match id given.");
-
-		const stored = this.storage.select("match", match.id);
-		if (!stored) throw Error("Match not found.");
-
-		this.updateMatch(stored, match, force);
-	}
-}
diff --git a/app/modules/brackets-memory-db/README.md b/app/modules/brackets-memory-db/README.md
deleted file mode 100644
index 186e43067..000000000
--- a/app/modules/brackets-memory-db/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Taken from https://github.com/Drarig29/brackets-storage
diff --git a/app/modules/brackets-memory-db/index.ts b/app/modules/brackets-memory-db/index.ts
deleted file mode 100644
index d09cc3d96..000000000
--- a/app/modules/brackets-memory-db/index.ts
+++ /dev/null
@@ -1,264 +0,0 @@
-import type {
-	CrudInterface,
-	Database,
-	OmitId,
-	Table,
-} from "~/modules/brackets-manager";
-
-export class InMemoryDatabase implements CrudInterface {
-	protected data: Database = {
-		stage: [],
-		group: [],
-		round: [],
-		match: [],
-	};
-
-	/**
-	 * @param data "import" data from external
-	 */
-	setData(data: Database): void {
-		this.data = data;
-	}
-
-	/**
-	 * @param partial Filter
-	 */
-	makeFilter(partial: any): (entry: any) => boolean {
-		return (entry: any): boolean => {
-			let result = true;
-			for (const key of Object.keys(partial))
-				result = result && entry[key] === partial[key];
-
-			return result;
-		};
-	}
-
-	/**
-	 * Clearing all of the data
-	 */
-	reset(): void {
-		this.data = {
-			stage: [],
-			group: [],
-			round: [],
-			match: [],
-		};
-	}
-
-	insert<T>(table: Table, value: OmitId<T>): number;
-	/**
-	 * Inserts multiple values in the database.
-	 *
-	 * @param table Where to insert.
-	 * @param values What to insert.
-	 */
-	insert<T>(table: Table, values: OmitId<T>[]): boolean;
-
-	/**
-	 * Implementation of insert
-	 *
-	 * @param table Where to insert.
-	 * @param values What to insert.
-	 */
-	insert<T>(table: Table, values: OmitId<T> | OmitId<T>[]): number | boolean {
-		let id =
-			this.data[table].length > 0
-				? Math.max(...this.data[table].map((d) => d.id)) + 1
-				: 0;
-
-		if (!Array.isArray(values)) {
-			try {
-				// @ts-expect-error idc
-				if (values.id) {
-					// @ts-expect-error idc
-					this.data[table][values.id] = values;
-				} else {
-					// @ts-expect-error imported
-					this.data[table].push({ id, ...values });
-				}
-			} catch {
-				return -1;
-			}
-			return id;
-		}
-
-		try {
-			for (const object of values) {
-				// @ts-expect-error idc
-				if (object.id) {
-					// @ts-expect-error idc
-					this.data[table][object.id] = object;
-				} else {
-					// @ts-expect-error imported
-					this.data[table].push({ id: id++, ...object });
-				}
-			}
-		} catch {
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Gets all data from a table in the database.
-	 *
-	 * @param table Where to get from.
-	 */
-	select<T>(table: Table): T[] | null;
-	/**
-	 * Gets specific data from a table in the database.
-	 *
-	 * @param table Where to get from.
-	 * @param id What to get.
-	 */
-	select<T>(table: Table, id: number): T | null;
-	/**
-	 * Gets data from a table in the database with a filter.
-	 *
-	 * @param table Where to get from.
-	 * @param filter An object to filter data.
-	 */
-	select<T>(table: Table, filter: Partial<T>): T[] | null;
-
-	/**
-	 * @param table Where to get from.
-	 * @param arg Arg.
-	 */
-	select<T>(table: Table, arg?: number | Partial<T>): T[] | null {
-		try {
-			if (arg === undefined) {
-				// @ts-expect-error imported
-				return this.data[table].map((val) => structuredClone(val));
-			}
-
-			if (typeof arg === "number") {
-				// @ts-expect-error imported
-				return structuredClone(this.data[table].find((d) => d?.id === arg));
-			}
-
-			// @ts-expect-error imported
-			return this.data[table]
-				.filter(this.makeFilter(arg))
-				.map((val) => structuredClone(val));
-		} catch {
-			return null;
-		}
-	}
-
-	/**
-	 * Updates data in a table.
-	 *
-	 * @param table Where to update.
-	 * @param id What to update.
-	 * @param value How to update.
-	 */
-
-	update<T>(table: Table, id: number, value: T): boolean;
-
-	/**
-	 * Updates data in a table.
-	 *
-	 * @param table Where to update.
-	 * @param filter An object to filter data.
-	 * @param value How to update.
-	 */
-	update<T>(table: Table, filter: Partial<T>, value: Partial<T>): boolean;
-
-	/**
-	 * Updates data in a table.
-	 *
-	 * @param table Where to update.
-	 * @param arg
-	 * @param value How to update.
-	 */
-	update<T>(
-		table: Table,
-		arg: number | Partial<T>,
-		value?: Partial<T>,
-	): boolean {
-		if (typeof arg === "number") {
-			if (
-				this.data[table][arg] &&
-				value &&
-				// @ts-expect-error idc
-				this.data[table][arg].id !== value.id
-			) {
-				throw new Error("ID mismatch.");
-			}
-			try {
-				// @ts-expect-error imported
-				this.data[table][arg] = value;
-				return true;
-			} catch {
-				return false;
-			}
-		}
-
-		const values = this.data[table].filter(this.makeFilter(arg));
-		if (!values) {
-			return false;
-		}
-
-		for (const v of values) {
-			const existing = this.data[table][v.id];
-			for (const key in value) {
-				if (
-					// @ts-expect-error imported
-					existing[key] &&
-					typeof existing[key] === "object" &&
-					typeof value[key] === "object"
-				) {
-					Object.assign(existing[key], value[key]); // For opponent objects, this does a deep merge of level 2.
-				} else {
-					// @ts-expect-error imported
-					existing[key] = value[key]; // Otherwise, do a simple value assignment.
-				}
-			}
-			this.data[table][v.id] = existing;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Empties a table completely.
-	 *
-	 * @param table Where to delete everything.
-	 */
-	delete(table: Table): boolean;
-	/**
-	 * Delete data in a table, based on a filter.
-	 *
-	 * @param table Where to delete in.
-	 * @param filter An object to filter data.
-	 */
-	delete<T>(table: Table, filter: Partial<T>): boolean;
-
-	/**
-	 * Delete data in a table, based on a filter.
-	 *
-	 * @param table Where to delete in.
-	 * @param filter An object to filter data.
-	 */
-	delete<T>(table: Table, filter?: Partial<T>): boolean {
-		const values = this.data[table];
-		if (!values) {
-			return false;
-		}
-
-		if (!filter) {
-			this.data[table] = [];
-
-			return true;
-		}
-
-		const predicate = this.makeFilter(filter);
-		const negativeFilter = (value: any): boolean => !predicate(value);
-
-		// @ts-expect-error imported
-		this.data[table] = values.filter(negativeFilter);
-
-		return true;
-	}
-}
diff --git a/app/modules/brackets-model/index.ts b/app/modules/brackets-model/index.ts
deleted file mode 100644
index 78c2505d4..000000000
--- a/app/modules/brackets-model/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from "./input";
-export * from "./other";
-export * from "./storage";
-export * from "./unions";
diff --git a/app/modules/brackets-model/input.ts b/app/modules/brackets-model/input.ts
deleted file mode 100644
index 205fed8dd..000000000
--- a/app/modules/brackets-model/input.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/*------------------------------------------------------------|
- * Contains everything which is given by the user as input.
- *-----------------------------------------------------------*/
-
-import type {
-	GrandFinalType,
-	RoundRobinMode,
-	SeedOrdering,
-	StageType,
-} from "./unions";
-
-/**
- * The seeding for a stage.
- *
- * Each element represents a participant, which can be:
- * - A full object, with possibly extra fields.
- * - Its name.
- * - Its ID.
- * - Or a BYE: `null`.
- */
-export type Seeding = (number | null)[];
-
-/**
- * Used to create a stage.
- */
-export interface InputStage {
-	/**
-	 * ID of the parent tournament.
-	 *
-	 * Used to determine the `number` property of a stage related to a tournament.
-	 */
-	tournamentId: number;
-
-	/** Name of the stage. */
-	name: string;
-
-	/** Type of stage. */
-	type: StageType;
-
-	/** The number of the stage in its tournament. Is determined if not given. */
-	number?: number;
-
-	/** Contains participants or `null` for BYEs. */
-	seeding?: Seeding;
-
-	/**
-	 * A/B division assignment parallel to `seeding`. `0` = A, `1` = B.
-	 * Required when `settings.hasAbDivisions` is `true`.
-	 */
-	abDivisions?: (0 | 1)[];
-
-	/** Contains optional settings specific to each stage type. */
-	settings?: StageSettings;
-}
-
-/**
- * The possible settings for a stage.
- */
-export interface StageSettings {
-	/**
-	 * The number of participants.
-	 */
-	size?: number;
-
-	/**
-	 * A list of ordering methods to apply to the seeding.
-	 *
-	 * - For a round-robin stage: 1 item required (**with** `"groups."` prefix).
-	 *   - Used to distribute in groups.
-	 * - For a simple elimination stage, 1 item required (**without** `"groups."` prefix).
-	 *   - Used to distribute in round 1.
-	 * - For a double elimination stage, 1 item required, 3+ items supported (**without** `"groups."` prefix).
-	 *   - Item 1 (required) - Used to distribute in WB round 1.
-	 *   - Item 2 - Used to distribute WB losers in LB round 1.
-	 *   - Items 3+ - Used to distribute WB losers in LB minor rounds (1 per round).
-	 */
-	seedOrdering?: SeedOrdering[];
-
-	/**
-	 * Whether to balance BYEs in the seeding of an elimination stage.
-	 *
-	 * This prevents having BYE against BYE in matches.
-	 */
-	balanceByes?: boolean;
-
-	/**
-	 * Number of groups in a round-robin stage.
-	 */
-	groupCount?: number;
-
-	/**
-	 * The mode for the round-robin stage.
-	 *
-	 * - If `simple`, each participant plays each opponent once.
-	 * - If `double`, each participant plays each opponent twice, once at home and once away.
-	 */
-	roundRobinMode?: RoundRobinMode;
-
-	/**
-	 * Whether to generate a bipartite round-robin where teams are split into two
-	 * A/B divisions and every match pairs one A team with one B team.
-	 * Only valid on round-robin stages.
-	 */
-	hasAbDivisions?: boolean;
-
-	/**
-	 * A list of seeds per group for a round-robin stage to be manually ordered.
-	 *
-	 * Seed ordering is ignored if this property is given.
-	 */
-	manualOrdering?: number[][];
-
-	/**
-	 * Whether matches in a round-robin stage are playable independently of each other.
-	 *
-	 * - If `false` (default), only round 1 matches start `Ready`; later rounds start
-	 *   `Locked` and unlock as both opponents complete the previous round.
-	 * - If `true`, every match with two opponents starts `Ready` (used by league
-	 *   formats where weeks are scheduled independently and may be played out of order).
-	 */
-	independentRounds?: boolean;
-
-	/**
-	 * Optional final between semi-final losers.
-	 */
-	consolationFinal?: boolean;
-
-	/**
-	 * Whether to skip the first round of the WB of a double elimination stage.
-	 */
-	skipFirstRound?: boolean;
-
-	/**
-	 * Optional grand final between WB and LB winners.
-	 *
-	 * - If `none`, there is no grand final.
-	 * - If `simple`, the final is a single match. The winner is the winner of the stage.
-	 * - If `double`, if the WB winner wins, he's the winner of the stage. But if he loses, the final is reset and there is a very last match.
-	 * It might be fairer since it gives the WB winner the right to lose once during the stage...
-	 */
-	grandFinal?: GrandFinalType;
-
-	swiss?: {
-		groupCount: number;
-		roundCount: number;
-	};
-}
diff --git a/app/modules/brackets-model/other.ts b/app/modules/brackets-model/other.ts
deleted file mode 100644
index d798ce15a..000000000
--- a/app/modules/brackets-model/other.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------|
- * Contains the rest of the types which doesn't belong to the other files.
- *--------------------------------------------------------------------------*/
-
-import type { Result } from "./unions";
-
-/**
- * The possible status for a match.
- */
-export const Status = {
-	/** The two matches leading to this one are not completed yet. */
-	Locked: 0,
-
-	/** One participant is ready and waiting for the other one. */
-	Waiting: 1,
-
-	/** Both participants are ready to start. */
-	Ready: 2,
-
-	/** The match is running. */
-	Running: 3,
-
-	/** The match is completed. */
-	Completed: 4,
-};
-export type Status = (typeof Status)[keyof typeof Status];
-
-/**
- * The results of a participant in a match.
- */
-export interface ParticipantResult {
-	/** If `null`, the participant is to be determined. */
-	id: number | null;
-
-	/** Indicates where the participant comes from. */
-	position?: number;
-
-	/** If this participant forfeits, the other automatically wins. */
-	forfeit?: boolean;
-
-	/** The current score of the participant. */
-	score?: number;
-
-	/** How many points in total participant scored in total this set. KO = 100 points. Getting KO'd = 0 points. */
-	totalPoints?: number;
-
-	/** How many KO wins (100-0 games) the participant scored in this set. */
-	totalKos?: number;
-
-	/** Tells what is the result of a duel for this participant. */
-	result?: Result;
-}
-
-/**
- * Only contains information about match status and results.
- */
-export interface MatchResults {
-	/** Status of the match. */
-	status: Status;
-
-	/** First opponent of the match. */
-	opponent1: ParticipantResult | null;
-
-	/** Second opponent of the match. */
-	opponent2: ParticipantResult | null;
-}
diff --git a/app/modules/brackets-model/storage.ts b/app/modules/brackets-model/storage.ts
deleted file mode 100644
index 02c37ce5f..000000000
--- a/app/modules/brackets-model/storage.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-/*-----------------------------------------------------------------|
- * Contains the types which are persisted in the chosen storage.
- *----------------------------------------------------------------*/
-
-import type { TournamentRoundMaps } from "~/db/tables";
-import type { StageSettings } from "./input";
-import type { MatchResults } from "./other";
-import type { StageType } from "./unions";
-
-/**
- * A participant of a stage (team or individual).
- */
-
-/**
- * A stage, which can be a round-robin stage or a single/double elimination stage.
- */
-export interface Stage {
-	/** ID of the stage. */
-	id: number;
-
-	/** ID of the tournament this stage belongs to. */
-	tournament_id: number;
-
-	/** Name of the stage. */
-	name: string;
-
-	/** Type of the stage. */
-	type: StageType;
-
-	/** Settings of the stage. */
-	settings: StageSettings;
-
-	/** The number of the stage in its tournament. */
-	number: number;
-
-	createdAt?: number | null;
-}
-
-/**
- * A group of a stage.
- */
-export interface Group {
-	/** ID of the group. */
-	id: number;
-
-	/** ID of the parent stage. */
-	stage_id: number;
-
-	/** The number of the group in its stage. */
-	number: number;
-}
-
-// The next levels don't have a `name` property. They are automatically named with their `number` and their context (parent levels).
-
-/**
- * A round of a group.
- */
-export interface Round {
-	/** ID of the round. */
-	id: number;
-
-	/** ID of the parent stage. */
-	stage_id: number;
-
-	/** ID of the parent group. */
-	group_id: number;
-
-	/** The number of the round in its group. */
-	number: number;
-
-	/** Info about the maps count */
-	maps?: Pick<TournamentRoundMaps, "count" | "type" | "pickBan"> | null;
-}
-
-/**
- * A match of a round.
- */
-export interface Match extends MatchResults {
-	/** ID of the match. */
-	id: number;
-
-	/** ID of the parent stage. */
-	stage_id: number;
-
-	/** ID of the parent group. */
-	group_id: number;
-
-	/** ID of the parent round. */
-	round_id: number;
-
-	/** The number of the match in its round. */
-	number: number;
-
-	startedAt?: number | null;
-}
diff --git a/app/modules/brackets-model/unions.ts b/app/modules/brackets-model/unions.ts
deleted file mode 100644
index 3cef1aca7..000000000
--- a/app/modules/brackets-model/unions.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-/*----------------------------------------|
- * Contains all the string union types.
- *---------------------------------------*/
-
-/**
- * The only supported types of stage.
- */
-export type StageType =
-	| "round_robin"
-	| "single_elimination"
-	| "double_elimination"
-	| "swiss";
-
-/**
- * All the possible types of group in an elimination stage.
- *
- * - `single_bracket` for single elimination.
- * - `winner_bracket` and `loser_bracket` for double elimination.
- * - `final_group` for both single and double elimination.
- */
-export type GroupType =
-	| "single_bracket"
-	| "winner_bracket"
-	| "loser_bracket"
-	| "final_group";
-
-/**
- * The possible types for a double elimination stage's grand final.
- */
-export type GrandFinalType = "none" | "simple" | "double";
-
-/**
- * The possible modes for a round-robin stage.
- */
-export type RoundRobinMode = "simple" | "double";
-
-/**
- * Used to order seeds.
- */
-export type SeedOrdering =
-	| "natural"
-	| "reverse"
-	| "half_shift"
-	| "reverse_half_shift"
-	| "pair_flip"
-	| "inner_outer"
-	| "space_between"
-	| "groups.effort_balanced"
-	| "groups.seed_optimized"
-	| "groups.bracket_optimized";
-
-/**
- * The possible results of a duel for a participant.
- */
-export type Result = "win" | "loss";
diff --git a/app/routines/syncTournamentVods.test.ts b/app/routines/syncTournamentVods.test.ts
index 4c772bef0..c1b2df90e 100644
--- a/app/routines/syncTournamentVods.test.ts
+++ b/app/routines/syncTournamentVods.test.ts
@@ -307,7 +307,7 @@ async function seedTournamentWithMatches({
 		.run();
 
 	const insertTournamentMatchStm = sql.prepare(
-		/*sql*/ `insert into "TournamentMatch" ("id", "roundId", "stageId", "groupId", "number", "opponentOne", "opponentTwo", "status", "startedAt") values (?, 1, 1, 1, ?, ?, ?, 4, ?)`,
+		/*sql*/ `insert into "TournamentMatch" ("id", "roundId", "stageId", "groupId", "number", "opponentOne", "opponentTwo", "startedAt") values (?, 1, 1, 1, ?, ?, ?, ?)`,
 	);
 
 	insertTournamentMatchStm.run(
diff --git a/db-test.sqlite3 b/db-test.sqlite3
index 4573e552c..ae29a95b4 100644
Binary files a/db-test.sqlite3 and b/db-test.sqlite3 differ
diff --git a/e2e/helpers/playwright.ts b/e2e/helpers/playwright.ts
index c410aebbc..9298e8ba1 100644
--- a/e2e/helpers/playwright.ts
+++ b/e2e/helpers/playwright.ts
@@ -171,11 +171,9 @@ async function retryPost(
 }
 
 export async function submit(page: Page, testId?: string) {
-	const postPromise = page.waitForResponse(
-		(res) => res.request().method() === "POST",
-	);
-	await page.getByTestId(testId ?? "submit-button").click();
-	const postRes = await postPromise;
+	const postRes = await waitForPOSTResponse(page, async () => {
+		await page.getByTestId(testId ?? "submit-button").click();
+	});
 
 	// Remix returns 202 from action endpoints when the action threw/returned a
 	// redirect. The fetcher then drives a client-side navigation and, once
@@ -199,8 +197,9 @@ export async function waitForPOSTResponse(page: Page, cb: () => Promise<void>) {
 
 	// React Aria buttons fire their handler on press end. Occasionally a click
 	// registers the press start (the button goes `:active`) but the press never
-	// completes into a submit, so no POST fires. Re-issue the action when the
-	// expected POST doesn't arrive within the per-attempt window.
+	// completes into a submit, so no POST fires. The match page revalidating on
+	// a websocket message mid-click is one way this happens. Re-issue the action
+	// when the expected POST doesn't arrive within the per-attempt window.
 	for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
 		const responsePromise = page.waitForResponse(
 			(res) => res.request().method() === "POST",
@@ -208,12 +207,13 @@ export async function waitForPOSTResponse(page: Page, cb: () => Promise<void>) {
 		);
 		await cb();
 		try {
-			await responsePromise;
-			return;
+			return await responsePromise;
 		} catch (error) {
 			if (attempt === MAX_ATTEMPTS) throw error;
 		}
 	}
+
+	throw new Error("waitForPOSTResponse: unreachable");
 }
 
 export function isNotVisible(locator: Locator) {
diff --git a/e2e/helpers/tournament-match.ts b/e2e/helpers/tournament-match.ts
index 67bc8ee18..9044e6795 100644
--- a/e2e/helpers/tournament-match.ts
+++ b/e2e/helpers/tournament-match.ts
@@ -75,6 +75,20 @@ const ensureActiveRostersSet = async (page: Page) => {
 	}
 };
 
+/**
+ * Selects one of the pick/ban options and submits it.
+ *
+ * Selecting and submitting are retried together as one unit because the match
+ * page revalidates on websocket messages: a re-render landing mid-click can
+ * swallow the submit press (see waitForPOSTResponse) and, if the panel
+ * remounted, the selection with it — so re-submitting alone would not be enough.
+ */
+export const pickBanMap = (page: Page, option: "first" | "last" = "first") =>
+	waitForPOSTResponse(page, async () => {
+		await page.getByTestId("pick-ban-button")[option]().click();
+		await page.getByTestId("pick-ban-submit-button").click();
+	});
+
 /**
  * Sweeps `mapsToReport` maps in a row, all won by `winner`. By default the
  * last map ends the set (the typical case — full Bo3/Bo5 sweep), and the
diff --git a/e2e/seeds/db-seed-AB_RR.sqlite3 b/e2e/seeds/db-seed-AB_RR.sqlite3
index 6bd543bd4..1d888b22d 100644
Binary files a/e2e/seeds/db-seed-AB_RR.sqlite3 and b/e2e/seeds/db-seed-AB_RR.sqlite3 differ
diff --git a/e2e/seeds/db-seed-DEFAULT.sqlite3 b/e2e/seeds/db-seed-DEFAULT.sqlite3
index 55e16f05e..eccca0804 100644
Binary files a/e2e/seeds/db-seed-DEFAULT.sqlite3 and b/e2e/seeds/db-seed-DEFAULT.sqlite3 differ
diff --git a/e2e/seeds/db-seed-FINALIZED_BRACKET.sqlite3 b/e2e/seeds/db-seed-FINALIZED_BRACKET.sqlite3
index 814dad20e..ba5df865b 100644
Binary files a/e2e/seeds/db-seed-FINALIZED_BRACKET.sqlite3 and b/e2e/seeds/db-seed-FINALIZED_BRACKET.sqlite3 differ
diff --git a/e2e/seeds/db-seed-IN_SQ_MATCH.sqlite3 b/e2e/seeds/db-seed-IN_SQ_MATCH.sqlite3
index a66d65483..ffb1c7855 100644
Binary files a/e2e/seeds/db-seed-IN_SQ_MATCH.sqlite3 and b/e2e/seeds/db-seed-IN_SQ_MATCH.sqlite3 differ
diff --git a/e2e/seeds/db-seed-NO_SCRIMS.sqlite3 b/e2e/seeds/db-seed-NO_SCRIMS.sqlite3
index ef7163f9c..5367c9949 100644
Binary files a/e2e/seeds/db-seed-NO_SCRIMS.sqlite3 and b/e2e/seeds/db-seed-NO_SCRIMS.sqlite3 differ
diff --git a/e2e/seeds/db-seed-NO_SQ_GROUPS.sqlite3 b/e2e/seeds/db-seed-NO_SQ_GROUPS.sqlite3
index 9e5464916..6509ebd90 100644
Binary files a/e2e/seeds/db-seed-NO_SQ_GROUPS.sqlite3 and b/e2e/seeds/db-seed-NO_SQ_GROUPS.sqlite3 differ
diff --git a/e2e/seeds/db-seed-NO_TOURNAMENT_TEAMS.sqlite3 b/e2e/seeds/db-seed-NO_TOURNAMENT_TEAMS.sqlite3
index 4ec3dcf64..16705a4b9 100644
Binary files a/e2e/seeds/db-seed-NO_TOURNAMENT_TEAMS.sqlite3 and b/e2e/seeds/db-seed-NO_TOURNAMENT_TEAMS.sqlite3 differ
diff --git a/e2e/seeds/db-seed-NZAP_IN_TEAM.sqlite3 b/e2e/seeds/db-seed-NZAP_IN_TEAM.sqlite3
index 83dac6759..13e8d0dcb 100644
Binary files a/e2e/seeds/db-seed-NZAP_IN_TEAM.sqlite3 and b/e2e/seeds/db-seed-NZAP_IN_TEAM.sqlite3 differ
diff --git a/e2e/seeds/db-seed-REG_OPEN.sqlite3 b/e2e/seeds/db-seed-REG_OPEN.sqlite3
index e970b22b2..dd86ac487 100644
Binary files a/e2e/seeds/db-seed-REG_OPEN.sqlite3 and b/e2e/seeds/db-seed-REG_OPEN.sqlite3 differ
diff --git a/e2e/seeds/db-seed-SMALL_SOS.sqlite3 b/e2e/seeds/db-seed-SMALL_SOS.sqlite3
index 9329d8bc5..f472f231e 100644
Binary files a/e2e/seeds/db-seed-SMALL_SOS.sqlite3 and b/e2e/seeds/db-seed-SMALL_SOS.sqlite3 differ
diff --git a/e2e/seeds/db-seed-TEAM_MAP_PREFS.sqlite3 b/e2e/seeds/db-seed-TEAM_MAP_PREFS.sqlite3
index 2fe1806c2..8390e246f 100644
Binary files a/e2e/seeds/db-seed-TEAM_MAP_PREFS.sqlite3 and b/e2e/seeds/db-seed-TEAM_MAP_PREFS.sqlite3 differ
diff --git a/e2e/tournament-bracket.spec.ts b/e2e/tournament-bracket.spec.ts
index bba0f69fd..408e1b755 100644
--- a/e2e/tournament-bracket.spec.ts
+++ b/e2e/tournament-bracket.spec.ts
@@ -32,6 +32,7 @@ import {
 	expectScore,
 	goToTab,
 	navigateToMatch,
+	pickBanMap,
 	reportResult,
 	undoLastReport,
 } from "./helpers/tournament-match";
@@ -1074,8 +1075,7 @@ test.describe("Tournament bracket", () => {
 					});
 					await goToTab(page, "action");
 
-					await page.getByTestId("pick-ban-button").first().click();
-					await submit(page, "pick-ban-submit-button");
+					await pickBanMap(page);
 				}
 
 				// once both teams banned the ban prompt is gone and the actual map
@@ -1094,8 +1094,7 @@ test.describe("Tournament bracket", () => {
 			await reportResult(page, { mapsToReport: 1, winner: 2, setEnds: false });
 
 			if (pickBan === "COUNTERPICK") {
-				await page.getByTestId("pick-ban-button").first().click();
-				await submit(page, "pick-ban-submit-button");
+				await pickBanMap(page);
 			}
 
 			await impersonate(page, teamTwoCaptainId);
@@ -1109,8 +1108,7 @@ test.describe("Tournament bracket", () => {
 			await reportResult(page, { mapsToReport: 1, winner: 1, setEnds: false });
 
 			if (pickBan === "COUNTERPICK") {
-				await page.getByTestId("pick-ban-button").first().click();
-				await submit(page, "pick-ban-submit-button");
+				await pickBanMap(page);
 
 				await undoLastReport(page);
 				await expect(page.getByText("Select the winner")).toBeVisible();
@@ -1119,8 +1117,7 @@ test.describe("Tournament bracket", () => {
 					winner: 1,
 					setEnds: false,
 				});
-				await page.getByTestId("pick-ban-button").last().click();
-				await submit(page, "pick-ban-submit-button");
+				await pickBanMap(page, "last");
 				await expect(
 					page.getByText("Counterpick", { exact: true }),
 				).toBeVisible();
@@ -1282,12 +1279,10 @@ test.describe("Tournament bracket", () => {
 		});
 		await goToTab(page, "action");
 
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		await expect(page.getByText(/Ban a map \(2\/2\)/)).toBeVisible();
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		// 3) PreSet: Lower seed bans 2 maps
 		await impersonate(page, lowerSeedCaptainId);
@@ -1297,12 +1292,10 @@ test.describe("Tournament bracket", () => {
 		});
 		await goToTab(page, "action");
 
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		await expect(page.getByText(/Ban a map \(2\/2\)/)).toBeVisible();
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		// 4) Roll auto-executed after last ban; report game 1 score
 		await expect(page.getByTestId("stage-banner")).toBeVisible();
@@ -1313,12 +1306,10 @@ test.describe("Tournament bracket", () => {
 
 		// 5) PostGame: Winner (team 1, captain 33) bans 2 maps
 		await expect(page.getByText(/Ban a map/)).toBeVisible();
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		await expect(page.getByText(/Ban a map \(2\/2\)/)).toBeVisible();
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		// PostGame: Loser (team 2, captain 29) picks a map
 		await impersonate(page, higherSeedCaptainId);
@@ -1329,8 +1320,7 @@ test.describe("Tournament bracket", () => {
 		await goToTab(page, "action");
 
 		await expect(page.getByText(/Pick a map/)).toBeVisible();
-		await page.getByTestId("pick-ban-button").first().click();
-		await submit(page, "pick-ban-submit-button");
+		await pickBanMap(page);
 
 		// 6) Undo game 1 score — also deletes postGame pick/ban events
 		await expect(page.getByTestId("stage-banner")).toBeVisible();
diff --git a/migrations/161-tournament-match-nullable-opponents.js b/migrations/161-tournament-match-nullable-opponents.js
new file mode 100644
index 000000000..204b3e7ba
--- /dev/null
+++ b/migrations/161-tournament-match-nullable-opponents.js
@@ -0,0 +1,107 @@
+export function up(db) {
+	db.pragma("foreign_keys = OFF");
+
+	db.transaction(() => {
+		db.prepare(
+			/* sql */ `
+				create table "TournamentMatch_new" (
+					"id" integer primary key,
+					"roundId" integer not null,
+					"stageId" integer not null,
+					"groupId" integer not null,
+					"number" integer not null,
+					"opponentOne" text,
+					"opponentTwo" text,
+					"winnerSide" text check ("winnerSide" in ('opponent1','opponent2')),
+					"chatCode" text,
+					"startedAt" integer,
+					foreign key ("roundId") references "TournamentRound"("id") on delete cascade,
+					foreign key ("stageId") references "TournamentStage"("id") on delete cascade,
+					foreign key ("groupId") references "TournamentGroup"("id") on delete cascade,
+					unique("number", "roundId") on conflict rollback
+				) strict
+			`,
+		).run();
+
+		db.prepare(
+			/* sql */ `
+				insert into "TournamentMatch_new" ("id", "roundId", "stageId", "groupId", "number", "opponentOne", "opponentTwo", "winnerSide", "chatCode", "startedAt")
+				select
+					"id",
+					"roundId",
+					"stageId",
+					"groupId",
+					"number",
+					case when "opponentOne" = 'null' then null else json_remove("opponentOne", '$.result', '$.forfeit', '$.totalPoints', '$.totalKos') end,
+					case when "opponentTwo" = 'null' then null else json_remove("opponentTwo", '$.result', '$.forfeit', '$.totalPoints', '$.totalKos') end,
+					case
+						when "opponentOne" ->> '$.result' = 'win' then 'opponent1'
+						when "opponentTwo" ->> '$.result' = 'win' then 'opponent2'
+					end,
+					"chatCode",
+					"startedAt"
+				from "TournamentMatch"
+			`,
+		).run();
+
+		db.prepare(/* sql */ `drop table "TournamentMatch"`).run();
+
+		db.prepare(
+			/* sql */ `alter table "TournamentMatch_new" rename to "TournamentMatch"`,
+		).run();
+
+		db.prepare(
+			/* sql */ `create index tournament_match_round_id on "TournamentMatch"("roundId")`,
+		).run();
+		db.prepare(
+			/* sql */ `create index tournament_match_stage_id on "TournamentMatch"("stageId")`,
+		).run();
+		db.prepare(
+			/* sql */ `create index tournament_match_group_id on "TournamentMatch"("groupId")`,
+		).run();
+		db.prepare(
+			/* sql */ `create index idx_tournament_match_opponent_one_id on "TournamentMatch"("opponentOne" ->> '$.id')`,
+		).run();
+		db.prepare(
+			/* sql */ `create index idx_tournament_match_opponent_two_id on "TournamentMatch"("opponentTwo" ->> '$.id')`,
+		).run();
+
+		db.prepare(
+			/* sql */ `alter table "TournamentMatchGameResult" add "ko" integer`,
+		).run();
+
+		db.prepare(
+			/* sql */ `
+				update "TournamentMatchGameResult"
+				set "ko" = 1
+				where ("opponentOnePoints" = 100 and "opponentTwoPoints" = 0)
+					or ("opponentOnePoints" = 0 and "opponentTwoPoints" = 100)
+			`,
+		).run();
+
+		db.prepare(
+			/* sql */ `alter table "TournamentMatchGameResult" drop column "opponentOnePoints"`,
+		).run();
+		db.prepare(
+			/* sql */ `alter table "TournamentMatchGameResult" drop column "opponentTwoPoints"`,
+		).run();
+
+		db.prepare(
+			/* sql */ `
+				update "TournamentStage"
+				set "settings" = json_patch(
+					json_remove("settings", '$.swiss'),
+					json_object(
+						'groupCount', "settings" ->> '$.swiss.groupCount',
+						'roundCount', "settings" ->> '$.swiss.roundCount'
+					)
+				)
+				where "settings" ->> '$.swiss' is not null
+			`,
+		).run();
+
+		db.pragma("foreign_key_check");
+	})();
+
+	db.pragma("foreign_keys = ON");
+}