Stage 13: alphabet on the wire (UI alphabet-agnostic, TODO-4)

Live play now exchanges per-variant alphabet indices instead of concrete
letters (rack out; submit-play, evaluate, exchange, word-check in). The client
caches each variant's (index, letter, value) table behind
StateRequest.include_alphabet and renders the rack and blank chooser from it,
dropping the hardcoded value/alphabet tables. History, the durable journal and
GCG stay decoded concrete characters (ARCHITECTURE §9.1, unchanged).

- pkg/fbs: new AlphabetEntry + PlayTile; StateView.rack -> [ubyte] + alphabet;
  StateRequest.include_alphabet; SubmitPlay/Eval tiles -> [PlayTile];
  Exchange tiles + CheckWord word -> [ubyte] (committed Go + TS regenerated).
- engine: AlphabetTable + a cached per-variant codec (LetterForIndex/EncodeRack/
  DecodeTiles/DecodeWord) + BlankIndex sentinel; Go parity test.
- backend server edge maps index<->letter (new thin game.Service.GameVariant);
  game.Service domain methods, engine.Game and the robot keep one letter-based
  play path. The gateway forwards indices verbatim (no alphabet table).
- ui: lib/alphabet.ts in-memory cache; codec encodes/decodes indices; premiums.ts
  is geometry-only; the mock seeds a fixture table; the UI normalises display to
  upper case (codec + cache), leaving placement/board/checkword unchanged.

Parity moved to the Go engine.AlphabetTable test; premiums.ts loses its value
tables. Discharges TODO-4.

backend/internal/server/handlers_user.go

@@ -26,17 +26,33 @@ func (s *Server) handleProfile(c *gin.Context) {
 	c.JSON(http.StatusOK, profileResponseFor(acc))
 }
 
-// submitPlayRequest places tiles in a direction on the player's turn.
+// submitPlayRequest places tiles in a direction on the player's turn. Each tile's Letter
+// is a wire alphabet index (Stage 13); for a blank it is the designated letter's index.
 type submitPlayRequest struct {
 	Dir   string `json:"dir"`
 	Tiles []struct {
-		Row    int    `json:"row"`
-		Col    int    `json:"col"`
-		Letter string `json:"letter"`
-		Blank  bool   `json:"blank"`
+		Row    int  `json:"row"`
+		Col    int  `json:"col"`
+		Letter int  `json:"letter"`
+		Blank  bool `json:"blank"`
 	} `json:"tiles"`
 }
 
+// tilesFromRequest maps a play/evaluate request's index-addressed tiles to engine tile
+// records for the game's variant (Stage 13: a placed blank carries its designated letter's
+// index with Blank set). An out-of-range index surfaces as engine.ErrIllegalPlay (HTTP 400).
+func tilesFromRequest(variant engine.Variant, req submitPlayRequest) ([]engine.TileRecord, error) {
+	tiles := make([]engine.TileRecord, 0, len(req.Tiles))
+	for _, t := range req.Tiles {
+		letter, err := engine.LetterForIndex(variant, t.Letter)
+		if err != nil {
+			return nil, err
+		}
+		tiles = append(tiles, engine.TileRecord{Row: t.Row, Col: t.Col, Letter: letter, Blank: t.Blank})
+	}
+	return tiles, nil
+}
+
 // handleSubmitPlay validates, scores and commits a placement.
 func (s *Server) handleSubmitPlay(c *gin.Context) {
 	uid, ok := userID(c)
@@ -59,9 +75,15 @@ func (s *Server) handleSubmitPlay(c *gin.Context) {
 		abortBadRequest(c, "dir must be H or V")
 		return
 	}
-	tiles := make([]engine.TileRecord, 0, len(req.Tiles))
-	for _, t := range req.Tiles {
-		tiles = append(tiles, engine.TileRecord{Row: t.Row, Col: t.Col, Letter: t.Letter, Blank: t.Blank})
+	variant, err := s.games.GameVariant(c.Request.Context(), gameID)
+	if err != nil {
+		s.abortErr(c, err)
+		return
+	}
+	tiles, err := tilesFromRequest(variant, req)
+	if err != nil {
+		s.abortErr(c, err)
+		return
 	}
 	res, err := s.games.SubmitPlay(c.Request.Context(), gameID, uid, dir, tiles)
 	if err != nil {
@@ -88,7 +110,11 @@ func (s *Server) handleGameState(c *gin.Context) {
 		s.abortErr(c, err)
 		return
 	}
-	dto := stateDTOFrom(view)
+	dto, err := stateDTOFrom(view, c.Query("include_alphabet") == "true")
+	if err != nil {
+		s.abortErr(c, err)
+		return
+	}
 	s.fillSeatNames(c.Request.Context(), &dto.Game, map[string]string{})
 	c.JSON(http.StatusOK, dto)
 }