From ab3e61ba33b89b3ab1ed574c1b17758956cf4f35 Mon Sep 17 00:00:00 2001
From: javaisbetterthanpython <a@b.c>
Date: Sun, 7 Jun 2026 22:50:23 -0400
Subject: [PATCH 1/3] Fix blank rounds, re-jumble, and court-count handling.

Regenerate no longer drops the current round until generation succeeds,
failed rounds clear the generating flag, sit-outs respect court capacity,
and round navigation stays in sync after new rounds.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 pages/rounds.tsx           | 33 ++++++++++++++++--------
 src/CourtsModal.tsx        | 10 ++++++--
 src/matching/heuristics.ts | 51 +++++++++++++++++++++++++++-----------
 src/useShuffler.tsx        | 46 +++++++++++++++++++++++++---------
 4 files changed, 101 insertions(+), 39 deletions(-)

diff --git a/pages/rounds.tsx b/pages/rounds.tsx
index 8319f14..89b84f9 100644
--- a/pages/rounds.tsx
+++ b/pages/rounds.tsx
@@ -35,17 +35,28 @@ export default function Rounds() {
   const [courtsModal, setCourtsModal] = useState(false);
 
   const [roundIndex, setRoundIndex] = useState(0);
+  const prevRoundCount = React.useRef(state.rounds.length);
 
-  // Handle rounds loading into state.
+  // Jump to latest round when a new round is appended (not when regenerating).
   useEffect(() => {
-    if (state.rounds.length && roundIndex === 0) {
-      setRoundIndex(Math.max(state.rounds.length - 1, 0));
+    if (state.rounds.length > prevRoundCount.current) {
+      setRoundIndex(state.rounds.length - 1);
       window.scrollTo(0, 0);
+    } else if (roundIndex >= state.rounds.length && state.rounds.length > 0) {
+      setRoundIndex(state.rounds.length - 1);
+    }
+    prevRoundCount.current = state.rounds.length;
+  }, [state.rounds.length, roundIndex]);
+
+  useEffect(() => {
+    if (state.rounds.length && roundIndex === 0 && prevRoundCount.current <= 1) {
+      setRoundIndex(Math.max(state.rounds.length - 1, 0));
     }
-  }, [state.rounds]);
+  }, [state.rounds.length, roundIndex]);
+
   const displayIndex = Math.max(
     0,
-    Math.min(roundIndex, state.rounds.length - 1)
+    Math.min(roundIndex, Math.max(state.rounds.length - 1, 0))
   );
   const round = state.rounds[displayIndex];
   const volunteers = state.volunteerSitoutsByRound[displayIndex];
@@ -84,7 +95,6 @@ export default function Rounds() {
               fixedPairs,
               regenerate,
             });
-            if (!regenerate && roundIndex) setRoundIndex((index) => index + 1);
             setPlayersModal(false);
           }}
         />
@@ -96,7 +106,6 @@ export default function Rounds() {
               regenerate,
               courts,
             });
-            if (!regenerate && roundIndex) setRoundIndex((index) => index + 1);
             setCourtsModal(false);
           }}
         />
@@ -138,6 +147,9 @@ export default function Rounds() {
           )}
         </div>
 
+        {state.generating && !round ? (
+          <p className="text-center text-lg my-8">Jumbling the next round…</p>
+        ) : null}
         <div className="flex gap-4 items-stretch justify-center flex-wrap">
           {/* Sitting out */}{" "}
           <div className="basis-full sm:basis-64 md:basis-64 xl:basis-64">
@@ -224,16 +236,17 @@ export default function Rounds() {
         <div className="flex justify-around">
           <Button
             size="lg"
+            isDisabled={state.generating}
             onPress={async () => {
               await newRound(dispatch, state, worker, {
                 volunteerSitouts: [],
               });
-              setRoundIndex(state.rounds.length);
-              window.scrollTo(0, 0);
             }}
             className="bg-gradient-to-l from-blue-600 to-pink-600 text-white"
           >
-            Start round {state.rounds.length + 1}!
+            {state.generating
+              ? "Jumbling…"
+              : `Start round ${state.rounds.length + 1}!`}
           </Button>
         </div>
         <Spacer y={2} />
diff --git a/src/CourtsModal.tsx b/src/CourtsModal.tsx
index 4ae8935..b9e2aae 100644
--- a/src/CourtsModal.tsx
+++ b/src/CourtsModal.tsx
@@ -66,13 +66,19 @@ export function CourtsModal({
             Cancel
           </Button>
           <Button
-            onPress={() => onSubmit(parseInt(courts), true)}
+            onPress={() => {
+              const count = parseInt(courts, 10);
+              if (count >= 1) onSubmit(count, true);
+            }}
             color="danger"
           >
             Redo round
           </Button>
           <Button
-            onPress={() => onSubmit(parseInt(courts), false)}
+            onPress={() => {
+              const count = parseInt(courts, 10);
+              if (count >= 1) onSubmit(count, false);
+            }}
             color="primary"
           >
             New round
diff --git a/src/matching/heuristics.ts b/src/matching/heuristics.ts
index 89e0d49..241f988 100644
--- a/src/matching/heuristics.ts
+++ b/src/matching/heuristics.ts
@@ -720,11 +720,10 @@ const getSitOuts = (
   const players = allPlayers.filter(
     (player) => !expandedVolunteers.includes(player)
   );
-  const capacity = courts * 4;
-  const rawSitouts =
-    players.length > capacity
-      ? players.length - courts * 4
-      : players.length % 4;
+  const capacity = Math.max(courts, 1) * 4;
+  const playable = Math.min(players.length, capacity);
+  const playableRounded = playable - (playable % 4);
+  const rawSitouts = players.length - playableRounded;
 
   const units = buildSitOutUnits(players, fixedPairs);
   const sitouts = adjustSitOutCountForUnits(rawSitouts, units);
@@ -942,8 +941,12 @@ async function getNextRound(
   if (!bestMatches) {
     throw new Error("no matches found");
   }
+  const maxMatches = Math.max(courts, 1);
   return [
-    { sitOuts: bestTeams.sitOuts, matches: bestMatches },
+    {
+      sitOuts: bestTeams.sitOuts,
+      matches: bestMatches.slice(0, maxMatches),
+    },
     { bestTeamScore, bestMatchesScore },
   ];
 }
@@ -1005,20 +1008,27 @@ async function getNextBestRound(
       roundGeneration++
     ) {
       try {
-        const [newRound, roundStats] = await getNextRound(
-          rounds,
+        const [candidateRound, roundStats] = await getNextRound(
+          [...rounds, ...newRounds],
           players,
           courts,
-          volunteerSitouts,
-          heuristics,
+          roundGeneration === 0 ? volunteerSitouts : [],
+          newHeuristics,
           fixedPairs
         );
-        const [, newDuplicates] = getUniqueMatchCounts([newRound], matchCounts);
-        newHeuristics = getHeuristics([newRound], players, newHeuristics);
-        newRounds.push(newRound);
+        const [, newDuplicates] = getUniqueMatchCounts(
+          [candidateRound],
+          matchCounts
+        );
+        newHeuristics = getHeuristics(
+          [candidateRound],
+          players,
+          newHeuristics
+        );
+        newRounds.push(candidateRound);
         if (roundGeneration === 0) {
           backToBackOpponents = countBackToBackOpponentRepeats(
-            newRound,
+            candidateRound,
             heuristics
           );
         }
@@ -1062,7 +1072,18 @@ async function getNextBestRound(
     }
   }
 
-  return selectedRound!;
+  if (!selectedRound) {
+    const [fallbackRound] = await getNextRound(
+      rounds,
+      players,
+      courts,
+      volunteerSitouts,
+      heuristics,
+      fixedPairs
+    );
+    return fallbackRound;
+  }
+  return selectedRound;
 }
 
 export {
diff --git a/src/useShuffler.tsx b/src/useShuffler.tsx
index f097b75..0389844 100644
--- a/src/useShuffler.tsx
+++ b/src/useShuffler.tsx
@@ -57,6 +57,7 @@ type Action =
         round: Round;
         courts?: number;
         volunteerSitouts: PlayerId[];
+        regenerate?: boolean;
       };
     }
   | {
@@ -216,30 +217,42 @@ function shufflerReducer(state: State, action: Action): State {
       return loadFromCache(state);
     }
     case "start-generation":
-      const { regenerate } = action.payload;
       return {
         ...state,
         generating: true,
-        rounds: regenerate ? state.rounds.slice(0, -1) : state.rounds,
-        volunteerSitoutsByRound: regenerate
-          ? state.volunteerSitoutsByRound.slice(0, -1)
-          : state.volunteerSitoutsByRound,
         players: action.payload.players || state.players,
         playersById: action.payload.playersById || state.playersById,
         fixedPairs: action.payload.fixedPairs ?? state.fixedPairs,
       };
     case "new-round": {
+      const { regenerate } = action.payload;
+      const rounds = regenerate
+        ? [...state.rounds.slice(0, -1), action.payload.round]
+        : [...state.rounds, action.payload.round];
+      const volunteerSitoutsByRound = regenerate
+        ? [
+            ...state.volunteerSitoutsByRound.slice(0, -1),
+            action.payload.volunteerSitouts,
+          ]
+        : [
+            ...state.volunteerSitoutsByRound,
+            action.payload.volunteerSitouts,
+          ];
       return cacheState({
         ...state,
         generating: false,
-        rounds: [...state.rounds, action.payload.round],
-        courts: action.payload.courts || state.courts,
-        volunteerSitoutsByRound: [
-          ...state.volunteerSitoutsByRound,
-          action.payload.volunteerSitouts,
-        ],
+        rounds,
+        courts: action.payload.courts ?? state.courts,
+        volunteerSitoutsByRound,
       });
     }
+    case "new-round-fail":
+    case "new-game-fail": {
+      return {
+        ...state,
+        generating: false,
+      };
+    }
   }
   return state;
 }
@@ -264,9 +277,16 @@ async function newRound(
       payload.volunteerSitouts,
       state.fixedPairs
     );
+    if (!nextRound?.matches) {
+      throw new Error("Round generation returned an empty round");
+    }
     dispatch({
       type: "new-round",
-      payload: { round: nextRound, volunteerSitouts: payload.volunteerSitouts },
+      payload: {
+        round: nextRound,
+        volunteerSitouts: payload.volunteerSitouts,
+        regenerate: payload.regenerate ?? false,
+      },
     });
   } catch (error) {
     dispatch({ type: "new-round-fail", payload: { error: error as Error } });
@@ -374,6 +394,7 @@ async function editCourts(
         round,
         volunteerSitouts,
         courts,
+        regenerate,
       },
     });
   } catch (error) {
@@ -423,6 +444,7 @@ async function editPlayers(
       payload: {
         round: nextRound,
         volunteerSitouts,
+        regenerate,
       },
     });
   } catch (error) {

From e40f3b589a65239c22e2f5312d1247fb20677066 Mon Sep 17 00:00:00 2001
From: javaisbetterthanpython <a@b.c>
Date: Sun, 7 Jun 2026 23:10:47 -0400
Subject: [PATCH 2/3] Fix TypeScript inference error in getNextBestRound
 lookahead.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/matching/heuristics.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/matching/heuristics.ts b/src/matching/heuristics.ts
index 241f988..72fc035 100644
--- a/src/matching/heuristics.ts
+++ b/src/matching/heuristics.ts
@@ -1008,7 +1008,7 @@ async function getNextBestRound(
       roundGeneration++
     ) {
       try {
-        const [candidateRound, roundStats] = await getNextRound(
+        const roundResult = await getNextRound(
           [...rounds, ...newRounds],
           players,
           courts,
@@ -1016,6 +1016,8 @@ async function getNextBestRound(
           newHeuristics,
           fixedPairs
         );
+        const candidateRound = roundResult[0];
+        const roundStats = roundResult[1];
         const [, newDuplicates] = getUniqueMatchCounts(
           [candidateRound],
           matchCounts

From db1a9ecd820e1a8ffdd881621d9bd060f0ca360d Mon Sep 17 00:00:00 2001
From: javaisbetterthanpython <a@b.c>
Date: Sun, 7 Jun 2026 23:11:38 -0400
Subject: [PATCH 3/3] Annotate lookahead round types for strict TypeScript
 build.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/matching/heuristics.ts | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/matching/heuristics.ts b/src/matching/heuristics.ts
index 72fc035..447210a 100644
--- a/src/matching/heuristics.ts
+++ b/src/matching/heuristics.ts
@@ -996,7 +996,7 @@ async function getNextBestRound(
   for (let attempt = 0; attempt < ROUND_ATTEMPTS; attempt++) {
     await new Promise((resolve) => resolve(undefined));
     let newHeuristics = heuristics;
-    let newRounds = [];
+    let newRounds: Round[] = [];
     let backToBackOpponents = Infinity;
     let partnerScore = 0;
     let opponentScore = Infinity;
@@ -1008,7 +1008,10 @@ async function getNextBestRound(
       roundGeneration++
     ) {
       try {
-        const roundResult = await getNextRound(
+        const [candidateRound, roundStats]: [
+          Round,
+          { bestTeamScore: number; bestMatchesScore: number },
+        ] = await getNextRound(
           [...rounds, ...newRounds],
           players,
           courts,
@@ -1016,8 +1019,6 @@ async function getNextBestRound(
           newHeuristics,
           fixedPairs
         );
-        const candidateRound = roundResult[0];
-        const roundStats = roundResult[1];
         const [, newDuplicates] = getUniqueMatchCounts(
           [candidateRound],
           matchCounts