feat(lobby): enter the game immediately and wait for the opponent inside it

Quick auto-match no longer waits on a separate screen: Enqueue opens a real game seating the caller with an empty opponent seat (new game status 'open') and the player enters it at once. A second human searching the same variant+rule joins that open game; otherwise a background reaper seats a robot after a 90s + random 0-90s wait, pushing a new in-app opponent_joined event that fills the opponent card and re-enables resign and chat in place.

Matchmaking state is now the open games in the database (the in-memory pool, lobby.poll and lobby.cancel are gone), serialised by a per-bucket advisory lock. While a game is open the starter may move on their turn, but resign, chat and nudge are refused; the lobby and opponent card show "searching for opponent".

Schema edited in the baseline (no prod data): 'open' status, nullable game_players.account_id for the empty seat, and a games.open_deadline_at stamp; jet code regenerated.

backend/internal/server/dto.go

@@ -1,6 +1,8 @@
 package server
 
 import (
+	"github.com/google/uuid"
+
 	"scrabble/backend/internal/account"
 	"scrabble/backend/internal/engine"
 	"scrabble/backend/internal/game"
@@ -186,9 +188,16 @@ const awayTimeLayout = "15:04"
 func gameDTOFromGame(g game.Game) gameDTO {
 	seats := make([]seatDTO, 0, len(g.Seats))
 	for _, s := range g.Seats {
+		// An open game's still-empty opponent seat has no account: emit an empty id (the
+		// display name is left empty by fillSeatNames) so the client shows "searching for
+		// opponent" rather than the nil-UUID.
+		accountID := ""
+		if s.AccountID != uuid.Nil {
+			accountID = s.AccountID.String()
+		}
 		seats = append(seats, seatDTO{
 			Seat:      s.Seat,
-			AccountID: s.AccountID.String(),
+			AccountID: accountID,
 			Score:     s.Score,
 			HintsUsed: s.HintsUsed,
 			IsWinner:  s.IsWinner,
@@ -277,13 +286,12 @@ func stateDTOFrom(v game.StateView, includeAlphabet bool) (stateDTO, error) {
 	return dto, nil
 }
 
-// matchDTOFrom projects an enqueue/poll result into its DTO.
+// matchDTOFrom projects an enqueue result into its DTO. Enqueue always lands the
+// caller in a game (freshly opened or joined), so the game is always present; Matched
+// reports whether it already had an opponent.
 func matchDTOFrom(r lobby.EnqueueResult) matchDTO {
-	if !r.Matched {
-		return matchDTO{Matched: false}
-	}
 	g := gameDTOFromGame(r.Game)
-	return matchDTO{Matched: true, Game: &g}
+	return matchDTO{Matched: r.Matched, Game: &g}
 }
 
 // chatDTOFrom projects a chat message into its DTO.

backend/internal/server/handlers.go

@@ -76,8 +76,6 @@ func (s *Server) registerRoutes() {
 	}
 	if s.matchmaker != nil {
 		u.POST("/lobby/enqueue", s.handleEnqueue)
-		u.POST("/lobby/cancel", s.handleCancel)
-		u.GET("/lobby/poll", s.handlePoll)
 	}
 	if s.invitations != nil {
 		u.GET("/invitations", s.handleListInvitations)
@@ -161,14 +159,14 @@ func statusForError(err error) (int, string) {
 		return http.StatusConflict, "nudge_own_turn"
 	case errors.Is(err, game.ErrFinished), errors.Is(err, social.ErrGameNotActive):
 		return http.StatusConflict, "game_finished"
+	case errors.Is(err, game.ErrNoOpponentYet):
+		return http.StatusConflict, "no_opponent_yet"
 	case errors.Is(err, game.ErrGameActive):
 		return http.StatusConflict, "game_active"
 	case errors.Is(err, account.ErrInvalidProfile):
 		return http.StatusBadRequest, "invalid_profile"
 	case errors.Is(err, account.ErrAlreadyConfirmed):
 		return http.StatusConflict, "already_confirmed"
-	case errors.Is(err, lobby.ErrAlreadyQueued):
-		return http.StatusConflict, "already_queued"
 	case errors.Is(err, lobby.ErrInvalidInvitation):
 		return http.StatusBadRequest, "invalid_invitation"
 	case errors.Is(err, lobby.ErrInvitationBlocked):

backend/internal/server/handlers_user.go

@@ -133,13 +133,15 @@ func (s *Server) handleGameState(c *gin.Context) {
 	c.JSON(http.StatusOK, dto)
 }
 
-// enqueueRequest joins the per-variant auto-match pool under a per-turn word rule.
+// enqueueRequest enters per-variant auto-match under a per-turn word rule.
 type enqueueRequest struct {
 	Variant              string `json:"variant"`
 	MultipleWordsPerTurn bool   `json:"multiple_words_per_turn"`
 }
 
-// handleEnqueue joins the auto-match pool for a variant.
+// handleEnqueue enters the caller into auto-match for a variant and returns the game
+// they land in immediately: a freshly opened game awaiting an opponent, or another
+// player's open game they just joined. The client navigates straight into the game.
 func (s *Server) handleEnqueue(c *gin.Context) {
 	uid, ok := userID(c)
 	if !ok {
@@ -168,39 +170,6 @@ func (s *Server) handleEnqueue(c *gin.Context) {
 	c.JSON(http.StatusOK, dto)
 }
 
-// handleCancel removes the caller from the auto-match pool (and drops any pending
-// matched result), so a cancelled quick-match neither blocks a re-queue nor later
-// surfaces a robot-substituted game the player abandoned. It is idempotent: cancelling
-// when not queued is a no-op success.
-func (s *Server) handleCancel(c *gin.Context) {
-	uid, ok := userID(c)
-	if !ok {
-		abortBadRequest(c, "missing identity")
-		return
-	}
-	s.matchmaker.Cancel(c.Request.Context(), uid)
-	c.Status(http.StatusNoContent)
-}
-
-// handlePoll reports whether the caller has been paired since queueing.
-func (s *Server) handlePoll(c *gin.Context) {
-	uid, ok := userID(c)
-	if !ok {
-		abortBadRequest(c, "missing identity")
-		return
-	}
-	res, err := s.matchmaker.Poll(c.Request.Context(), uid)
-	if err != nil {
-		s.abortErr(c, err)
-		return
-	}
-	dto := matchDTOFrom(res)
-	if dto.Game != nil {
-		s.fillSeatNames(c.Request.Context(), dto.Game, map[string]string{})
-	}
-	c.JSON(http.StatusOK, dto)
-}
-
 // chatPostRequest posts a per-game chat message.
 type chatPostRequest struct {
 	Body string `json:"body"`