From c1e1e88c54c98a32ee127421ca938da6412ebc39 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Fri, 25 Jul 2025 06:55:33 +0200
Subject: [PATCH 1/9] hotfix: Improve tournament name visibility and efficiency

---
 convex/_generated/api.d.ts                    |  2 --
 .../mutations/createTournamentCompetitor.ts   | 10 ++++++
 .../_helpers/checkUserTournamentForcedName.ts | 34 -------------------
 .../checkUserTournamentRelationship.ts        | 10 +++---
 convex/_model/users/_helpers/redactUser.ts    |  7 +---
 .../UserProfileForm/UserProfileForm.tsx       |  9 +++--
 .../UserProfileForm/UserProfileForm.utils.ts  | 18 ++++++++--
 7 files changed, 40 insertions(+), 50 deletions(-)
 delete mode 100644 convex/_model/users/_helpers/checkUserTournamentForcedName.ts

diff --git a/convex/_generated/api.d.ts b/convex/_generated/api.d.ts
index 26751c9a..2409c14c 100644
--- a/convex/_generated/api.d.ts
+++ b/convex/_generated/api.d.ts
@@ -132,7 +132,6 @@ import type * as _model_tournaments_queries_getTournaments from "../_model/tourn
 import type * as _model_tournaments_queries_getTournamentsByStatus from "../_model/tournaments/queries/getTournamentsByStatus.js";
 import type * as _model_tournaments_queries_getTournamentsByUser from "../_model/tournaments/queries/getTournamentsByUser.js";
 import type * as _model_users__helpers_checkUserAuth from "../_model/users/_helpers/checkUserAuth.js";
-import type * as _model_users__helpers_checkUserTournamentForcedName from "../_model/users/_helpers/checkUserTournamentForcedName.js";
 import type * as _model_users__helpers_checkUserTournamentRelationship from "../_model/users/_helpers/checkUserTournamentRelationship.js";
 import type * as _model_users__helpers_getShallowUser from "../_model/users/_helpers/getShallowUser.js";
 import type * as _model_users__helpers_redactUser from "../_model/users/_helpers/redactUser.js";
@@ -321,7 +320,6 @@ declare const fullApi: ApiFromModules<{
   "_model/tournaments/queries/getTournamentsByStatus": typeof _model_tournaments_queries_getTournamentsByStatus;
   "_model/tournaments/queries/getTournamentsByUser": typeof _model_tournaments_queries_getTournamentsByUser;
   "_model/users/_helpers/checkUserAuth": typeof _model_users__helpers_checkUserAuth;
-  "_model/users/_helpers/checkUserTournamentForcedName": typeof _model_users__helpers_checkUserTournamentForcedName;
   "_model/users/_helpers/checkUserTournamentRelationship": typeof _model_users__helpers_checkUserTournamentRelationship;
   "_model/users/_helpers/getShallowUser": typeof _model_users__helpers_getShallowUser;
   "_model/users/_helpers/redactUser": typeof _model_users__helpers_redactUser;
diff --git a/convex/_model/tournamentCompetitors/mutations/createTournamentCompetitor.ts b/convex/_model/tournamentCompetitors/mutations/createTournamentCompetitor.ts
index 6f41797b..a26e345a 100644
--- a/convex/_model/tournamentCompetitors/mutations/createTournamentCompetitor.ts
+++ b/convex/_model/tournamentCompetitors/mutations/createTournamentCompetitor.ts
@@ -51,6 +51,16 @@ export const createTournamentCompetitor = async (
   }
 
   // ---- PRIMARY ACTIONS ----
+
+  if (tournament.requireRealNames) {
+    for (const { userId } of args.players) {
+      const user = await ctx.db.get(userId);
+      if (user?.nameVisibility && ['hidden', 'friends'].includes(user.nameVisibility)) {
+        await ctx.db.patch(userId, { nameVisibility: 'tournaments' });
+      }
+    }
+  }
+
   return await ctx.db.insert('tournamentCompetitors', {
     ...args,
     active: false,
diff --git a/convex/_model/users/_helpers/checkUserTournamentForcedName.ts b/convex/_model/users/_helpers/checkUserTournamentForcedName.ts
deleted file mode 100644
index 423be595..00000000
--- a/convex/_model/users/_helpers/checkUserTournamentForcedName.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { Id } from '../../../_generated/dataModel';
-import { QueryCtx } from '../../../_generated/server';
-import { getTournamentUserIds } from '../../../_model/tournaments';
-
-export const checkUserTournamentForcedName = async (
-  ctx: QueryCtx,
-  userIdA?: Id<'users'> | null,
-  userIdB?: Id<'users'> | null,
-): Promise<boolean> => {
-  if (!userIdA || !userIdB) {
-    return false;
-  }
-
-  const tournaments = await ctx.db.query('tournaments').collect();
-
-  // Check each tournament for a relationship, return true if one is found
-  // Check each tournament for a relationship, return true if one is found
-  for (const { _id, organizerUserIds, requireRealNames } of tournaments) {
-    const playerUserIds = await getTournamentUserIds(ctx, _id);
-
-    // Merge all organizer IDs and player IDs into one set
-    const allTournamentUserIds = new Set([
-      ...organizerUserIds,
-      ...playerUserIds,
-    ]);
-
-    // If the set contains both user IDs, they were at the same tournament
-    if (allTournamentUserIds.has(userIdA) && allTournamentUserIds.has(userIdB) && requireRealNames) {
-      return true;
-    }
-  }
-
-  return false;
-};
diff --git a/convex/_model/users/_helpers/checkUserTournamentRelationship.ts b/convex/_model/users/_helpers/checkUserTournamentRelationship.ts
index 716a4d78..3d83fe3c 100644
--- a/convex/_model/users/_helpers/checkUserTournamentRelationship.ts
+++ b/convex/_model/users/_helpers/checkUserTournamentRelationship.ts
@@ -14,8 +14,7 @@ export const checkUserTournamentRelationship = async (
   const tournaments = await ctx.db.query('tournaments').collect();
 
   // Check each tournament for a relationship, return true if one is found
-  return tournaments.some(async ({ _id, organizerUserIds }) => {
-
+  for (const { _id, organizerUserIds } of tournaments) {
     const playerUserIds = await getTournamentUserIds(ctx, _id);
 
     // Merge all organizer IDs and player IDs into one set
@@ -25,6 +24,9 @@ export const checkUserTournamentRelationship = async (
     ]);
 
     // If the set contains both user IDs, they were at the same tournament
-    return allTournamentUserIds.has(userIdA) && allTournamentUserIds.has(userIdB);
-  });
+    if (allTournamentUserIds.has(userIdA) && allTournamentUserIds.has(userIdB)) {
+      return true;
+    }
+  }
+  return false;
 };
diff --git a/convex/_model/users/_helpers/redactUser.ts b/convex/_model/users/_helpers/redactUser.ts
index 961820b9..d3e001ef 100644
--- a/convex/_model/users/_helpers/redactUser.ts
+++ b/convex/_model/users/_helpers/redactUser.ts
@@ -3,7 +3,6 @@ import { getAuthUserId } from '@convex-dev/auth/server';
 import { Doc } from '../../../_generated/dataModel';
 import { QueryCtx } from '../../../_generated/server';
 import { getStorageUrl } from '../../common/_helpers/getStorageUrl';
-import { checkUserTournamentForcedName } from './checkUserTournamentForcedName';
 import { checkUserTournamentRelationship } from './checkUserTournamentRelationship';
 
 /**
@@ -52,15 +51,11 @@ export const redactUser = async (
   // If user is querying someone they are in a tournament with
   const hasTournamentRelationship = await checkUserTournamentRelationship(ctx, userId, user._id);
 
-  // If user is querying someone they are in a tournament with which requires real names
-  const requiredByTournament = await checkUserTournamentForcedName(ctx, userId, user._id);
-
   // Add name information if allowed
   if (
     (user?.nameVisibility === 'public') ||
     (user?.nameVisibility === 'friends' && hasFriendRelationship) ||
-    (user?.nameVisibility === 'tournaments' && (hasFriendRelationship || hasTournamentRelationship)) ||
-    requiredByTournament
+    (user?.nameVisibility === 'tournaments' && (hasFriendRelationship || hasTournamentRelationship))
   ) {
     limitedUser.givenName = user.givenName;
     limitedUser.familyName = user.familyName;
diff --git a/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.tsx b/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.tsx
index 1a99a702..c4163639 100644
--- a/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.tsx
+++ b/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.tsx
@@ -8,13 +8,14 @@ import { Form, FormField } from '~/components/generic/Form';
 import { InputSelect } from '~/components/generic/InputSelect';
 import { InputText } from '~/components/generic/InputText';
 import { Separator } from '~/components/generic/Separator';
+import { useGetTournamentsByUser } from '~/services/tournaments';
 import { useUpdateUser } from '~/services/users';
 import { userProfileNameVisibilityOptions } from '~/types/UserProfileNameVisibility';
 import { getCountryOptions } from '~/utils/common/getCountryOptions';
 import {
+  createSchema,
   defaultValues,
   UserProfileFormData,
-  userProfileFormSchema,
 } from './UserProfileForm.utils';
 
 import styles from './UserProfileForm.module.scss';
@@ -22,12 +23,16 @@ import styles from './UserProfileForm.module.scss';
 export const UserProfileForm = (): JSX.Element => {
   const user = useAuth();
 
+  const { data: tournaments } = useGetTournamentsByUser(user ? {
+    userId: user._id,
+  } : 'skip');
+
   const { mutation: updateUser } = useUpdateUser({
     successMessage: 'Profile updated!',
   });
 
   const form = useForm<UserProfileFormData>({
-    resolver: zodResolver(userProfileFormSchema),
+    resolver: zodResolver(createSchema(tournaments ?? [])),
     defaultValues,
     values: { ...defaultValues, ...(user ?? {}) },
   });
diff --git a/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.utils.ts b/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.utils.ts
index fb23f5dd..72d25801 100644
--- a/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.utils.ts
+++ b/src/pages/SettingsPage/components/UserProfileForm/UserProfileForm.utils.ts
@@ -1,8 +1,11 @@
 import { z } from 'zod';
 
+import { Tournament } from '~/api';
 import { UserProfileNameVisibility, userProfileNameVisibilitySchema } from '~/types/UserProfileNameVisibility';
 
-export const userProfileFormSchema = z.object({
+export const createSchema = (
+  userTournaments: Tournament[],
+) => z.object({
   username: z.string().min(3, {
     message: 'Username must be at least 3 characters.',
   }),
@@ -10,9 +13,20 @@ export const userProfileFormSchema = z.object({
   familyName: z.string().min(2),
   nameVisibility: userProfileNameVisibilitySchema,
   countryCode: z.optional(z.string()),
+}).superRefine((data, ctx) => {
+  const requireRealNames = userTournaments.some((tournament) => (
+    tournament.requireRealNames && (tournament.status === 'published' || tournament.status === 'active')
+  ));
+  if (['hidden', 'friends'].includes(data.nameVisibility) && requireRealNames) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'You are currently registered in a tournament which requires real names.',
+      path: ['nameVisibility'],
+    });
+  }
 });
 
-export type UserProfileFormData = z.infer<typeof userProfileFormSchema> ;
+export type UserProfileFormData = z.infer<ReturnType<typeof createSchema>>;
 
 export const defaultValues = {
   username: '',

From 9c4fd6da461d475c0af9c04071e858bb935bf9b8 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Fri, 25 Jul 2025 08:51:08 +0200
Subject: [PATCH 2/9] hotfix: Improve add-match label

---
 .../components/ActiveTournament/ActiveTournament.tsx            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
index 1c600420..f653bb89 100644
--- a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
+++ b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
@@ -90,7 +90,7 @@ export const ActiveTournament = ({
               </span>
               <CheckInMatchDialog tournamentPairingId={pairing._id}>
                 <Button className={styles.ActiveTournamentCard_OpponentSection_CheckInButton}>
-                  <Plus /> Check-In
+                  <Plus /> Add Match Result
                 </Button>
               </CheckInMatchDialog>
             </div>

From 8fa4bf155b0fc855831734983eb103d1987a76ad Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Fri, 25 Jul 2025 14:27:27 +0200
Subject: [PATCH 3/9] hotfix: Fix battle plan display in match result details

---
 .../FowV4MatchResultDetails/FowV4MatchResultDetails.tsx       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.tsx b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.tsx
index 24a443aa..3769a946 100644
--- a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.tsx
+++ b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.tsx
@@ -27,8 +27,8 @@ export const FowV4MatchResultDetails = ({
   const score = calculateMatchScore(matchResult.details);
   const missionName = matchResult.details.missionName ?? getMission(matchResult.details.missionId)?.displayName;
   const battlePlans: [string, string] = [
-    fowV4BattlePlanOptions.find((option) => option.value === matchResult.details.player0BattlePlan)?.label ?? '',
-    fowV4BattlePlanOptions.find((option) => option.value === matchResult.details.player0BattlePlan)?.label ?? '',
+    fowV4BattlePlanOptions.find((option) => option.value === matchResult.details.player0BattlePlan)?.label ?? 'Hidden',
+    fowV4BattlePlanOptions.find((option) => option.value === matchResult.details.player1BattlePlan)?.label ?? 'Hidden',
   ];
   const unitsLost: [number, number] = [
     matchResult.details.player0UnitsLost,

From d495934b1316ffbd624fef9d251955ae52201e77 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Fri, 25 Jul 2025 14:27:42 +0200
Subject: [PATCH 4/9] hotfix: Allow selection of any mission

---
 convex/static/fowV4/missionPacks.ts                  |  4 ++++
 src/api.ts                                           |  1 +
 .../components/GameConfigFields.tsx                  | 12 ++++++++----
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/convex/static/fowV4/missionPacks.ts b/convex/static/fowV4/missionPacks.ts
index d0d64bb0..657010cc 100644
--- a/convex/static/fowV4/missionPacks.ts
+++ b/convex/static/fowV4/missionPacks.ts
@@ -402,6 +402,10 @@ export const getFowV4MissionMatrixesByMissionPackId = (id: string): FowV4Mission
   missionPacks.find((missionPack) => missionPack.id === id)?.matrixes
 );
 
+export const getFowV4MissionsByMissionPackId = (id: string): FowV4Mission[] | undefined => (
+  missionPacks.find((missionPack) => missionPack.id === id)?.missions
+);
+
 export const getFowV4MissionMatrixOptionsByMissionPackId = (
   id?: string,
 ): { value: string; label: string; }[] => {
diff --git a/src/api.ts b/src/api.ts
index 2193ecae..d06c9418 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -154,5 +154,6 @@ export type { FowV4MissionMatrixId } from '../convex/static/fowV4/missionPacks';
 export {
   getFowV4MissionMatrixesByMissionPackId,
   getFowV4MissionMatrixOptionsByMissionPackId,
+  getFowV4MissionsByMissionPackId,
 } from '../convex/static/fowV4/missionPacks';
 export type { FowV4MissionMatrix } from '../convex/static/fowV4/missionPacks.types';
diff --git a/src/components/FowV4MatchResultForm/components/GameConfigFields.tsx b/src/components/FowV4MatchResultForm/components/GameConfigFields.tsx
index f9f9f835..a8a7de70 100644
--- a/src/components/FowV4MatchResultForm/components/GameConfigFields.tsx
+++ b/src/components/FowV4MatchResultForm/components/GameConfigFields.tsx
@@ -5,7 +5,7 @@ import {
   fowV4EraOptions,
   fowV4LessonsFromTheFrontVersionOptions,
   fowV4MissionPackOptions,
-  getFowV4MissionMatrixOptionsByMissionPackId,
+  getFowV4MissionsByMissionPackId,
 } from '~/api';
 import { Animate } from '~/components/generic/Animate';
 import { FormField } from '~/components/generic/Form';
@@ -35,7 +35,11 @@ export const GameConfigFields = ({
 
   const missionPackId = watch(`${formPath}.missionPackId`);
 
-  const matrixOptions = getFowV4MissionMatrixOptionsByMissionPackId(missionPackId);
+  const missionOptions = (getFowV4MissionsByMissionPackId(missionPackId) ?? []).map((mission) => ({
+    label: mission.displayName,
+    value: mission.id,
+  }));
+
   return (
     <div className={styles.Root}>
       <div className={styles.CoreConfig}>
@@ -63,8 +67,8 @@ export const GameConfigFields = ({
             <FormField name={`${formPath}.missionPackId`} label="Mission Pack" disabled={fowV4MissionPackOptions.length < 2}>
               <InputSelect options={fowV4MissionPackOptions} />
             </FormField>
-            <FormField name={`${formPath}.missionMatrixId`} label="Mission Matrix" disabled={matrixOptions.length < 2}>
-              <InputSelect options={matrixOptions} />
+            <FormField name={`${formPath}.missionMatrixId`} label="Mission Matrix" disabled={missionOptions.length < 2}>
+              <InputSelect options={missionOptions} />
             </FormField>
             <FormField name={`${formPath}.useExperimentalMissions`} label="Prefer experimental missions">
               <Switch />

From 3f93d77384d345126794e5290d9a13540c6135e5 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Sat, 26 Jul 2025 08:39:12 +0200
Subject: [PATCH 5/9] ETC improvements day 2 (#127)

* feat: Add tournament pairing detail page

* feat: Add score to match results

* feat: Improve match result editing and creation for tournaments

* fix: Improve dashboard styling

* feat: Improve match result editing and creation for tournaments (pt2)
---
 .../fowV4/calculateFowV4MatchResultScore.ts   |  3 +-
 .../_helpers/deepenMatchResult.ts             |  6 ++
 .../_helpers/deepenTournamentPairing.ts       |  2 +-
 .../FowV4MatchResultDetails.types.ts          |  2 +-
 .../FowV4MatchResultForm.tsx                  | 28 +++----
 .../components/CommonFields.hooks.ts          |  8 +-
 .../components/TournamentPlayersFields.tsx    | 14 ++--
 src/components/IdentityBadge/index.ts         |  5 +-
 .../MatchResultContextMenu.tsx                |  9 ++-
 .../MatchResultCreateDialog.hooks.tsx         |  3 +-
 .../MatchResultCreateDialog.tsx               | 12 ++-
 .../MatchResultEditDialog.tsx                 |  2 +-
 src/pages/DashboardPage/DashboardPage.tsx     |  2 +-
 .../ActiveTournament.module.scss              |  8 +-
 .../ActiveTournament/ActiveTournament.tsx     | 32 ++++----
 .../TournamentPairingsCard.tsx                |  4 +-
 .../TournamentPairingsCard.utils.tsx          | 21 ++++-
 .../TournamentPairingDetailPage.module.scss   | 22 ++++++
 .../TournamentPairingDetailPage.tsx           | 76 +++++++++++++++++++
 .../TournamentPairingDetailPage/index.ts      |  1 +
 src/routes.tsx                                |  6 ++
 src/settings.ts                               |  1 +
 22 files changed, 206 insertions(+), 61 deletions(-)
 create mode 100644 src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.module.scss
 create mode 100644 src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
 create mode 100644 src/pages/TournamentPairingDetailPage/index.ts

diff --git a/convex/_model/fowV4/calculateFowV4MatchResultScore.ts b/convex/_model/fowV4/calculateFowV4MatchResultScore.ts
index 21d695ba..74c2517c 100644
--- a/convex/_model/fowV4/calculateFowV4MatchResultScore.ts
+++ b/convex/_model/fowV4/calculateFowV4MatchResultScore.ts
@@ -1,5 +1,4 @@
 import { Doc } from '../../_generated/dataModel';
-import { DeepMatchResult } from '../matchResults';
 
 /**
  * Calculate the Victory Points (i.e. score) for a given match result.
@@ -10,7 +9,7 @@ import { DeepMatchResult } from '../matchResults';
  * @param matchResult - The match result to score
  * @returns - A tuple with the scores for player 0 and 1 respectively
  */
-export const calculateFowV4MatchResultScore = (matchResult: Doc<'matchResults'> | DeepMatchResult): [number, number] => {
+export const calculateFowV4MatchResultScore = (matchResult: Doc<'matchResults'>): [number, number] => {
 
   // TODO: Add some guards in case matchResult is not FowV4
 
diff --git a/convex/_model/matchResults/_helpers/deepenMatchResult.ts b/convex/_model/matchResults/_helpers/deepenMatchResult.ts
index 55cd026f..b9d7625f 100644
--- a/convex/_model/matchResults/_helpers/deepenMatchResult.ts
+++ b/convex/_model/matchResults/_helpers/deepenMatchResult.ts
@@ -1,5 +1,6 @@
 import { Doc } from '../../../_generated/dataModel';
 import { QueryCtx } from '../../../_generated/server';
+import { calculateFowV4MatchResultScore } from '../../fowV4/calculateFowV4MatchResultScore';
 import { getMission } from '../../fowV4/getMission';
 import { getUser } from '../../users/queries/getUser';
 import { checkMatchResultBattlePlanVisibility } from './checkMatchResultBattlePlanVisibility';
@@ -38,6 +39,9 @@ export const deepenMatchResult = async (
   const mission = getMission(matchResult.details.missionId);
   const battlePlansVisible = await checkMatchResultBattlePlanVisibility(ctx, matchResult);
 
+  // TODO: This is FowV4 specific, needs to be made generic!
+  const [player0Score, player1Score] = calculateFowV4MatchResultScore(matchResult);
+
   return {
     ...matchResult,
     ...(player0User ? { player0User } : {}),
@@ -47,6 +51,8 @@ export const deepenMatchResult = async (
       player0BattlePlan: battlePlansVisible ? matchResult.details.player0BattlePlan : undefined,
       player1BattlePlan: battlePlansVisible ? matchResult.details.player1BattlePlan : undefined,
       missionName: mission?.displayName,
+      player0Score,
+      player1Score,
     },
     likedByUserIds: likes.map((like) => like.userId),
     commentCount: comments.length,
diff --git a/convex/_model/tournamentPairings/_helpers/deepenTournamentPairing.ts b/convex/_model/tournamentPairings/_helpers/deepenTournamentPairing.ts
index 1ed4b351..00650d54 100644
--- a/convex/_model/tournamentPairings/_helpers/deepenTournamentPairing.ts
+++ b/convex/_model/tournamentPairings/_helpers/deepenTournamentPairing.ts
@@ -14,7 +14,7 @@ import { getTournamentShallow } from '../../tournaments';
  * This method's return type is, by nature, the definition of a deep TournamentPairing.
  * 
  * @param ctx - Convex query context
- * @param tournament - Raw TournamentPairing document
+ * @param tournamentPairing - Raw TournamentPairing document
  * @returns A deep TournamentPairing
  */
 export const deepenTournamentPairing = async (
diff --git a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
index 15c3b11c..4ecf00f2 100644
--- a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
+++ b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
@@ -3,7 +3,7 @@ import { MatchResult, User } from '~/api';
 export type FowV4MatchResultDetailsData = Pick<MatchResult, 'player0User' | 'player0UserId' | 'player0Placeholder' | 'player1User' | 'player1UserId' | 'player1Placeholder'> & {
   player0User?: User;
   player1User?: User;
-  details: Omit<MatchResult['details'], 'missionName'> & {
+  details: Omit<MatchResult['details'], 'missionName' | 'player0Score' | 'player1Score'> & {
     missionName?: string;
   }
 };
diff --git a/src/components/FowV4MatchResultForm/FowV4MatchResultForm.tsx b/src/components/FowV4MatchResultForm/FowV4MatchResultForm.tsx
index 4c872870..04a0de8f 100644
--- a/src/components/FowV4MatchResultForm/FowV4MatchResultForm.tsx
+++ b/src/components/FowV4MatchResultForm/FowV4MatchResultForm.tsx
@@ -3,7 +3,7 @@ import { zodResolver } from '@hookform/resolvers/zod';
 import clsx from 'clsx';
 
 import {
-  MatchResultId,
+  MatchResult,
   TournamentPairingId,
   UserId,
 } from '~/api';
@@ -16,11 +16,7 @@ import { SelectValue } from '~/components/generic/InputSelect/InputSelect.types'
 import { Label } from '~/components/generic/Label';
 import { Separator } from '~/components/generic/Separator';
 import { useAsyncState } from '~/hooks/useAsyncState';
-import {
-  useCreateMatchResult,
-  useGetMatchResult,
-  useUpdateMatchResult,
-} from '~/services/matchResults';
+import { useCreateMatchResult, useUpdateMatchResult } from '~/services/matchResults';
 import { useGetActiveTournamentPairingsByUser } from '~/services/tournamentPairings';
 import { getTournamentPairingDisplayName } from '~/utils/common/getTournamentPairingDisplayName';
 import { CommonFields } from './components/CommonFields';
@@ -40,7 +36,7 @@ const confirmMatchResultDialogId = 'confirm-match-result';
 export interface FowV4MatchResultFormProps {
   id: string;
   className?: string;
-  matchResultId?: MatchResultId;
+  matchResult?: MatchResult;
   tournamentPairingId?: TournamentPairingId;
   onSuccess?: () => void;
 }
@@ -48,17 +44,12 @@ export interface FowV4MatchResultFormProps {
 export const FowV4MatchResultForm = ({
   id,
   className,
-  matchResultId,
+  matchResult,
   tournamentPairingId: forcedTournamentPairingId,
   onSuccess,
 }: FowV4MatchResultFormProps): JSX.Element => {
   const user = useAuth();
 
-  const {
-    data: matchResult,
-    loading: matchResultLoading,
-  } = useGetMatchResult(matchResultId ? { id: matchResultId } : 'skip');
-
   const [
     tournamentPairingId,
     setTournamentPairingId,
@@ -89,9 +80,10 @@ export const FowV4MatchResultForm = ({
 
   const form = useForm<FowV4MatchResultFormData>({
     resolver: zodResolver(fowV4MatchResultFormSchema),
-    defaultValues,
-    // React-Hook-Form is stupid and doesn't allow applying a partial record to the form values
-    values: { ...matchResult as FowV4MatchResultFormData },
+    defaultValues: {
+      ...defaultValues,
+      ...(matchResult ? fowV4MatchResultFormSchema.parse(matchResult) : {}),
+    },
     mode: 'onSubmit',
   });
 
@@ -143,13 +135,13 @@ export const FowV4MatchResultForm = ({
 
   const disableSubmit = createMatchResultLoading || updateMatchResultLoading;
 
-  if (tournamentPairingsLoading || matchResultLoading) {
+  if (tournamentPairingsLoading) {
     return <div>Loading...</div>;
   }
 
   return (
     <Form id={id} form={form} onSubmit={onSubmit} className={clsx(styles.FowV4MatchResultForm, className)}>
-      {!matchResultId && (
+      {!matchResult && !forcedTournamentPairingId && (
         <>
           <div className={styles.FowV4MatchResultForm_ResultForSection}>
             <Label>
diff --git a/src/components/FowV4MatchResultForm/components/CommonFields.hooks.ts b/src/components/FowV4MatchResultForm/components/CommonFields.hooks.ts
index 79edc529..06131552 100644
--- a/src/components/FowV4MatchResultForm/components/CommonFields.hooks.ts
+++ b/src/components/FowV4MatchResultForm/components/CommonFields.hooks.ts
@@ -53,7 +53,6 @@ export const useMissionOptions = () => {
   const {
     missionMatrixId,
     missionPackId,
-    useExperimentalMissions,
   } = gameSystemConfig;
   return useMemo(() => {
     const missionPack = getMissionPack(missionPackId);
@@ -78,15 +77,12 @@ export const useMissionOptions = () => {
     
     const matrixEntryMissionIds = matrixEntry.missions.reduce((acc: string[], item) => {
       if (Array.isArray(item)) {
-        if (item[1] && useExperimentalMissions) {
-          return [...acc, item[1]];
-        }
         return [ ...acc, ...item];
       }
-      return [ ...acc,item];
+      return [ ...acc, item];
     }, []);
     return missionsOptions.filter((option) => matrixEntryMissionIds.includes(option.value));
-  }, [player0BattlePlan, player1BattlePlan, missionPackId, missionMatrixId, useExperimentalMissions]);
+  }, [player0BattlePlan, player1BattlePlan, missionPackId, missionMatrixId ]);
 };
 
 export const useOutcomeTypeOptions = () => {
diff --git a/src/components/FowV4MatchResultForm/components/TournamentPlayersFields.tsx b/src/components/FowV4MatchResultForm/components/TournamentPlayersFields.tsx
index caf6736b..68145733 100644
--- a/src/components/FowV4MatchResultForm/components/TournamentPlayersFields.tsx
+++ b/src/components/FowV4MatchResultForm/components/TournamentPlayersFields.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo } from 'react';
+import { useEffect } from 'react';
 import { useFormContext } from 'react-hook-form';
 
 import { fowV4BattlePlanOptions, TournamentPairingId } from '~/api';
@@ -27,12 +27,8 @@ export const TournamentPlayersFields = ({
   const player0Label = `${getTournamentCompetitorDisplayName(selectedPairing?.tournamentCompetitor0)} Player`;
   const player1Label = `${getTournamentCompetitorDisplayName(selectedPairing?.tournamentCompetitor1)} Player`;
 
-  const player0Options = useMemo(() => (
-    getCompetitorPlayerOptions(selectedPairing?.tournamentCompetitor0)
-  ), [selectedPairing]);
-  const player1Options = useMemo(() => (
-    getCompetitorPlayerOptions(selectedPairing?.tournamentCompetitor1)
-  ), [selectedPairing]);
+  const player0Options = getCompetitorPlayerOptions(selectedPairing?.tournamentCompetitor0);
+  const player1Options = getCompetitorPlayerOptions(selectedPairing?.tournamentCompetitor1);
 
   // Automatically set "Player 1" if possible
   useEffect(() => {
@@ -48,6 +44,10 @@ export const TournamentPlayersFields = ({
     }
   }, [player1Options, player1UserId, setValue]);
 
+  if (!selectedPairing) {
+    return <div>Loading...</div>;
+  }
+
   return (
     <div className={styles.Root}>
       <div className={styles.Player0Section}>
diff --git a/src/components/IdentityBadge/index.ts b/src/components/IdentityBadge/index.ts
index 0dfc5141..6be5ab60 100644
--- a/src/components/IdentityBadge/index.ts
+++ b/src/components/IdentityBadge/index.ts
@@ -1,3 +1,6 @@
 export type { IdentityBadgeProps } from './IdentityBadge';
 export { IdentityBadge } from './IdentityBadge';
-export type { Identity } from './IdentityBadge.types';
+export type {
+  Identity,
+  IdentityBadgePlaceholder,
+} from './IdentityBadge.types';
diff --git a/src/components/MatchResultContextMenu/MatchResultContextMenu.tsx b/src/components/MatchResultContextMenu/MatchResultContextMenu.tsx
index 868df3e8..ed6a3303 100644
--- a/src/components/MatchResultContextMenu/MatchResultContextMenu.tsx
+++ b/src/components/MatchResultContextMenu/MatchResultContextMenu.tsx
@@ -6,6 +6,7 @@ import { PopoverMenu } from '~/components/generic/PopoverMenu';
 import { MatchResultDeleteDialog, useMatchResultDeleteDialog } from '~/components/MatchResultDeleteDialog';
 import { MatchResultEditDialog, useMatchResultEditDialog } from '~/components/MatchResultEditDialog';
 import { useMatchResult } from '~/components/MatchResultProvider';
+import { useGetTournament } from '~/services/tournaments';
 
 export interface MatchResultContextMenuProps {
   size?: 'small' | 'normal' | 'large';
@@ -16,12 +17,18 @@ export const MatchResultContextMenu = ({
 }: MatchResultContextMenuProps): JSX.Element | null => {
   const user = useAuth();
   const matchResult = useMatchResult();
+  const { data: tournament } = useGetTournament(matchResult.tournamentId ? {
+    id: matchResult.tournamentId,
+  } : 'skip');
 
   const { open: openEditDialog } = useMatchResultEditDialog(matchResult._id);
   const { open: openDeleteDialog } = useMatchResultDeleteDialog(matchResult._id);
 
   // TODO: Make better check for showing context menu
-  const showContextMenu = user && !matchResult.tournamentPairingId && [matchResult.player0UserId, matchResult.player1UserId].includes(user._id);
+  const isOrganizer = user && tournament?.organizerUserIds.includes(user._id) && tournament?.status === 'active';
+  const isPlayer = user && [matchResult.player0UserId, matchResult.player1UserId].includes(user._id);
+
+  const showContextMenu = isOrganizer || (isPlayer && !matchResult.tournamentId); // Don't allow editing of tournament results
   const contextMenuItems = [
     { label: 'Edit', onClick: openEditDialog },
     { label: 'Delete', onClick: openDeleteDialog },
diff --git a/src/components/MatchResultCreateDialog/MatchResultCreateDialog.hooks.tsx b/src/components/MatchResultCreateDialog/MatchResultCreateDialog.hooks.tsx
index b6e35eb8..6d741635 100644
--- a/src/components/MatchResultCreateDialog/MatchResultCreateDialog.hooks.tsx
+++ b/src/components/MatchResultCreateDialog/MatchResultCreateDialog.hooks.tsx
@@ -1,3 +1,4 @@
+import { TournamentPairingId } from '~/api';
 import { useModal } from '~/modals';
 
-export const useMatchResultCreateDialog = () => useModal('match-result-create-dialog');
+export const useMatchResultCreateDialog = () => useModal<{ tournamentPairingId: TournamentPairingId }>('match-result-create-dialog');
diff --git a/src/components/MatchResultCreateDialog/MatchResultCreateDialog.tsx b/src/components/MatchResultCreateDialog/MatchResultCreateDialog.tsx
index b8c09d4f..cc31d0d8 100644
--- a/src/components/MatchResultCreateDialog/MatchResultCreateDialog.tsx
+++ b/src/components/MatchResultCreateDialog/MatchResultCreateDialog.tsx
@@ -1,3 +1,4 @@
+import { TournamentPairingId } from '~/api';
 import { FowV4MatchResultForm } from '~/components/FowV4MatchResultForm';
 import { Button } from '~/components/generic/Button';
 import {
@@ -11,8 +12,14 @@ import { useMatchResultCreateDialog } from './MatchResultCreateDialog.hooks';
 
 import styles from './MatchResultCreateDialog.module.scss';
 
-export const MatchResultCreateDialog = (): JSX.Element => {
-  const { id, close } = useMatchResultCreateDialog();
+export interface MatchResultCreateDialogProps {
+  tournamentPairingId?: TournamentPairingId;
+}
+
+export const MatchResultCreateDialog = ({
+  tournamentPairingId,
+}: MatchResultCreateDialogProps): JSX.Element => {
+  const { id, close, data } = useMatchResultCreateDialog();
   return (
     <ControlledDialog id={id} className={styles.MatchResultCreateDialog}>
       <DialogHeader title="Create Match Result" onCancel={close} />
@@ -20,6 +27,7 @@ export const MatchResultCreateDialog = (): JSX.Element => {
       <ScrollArea type="scroll" indicatorBorders={['top', 'bottom']}>
         <FowV4MatchResultForm
           id="fow-v4-match-result-form"
+          tournamentPairingId={tournamentPairingId ?? data?.tournamentPairingId}
           className={styles.Form}
           onSuccess={close}
         />
diff --git a/src/components/MatchResultEditDialog/MatchResultEditDialog.tsx b/src/components/MatchResultEditDialog/MatchResultEditDialog.tsx
index f0a88742..cb5fc08c 100644
--- a/src/components/MatchResultEditDialog/MatchResultEditDialog.tsx
+++ b/src/components/MatchResultEditDialog/MatchResultEditDialog.tsx
@@ -22,7 +22,7 @@ export const MatchResultEditDialog = (): JSX.Element => {
       <ScrollArea type="scroll" indicatorBorders={['top', 'bottom']}>
         <FowV4MatchResultForm
           id="fow-v4-match-result-form"
-          matchResultId={matchResult._id}
+          matchResult={matchResult}
           className={styles.Form}
           onSuccess={close}
         />
diff --git a/src/pages/DashboardPage/DashboardPage.tsx b/src/pages/DashboardPage/DashboardPage.tsx
index 320a7fcf..6e2d396d 100644
--- a/src/pages/DashboardPage/DashboardPage.tsx
+++ b/src/pages/DashboardPage/DashboardPage.tsx
@@ -27,7 +27,7 @@ export const DashboardPage = (): JSX.Element => {
     stats: <LineChart />,
   };
   return (
-    <PageWrapper title="Dashboard" fitToWindow footer={!isDesktop ? (
+    <PageWrapper title="Dashboard" fitToWindow={isDesktop} footer={!isDesktop ? (
       <div className={styles.DashboardPage_Tabs}>
         {Object.entries(tabs).map(([key, icon]) => (
           <div key={key} className={styles.DashboardPage_TabTrigger}>
diff --git a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.module.scss b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.module.scss
index fa8eefd2..7efb0066 100644
--- a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.module.scss
+++ b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.module.scss
@@ -26,9 +26,10 @@
   &_OpponentSection {
     display: grid;
     grid-template-areas:
-      "opponentLabel tableLabel ."
-      "opponent table checkInButton";
-    grid-template-columns: 1fr auto auto;
+      "opponentLabel tableLabel"
+      "opponent table"
+      "checkInButton checkInButton";
+    grid-template-columns: 1fr auto;
     grid-template-rows: auto auto;
     row-gap: 0.5rem;
     column-gap: 1rem;
@@ -56,6 +57,7 @@
 
     &_CheckInButton {
       grid-area: checkInButton;
+      margin-top: 1rem;
     }
   }
 
diff --git a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
index f653bb89..6b76880b 100644
--- a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
+++ b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
@@ -1,6 +1,6 @@
 import { generatePath, useNavigate } from 'react-router-dom';
 import clsx from 'clsx';
-import { ChevronRight, Plus } from 'lucide-react';
+import { ChevronRight } from 'lucide-react';
 
 import {
   Tournament,
@@ -8,7 +8,6 @@ import {
   TournamentPairing,
 } from '~/api';
 import { useAuth } from '~/components/AuthProvider';
-import { CheckInMatchDialog } from '~/components/CheckInMatchDialog';
 import { Button } from '~/components/generic/Button';
 import { Separator } from '~/components/generic/Separator';
 import { IdentityBadge } from '~/components/IdentityBadge';
@@ -47,6 +46,12 @@ export const ActiveTournament = ({
   const handleViewMore = (): void => {
     navigate(generatePath(PATHS.tournamentDetails, { id: tournament._id }));
   };
+  const handleViewMatchResults = (): void => {
+    if (!pairing) {
+      return;
+    }
+    navigate(generatePath(PATHS.tournamentPairingDetails, { id: pairing._id }));
+  };
 
   const isOrganizer = user && tournament && tournament.organizerUserIds.includes(user._id);
   const showTimer = tournament && tournament.currentRound !== undefined;
@@ -68,31 +73,32 @@ export const ActiveTournament = ({
         </Header>
         {showTimer && (
           <>
-            <TournamentTimer className={styles.ActiveTournamentCard_Timer} />
+            <TournamentTimer className={styles.ActiveTournament_Timer} />
             <Separator />
           </>
         )}
         {showOpponent && (
           <>
-            <div className={styles.ActiveTournamentCard_OpponentSection}>
-              <h3 className={styles.ActiveTournamentCard_OpponentSection_OpponentLabel}>
+            <div className={styles.ActiveTournament_OpponentSection}>
+              <h3 className={styles.ActiveTournament_OpponentSection_OpponentLabel}>
                 {tournament.currentRound !== undefined ? 'Current Opponent' : 'Next Opponent'}
               </h3>
               <IdentityBadge
-                className={styles.ActiveTournamentCard_OpponentSection_Opponent}
+                className={styles.ActiveTournament_OpponentSection_Opponent}
                 competitor={opponent}
               />
-              <h3 className={styles.ActiveTournamentCard_OpponentSection_TableLabel}>
+              <h3 className={styles.ActiveTournament_OpponentSection_TableLabel}>
                 Table
               </h3>
-              <span className={styles.ActiveTournamentCard_OpponentSection_Table}>
+              <span className={styles.ActiveTournament_OpponentSection_Table}>
                 {(pairing?.table ?? 0) + 1}
               </span>
-              <CheckInMatchDialog tournamentPairingId={pairing._id}>
-                <Button className={styles.ActiveTournamentCard_OpponentSection_CheckInButton}>
-                  <Plus /> Add Match Result
-                </Button>
-              </CheckInMatchDialog>
+              <Button
+                className={styles.ActiveTournament_OpponentSection_CheckInButton}
+                onClick={handleViewMatchResults}
+              >
+                Match Results <ChevronRight />
+              </Button>
             </div>
             <Separator />
           </>
diff --git a/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.tsx b/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.tsx
index 22eb0c02..1b0dfc35 100644
--- a/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.tsx
+++ b/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.tsx
@@ -1,4 +1,5 @@
 import { ReactElement, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
 import clsx from 'clsx';
 import { Zap } from 'lucide-react';
 
@@ -21,6 +22,7 @@ export interface TournamentPairingsCardProps {
 export const TournamentPairingsCard = ({
   className,
 }: TournamentPairingsCardProps): JSX.Element => {
+  const navigate = useNavigate();
   const { _id: tournamentId, lastRound, roundCount } = useTournament();
   const actions = useTournamentActions();
 
@@ -34,7 +36,7 @@ export const TournamentPairingsCard = ({
     round,
   });
 
-  const columns = getTournamentPairingTableConfig();
+  const columns = getTournamentPairingTableConfig(navigate);
   const rows = (tournamentPairings || []);
 
   const showEmptyState = !loading && !rows.length;
diff --git a/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.utils.tsx b/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.utils.tsx
index b7225739..700033e9 100644
--- a/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.utils.tsx
+++ b/src/pages/TournamentDetailPage/components/TournamentPairingsCard/TournamentPairingsCard.utils.tsx
@@ -1,16 +1,19 @@
-import { Swords } from 'lucide-react';
+import { generatePath, NavigateFunction } from 'react-router-dom';
+import { ChevronRight, Swords } from 'lucide-react';
 
 import { TournamentPairing } from '~/api';
+import { Button } from '~/components/generic/Button';
 import { CircularProgress } from '~/components/generic/CircularProgress';
 import { InfoPopover } from '~/components/generic/InfoPopover';
 import { ColumnDef } from '~/components/generic/Table';
 import { TournamentPairingRow } from '~/components/TournamentPairingRow';
+import { PATHS } from '~/settings';
 
 import styles from './TournamentPairingsCard.module.scss';
 
 const matchIndicatorSize = 40; // 2.5rem
 
-export const getTournamentPairingTableConfig = (): ColumnDef<TournamentPairing>[] => [
+export const getTournamentPairingTableConfig = (navigate: NavigateFunction): ColumnDef<TournamentPairing>[] => [
   {
     key: 'table',
     label: 'Table',
@@ -48,4 +51,18 @@ export const getTournamentPairingTableConfig = (): ColumnDef<TournamentPairing>[
       </InfoPopover>
     ),
   },
+  {
+    key: 'viewPairing',
+    width: matchIndicatorSize,
+    align: 'center',
+    renderCell: ({ _id }) => (
+      <Button
+        variant="secondary"
+        onClick={() => navigate(generatePath(PATHS.tournamentPairingDetails, { id: _id }))}
+      >
+        <ChevronRight />
+      </Button>
+    ),
+    renderHeader: () => null,
+  },
 ];
diff --git a/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.module.scss b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.module.scss
new file mode 100644
index 00000000..ab694245
--- /dev/null
+++ b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.module.scss
@@ -0,0 +1,22 @@
+@use "/src/style/flex";
+@use "/src/style/text";
+@use "/src/style/variables";
+@use "/src/style/corners";
+@use "/src/style/variants";
+@use "/src/style/shadows";
+@use "/src/style/borders";
+
+.TournamentPairingDetailPage {
+  @include flex.column;
+
+  &_Details {
+    @include variants.card;
+    @include flex.column;
+
+    padding: var(--container-padding-x);
+  }
+
+  &_MatchResults {
+    @include flex.column;
+  }
+}
diff --git a/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
new file mode 100644
index 00000000..83fd3c7d
--- /dev/null
+++ b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
@@ -0,0 +1,76 @@
+import { useParams } from 'react-router-dom';
+import { Plus } from 'lucide-react';
+
+import { TournamentPairingId } from '~/api';
+import { useAuth } from '~/components/AuthProvider';
+import { Button } from '~/components/generic/Button';
+import { Spinner } from '~/components/generic/Spinner';
+import { MatchResultCard } from '~/components/MatchResultCard';
+import { MatchResultCreateDialog, useMatchResultCreateDialog } from '~/components/MatchResultCreateDialog';
+import { PageWrapper } from '~/components/PageWrapper';
+import { TournamentPairingRow } from '~/components/TournamentPairingRow';
+import { useGetMatchResultsByTournamentPairing } from '~/services/matchResults';
+import { useGetTournamentPairing } from '~/services/tournamentPairings';
+import { useGetTournament } from '~/services/tournaments';
+
+import styles from './TournamentPairingDetailPage.module.scss';
+
+export const TournamentPairingDetailPage = (): JSX.Element => {
+  const user = useAuth();
+  const params = useParams();
+  const tournamentPairingId = params.id! as TournamentPairingId; // Must exist or else how did we get to this route?
+
+  const { data: tournamentPairing, loading: tournamentPairingLoading } = useGetTournamentPairing({ id: tournamentPairingId });
+  const { data: tournament, loading: tournamentLoading } = useGetTournament(tournamentPairing ? {
+    id: tournamentPairing.tournamentId,
+  } : 'skip');
+  const { data: matchResults, loading: matchResultsLoading } = useGetMatchResultsByTournamentPairing({
+    tournamentPairingId: tournamentPairingId,
+  });
+
+  const { open: openMatchResultCreateDialog } = useMatchResultCreateDialog();
+
+  const showLoading = !tournamentPairing || tournamentPairingLoading || matchResultsLoading || tournamentLoading;
+
+  const isPlayer = user && tournamentPairing?.playerUserIds.includes(user._id);
+  const isOrganizer = user && tournament?.organizerUserIds.includes(user._id);
+  const isComplete = tournamentPairing && tournamentPairing.matchResultsProgress.submitted === tournamentPairing?.matchResultsProgress.required;
+  const showAddMatchResult = (isPlayer || isOrganizer) && !isComplete;
+
+  return (
+    <PageWrapper
+      showBackButton
+      maxWidth={540}
+      title="Pairing Details"
+      footer={showAddMatchResult ? (
+        <div>
+          <Button onClick={() => openMatchResultCreateDialog({ tournamentPairingId })}>
+            <Plus />Add Match Result
+          </Button>
+        </div>
+      ) : null}
+    >
+      <div className={styles.TournamentPairingDetailPage}>
+        {showLoading ? (
+          <Spinner />
+        ) : (
+          <>
+            <div className={styles.TournamentPairingDetailPage_Details}>
+              <TournamentPairingRow pairing={tournamentPairing} />
+              <p>
+                {`Submitted Match Results: ${tournamentPairing.matchResultsProgress.submitted}/${tournamentPairing.matchResultsProgress.required}`}
+              </p>
+            </div>
+
+            <div className={styles.TournamentPairingDetailPage_MatchResults}>
+              {(matchResults ?? []).map((matchResult) => (
+                <MatchResultCard key={matchResult._id} matchResult={matchResult} />
+              ))}
+            </div>
+          </>
+        )}
+      </div>
+      <MatchResultCreateDialog />
+    </PageWrapper>
+  );
+};
diff --git a/src/pages/TournamentPairingDetailPage/index.ts b/src/pages/TournamentPairingDetailPage/index.ts
new file mode 100644
index 00000000..a41f48d9
--- /dev/null
+++ b/src/pages/TournamentPairingDetailPage/index.ts
@@ -0,0 +1 @@
+export { TournamentPairingDetailPage } from './TournamentPairingDetailPage';
diff --git a/src/routes.tsx b/src/routes.tsx
index 6783efd6..9d681eee 100644
--- a/src/routes.tsx
+++ b/src/routes.tsx
@@ -28,6 +28,7 @@ import {
 import { TournamentCreatePage } from '~/pages/TournamentCreatePage';
 import { TournamentDetailPage } from '~/pages/TournamentDetailPage';
 import { TournamentEditPage } from '~/pages/TournamentEditPage/TournamentEditPage';
+import { TournamentPairingDetailPage } from '~/pages/TournamentPairingDetailPage';
 import { TournamentPairingsPage } from '~/pages/TournamentPairingsPage';
 import { TournamentsPage } from '~/pages/TournamentsPage';
 import { PATHS } from '~/settings';
@@ -137,6 +138,11 @@ export const routes = [
     visibility: [],
     element: <TournamentPairingsPage />,
   },
+  {
+    path: PATHS.tournamentPairingDetails,
+    visibility: [],
+    element: <TournamentPairingDetailPage />,
+  },
   {
     path: PATHS.tournamentEdit,
     visibility: [],
diff --git a/src/settings.ts b/src/settings.ts
index 700a206d..728b76e6 100644
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -21,4 +21,5 @@ export const PATHS = {
   tournamentEdit: '/tournaments/:id/edit',
   tournamentPairings: '/tournaments/:id/pairings',
   tournaments: '/tournaments',
+  tournamentPairingDetails: '/pairings/:id',
 } as const;

From 44a3dd4eabb9b92cff82b04ff2807014168358b3 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Sat, 26 Jul 2025 08:54:33 +0200
Subject: [PATCH 6/9] hotfix: Don't show submit match button if there is no
 current round

---
 .../TournamentPairingDetailPage/TournamentPairingDetailPage.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
index 83fd3c7d..2f8ae5d0 100644
--- a/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
+++ b/src/pages/TournamentPairingDetailPage/TournamentPairingDetailPage.tsx
@@ -35,7 +35,7 @@ export const TournamentPairingDetailPage = (): JSX.Element => {
   const isPlayer = user && tournamentPairing?.playerUserIds.includes(user._id);
   const isOrganizer = user && tournament?.organizerUserIds.includes(user._id);
   const isComplete = tournamentPairing && tournamentPairing.matchResultsProgress.submitted === tournamentPairing?.matchResultsProgress.required;
-  const showAddMatchResult = (isPlayer || isOrganizer) && !isComplete;
+  const showAddMatchResult = (isPlayer || isOrganizer) && !isComplete && tournament?.currentRound !== undefined;
 
   return (
     <PageWrapper

From 921fdcc2901840e6c56292765221b1cc1ee8847a Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Wed, 30 Jul 2025 23:35:58 +0200
Subject: [PATCH 7/9] Performance improvements (#130)

* refactor: Tournament actions

* refactor: Remove IDs from <IdentityBadge/> to reduce Convex fn calls
---
 .../tournaments/_helpers/deepenTournament.ts  |  6 +-
 .../_helpers/getTournamentNextRound.ts        | 14 +++
 .../_helpers/getTournamentPlayerUserIds.ts    | 25 +++++
 convex/_model/tournaments/index.ts            |  4 +
 .../queries/getAvailableTournamentActions.ts  | 91 +++++++++++++++++++
 convex/tournaments.ts                         |  5 +
 .../FowV4MatchResultDetails.hooks.ts          | 21 +----
 .../FowV4MatchResultDetails.types.ts          |  2 +-
 .../IdentityBadge/IdentityBadge.hooks.tsx     | 25 +----
 .../IdentityBadge/IdentityBadge.tsx           | 13 +--
 .../IdentityBadge/IdentityBadge.types.ts      | 15 +--
 .../TournamentActionsProvider.hooks.tsx       | 25 +----
 .../TournamentPairingRow.tsx                  |  6 +-
 .../TournamentPairingRow.utils.tsx            | 47 ++--------
 .../ActiveTournament/ActiveTournament.tsx     |  8 +-
 .../ActiveTournament.utils.tsx                | 11 +--
 .../TournamentPairingsPage.utils.tsx          |  2 +-
 .../ConfirmPairingsDialog.tsx                 | 30 +-----
 ...ils.ts => ConfirmPairingsDialog.utils.tsx} | 42 ++++++++-
 src/services/tournaments.ts                   |  1 +
 20 files changed, 225 insertions(+), 168 deletions(-)
 create mode 100644 convex/_model/tournaments/_helpers/getTournamentNextRound.ts
 create mode 100644 convex/_model/tournaments/_helpers/getTournamentPlayerUserIds.ts
 create mode 100644 convex/_model/tournaments/queries/getAvailableTournamentActions.ts
 rename src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/{ConfirmPairingsDialog.utils.ts => ConfirmPairingsDialog.utils.tsx} (62%)

diff --git a/convex/_model/tournaments/_helpers/deepenTournament.ts b/convex/_model/tournaments/_helpers/deepenTournament.ts
index 7096b60f..fa62f304 100644
--- a/convex/_model/tournaments/_helpers/deepenTournament.ts
+++ b/convex/_model/tournaments/_helpers/deepenTournament.ts
@@ -1,6 +1,7 @@
 import { Doc, Id } from '../../../_generated/dataModel';
 import { QueryCtx } from '../../../_generated/server';
 import { getStorageUrl } from '../../common/_helpers/getStorageUrl';
+import { getTournamentNextRound } from './getTournamentNextRound';
 
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /**
@@ -35,9 +36,6 @@ export const deepenTournament = async (
     ...c.players.filter((p) => p.active).map((p) => p.userId),
   ], [] as Id<'users'>[]);
 
-  // Computed properties (easy to do, but used so frequently, it's nice to include them by default)
-  const nextRound = (tournament.currentRound ?? tournament.lastRound ?? -1) + 1;
-
   return {
     ...tournament,
     logoUrl,
@@ -49,7 +47,7 @@ export const deepenTournament = async (
     activePlayerUserIds,
     maxPlayers : tournament.maxCompetitors * tournament.competitorSize,
     useTeams: tournament.competitorSize > 1,
-    nextRound: nextRound < tournament.roundCount ? nextRound : undefined,
+    nextRound: getTournamentNextRound(tournament),
   };
 };
 
diff --git a/convex/_model/tournaments/_helpers/getTournamentNextRound.ts b/convex/_model/tournaments/_helpers/getTournamentNextRound.ts
new file mode 100644
index 00000000..ac1af029
--- /dev/null
+++ b/convex/_model/tournaments/_helpers/getTournamentNextRound.ts
@@ -0,0 +1,14 @@
+import { Doc } from '../../../_generated/dataModel';
+
+/**
+ * Gets the next round of a tournament.
+ * 
+ * @param tournament - Raw Tournament document
+ * @returns The next round if there will be one, otherwise undefined
+ */
+export const getTournamentNextRound = (
+  tournament: Doc<'tournaments'>,
+): number | undefined => {
+  const nextRound = (tournament.currentRound ?? tournament.lastRound ?? -1) + 1;
+  return nextRound < tournament.roundCount ? nextRound : undefined;
+};
diff --git a/convex/_model/tournaments/_helpers/getTournamentPlayerUserIds.ts b/convex/_model/tournaments/_helpers/getTournamentPlayerUserIds.ts
new file mode 100644
index 00000000..0fdc4fcb
--- /dev/null
+++ b/convex/_model/tournaments/_helpers/getTournamentPlayerUserIds.ts
@@ -0,0 +1,25 @@
+import { Id } from '../../../_generated/dataModel';
+import { QueryCtx } from '../../../_generated/server';
+
+/**
+ * Get a list of user IDs for the players of a tournament.
+ * 
+ * @param ctx - Convex query context
+ * @param tournamentId - ID of the tournament
+ * @param activeOnly - Limit to active players
+ * @returns Array of user IDs
+ */
+export const getTournamentPlayerUserIds = async (
+  ctx: QueryCtx,
+  tournamentId: Id<'tournaments'>,
+  activeOnly = false,
+): Promise<Id<'users'>[]> => {
+  const tournamentCompetitors = await ctx.db.query('tournamentCompetitors').withIndex(
+    'by_tournament_id',
+    (q) => q.eq('tournamentId', tournamentId),
+  ).collect();
+  return tournamentCompetitors.reduce((acc, c) => [
+    ...acc,
+    ...c.players.filter((p) => activeOnly ? p.active : true).map((p) => p.userId),
+  ], [] as Id<'users'>[]);
+};
diff --git a/convex/_model/tournaments/index.ts b/convex/_model/tournaments/index.ts
index a8d9e67f..1b5d40ec 100644
--- a/convex/_model/tournaments/index.ts
+++ b/convex/_model/tournaments/index.ts
@@ -66,6 +66,10 @@ export {
 } from './mutations/updateTournament';
 
 // Queries
+export {
+  getAvailableTournamentActions,
+  getAvailableTournamentActionsArgs,
+} from './queries/getAvailableTournamentActions';
 export {
   getTournament,
   getTournamentArgs,
diff --git a/convex/_model/tournaments/queries/getAvailableTournamentActions.ts b/convex/_model/tournaments/queries/getAvailableTournamentActions.ts
new file mode 100644
index 00000000..e55fe23a
--- /dev/null
+++ b/convex/_model/tournaments/queries/getAvailableTournamentActions.ts
@@ -0,0 +1,91 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { Infer, v } from 'convex/values';
+
+import { QueryCtx } from '../../../_generated/server';
+import { TournamentActionKey } from '..';
+import { checkTournamentVisibility } from '../_helpers/checkTournamentVisibility';
+import { getTournamentNextRound } from '../_helpers/getTournamentNextRound';
+import { getTournamentPlayerUserIds } from '../_helpers/getTournamentPlayerUserIds';
+
+export const getAvailableTournamentActionsArgs = v.object({
+  id: v.id('tournaments'),
+});
+
+/**
+ * Gets a list of tournament actions which are available to a user.
+ * 
+ * @param ctx - Convex query context
+ * @param args - Convex query args
+ * @param args.id - ID of the tournament
+ * @returns An array of TournamentActionKey(s)
+ */
+export const getAvailableTournamentActions = async (
+  ctx: QueryCtx,
+  args: Infer<typeof getAvailableTournamentActionsArgs>,
+): Promise<TournamentActionKey[]> => {
+  const tournament = await ctx.db.get(args.id);
+  if (!tournament) {
+    return [];
+  }
+
+  // --- CHECK AUTH ----
+  const userId = await getAuthUserId(ctx);
+  if (!(await checkTournamentVisibility(ctx, tournament))) {
+    return [];
+  }
+
+  // ---- GATHER DATA ----
+  const nextRound = getTournamentNextRound(tournament);
+  const nextRoundPairings = await ctx.db.query('tournamentPairings')
+    .withIndex('by_tournament_id', (q) => q.eq('tournamentId', args.id))
+    .collect();
+  const nextRoundPairingCount = (nextRoundPairings ?? []).length;
+  const playerUserIds = await getTournamentPlayerUserIds(ctx, tournament._id);
+
+  const isOrganizer = !!userId && tournament.organizerUserIds.includes(userId);
+  const isPlayer = !!userId && playerUserIds.includes(userId);
+
+  const hasCurrentRound = tournament.currentRound !== undefined;
+  const hasNextRound = nextRound !== undefined;
+
+  // ---- PRIMARY ACTIONS ----
+  const actions: TournamentActionKey[] = [];
+
+  if (isOrganizer && ['draft', 'published'].includes(tournament.status)) {
+    actions.push(TournamentActionKey.Edit);
+  }
+
+  if (isOrganizer && tournament.status === 'draft') {
+    actions.push(TournamentActionKey.Delete);
+  }
+      
+  if (isOrganizer && tournament.status === 'draft') {
+    actions.push(TournamentActionKey.Publish);
+  }
+
+  if (isOrganizer && tournament.status === 'published') { // TODO: Check for at least 2 competitors
+    actions.push(TournamentActionKey.Start);
+  }
+
+  if (isOrganizer && !hasCurrentRound && hasNextRound && nextRoundPairingCount === 0) {
+    actions.push(TournamentActionKey.ConfigureRound);
+  }
+
+  if (isOrganizer && !hasCurrentRound && hasNextRound && nextRoundPairingCount > 0) {
+    actions.push(TournamentActionKey.StartRound);
+  }
+
+  if ((isOrganizer || isPlayer) && hasCurrentRound) { // TODO: Don't show if all matches checked in
+    actions.push(TournamentActionKey.SubmitMatchResult);
+  }
+
+  if (isOrganizer && hasCurrentRound) {
+    actions.push(TournamentActionKey.EndRound);
+  }
+
+  if (isOrganizer && !hasCurrentRound) {
+    actions.push(TournamentActionKey.End);
+  }
+
+  return actions;
+};
diff --git a/convex/tournaments.ts b/convex/tournaments.ts
index 9c50a783..69f72f22 100644
--- a/convex/tournaments.ts
+++ b/convex/tournaments.ts
@@ -31,6 +31,11 @@ export const getTournamentRankings = query({
   handler: model.getTournamentRankings,
 });
 
+export const getAvailableTournamentActions = query({
+  args: model.getAvailableTournamentActionsArgs,
+  handler: model.getAvailableTournamentActions,
+});
+
 export const createTournament = mutation({
   args: model.createTournamentArgs,
   handler: model.createTournament,
diff --git a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.hooks.ts b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.hooks.ts
index 243b5356..c1592c2a 100644
--- a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.hooks.ts
+++ b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.hooks.ts
@@ -1,6 +1,3 @@
-import { useQuery } from 'convex/react';
-
-import { api } from '~/api';
 import { Identity } from '~/components/IdentityBadge';
 import { getUserDisplayNameString } from '~/utils/common/getUserDisplayNameString';
 import { FowV4MatchResultDetailsData } from './FowV4MatchResultDetails.types';
@@ -15,14 +12,9 @@ export const usePlayerName = (
   identity: Identity,
   loading?: boolean,
 ): UserPlayerNameResult => {
-  const { user, userId, placeholder } = identity;
-
-  // TODO: Replace with a service hook
-  const queryUser = useQuery(api.users.getUser, userId ? {
-    id: userId,
-  } : 'skip');
+  const { user, placeholder } = identity;
 
-  if (loading || (userId && !queryUser)) {
+  if (loading) {
     return {
       loading: true,
     };
@@ -34,13 +26,6 @@ export const usePlayerName = (
       displayName: getUserDisplayNameString(user),
     };
   }
-  
-  if (userId && queryUser) {
-    return {
-      loading: false,
-      displayName: getUserDisplayNameString(queryUser),
-    };  
-  }
 
   if (placeholder) {
     return {
@@ -62,14 +47,12 @@ export const usePlayerNames = (
 ): UserPlayerNamesResult => {
   const { displayName: player0DisplayName, loading: player0Loading } = usePlayerName({
     user: matchResult.player0User,
-    userId: matchResult.player0UserId,
     placeholder: matchResult.player0Placeholder ? {
       displayName: matchResult.player0Placeholder,
     } : undefined,
   });
   const { displayName: player1DisplayName, loading: player1Loading } = usePlayerName({
     user: matchResult.player1User,
-    userId: matchResult.player1UserId,
     placeholder: matchResult.player1Placeholder ? {
       displayName: matchResult.player1Placeholder,
     } : undefined,
diff --git a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
index 4ecf00f2..fe059936 100644
--- a/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
+++ b/src/components/FowV4MatchResultDetails/FowV4MatchResultDetails.types.ts
@@ -1,6 +1,6 @@
 import { MatchResult, User } from '~/api';
 
-export type FowV4MatchResultDetailsData = Pick<MatchResult, 'player0User' | 'player0UserId' | 'player0Placeholder' | 'player1User' | 'player1UserId' | 'player1Placeholder'> & {
+export type FowV4MatchResultDetailsData = Pick<MatchResult, 'player0User' | 'player0Placeholder' | 'player1User' | 'player1Placeholder'> & {
   player0User?: User;
   player1User?: User;
   details: Omit<MatchResult['details'], 'missionName' | 'player0Score' | 'player1Score'> & {
diff --git a/src/components/IdentityBadge/IdentityBadge.hooks.tsx b/src/components/IdentityBadge/IdentityBadge.hooks.tsx
index a38de72e..714ff005 100644
--- a/src/components/IdentityBadge/IdentityBadge.hooks.tsx
+++ b/src/components/IdentityBadge/IdentityBadge.hooks.tsx
@@ -4,8 +4,6 @@ import { Ghost, HelpCircle } from 'lucide-react';
 import { TournamentCompetitor } from '~/api';
 import { Avatar } from '~/components/generic/Avatar';
 import { FlagCircle } from '~/components/generic/FlagCircle';
-import { useGetTournamentCompetitor } from '~/services/tournamentCompetitors';
-import { useGetUser } from '~/services/users';
 import { getCountryName } from '~/utils/common/getCountryName';
 import { getUserDisplayNameString } from '~/utils/common/getUserDisplayNameString';
 import { Identity } from './IdentityBadge.types';
@@ -39,13 +37,10 @@ const getCompetitorDisplayName = (competitor: TournamentCompetitor): ReactElemen
 };
 
 export const useIdentityElements = (identity: Identity, loading?: boolean): ReactElement[] => {
-  const { user, userId, competitor, competitorId, placeholder } = identity;
+  const { user, competitor, placeholder } = identity;
 
-  const { data: queryUser } = useGetUser(userId ? { id: userId } : 'skip');
-  const { data: queryCompetitor } = useGetTournamentCompetitor(competitorId ? { id: competitorId } : 'skip');
-
-  // Render loading skeleton if explicitly loading or an ID was provided and it is fetching
-  if (loading || (userId && !queryUser) || competitorId && !queryCompetitor) {
+  // Render loading skeleton if explicitly loading 
+  if (loading) {
     return [
       <Avatar loading />,
       <span>Loading...</span>,
@@ -59,13 +54,6 @@ export const useIdentityElements = (identity: Identity, loading?: boolean): Reac
     ];
   }
 
-  if (userId && queryUser) {
-    return [
-      <Avatar url={queryUser?.avatarUrl} />,
-      <span>{getUserDisplayNameString(queryUser)}</span>,
-    ];
-  }
-
   if (competitor) {
     return [
       getCompetitorAvatar(competitor),
@@ -73,13 +61,6 @@ export const useIdentityElements = (identity: Identity, loading?: boolean): Reac
     ];
   }
 
-  if (competitorId && queryCompetitor) {
-    return [
-      getCompetitorAvatar(queryCompetitor),
-      getCompetitorDisplayName(queryCompetitor),
-    ];
-  }
-
   if (placeholder) {
     return [
       <Avatar icon={placeholder.icon ?? <Ghost />} muted />,
diff --git a/src/components/IdentityBadge/IdentityBadge.tsx b/src/components/IdentityBadge/IdentityBadge.tsx
index 41333e89..9b180822 100644
--- a/src/components/IdentityBadge/IdentityBadge.tsx
+++ b/src/components/IdentityBadge/IdentityBadge.tsx
@@ -1,12 +1,7 @@
 import { cloneElement } from 'react';
 import clsx from 'clsx';
 
-import {
-  TournamentCompetitor,
-  TournamentCompetitorId,
-  User,
-  UserId,
-} from '~/api';
+import { TournamentCompetitor, User } from '~/api';
 import { ElementSize } from '~/types/componentLib';
 import { useIdentityElements } from './IdentityBadge.hooks';
 import { IdentityBadgePlaceholder } from './IdentityBadge.types';
@@ -23,32 +18,26 @@ const sizeClasses: Record<ElementSize, string | undefined> = {
 export interface IdentityBadgeProps {
   className?: string;
   competitor?: TournamentCompetitor;
-  competitorId?: TournamentCompetitorId;
   flipped?: boolean;
   loading?: boolean;
   placeholder?: IdentityBadgePlaceholder;
   size?: ElementSize;
   user?: User;
-  userId?: UserId;
 }
 
 export const IdentityBadge = ({
   className,
   competitor,
-  competitorId,
   flipped = false,
   loading = false,
   placeholder,
   size = 'normal',
   user,
-  userId,
 }: IdentityBadgeProps): JSX.Element | null => {
   const [displayAvatar, displayName] = useIdentityElements({
     user,
     competitor,
     placeholder,
-    competitorId,
-    userId,
   }, loading);
   const elements = [
     cloneElement(displayAvatar, { className: styles.IdentityBadge_Avatar, key: 'avatar' }),
diff --git a/src/components/IdentityBadge/IdentityBadge.types.ts b/src/components/IdentityBadge/IdentityBadge.types.ts
index e7bacc00..904f9743 100644
--- a/src/components/IdentityBadge/IdentityBadge.types.ts
+++ b/src/components/IdentityBadge/IdentityBadge.types.ts
@@ -1,23 +1,10 @@
 import { ReactElement } from 'react';
 
-import {
-  TournamentCompetitor,
-  TournamentCompetitorId,
-  User,
-  UserId,
-} from '~/api';
-
-export type IdentityBadgeInput = {
-  user?: User;
-  competitor?: TournamentCompetitor;
-  placeholder?: IdentityBadgePlaceholder;
-};
+import { TournamentCompetitor, User } from '~/api';
 
 export type Identity = {
-  userId?: UserId;
   user?: User;
   competitor?: TournamentCompetitor;
-  competitorId?: TournamentCompetitorId;
   placeholder?: IdentityBadgePlaceholder;
 };
 
diff --git a/src/components/TournamentActionsProvider/TournamentActionsProvider.hooks.tsx b/src/components/TournamentActionsProvider/TournamentActionsProvider.hooks.tsx
index 7d510865..fe668e5f 100644
--- a/src/components/TournamentActionsProvider/TournamentActionsProvider.hooks.tsx
+++ b/src/components/TournamentActionsProvider/TournamentActionsProvider.hooks.tsx
@@ -2,18 +2,17 @@ import { useContext } from 'react';
 import { generatePath, useNavigate } from 'react-router-dom';
 
 import { TournamentActionKey } from '~/api';
-import { useAuth } from '~/components/AuthProvider';
 import { ConfirmationDialogData } from '~/components/ConfirmationDialog';
 import { Warning } from '~/components/generic/Warning';
 import { useMatchResultCreateDialog } from '~/components/MatchResultCreateDialog';
 import { toast } from '~/components/ToastProvider';
 import { useTournament } from '~/components/TournamentProvider';
 import { useGetTournamentCompetitorsByTournament } from '~/services/tournamentCompetitors';
-import { useGetTournamentPairings } from '~/services/tournamentPairings';
 import {
   useDeleteTournament,
   useEndTournament,
   useEndTournamentRound,
+  useGetAvailableTournamentActions,
   useGetTournamentOpenRound,
   usePublishTournament,
   useStartTournament,
@@ -37,11 +36,9 @@ export const useTournamentActions = () => {
 
 type ActionDefinition = Action & {
   key: TournamentActionKey;
-  available: boolean;
 };
 
 export const useActions = (openDialog: (data?: ConfirmationDialogData) => void): TournamentActions => {
-  const user = useAuth();
   const tournament = useTournament();
 
   // ---- HANDLERS ----
@@ -88,9 +85,8 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
   });
 
   // ---- DATA ----
-  const { data: nextRoundPairings } = useGetTournamentPairings({
-    tournamentId: tournament._id,
-    round: tournament.nextRound,
+  const { data: availableActions } = useGetAvailableTournamentActions({
+    id: tournament._id,
   });
   const { data: openRound } = useGetTournamentOpenRound({
     id: tournament._id,
@@ -98,10 +94,6 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
   const { data: tournamentCompetitors } = useGetTournamentCompetitorsByTournament({
     tournamentId: tournament._id,
   });
-  const isOrganizer = !!user && tournament.organizerUserIds.includes(user._id);
-  const isPlayer = !!user && tournament.playerUserIds.includes(user._id);
-  const isBetweenRounds = tournament.status === 'active' && !openRound;
-  const hasNextRound = tournament.nextRound !== undefined;
 
   // Labels for messages:
   const nextRoundLabel = (tournament.nextRound ?? 0) + 1;
@@ -113,13 +105,11 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.Edit,
       label: 'Edit',
-      available: isOrganizer && ['draft', 'published'].includes(tournament.status),
       handler: () => navigate(generatePath(PATHS.tournamentEdit, { id: tournament._id })),
     },
     {
       key: TournamentActionKey.Delete,
       label: 'Delete',
-      available: isOrganizer && tournament.status === 'draft',
       handler: () => {
         // TODO: Implement confirmation dialog
         deleteTournament({ id: tournament._id });
@@ -128,7 +118,6 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.Publish,
       label: 'Publish',
-      available: isOrganizer && tournament.status === 'draft',
       handler: () => {
         // TODO: Implement confirmation dialog
         publishTournament({ id: tournament._id });
@@ -137,7 +126,6 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.Start,
       label: 'Start',
-      available: isOrganizer && tournament.status === 'published',
       handler: () => {
         // TODO: Implement confirmation dialog
         startTournament({ id: tournament._id });
@@ -146,7 +134,6 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.ConfigureRound,
       label: `Configure Round ${nextRoundLabel}`,
-      available: isOrganizer && isBetweenRounds && hasNextRound && nextRoundPairings?.length === 0,
       handler: () => {
         const { errors, warnings } = validateConfigureRound(tournament, tournamentCompetitors);
         if (errors.length) {
@@ -171,19 +158,16 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.StartRound,
       label: `Start Round ${nextRoundLabel}`,
-      available: isOrganizer && isBetweenRounds && hasNextRound && (nextRoundPairings ?? []).length > 0,
       handler: () => startTournamentRound({ id: tournament._id }),
     },
     {
       key: TournamentActionKey.SubmitMatchResult,
       label: 'Submit Match Result',
-      available: !!openRound && (isOrganizer || isPlayer),
       handler: () => openMatchResultCreateDialog(),
     },
     {
       key: TournamentActionKey.EndRound,
       label: `End Round ${currentRoundLabel}`,
-      available: isOrganizer && !!openRound,
       handler: () => {
         if (openRound && openRound.matchResultsProgress.remaining > 0) {
           openDialog({
@@ -209,7 +193,6 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     {
       key: TournamentActionKey.End,
       label: 'End Tournament',
-      available: isOrganizer && isBetweenRounds,
       handler: () => {
         if (tournament.nextRound !== undefined && tournament.nextRound < tournament.roundCount) {
           openDialog({
@@ -231,7 +214,7 @@ export const useActions = (openDialog: (data?: ConfirmationDialogData) => void):
     },
   ];
 
-  return actions.filter(({ available }) => available).reduce((acc, { key, ...action }) => ({
+  return actions.filter(({ key }) => (availableActions ?? []).includes(key)).reduce((acc, { key, ...action }) => ({
     ...acc,
     [key]: action,
   }), {} as TournamentActions);
diff --git a/src/components/TournamentPairingRow/TournamentPairingRow.tsx b/src/components/TournamentPairingRow/TournamentPairingRow.tsx
index 37d1aeb5..c07e4032 100644
--- a/src/components/TournamentPairingRow/TournamentPairingRow.tsx
+++ b/src/components/TournamentPairingRow/TournamentPairingRow.tsx
@@ -1,15 +1,17 @@
 import { useWindowWidth } from '@react-hook/window-size/throttled';
 import clsx from 'clsx';
 
-import { DraftTournamentPairing, TournamentPairing } from '~/api';
+import { TournamentPairing } from '~/api';
 import { IdentityBadge } from '~/components/IdentityBadge';
 import { MOBILE_BREAKPOINT } from '~/settings';
 import { getIdentityBadgeProps } from './TournamentPairingRow.utils';
 
 import styles from './TournamentPairingRow.module.scss';
 
+export type TournamentPairingRowData = Pick<TournamentPairing, 'tournamentCompetitor0' | 'tournamentCompetitor1' | 'table'>;
+
 export interface TournamentPairingRowProps {
-  pairing?: TournamentPairing | DraftTournamentPairing;
+  pairing?: TournamentPairingRowData;
   loading?: boolean;
   className?: string;
 }
diff --git a/src/components/TournamentPairingRow/TournamentPairingRow.utils.tsx b/src/components/TournamentPairingRow/TournamentPairingRow.utils.tsx
index 9e60cfff..ea8d7ad4 100644
--- a/src/components/TournamentPairingRow/TournamentPairingRow.utils.tsx
+++ b/src/components/TournamentPairingRow/TournamentPairingRow.utils.tsx
@@ -1,49 +1,22 @@
 import { ChevronRight } from 'lucide-react';
 
-import { DraftTournamentPairing, TournamentPairing } from '~/api';
+import { TournamentPairing } from '~/api';
 import { IdentityBadgeProps } from '~/components/IdentityBadge';
-import { TournamentPairingFormItem } from '~/pages/TournamentPairingsPage/TournamentPairingsPage.schema';
-
-export function isUnassignedPairingInput(pairing: unknown): pairing is DraftTournamentPairing {
-  return typeof pairing === 'object' &&
-    pairing !== null &&
-    'tournamentCompetitor0Id' in pairing;
-}
-
-export function isTournamentPairing(pairing: unknown): pairing is TournamentPairing {
-  return typeof pairing === 'object' &&
-    pairing !== null &&
-    'tournamentCompetitor0' in pairing;
-}
 
 export const getIdentityBadgeProps = (
-  pairing?: TournamentPairing | TournamentPairingFormItem | DraftTournamentPairing,
+  pairing?: Pick<TournamentPairing, 'tournamentCompetitor0' | 'tournamentCompetitor1' | 'table'>,
 ): [Partial<IdentityBadgeProps>, Partial<IdentityBadgeProps>] => {
-  if (isUnassignedPairingInput(pairing)) {
-    if (pairing.tournamentCompetitor1Id) {
-      return [
-        { competitorId: pairing.tournamentCompetitor0Id },
-        { competitorId: pairing.tournamentCompetitor1Id },
-      ];
-    }
-    return [
-      { competitorId: pairing.tournamentCompetitor0Id },
-      { placeholder: { displayName: 'Bye', icon: <ChevronRight /> } },
-    ];
+  if (!pairing) {
+    return [{}, {}];
   }
-
-  if (isTournamentPairing(pairing)) {
-    if (pairing.tournamentCompetitor1) {
-      return [
-        { competitor: pairing.tournamentCompetitor0 },
-        { competitor: pairing.tournamentCompetitor1 },
-      ];
-    }
+  if (pairing.tournamentCompetitor1) {
     return [
       { competitor: pairing.tournamentCompetitor0 },
-      { placeholder: { displayName: 'Bye', icon: <ChevronRight /> } },
+      { competitor: pairing.tournamentCompetitor1 },
     ];
   }
-
-  return [{}, {}];
+  return [
+    { competitor: pairing.tournamentCompetitor0 },
+    { placeholder: { displayName: 'Bye', icon: <ChevronRight /> } },
+  ];
 };
diff --git a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
index 6b76880b..ffe80774 100644
--- a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
+++ b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.tsx
@@ -15,6 +15,7 @@ import { TournamentActionsProvider } from '~/components/TournamentActionsProvide
 import { TournamentContextMenu } from '~/components/TournamentContextMenu';
 import { TournamentProvider } from '~/components/TournamentProvider';
 import { TournamentTimer } from '~/components/TournamentTimer';
+import { useGetTournamentCompetitorsByTournament } from '~/services/tournamentCompetitors';
 import { PATHS } from '~/settings';
 import { Header } from '../Header';
 import {
@@ -41,6 +42,11 @@ export const ActiveTournament = ({
   const navigate = useNavigate();
   const user = useAuth();
 
+  const { data: tournamentCompetitors } = useGetTournamentCompetitorsByTournament({
+    tournamentId: tournament._id,
+    includeRankings: tournament.lastRound,
+  });
+
   const opponent = getOpponent(user?._id, pairing);
 
   const handleViewMore = (): void => {
@@ -103,7 +109,7 @@ export const ActiveTournament = ({
             <Separator />
           </>
         )}
-        {showRankings && renderRankings(tournament, rankedCompetitors)}
+        {showRankings && renderRankings(tournament, tournamentCompetitors)}
       </TournamentProvider>
     </div>
   );
diff --git a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.utils.tsx b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.utils.tsx
index 3ca2ca41..3c0a9e8b 100644
--- a/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.utils.tsx
+++ b/src/pages/DashboardPage/components/ActiveTournament/ActiveTournament.utils.tsx
@@ -4,7 +4,6 @@ import { Trophy } from 'lucide-react';
 import {
   Tournament,
   TournamentCompetitor,
-  TournamentCompetitorRanked,
   TournamentPairing,
   UserId,
 } from '~/api';
@@ -50,7 +49,7 @@ export const renderTitle = (title: string): ReactElement => (
 
 export const renderRankings = (
   tournament: Tournament,
-  competitors: TournamentCompetitorRanked[] = [],
+  competitors: TournamentCompetitor[] = [],
 ): ReactElement => (
   !competitors.length ? (
     <EmptyState icon={<Trophy />} />
@@ -65,19 +64,19 @@ export const renderRankings = (
           label: 'Rank',
           width: 40,
           align: 'center',
-          renderCell: (r) => (
+          renderCell: ({ rank }) => (
             <div>
-              {tournament.lastRound !== undefined ? r.rank + 1 : '-'}
+              {tournament.lastRound !== undefined && rank !== undefined ? rank + 1 : '-'}
             </div>
           ),
         },
         {
           key: 'identity',
           label: tournament?.useTeams ? 'Team' : 'Player',
-          renderCell: (r) => (
+          renderCell: (competitor) => (
             <IdentityBadge
               size="small"
-              competitorId={r.id}
+              competitor={competitor}
               className={styles.TournamentRankingsCard_IdentityBadge}
             />
           ),
diff --git a/src/pages/TournamentPairingsPage/TournamentPairingsPage.utils.tsx b/src/pages/TournamentPairingsPage/TournamentPairingsPage.utils.tsx
index f3cf4905..3b7a9748 100644
--- a/src/pages/TournamentPairingsPage/TournamentPairingsPage.utils.tsx
+++ b/src/pages/TournamentPairingsPage/TournamentPairingsPage.utils.tsx
@@ -167,7 +167,7 @@ export const renderCompetitorCard = (
 
   return (
     <div className={styles.TournamentPairingsPage_Form_CompetitorCard}>
-      <IdentityBadge competitorId={id as TournamentCompetitorId} />
+      <IdentityBadge competitor={rankedCompetitor} />
       <div>{rankedCompetitor.rank !== undefined ? rankedCompetitor.rank + 1 : '-'}</div>
       <Pulsar color={isValid ? 'green' : 'red'} visible={!!state.activeId && !state.isActive} />
     </div>
diff --git a/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.tsx b/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.tsx
index fdf0efb9..a11c38e8 100644
--- a/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.tsx
+++ b/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.tsx
@@ -1,11 +1,10 @@
 import { DraftTournamentPairing, TournamentCompetitor } from '~/api';
 import { ConfirmationDialog } from '~/components/ConfirmationDialog';
-import { ColumnDef, Table } from '~/components/generic/Table';
+import { Table } from '~/components/generic/Table';
 import { Warning } from '~/components/generic/Warning';
-import { TournamentPairingRow } from '~/components/TournamentPairingRow';
 import { useTournament } from '~/components/TournamentProvider';
 import { TournamentPairingFormItem } from '../../TournamentPairingsPage.schema';
-import { assignTables } from './ConfirmPairingsDialog.utils';
+import { assignTables, getTableColumns } from './ConfirmPairingsDialog.utils';
 
 import styles from './ConfirmPairingsDialog.module.scss';
 
@@ -38,30 +37,7 @@ export const ConfirmPairingsDialog = ({
     onConfirm(assignedPairings);
   };
 
-  const columns: ColumnDef<DraftTournamentPairing>[] = [
-    {
-      key: 'table',
-      label: 'Table',
-      width: 40,
-      align: 'center',
-      renderCell: (r) => (
-        <div className={styles.ConfirmPairingsDialog_Table}>
-          {r.table === null ? '-' : r.table + 1}
-        </div>
-      ),
-    },
-    {
-      key: 'pairing',
-      label: 'Pairing',
-      align: 'center',
-      renderCell: (r) => (
-        <TournamentPairingRow
-          pairing={r}
-          className={styles.ConfirmPairingsDialog_Pairing}
-        />
-      ),
-    },
-  ];
+  const columns = getTableColumns(competitors);
 
   return (
     <ConfirmationDialog
diff --git a/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.ts b/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.tsx
similarity index 62%
rename from src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.ts
rename to src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.tsx
index e828f2a9..2b75cccb 100644
--- a/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.ts
+++ b/src/pages/TournamentPairingsPage/components/ConfirmPairingsDialog/ConfirmPairingsDialog.utils.tsx
@@ -1,6 +1,46 @@
-import { DraftTournamentPairing } from '~/api';
+import { DraftTournamentPairing, TournamentCompetitor } from '~/api';
+import { ColumnDef } from '~/components/generic/Table';
+import { TournamentPairingRow } from '~/components/TournamentPairingRow';
 import { TournamentPairingFormItem } from '../../TournamentPairingsPage.schema';
 
+import styles from './ConfirmPairingsDialog.module.scss';
+
+export const getTableColumns = (competitors: TournamentCompetitor[]): ColumnDef<DraftTournamentPairing>[] => [
+  {
+    key: 'table',
+    label: 'Table',
+    width: 40,
+    align: 'center',
+    renderCell: (r) => (
+      <div className={styles.ConfirmPairingsDialog_Table}>
+        {r.table === null ? '-' : r.table + 1}
+      </div>
+    ),
+  },
+  {
+    key: 'pairing',
+    label: 'Pairing',
+    align: 'center',
+    renderCell: (r) => {
+      const tournamentCompetitor0 = competitors.find((c) => c._id === r.tournamentCompetitor0Id) ?? null;
+      const tournamentCompetitor1 = competitors.find((c) => c._id === r.tournamentCompetitor1Id) ?? null;
+      if (!tournamentCompetitor0) {
+        return null;
+      }
+      return (
+        <TournamentPairingRow
+          pairing={{
+            table: r.table,
+            tournamentCompetitor0,
+            tournamentCompetitor1,
+          }}
+          className={styles.ConfirmPairingsDialog_Pairing}
+        />
+      );
+    },
+  },
+];
+
 export const assignTables = (
   pairings: (TournamentPairingFormItem & {
     playedTables: (number | null)[];
diff --git a/src/services/tournaments.ts b/src/services/tournaments.ts
index a7c18a48..4d3480cc 100644
--- a/src/services/tournaments.ts
+++ b/src/services/tournaments.ts
@@ -6,6 +6,7 @@ export const useGetTournament = createQueryHook(api.tournaments.getTournament);
 export const useGetTournaments = createQueryHook(api.tournaments.getTournaments);
 
 // Special Queries
+export const useGetAvailableTournamentActions = createQueryHook(api.tournaments.getAvailableTournamentActions);
 export const useGetTournamentOpenRound = createQueryHook(api.tournaments.getTournamentOpenRound);
 export type TournamentOpenRound = typeof api.tournaments.getTournamentOpenRound._returnType; // TODO: Move to back-end
 export const useGetTournamentRankings = createQueryHook(api.tournaments.getTournamentRankings);

From 528452aeb77bc9b70a07b82e44b11740bc5f0d97 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Wed, 30 Jul 2025 17:36:59 -0400
Subject: [PATCH 8/9] Update api.d.ts

---
 convex/_generated/api.d.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/convex/_generated/api.d.ts b/convex/_generated/api.d.ts
index 2409c14c..3ef653ab 100644
--- a/convex/_generated/api.d.ts
+++ b/convex/_generated/api.d.ts
@@ -113,6 +113,8 @@ import type * as _model_tournaments__helpers_checkTournamentAuth from "../_model
 import type * as _model_tournaments__helpers_checkTournamentVisibility from "../_model/tournaments/_helpers/checkTournamentVisibility.js";
 import type * as _model_tournaments__helpers_deepenTournament from "../_model/tournaments/_helpers/deepenTournament.js";
 import type * as _model_tournaments__helpers_getTournamentDeep from "../_model/tournaments/_helpers/getTournamentDeep.js";
+import type * as _model_tournaments__helpers_getTournamentNextRound from "../_model/tournaments/_helpers/getTournamentNextRound.js";
+import type * as _model_tournaments__helpers_getTournamentPlayerUserIds from "../_model/tournaments/_helpers/getTournamentPlayerUserIds.js";
 import type * as _model_tournaments__helpers_getTournamentShallow from "../_model/tournaments/_helpers/getTournamentShallow.js";
 import type * as _model_tournaments__helpers_getTournamentUserIds from "../_model/tournaments/_helpers/getTournamentUserIds.js";
 import type * as _model_tournaments_fields from "../_model/tournaments/fields.js";
@@ -125,6 +127,7 @@ import type * as _model_tournaments_mutations_publishTournament from "../_model/
 import type * as _model_tournaments_mutations_startTournament from "../_model/tournaments/mutations/startTournament.js";
 import type * as _model_tournaments_mutations_startTournamentRound from "../_model/tournaments/mutations/startTournamentRound.js";
 import type * as _model_tournaments_mutations_updateTournament from "../_model/tournaments/mutations/updateTournament.js";
+import type * as _model_tournaments_queries_getAvailableTournamentActions from "../_model/tournaments/queries/getAvailableTournamentActions.js";
 import type * as _model_tournaments_queries_getTournament from "../_model/tournaments/queries/getTournament.js";
 import type * as _model_tournaments_queries_getTournamentOpenRound from "../_model/tournaments/queries/getTournamentOpenRound.js";
 import type * as _model_tournaments_queries_getTournamentRankings from "../_model/tournaments/queries/getTournamentRankings.js";
@@ -301,6 +304,8 @@ declare const fullApi: ApiFromModules<{
   "_model/tournaments/_helpers/checkTournamentVisibility": typeof _model_tournaments__helpers_checkTournamentVisibility;
   "_model/tournaments/_helpers/deepenTournament": typeof _model_tournaments__helpers_deepenTournament;
   "_model/tournaments/_helpers/getTournamentDeep": typeof _model_tournaments__helpers_getTournamentDeep;
+  "_model/tournaments/_helpers/getTournamentNextRound": typeof _model_tournaments__helpers_getTournamentNextRound;
+  "_model/tournaments/_helpers/getTournamentPlayerUserIds": typeof _model_tournaments__helpers_getTournamentPlayerUserIds;
   "_model/tournaments/_helpers/getTournamentShallow": typeof _model_tournaments__helpers_getTournamentShallow;
   "_model/tournaments/_helpers/getTournamentUserIds": typeof _model_tournaments__helpers_getTournamentUserIds;
   "_model/tournaments/fields": typeof _model_tournaments_fields;
@@ -313,6 +318,7 @@ declare const fullApi: ApiFromModules<{
   "_model/tournaments/mutations/startTournament": typeof _model_tournaments_mutations_startTournament;
   "_model/tournaments/mutations/startTournamentRound": typeof _model_tournaments_mutations_startTournamentRound;
   "_model/tournaments/mutations/updateTournament": typeof _model_tournaments_mutations_updateTournament;
+  "_model/tournaments/queries/getAvailableTournamentActions": typeof _model_tournaments_queries_getAvailableTournamentActions;
   "_model/tournaments/queries/getTournament": typeof _model_tournaments_queries_getTournament;
   "_model/tournaments/queries/getTournamentOpenRound": typeof _model_tournaments_queries_getTournamentOpenRound;
   "_model/tournaments/queries/getTournamentRankings": typeof _model_tournaments_queries_getTournamentRankings;

From b586df6caf3340ae983c44b7b7cd54b2a705fa29 Mon Sep 17 00:00:00 2001
From: Ian Paschal <ianpaschal@users.noreply.github.com>
Date: Wed, 30 Jul 2025 17:39:51 -0400
Subject: [PATCH 9/9] Prepare release v1.8.5

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 56300639..71c5addf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "combat-command",
-  "version": "0.0.0",
+  "version": "1.8.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "combat-command",
-      "version": "0.0.0",
+      "version": "1.8.5",
       "dependencies": {
         "@convex-dev/auth": "^0.0.80",
         "@dnd-kit/core": "^6.3.1",
diff --git a/package.json b/package.json
index d961a5d3..9d42ef45 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "combat-command",
   "private": true,
-  "version": "0.0.0",
+  "version": "1.8.5",
   "type": "module",
   "scripts": {
     "dev": "npm-run-all --parallel dev:frontend dev:backend",