fix(lint): resolve all eslint errors across monorepo

- Type response bodies in gameController.test.ts to fix no-unsafe-member-access
- Replace async methods with Promise.resolve() in InMemoryGameSessionStore
  and InMemoryLobbyGameStore to satisfy require-await rule
- Add argsIgnorePattern and varsIgnorePattern to eslint config so
  underscore-prefixed params are globally ignored
- Fix no-misused-promises in ws/index.ts, lobbyHandlers, gameHandlers,
  __root.tsx, login.tsx and play.tsx by using void + .catch()
- Fix no-floating-promises on navigate calls in login.tsx
- Move API_URL outside Play component to fix useCallback dependency warning
- Type fetch response bodies in play.tsx to fix no-unsafe-assignment
- Add only-throw-error: off for route files (TanStack Router throw redirect)
- Remove unused WebSocket import from express.d.ts
- Fix unsafe return in connections.ts by typing empty Map constructor
- Exclude scripts/ folder from eslint
- Add targeted override for better-auth auth-client.ts (upstream typing issue)

apps/api/src/ws/connections.ts

@@ -24,7 +24,7 @@ export const removeConnection = (lobbyId: string, userId: string): void => {
 };
 
 export const getConnections = (lobbyId: string): Map<string, WebSocket> => {
-  return connections.get(lobbyId) ?? new Map();
+  return connections.get(lobbyId) ?? new Map<string, WebSocket>();
 };
 
 export const broadcastToLobby = (

apps/api/src/ws/handlers/gameHandlers.ts

@@ -126,27 +126,29 @@ export const resolveRound = async (
     await endGame(lobbyId, state);
   } else {
     // Wait 3s then broadcast next question
-    setTimeout(async () => {
-      const fresh = await lobbyGameStore.get(lobbyId);
-      if (!fresh) return;
-      const nextQuestion = fresh.questions[fresh.currentIndex];
-      if (!nextQuestion) return;
-      broadcastToLobby(lobbyId, {
-        type: "game:question",
-        question: {
-          questionId: nextQuestion.questionId,
-          prompt: nextQuestion.prompt,
-          gloss: nextQuestion.gloss,
-          options: nextQuestion.options,
-        },
-        questionNumber: fresh.currentIndex + 1,
-        totalQuestions,
-      });
-      // Restart timer for next round
-      const timer = setTimeout(async () => {
-        await resolveRound(lobbyId, fresh.currentIndex, totalQuestions);
-      }, 15000);
-      timers.set(lobbyId, timer);
+    setTimeout(() => {
+      void (async () => {
+        const fresh = await lobbyGameStore.get(lobbyId);
+        if (!fresh) return;
+        const nextQuestion = fresh.questions[fresh.currentIndex];
+        if (!nextQuestion) return;
+        broadcastToLobby(lobbyId, {
+          type: "game:question",
+          question: {
+            questionId: nextQuestion.questionId,
+            prompt: nextQuestion.prompt,
+            gloss: nextQuestion.gloss,
+            options: nextQuestion.options,
+          },
+          questionNumber: fresh.currentIndex + 1,
+          totalQuestions,
+        });
+        // Restart timer for next round
+        const timer = setTimeout(() => {
+          void resolveRound(lobbyId, fresh.currentIndex, totalQuestions);
+        }, 15000);
+        timers.set(lobbyId, timer);
+      })();
     }, 3000);
   }
 };

apps/api/src/ws/handlers/lobbyHandlers.ts

@@ -148,8 +148,10 @@ const startRoundTimer = (
   questionIndex: number,
   totalQuestions: number,
 ): void => {
-  const timer = setTimeout(async () => {
-    await resolveRound(lobbyId, questionIndex, totalQuestions);
+  const timer = setTimeout(() => {
+    void resolveRound(lobbyId, questionIndex, totalQuestions).catch((err) => {
+      console.error("Error resolving round after timeout:", err);
+    });
   }, 15000);
   timers.set(lobbyId, timer);
 };

apps/api/src/ws/index.ts

@@ -15,18 +15,31 @@ export const setupWebSocket = (server: Server): WebSocketServer => {
       socket.destroy();
       return;
     }
-    handleUpgrade(request, socket, head, wss);
+    void handleUpgrade(request, socket, head, wss).catch((err) => {
+      console.error("WebSocket upgrade error:", err);
+      socket.destroy();
+    });
   });
 
   wss.on(
     "connection",
     (ws: WebSocket, _request: IncomingMessage, auth: AuthenticatedUser) => {
       ws.on("message", (rawData) => {
-        handleMessage(ws, rawData, auth);
+        void handleMessage(ws, rawData, auth).catch((err) => {
+          console.error(
+            `WebSocket message error for user ${auth.user.id}:`,
+            err,
+          );
+        });
       });
 
       ws.on("close", () => {
-        handleDisconnect(ws, auth);
+        void handleDisconnect(ws, auth).catch((err) => {
+          console.error(
+            `WebSocket disconnect error for user ${auth.user.id}:`,
+            err,
+          );
+        });
       });
 
       ws.on("error", (err) => {