battle-fetch: migrate to user.games.battle ConnectRPC command

The Phase 27 BattleViewer was the last UI surface still issuing raw
fetch() against the backend REST contract (`/api/v1/user/games/...
/battles/...`). The dev-deploy gateway never proxied that path, so
the viewer worked only in tools/local-dev/. Move it onto the signed
ConnectRPC channel every other authenticated surface already uses.

Wire pieces:
- FBS GameBattleRequest in pkg/schema/fbs/battle.fbs, regenerated
  Go + TS bindings.
- MessageTypeUserGamesBattle constant + GameBattleRequest struct in
  pkg/model/report/messages.go.
- pkg/transcoder/battle.go gains GameBattleRequestToPayload and
  PayloadToGameBattleRequest helpers.
- gateway games_commands.go switches on the new message type and
  GETs /api/v1/user/games/{id}/battles/{turn}/{battle_id}; the JSON
  response is re-encoded as a FlatBuffers BattleReport before being
  returned. 404 from backend surfaces as the canonical `not_found`
  gateway error.
- ui/frontend/src/api/battle-fetch.ts now builds the FBS request,
  calls GalaxyClient.executeCommand, and decodes the FBS response
  into the existing UI shape (Record<string,string> race/ship maps,
  string-form UUID). BattleFetchError carries an HTTP-style status
  derived from the result code so the active-view's not_found branch
  keeps working.
- battle.svelte pulls the GalaxyClient from the in-game shell
  context. While the layout's boot Promise.all is in flight the
  effect stays in `loading` until the client handle becomes
  non-null.
- ui/Makefile FBS_INPUTS gains battle.fbs.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

gateway/internal/backendclient/games_commands.go

@@ -63,6 +63,12 @@ func (c *RESTClient) ExecuteGameCommand(ctx context.Context, command downstream.
 			return downstream.UnaryResult{}, fmt.Errorf("backendclient: execute game command %q: %w", command.MessageType, err)
 		}
 		return c.executeUserGamesReport(ctx, command.UserID, req)
+	case reportmodel.MessageTypeUserGamesBattle:
+		req, err := transcoder.PayloadToGameBattleRequest(command.PayloadBytes)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("backendclient: execute game command %q: %w", command.MessageType, err)
+		}
+		return c.executeUserGamesBattle(ctx, command.UserID, req)
 	default:
 		return downstream.UnaryResult{}, fmt.Errorf("backendclient: execute game command: unsupported message type %q", command.MessageType)
 	}
@@ -127,6 +133,26 @@ func (c *RESTClient) executeUserGamesReport(ctx context.Context, userID string,
 	return projectUserGamesReportResponse(status, respBody)
 }
 
+func (c *RESTClient) executeUserGamesBattle(ctx context.Context, userID string, req *reportmodel.GameBattleRequest) (downstream.UnaryResult, error) {
+	if req.GameID == uuid.Nil {
+		return downstream.UnaryResult{}, errors.New("execute user.games.battle: game_id must not be empty")
+	}
+	if req.BattleID == uuid.Nil {
+		return downstream.UnaryResult{}, errors.New("execute user.games.battle: battle_id must not be empty")
+	}
+	target := fmt.Sprintf("%s/api/v1/user/games/%s/battles/%d/%s",
+		c.baseURL,
+		url.PathEscape(req.GameID.String()),
+		req.Turn,
+		url.PathEscape(req.BattleID.String()),
+	)
+	respBody, status, err := c.do(ctx, http.MethodGet, target, userID, nil)
+	if err != nil {
+		return downstream.UnaryResult{}, fmt.Errorf("execute user.games.battle: %w", err)
+	}
+	return projectUserGamesBattleResponse(status, respBody)
+}
+
 // buildEngineCommandBody serialises a slice of typed commands into the
 // JSON shape expected by backend's command/order handlers (a
 // `gamerest.Command` with the actor field left empty — backend rebinds
@@ -262,3 +288,32 @@ func projectUserGamesReportResponse(statusCode int, payload []byte) (downstream.
 		return downstream.UnaryResult{}, fmt.Errorf("unexpected HTTP status %d", statusCode)
 	}
 }
+
+// projectUserGamesBattleResponse decodes the engine's BattleReport JSON
+// payload (forwarded by backend's user.games.battle proxy) and
+// re-encodes it as a FlatBuffers BattleReport for the signed-gRPC
+// client. 404 from backend surfaces as the canonical `not_found`
+// gateway error so the UI can render its "battle not found" state.
+func projectUserGamesBattleResponse(statusCode int, payload []byte) (downstream.UnaryResult, error) {
+	switch {
+	case statusCode == http.StatusOK:
+		var report reportmodel.BattleReport
+		if err := json.Unmarshal(payload, &report); err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("decode engine battle report: %w", err)
+		}
+		encoded, err := transcoder.BattleReportToPayload(&report)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("encode battle report payload: %w", err)
+		}
+		return downstream.UnaryResult{
+			ResultCode:   userCommandResultCodeOK,
+			PayloadBytes: encoded,
+		}, nil
+	case statusCode == http.StatusServiceUnavailable:
+		return downstream.UnaryResult{}, downstream.ErrDownstreamUnavailable
+	case statusCode >= 400 && statusCode <= 599:
+		return projectUserBackendError(statusCode, payload)
+	default:
+		return downstream.UnaryResult{}, fmt.Errorf("unexpected HTTP status %d", statusCode)
+	}
+}

gateway/internal/backendclient/games_commands_test.go

@@ -11,6 +11,7 @@ import (
 	"galaxy/gateway/internal/backendclient"
 	"galaxy/gateway/internal/downstream"
 	ordermodel "galaxy/model/order"
+	reportmodel "galaxy/model/report"
 	"galaxy/transcoder"
 
 	"github.com/google/uuid"
@@ -170,6 +171,78 @@ func TestExecuteUserGamesOrderGetRejectsNegativeTurn(t *testing.T) {
 	assert.Contains(t, err.Error(), "user.games.order.get")
 }
 
+func TestExecuteUserGamesBattleForwardsAndDecodesResponse(t *testing.T) {
+	t.Parallel()
+
+	gameID := uuid.MustParse("66666666-7777-8888-9999-aaaaaaaaaaaa")
+	battleID := uuid.MustParse("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t,
+			"/api/v1/user/games/"+gameID.String()+"/battles/7/"+battleID.String(),
+			r.URL.Path,
+		)
+		require.Equal(t, "user-1", r.Header.Get(backendclient.HeaderUserID))
+		raceID := uuid.MustParse("11111111-2222-3333-4444-555555555555")
+		writeJSON(t, w, http.StatusOK, map[string]any{
+			"id":         battleID.String(),
+			"planet":     uint(42),
+			"planetName": "Tau Ceti II",
+			"races":      map[string]string{"1": raceID.String()},
+			"ships":      map[string]map[string]any{},
+			"protocol":   []any{},
+		})
+	}))
+	t.Cleanup(server.Close)
+
+	client := newRESTClient(t, server)
+	payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
+		GameID:   gameID,
+		Turn:     7,
+		BattleID: battleID,
+	})
+	require.NoError(t, err)
+	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
+	require.NoError(t, err)
+	assert.Equal(t, "ok", result.ResultCode)
+
+	decoded, err := transcoder.PayloadToBattleReport(result.PayloadBytes)
+	require.NoError(t, err)
+	require.NotNil(t, decoded)
+	assert.Equal(t, battleID, decoded.ID)
+	assert.Equal(t, uint(42), decoded.Planet)
+	assert.Equal(t, "Tau Ceti II", decoded.PlanetName)
+}
+
+func TestExecuteUserGamesBattleMapsNotFound(t *testing.T) {
+	t.Parallel()
+
+	gameID := uuid.MustParse("77777777-8888-9999-aaaa-bbbbbbbbbbbb")
+	battleID := uuid.MustParse("99999999-aaaa-bbbb-cccc-dddddddddddd")
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		writeJSON(t, w, http.StatusNotFound, map[string]any{
+			"error": map[string]any{
+				"code":    "not_found",
+				"message": "battle not found",
+			},
+		})
+	}))
+	t.Cleanup(server.Close)
+
+	client := newRESTClient(t, server)
+	payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
+		GameID:   gameID,
+		Turn:     2,
+		BattleID: battleID,
+	})
+	require.NoError(t, err)
+	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
+	require.NoError(t, err)
+	assert.Equal(t, "not_found", result.ResultCode)
+}
+
 // writeJSON copy below mirrors the helper used by other test files
 // in this package; keeping it adjacent to its callers avoids
 // reaching across files in a fresh test.

gateway/internal/backendclient/routes.go

@@ -65,6 +65,7 @@ func GameRoutes(client *RESTClient) map[string]downstream.Client {
 		ordermodel.MessageTypeUserGamesOrder:     target,
 		ordermodel.MessageTypeUserGamesOrderGet:  target,
 		reportmodel.MessageTypeUserGamesReport:   target,
+		reportmodel.MessageTypeUserGamesBattle:   target,
 	}
 }
 

gateway/internal/backendclient/routes_test.go

@@ -60,6 +60,7 @@ func TestRoutesCoverAllAuthenticatedMessageTypes(t *testing.T) {
 				ordermodel.MessageTypeUserGamesOrder,
 				ordermodel.MessageTypeUserGamesOrderGet,
 				reportmodel.MessageTypeUserGamesReport,
+				reportmodel.MessageTypeUserGamesBattle,
 			},
 			actual: backendclient.GameRoutes(nil),
 		},