Stage 6: gateway edge (Connect/FlatBuffers over h2c, platform/email/guest auth, sessions, rate-limit, admin passthrough, live push bridge)

New public ingress and the first network edge. Framework + a vertical slice of
operations end-to-end; remaining ops reuse the same transcode pattern in Stage 7.

Contracts (new module scrabble/pkg):
- push.proto (backend->gateway gRPC server-stream) + scrabble.fbs (FlatBuffers
  edge payloads), committed generated Go; buf/flatc Makefiles (dev-time codegen).

Backend:
- REST handlers on the /api/v1 groups: internal session endpoints
  (telegram/guest/email login -> mint, resolve, revoke) and the user slice
  (profile, submit_play, state, lobby enqueue/poll, chat).
- internal/notify in-process Publisher hub + internal/pushgrpc gRPC server
  (BACKEND_GRPC_ADDR) streaming your_turn/opponent_moved/chat/nudge/match_found;
  emission in game.commit, social, matchmaker.
- migration 00005 accounts.is_guest; guests are durable rows excluded from stats;
  ProvisionGuest; email-as-login (RequestLoginCode/LoginWithCode).

Gateway (new module scrabble/gateway):
- Connect Gateway service over h2c (Execute + Subscribe), FlatBuffers<->JSON
  transcode registry, Telegram initData HMAC validator (seam), session cache,
  token-bucket rate limiter (3 classes), push fan-out hub, backend REST + push
  gRPC client, admin Basic-Auth reverse proxy.

go.work: use ./pkg, ./gateway + replace scrabble/pkg. CI: gateway/**, pkg/**
path filters; unit build/vet/test span all three modules. Docs (PLAN,
ARCHITECTURE, FUNCTIONAL+ru, TESTING, READMEs) updated; gateway/pkg unit tests +
guest/email-login integration tests.

pkg/fbs/scrabble.fbs

@@ -0,0 +1,205 @@
+// FlatBuffers payloads for the client <-> gateway edge transport (Stage 6).
+//
+// Every request and response that rides inside the Connect envelope
+// (gateway/proto/edge) `payload` field, and every push Event payload, is one of
+// these tables. They are the binary wire contract shared with the UI, which
+// generates TypeScript from this same schema (Stage 7). A single namespace keeps
+// nested tables (GameView inside MoveResult / MatchResult) free of
+// cross-namespace imports. Keep this schema and the backend JSON DTOs in lockstep
+// — the gateway transcodes one to the other.
+//
+// Generate Go with `make fbs` (flatc, version-pinned). The committed output lives
+// in fbs/scrabblefb/.
+namespace scrabblefb;
+
+// --- shared building blocks ---
+
+// TileRecord is one placed (or to-place) tile: its board coordinate, the concrete
+// letter ("?" when read from a hand for a blank) and whether it came from a blank.
+table TileRecord {
+  row:int;
+  col:int;
+  letter:string;
+  blank:bool;
+}
+
+// SeatView is one seat's public standing in a game.
+table SeatView {
+  seat:int;
+  account_id:string;
+  score:int;
+  hints_used:int;
+  is_winner:bool;
+}
+
+// GameView is the shared (non-private) game summary.
+table GameView {
+  id:string;
+  variant:string;
+  dict_version:string;
+  status:string;
+  players:int;
+  to_move:int;
+  turn_timeout_secs:int;
+  move_count:int;
+  end_reason:string;
+  seats:[SeatView];
+}
+
+// MoveRecord is one decoded move (a committed play, or a hint preview).
+table MoveRecord {
+  player:int;
+  action:string;
+  dir:string;
+  main_row:int;
+  main_col:int;
+  tiles:[TileRecord];
+  words:[string];
+  count:int;
+  score:int;
+  total:int;
+}
+
+// --- auth (unauthenticated) ---
+
+// TelegramLoginRequest carries the platform launch data; the gateway validates
+// its HMAC before forwarding the extracted identity to the backend.
+table TelegramLoginRequest {
+  init_data:string;
+}
+
+// GuestLoginRequest bootstraps an ephemeral guest session. locale is an optional
+// preferred-language hint.
+table GuestLoginRequest {
+  locale:string;
+}
+
+// EmailRequestRequest asks the backend to send a login confirm-code to email.
+table EmailRequestRequest {
+  email:string;
+}
+
+// EmailLoginRequest logs in (or provisions) the account owning email, verifying
+// the confirm-code.
+table EmailLoginRequest {
+  email:string;
+  code:string;
+}
+
+// Session is the minted credential returned by every auth operation.
+table Session {
+  token:string;
+  user_id:string;
+  is_guest:bool;
+  display_name:string;
+}
+
+// Ack is a simple success acknowledgement (e.g. an email-code request).
+table Ack {
+  ok:bool;
+}
+
+// --- profile (authenticated) ---
+
+// Profile is the authenticated account's own profile view.
+table Profile {
+  user_id:string;
+  display_name:string;
+  preferred_language:string;
+  time_zone:string;
+  hint_balance:int;
+  block_chat:bool;
+  block_friend_requests:bool;
+  is_guest:bool;
+}
+
+// --- game (authenticated) ---
+
+// SubmitPlayRequest places tiles in a direction on the player's turn.
+table SubmitPlayRequest {
+  game_id:string;
+  dir:string;
+  tiles:[TileRecord];
+}
+
+// MoveResult is the outcome of a committed move: the move and the post-move game.
+table MoveResult {
+  move:MoveRecord;
+  game:GameView;
+}
+
+// StateRequest asks for the requesting player's view of a game.
+table StateRequest {
+  game_id:string;
+}
+
+// StateView is a player's view of a game: the shared summary plus their private
+// rack, the bag size and their remaining hint budget.
+table StateView {
+  game:GameView;
+  seat:int;
+  rack:[string];
+  bag_len:int;
+  hints_remaining:int;
+}
+
+// --- lobby (authenticated) ---
+
+// EnqueueRequest joins the per-variant auto-match pool.
+table EnqueueRequest {
+  variant:string;
+}
+
+// MatchResult reports whether the caller has been paired into a game yet.
+table MatchResult {
+  matched:bool;
+  game:GameView;
+}
+
+// --- chat (authenticated) ---
+
+// ChatPostRequest posts a per-game chat message.
+table ChatPostRequest {
+  game_id:string;
+  body:string;
+}
+
+// ChatMessage is one stored chat message or nudge.
+table ChatMessage {
+  id:string;
+  game_id:string;
+  sender_id:string;
+  kind:string;
+  body:string;
+  created_at_unix:long;
+}
+
+// --- push event payloads ---
+
+// YourTurnEvent signals that it is now the recipient's turn.
+table YourTurnEvent {
+  game_id:string;
+  deadline_unix:long;
+}
+
+// OpponentMovedEvent summarises a move another seat just committed; the client
+// refetches the full state.
+table OpponentMovedEvent {
+  game_id:string;
+  seat:int;
+  action:string;
+  score:int;
+  total:int;
+}
+
+// NudgeEvent signals that a player nudged the recipient.
+table NudgeEvent {
+  game_id:string;
+  from_user_id:string;
+}
+
+// MatchFoundEvent signals that an auto-match pairing (or robot substitution)
+// started a game the recipient is seated in.
+table MatchFoundEvent {
+  game_id:string;
+}

pkg/fbs/scrabblefb/Ack.go

@@ -0,0 +1,64 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Ack struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsAck(buf []byte, offset flatbuffers.UOffsetT) *Ack {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Ack{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishAckBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsAck(buf []byte, offset flatbuffers.UOffsetT) *Ack {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Ack{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedAckBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Ack) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Ack) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Ack) Ok() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Ack) MutateOk(n bool) bool {
+	return rcv._tab.MutateBoolSlot(4, n)
+}
+
+func AckStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func AckAddOk(builder *flatbuffers.Builder, ok bool) {
+	builder.PrependBoolSlot(0, ok, false)
+}
+func AckEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/ChatMessage.go

@@ -0,0 +1,119 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ChatMessage struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsChatMessage(buf []byte, offset flatbuffers.UOffsetT) *ChatMessage {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ChatMessage{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishChatMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsChatMessage(buf []byte, offset flatbuffers.UOffsetT) *ChatMessage {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ChatMessage{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedChatMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ChatMessage) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ChatMessage) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ChatMessage) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatMessage) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatMessage) SenderId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatMessage) Kind() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatMessage) Body() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatMessage) CreatedAtUnix() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ChatMessage) MutateCreatedAtUnix(n int64) bool {
+	return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func ChatMessageStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func ChatMessageAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func ChatMessageAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(gameId), 0)
+}
+func ChatMessageAddSenderId(builder *flatbuffers.Builder, senderId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(senderId), 0)
+}
+func ChatMessageAddKind(builder *flatbuffers.Builder, kind flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(kind), 0)
+}
+func ChatMessageAddBody(builder *flatbuffers.Builder, body flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(body), 0)
+}
+func ChatMessageAddCreatedAtUnix(builder *flatbuffers.Builder, createdAtUnix int64) {
+	builder.PrependInt64Slot(5, createdAtUnix, 0)
+}
+func ChatMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/ChatPostRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ChatPostRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsChatPostRequest(buf []byte, offset flatbuffers.UOffsetT) *ChatPostRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ChatPostRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishChatPostRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsChatPostRequest(buf []byte, offset flatbuffers.UOffsetT) *ChatPostRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ChatPostRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedChatPostRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ChatPostRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ChatPostRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ChatPostRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ChatPostRequest) Body() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ChatPostRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ChatPostRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func ChatPostRequestAddBody(builder *flatbuffers.Builder, body flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(body), 0)
+}
+func ChatPostRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/EmailLoginRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type EmailLoginRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsEmailLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *EmailLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &EmailLoginRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishEmailLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsEmailLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *EmailLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &EmailLoginRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedEmailLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *EmailLoginRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *EmailLoginRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *EmailLoginRequest) Email() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *EmailLoginRequest) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func EmailLoginRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func EmailLoginRequestAddEmail(builder *flatbuffers.Builder, email flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(email), 0)
+}
+func EmailLoginRequestAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(code), 0)
+}
+func EmailLoginRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/EmailRequestRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type EmailRequestRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsEmailRequestRequest(buf []byte, offset flatbuffers.UOffsetT) *EmailRequestRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &EmailRequestRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishEmailRequestRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsEmailRequestRequest(buf []byte, offset flatbuffers.UOffsetT) *EmailRequestRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &EmailRequestRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedEmailRequestRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *EmailRequestRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *EmailRequestRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *EmailRequestRequest) Email() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func EmailRequestRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func EmailRequestRequestAddEmail(builder *flatbuffers.Builder, email flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(email), 0)
+}
+func EmailRequestRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/EnqueueRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type EnqueueRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsEnqueueRequest(buf []byte, offset flatbuffers.UOffsetT) *EnqueueRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &EnqueueRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishEnqueueRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsEnqueueRequest(buf []byte, offset flatbuffers.UOffsetT) *EnqueueRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &EnqueueRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedEnqueueRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *EnqueueRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *EnqueueRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *EnqueueRequest) Variant() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func EnqueueRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func EnqueueRequestAddVariant(builder *flatbuffers.Builder, variant flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(variant), 0)
+}
+func EnqueueRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/GameView.go

@@ -0,0 +1,190 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GameView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGameView(buf []byte, offset flatbuffers.UOffsetT) *GameView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GameView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGameViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGameView(buf []byte, offset flatbuffers.UOffsetT) *GameView {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GameView{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGameViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GameView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GameView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GameView) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameView) Variant() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameView) DictVersion() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameView) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameView) Players() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameView) MutatePlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func (rcv *GameView) ToMove() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameView) MutateToMove(n int32) bool {
+	return rcv._tab.MutateInt32Slot(14, n)
+}
+
+func (rcv *GameView) TurnTimeoutSecs() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameView) MutateTurnTimeoutSecs(n int32) bool {
+	return rcv._tab.MutateInt32Slot(16, n)
+}
+
+func (rcv *GameView) MoveCount() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameView) MutateMoveCount(n int32) bool {
+	return rcv._tab.MutateInt32Slot(18, n)
+}
+
+func (rcv *GameView) EndReason() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameView) Seats(obj *SeatView, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *GameView) SeatsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func GameViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func GameViewAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func GameViewAddVariant(builder *flatbuffers.Builder, variant flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(variant), 0)
+}
+func GameViewAddDictVersion(builder *flatbuffers.Builder, dictVersion flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(dictVersion), 0)
+}
+func GameViewAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(status), 0)
+}
+func GameViewAddPlayers(builder *flatbuffers.Builder, players int32) {
+	builder.PrependInt32Slot(4, players, 0)
+}
+func GameViewAddToMove(builder *flatbuffers.Builder, toMove int32) {
+	builder.PrependInt32Slot(5, toMove, 0)
+}
+func GameViewAddTurnTimeoutSecs(builder *flatbuffers.Builder, turnTimeoutSecs int32) {
+	builder.PrependInt32Slot(6, turnTimeoutSecs, 0)
+}
+func GameViewAddMoveCount(builder *flatbuffers.Builder, moveCount int32) {
+	builder.PrependInt32Slot(7, moveCount, 0)
+}
+func GameViewAddEndReason(builder *flatbuffers.Builder, endReason flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(endReason), 0)
+}
+func GameViewAddSeats(builder *flatbuffers.Builder, seats flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(seats), 0)
+}
+func GameViewStartSeatsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func GameViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/GuestLoginRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GuestLoginRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGuestLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *GuestLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GuestLoginRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGuestLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGuestLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *GuestLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GuestLoginRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGuestLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GuestLoginRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GuestLoginRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GuestLoginRequest) Locale() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func GuestLoginRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func GuestLoginRequestAddLocale(builder *flatbuffers.Builder, locale flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(locale), 0)
+}
+func GuestLoginRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/MatchFoundEvent.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MatchFoundEvent struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMatchFoundEvent(buf []byte, offset flatbuffers.UOffsetT) *MatchFoundEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MatchFoundEvent{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMatchFoundEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMatchFoundEvent(buf []byte, offset flatbuffers.UOffsetT) *MatchFoundEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MatchFoundEvent{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMatchFoundEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MatchFoundEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MatchFoundEvent) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MatchFoundEvent) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func MatchFoundEventStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func MatchFoundEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func MatchFoundEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/MatchResult.go

@@ -0,0 +1,80 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MatchResult struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMatchResult(buf []byte, offset flatbuffers.UOffsetT) *MatchResult {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MatchResult{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMatchResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMatchResult(buf []byte, offset flatbuffers.UOffsetT) *MatchResult {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MatchResult{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMatchResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MatchResult) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MatchResult) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MatchResult) Matched() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *MatchResult) MutateMatched(n bool) bool {
+	return rcv._tab.MutateBoolSlot(4, n)
+}
+
+func (rcv *MatchResult) Game(obj *GameView) *GameView {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(GameView)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func MatchResultStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func MatchResultAddMatched(builder *flatbuffers.Builder, matched bool) {
+	builder.PrependBoolSlot(0, matched, false)
+}
+func MatchResultAddGame(builder *flatbuffers.Builder, game flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(game), 0)
+}
+func MatchResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/MoveRecord.go

@@ -0,0 +1,210 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MoveRecord struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMoveRecord(buf []byte, offset flatbuffers.UOffsetT) *MoveRecord {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MoveRecord{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMoveRecordBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMoveRecord(buf []byte, offset flatbuffers.UOffsetT) *MoveRecord {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MoveRecord{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMoveRecordBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MoveRecord) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MoveRecord) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MoveRecord) Player() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutatePlayer(n int32) bool {
+	return rcv._tab.MutateInt32Slot(4, n)
+}
+
+func (rcv *MoveRecord) Action() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *MoveRecord) Dir() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *MoveRecord) MainRow() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutateMainRow(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *MoveRecord) MainCol() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutateMainCol(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func (rcv *MoveRecord) Tiles(obj *TileRecord, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *MoveRecord) TilesLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) Words(j int) []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+	}
+	return nil
+}
+
+func (rcv *MoveRecord) WordsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) Count() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutateCount(n int32) bool {
+	return rcv._tab.MutateInt32Slot(18, n)
+}
+
+func (rcv *MoveRecord) Score() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutateScore(n int32) bool {
+	return rcv._tab.MutateInt32Slot(20, n)
+}
+
+func (rcv *MoveRecord) Total() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *MoveRecord) MutateTotal(n int32) bool {
+	return rcv._tab.MutateInt32Slot(22, n)
+}
+
+func MoveRecordStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func MoveRecordAddPlayer(builder *flatbuffers.Builder, player int32) {
+	builder.PrependInt32Slot(0, player, 0)
+}
+func MoveRecordAddAction(builder *flatbuffers.Builder, action flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(action), 0)
+}
+func MoveRecordAddDir(builder *flatbuffers.Builder, dir flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(dir), 0)
+}
+func MoveRecordAddMainRow(builder *flatbuffers.Builder, mainRow int32) {
+	builder.PrependInt32Slot(3, mainRow, 0)
+}
+func MoveRecordAddMainCol(builder *flatbuffers.Builder, mainCol int32) {
+	builder.PrependInt32Slot(4, mainCol, 0)
+}
+func MoveRecordAddTiles(builder *flatbuffers.Builder, tiles flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(tiles), 0)
+}
+func MoveRecordStartTilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MoveRecordAddWords(builder *flatbuffers.Builder, words flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(words), 0)
+}
+func MoveRecordStartWordsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MoveRecordAddCount(builder *flatbuffers.Builder, count int32) {
+	builder.PrependInt32Slot(7, count, 0)
+}
+func MoveRecordAddScore(builder *flatbuffers.Builder, score int32) {
+	builder.PrependInt32Slot(8, score, 0)
+}
+func MoveRecordAddTotal(builder *flatbuffers.Builder, total int32) {
+	builder.PrependInt32Slot(9, total, 0)
+}
+func MoveRecordEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/MoveResult.go

@@ -0,0 +1,81 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MoveResult struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMoveResult(buf []byte, offset flatbuffers.UOffsetT) *MoveResult {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MoveResult{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMoveResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMoveResult(buf []byte, offset flatbuffers.UOffsetT) *MoveResult {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MoveResult{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMoveResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MoveResult) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MoveResult) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MoveResult) Move(obj *MoveRecord) *MoveRecord {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(MoveRecord)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *MoveResult) Game(obj *GameView) *GameView {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(GameView)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func MoveResultStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func MoveResultAddMove(builder *flatbuffers.Builder, move flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(move), 0)
+}
+func MoveResultAddGame(builder *flatbuffers.Builder, game flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(game), 0)
+}
+func MoveResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/NudgeEvent.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type NudgeEvent struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsNudgeEvent(buf []byte, offset flatbuffers.UOffsetT) *NudgeEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &NudgeEvent{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishNudgeEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsNudgeEvent(buf []byte, offset flatbuffers.UOffsetT) *NudgeEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &NudgeEvent{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedNudgeEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *NudgeEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *NudgeEvent) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *NudgeEvent) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *NudgeEvent) FromUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func NudgeEventStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func NudgeEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func NudgeEventAddFromUserId(builder *flatbuffers.Builder, fromUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(fromUserId), 0)
+}
+func NudgeEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/OpponentMovedEvent.go

@@ -0,0 +1,116 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OpponentMovedEvent struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOpponentMovedEvent(buf []byte, offset flatbuffers.UOffsetT) *OpponentMovedEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OpponentMovedEvent{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOpponentMovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOpponentMovedEvent(buf []byte, offset flatbuffers.UOffsetT) *OpponentMovedEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OpponentMovedEvent{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOpponentMovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OpponentMovedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OpponentMovedEvent) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OpponentMovedEvent) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OpponentMovedEvent) Seat() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OpponentMovedEvent) MutateSeat(n int32) bool {
+	return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *OpponentMovedEvent) Action() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OpponentMovedEvent) Score() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OpponentMovedEvent) MutateScore(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *OpponentMovedEvent) Total() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OpponentMovedEvent) MutateTotal(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func OpponentMovedEventStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func OpponentMovedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func OpponentMovedEventAddSeat(builder *flatbuffers.Builder, seat int32) {
+	builder.PrependInt32Slot(1, seat, 0)
+}
+func OpponentMovedEventAddAction(builder *flatbuffers.Builder, action flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(action), 0)
+}
+func OpponentMovedEventAddScore(builder *flatbuffers.Builder, score int32) {
+	builder.PrependInt32Slot(3, score, 0)
+}
+func OpponentMovedEventAddTotal(builder *flatbuffers.Builder, total int32) {
+	builder.PrependInt32Slot(4, total, 0)
+}
+func OpponentMovedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/Profile.go

@@ -0,0 +1,153 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Profile struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsProfile(buf []byte, offset flatbuffers.UOffsetT) *Profile {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Profile{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishProfileBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsProfile(buf []byte, offset flatbuffers.UOffsetT) *Profile {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Profile{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedProfileBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Profile) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Profile) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Profile) UserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Profile) DisplayName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Profile) PreferredLanguage() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Profile) TimeZone() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Profile) HintBalance() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Profile) MutateHintBalance(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func (rcv *Profile) BlockChat() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Profile) MutateBlockChat(n bool) bool {
+	return rcv._tab.MutateBoolSlot(14, n)
+}
+
+func (rcv *Profile) BlockFriendRequests() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Profile) MutateBlockFriendRequests(n bool) bool {
+	return rcv._tab.MutateBoolSlot(16, n)
+}
+
+func (rcv *Profile) IsGuest() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Profile) MutateIsGuest(n bool) bool {
+	return rcv._tab.MutateBoolSlot(18, n)
+}
+
+func ProfileStart(builder *flatbuffers.Builder) {
+	builder.StartObject(8)
+}
+func ProfileAddUserId(builder *flatbuffers.Builder, userId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(userId), 0)
+}
+func ProfileAddDisplayName(builder *flatbuffers.Builder, displayName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(displayName), 0)
+}
+func ProfileAddPreferredLanguage(builder *flatbuffers.Builder, preferredLanguage flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(preferredLanguage), 0)
+}
+func ProfileAddTimeZone(builder *flatbuffers.Builder, timeZone flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(timeZone), 0)
+}
+func ProfileAddHintBalance(builder *flatbuffers.Builder, hintBalance int32) {
+	builder.PrependInt32Slot(4, hintBalance, 0)
+}
+func ProfileAddBlockChat(builder *flatbuffers.Builder, blockChat bool) {
+	builder.PrependBoolSlot(5, blockChat, false)
+}
+func ProfileAddBlockFriendRequests(builder *flatbuffers.Builder, blockFriendRequests bool) {
+	builder.PrependBoolSlot(6, blockFriendRequests, false)
+}
+func ProfileAddIsGuest(builder *flatbuffers.Builder, isGuest bool) {
+	builder.PrependBoolSlot(7, isGuest, false)
+}
+func ProfileEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/SeatView.go

@@ -0,0 +1,120 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type SeatView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsSeatView(buf []byte, offset flatbuffers.UOffsetT) *SeatView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &SeatView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishSeatViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSeatView(buf []byte, offset flatbuffers.UOffsetT) *SeatView {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &SeatView{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedSeatViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *SeatView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *SeatView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *SeatView) Seat() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *SeatView) MutateSeat(n int32) bool {
+	return rcv._tab.MutateInt32Slot(4, n)
+}
+
+func (rcv *SeatView) AccountId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *SeatView) Score() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *SeatView) MutateScore(n int32) bool {
+	return rcv._tab.MutateInt32Slot(8, n)
+}
+
+func (rcv *SeatView) HintsUsed() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *SeatView) MutateHintsUsed(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *SeatView) IsWinner() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *SeatView) MutateIsWinner(n bool) bool {
+	return rcv._tab.MutateBoolSlot(12, n)
+}
+
+func SeatViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func SeatViewAddSeat(builder *flatbuffers.Builder, seat int32) {
+	builder.PrependInt32Slot(0, seat, 0)
+}
+func SeatViewAddAccountId(builder *flatbuffers.Builder, accountId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(accountId), 0)
+}
+func SeatViewAddScore(builder *flatbuffers.Builder, score int32) {
+	builder.PrependInt32Slot(2, score, 0)
+}
+func SeatViewAddHintsUsed(builder *flatbuffers.Builder, hintsUsed int32) {
+	builder.PrependInt32Slot(3, hintsUsed, 0)
+}
+func SeatViewAddIsWinner(builder *flatbuffers.Builder, isWinner bool) {
+	builder.PrependBoolSlot(4, isWinner, false)
+}
+func SeatViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/Session.go

@@ -0,0 +1,97 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Session struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsSession(buf []byte, offset flatbuffers.UOffsetT) *Session {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Session{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishSessionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSession(buf []byte, offset flatbuffers.UOffsetT) *Session {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Session{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedSessionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Session) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Session) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Session) Token() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Session) UserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Session) IsGuest() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Session) MutateIsGuest(n bool) bool {
+	return rcv._tab.MutateBoolSlot(8, n)
+}
+
+func (rcv *Session) DisplayName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func SessionStart(builder *flatbuffers.Builder) {
+	builder.StartObject(4)
+}
+func SessionAddToken(builder *flatbuffers.Builder, token flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(token), 0)
+}
+func SessionAddUserId(builder *flatbuffers.Builder, userId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(userId), 0)
+}
+func SessionAddIsGuest(builder *flatbuffers.Builder, isGuest bool) {
+	builder.PrependBoolSlot(2, isGuest, false)
+}
+func SessionAddDisplayName(builder *flatbuffers.Builder, displayName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(displayName), 0)
+}
+func SessionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/StateRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type StateRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsStateRequest(buf []byte, offset flatbuffers.UOffsetT) *StateRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &StateRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishStateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsStateRequest(buf []byte, offset flatbuffers.UOffsetT) *StateRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &StateRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedStateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *StateRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *StateRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *StateRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func StateRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func StateRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func StateRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/StateView.go

@@ -0,0 +1,133 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type StateView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsStateView(buf []byte, offset flatbuffers.UOffsetT) *StateView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &StateView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishStateViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsStateView(buf []byte, offset flatbuffers.UOffsetT) *StateView {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &StateView{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedStateViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *StateView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *StateView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *StateView) Game(obj *GameView) *GameView {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(GameView)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *StateView) Seat() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *StateView) MutateSeat(n int32) bool {
+	return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *StateView) Rack(j int) []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+	}
+	return nil
+}
+
+func (rcv *StateView) RackLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *StateView) BagLen() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *StateView) MutateBagLen(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *StateView) HintsRemaining() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *StateView) MutateHintsRemaining(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func StateViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func StateViewAddGame(builder *flatbuffers.Builder, game flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(game), 0)
+}
+func StateViewAddSeat(builder *flatbuffers.Builder, seat int32) {
+	builder.PrependInt32Slot(1, seat, 0)
+}
+func StateViewAddRack(builder *flatbuffers.Builder, rack flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(rack), 0)
+}
+func StateViewStartRackVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func StateViewAddBagLen(builder *flatbuffers.Builder, bagLen int32) {
+	builder.PrependInt32Slot(3, bagLen, 0)
+}
+func StateViewAddHintsRemaining(builder *flatbuffers.Builder, hintsRemaining int32) {
+	builder.PrependInt32Slot(4, hintsRemaining, 0)
+}
+func StateViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/SubmitPlayRequest.go

@@ -0,0 +1,97 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type SubmitPlayRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsSubmitPlayRequest(buf []byte, offset flatbuffers.UOffsetT) *SubmitPlayRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &SubmitPlayRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishSubmitPlayRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSubmitPlayRequest(buf []byte, offset flatbuffers.UOffsetT) *SubmitPlayRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &SubmitPlayRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedSubmitPlayRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *SubmitPlayRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *SubmitPlayRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *SubmitPlayRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *SubmitPlayRequest) Dir() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *SubmitPlayRequest) Tiles(obj *TileRecord, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *SubmitPlayRequest) TilesLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func SubmitPlayRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func SubmitPlayRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func SubmitPlayRequestAddDir(builder *flatbuffers.Builder, dir flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dir), 0)
+}
+func SubmitPlayRequestAddTiles(builder *flatbuffers.Builder, tiles flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(tiles), 0)
+}
+func SubmitPlayRequestStartTilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func SubmitPlayRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/TelegramLoginRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type TelegramLoginRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsTelegramLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *TelegramLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &TelegramLoginRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishTelegramLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTelegramLoginRequest(buf []byte, offset flatbuffers.UOffsetT) *TelegramLoginRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TelegramLoginRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedTelegramLoginRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *TelegramLoginRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *TelegramLoginRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *TelegramLoginRequest) InitData() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func TelegramLoginRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func TelegramLoginRequestAddInitData(builder *flatbuffers.Builder, initData flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(initData), 0)
+}
+func TelegramLoginRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/TileRecord.go

@@ -0,0 +1,105 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type TileRecord struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsTileRecord(buf []byte, offset flatbuffers.UOffsetT) *TileRecord {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &TileRecord{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishTileRecordBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTileRecord(buf []byte, offset flatbuffers.UOffsetT) *TileRecord {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TileRecord{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedTileRecordBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *TileRecord) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *TileRecord) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *TileRecord) Row() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *TileRecord) MutateRow(n int32) bool {
+	return rcv._tab.MutateInt32Slot(4, n)
+}
+
+func (rcv *TileRecord) Col() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *TileRecord) MutateCol(n int32) bool {
+	return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *TileRecord) Letter() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *TileRecord) Blank() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *TileRecord) MutateBlank(n bool) bool {
+	return rcv._tab.MutateBoolSlot(10, n)
+}
+
+func TileRecordStart(builder *flatbuffers.Builder) {
+	builder.StartObject(4)
+}
+func TileRecordAddRow(builder *flatbuffers.Builder, row int32) {
+	builder.PrependInt32Slot(0, row, 0)
+}
+func TileRecordAddCol(builder *flatbuffers.Builder, col int32) {
+	builder.PrependInt32Slot(1, col, 0)
+}
+func TileRecordAddLetter(builder *flatbuffers.Builder, letter flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(letter), 0)
+}
+func TileRecordAddBlank(builder *flatbuffers.Builder, blank bool) {
+	builder.PrependBoolSlot(3, blank, false)
+}
+func TileRecordEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/fbs/scrabblefb/YourTurnEvent.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package scrabblefb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type YourTurnEvent struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsYourTurnEvent(buf []byte, offset flatbuffers.UOffsetT) *YourTurnEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &YourTurnEvent{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishYourTurnEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsYourTurnEvent(buf []byte, offset flatbuffers.UOffsetT) *YourTurnEvent {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &YourTurnEvent{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedYourTurnEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *YourTurnEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *YourTurnEvent) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *YourTurnEvent) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *YourTurnEvent) DeadlineUnix() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *YourTurnEvent) MutateDeadlineUnix(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func YourTurnEventStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func YourTurnEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func YourTurnEventAddDeadlineUnix(builder *flatbuffers.Builder, deadlineUnix int64) {
+	builder.PrependInt64Slot(1, deadlineUnix, 0)
+}
+func YourTurnEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}