phase 8: lobby UI + cross-stack lobby command catalog + TS FlatBuffers

- Extend pkg/model/lobby and pkg/schema/fbs/lobby.fbs with public-games
  list, my-applications/invites lists, game-create, application-submit,
  invite-redeem/decline. Mirror the matching transcoder pairs and Go
  fixture round-trip tests.
- Wire the seven new lobby message types through
  gateway/internal/backendclient/{routes,lobby_commands}.go with
  per-command REST helpers, JSON-tolerant decoding of backend wire
  shapes, and httptest-based unit coverage for success / 4xx / 5xx /
  503 across each command.
- Introduce TS-side FlatBuffers via the `flatbuffers` runtime dep, a
  `make fbs-ts` target driving flatc, and the generated bindings under
  ui/frontend/src/proto/galaxy/fbs. Phase 7's `user.account.get` decode
  now uses these bindings as well, closing the JSON.parse vs
  FlatBuffers gap that would have failed against a real local stack.
- Replace the placeholder lobby with five sections (my games, pending
  invitations, my applications, public games, create new game) and the
  /lobby/create form. Submit-application uses an inline race-name
  form on the public-game card; create-game keeps name / description /
  turn_schedule / enrollment_ends_at always visible and the rest under
  an Advanced toggle with TS-side defaults.
- Update lobby/+page.svelte to throw LobbyError on non-ok result codes;
  GalaxyClient.executeCommand now returns { resultCode, payloadBytes }.
- Vitest binding round-trips, lobby.ts wrapper unit tests, lobby-page
  + lobby-create component tests, Playwright lobby-flow.spec covering
  create / submit / accept across all four projects. Phase 7 e2e was
  migrated to the FlatBuffers fixtures and to click+fill against the
  Safari-autofill readonly inputs.
- Mark Phase 8 done in ui/PLAN.md, mirror the wire-format note into
  Phase 7, append the new lobby commands to gateway/README.md and
  docs/ARCHITECTURE.md, add ui/docs/lobby.md.

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

pkg/model/lobby/lobby.go

@@ -9,10 +9,44 @@ const (
 	// used to read the calling user's own games.
 	MessageTypeMyGamesList = "lobby.my.games.list"
 
+	// MessageTypePublicGamesList is the authenticated gateway message
+	// type used to read the paginated list of joinable public games.
+	MessageTypePublicGamesList = "lobby.public.games.list"
+
+	// MessageTypeMyApplicationsList is the authenticated gateway message
+	// type used to read the caller's pending and decided applications to
+	// public games.
+	MessageTypeMyApplicationsList = "lobby.my.applications.list"
+
+	// MessageTypeMyInvitesList is the authenticated gateway message type
+	// used to read the caller's pending invites to private games.
+	MessageTypeMyInvitesList = "lobby.my.invites.list"
+
 	// MessageTypeOpenEnrollment is the authenticated gateway message
 	// type used by the game owner to transition a draft game to
 	// `enrollment_open`.
 	MessageTypeOpenEnrollment = "lobby.game.open-enrollment"
+
+	// MessageTypeGameCreate is the authenticated gateway message type
+	// used to create a private game owned by the caller. Public games
+	// are created exclusively through the admin surface; the gateway
+	// rejects any attempt to set visibility to `public`.
+	MessageTypeGameCreate = "lobby.game.create"
+
+	// MessageTypeApplicationSubmit is the authenticated gateway message
+	// type used by a user to submit an application to a public game in
+	// `enrollment_open`.
+	MessageTypeApplicationSubmit = "lobby.application.submit"
+
+	// MessageTypeInviteRedeem is the authenticated gateway message type
+	// used to accept an outstanding invite and create the corresponding
+	// membership.
+	MessageTypeInviteRedeem = "lobby.invite.redeem"
+
+	// MessageTypeInviteDecline is the authenticated gateway message type
+	// used to terminally decline an outstanding invite. No membership is
+	// created.
+	MessageTypeInviteDecline = "lobby.invite.decline"
 )
 
 // MyGamesListRequest stores the authenticated read request for the
@@ -26,18 +60,88 @@ type MyGamesListResponse struct {
 	Items []GameSummary `json:"items"`
 }
 
-// GameSummary stores one game record returned by `lobby.my.games.list`.
+// GameSummary stores one game record returned by the various lobby
+// list endpoints. `OwnerUserID` is empty for public games (no human
+// owner).
 type GameSummary struct {
-	GameID             string    `json:"game_id"`
-	GameName           string    `json:"game_name"`
-	GameType           string    `json:"game_type"`
-	Status             string    `json:"status"`
-	OwnerUserID        string    `json:"owner_user_id"`
-	MinPlayers         int       `json:"min_players"`
-	MaxPlayers         int       `json:"max_players"`
-	EnrollmentEndsAt   time.Time `json:"enrollment_ends_at"`
-	CreatedAt          time.Time `json:"created_at"`
-	UpdatedAt          time.Time `json:"updated_at"`
+	GameID           string    `json:"game_id"`
+	GameName         string    `json:"game_name"`
+	GameType         string    `json:"game_type"`
+	Status           string    `json:"status"`
+	OwnerUserID      string    `json:"owner_user_id"`
+	MinPlayers       int       `json:"min_players"`
+	MaxPlayers       int       `json:"max_players"`
+	EnrollmentEndsAt time.Time `json:"enrollment_ends_at"`
+	CreatedAt        time.Time `json:"created_at"`
+	UpdatedAt        time.Time `json:"updated_at"`
+}
+
+// PublicGamesListRequest stores the paginated read request for joinable
+// public games. Page numbers start at 1; page sizes are capped by the
+// backend.
+type PublicGamesListRequest struct {
+	Page     int `json:"page"`
+	PageSize int `json:"page_size"`
+}
+
+// PublicGamesListResponse stores one page of public games together with
+// the pagination metadata returned by the backend.
+type PublicGamesListResponse struct {
+	Items    []GameSummary `json:"items"`
+	Page     int           `json:"page"`
+	PageSize int           `json:"page_size"`
+	Total    int           `json:"total"`
+}
+
+// MyApplicationsListRequest stores the authenticated read request for
+// the caller's applications. Empty body — gateway derives identity from
+// the authenticated session.
+type MyApplicationsListRequest struct{}
+
+// MyApplicationsListResponse stores the caller's application list,
+// ordered as Lobby returns it.
+type MyApplicationsListResponse struct {
+	Items []ApplicationSummary `json:"items"`
+}
+
+// ApplicationSummary stores a single application record returned by
+// `lobby.my.applications.list` and `lobby.application.submit`.
+// `DecidedAt` is nil while the application is pending.
+type ApplicationSummary struct {
+	ApplicationID   string     `json:"application_id"`
+	GameID          string     `json:"game_id"`
+	ApplicantUserID string     `json:"applicant_user_id"`
+	RaceName        string     `json:"race_name"`
+	Status          string     `json:"status"`
+	CreatedAt       time.Time  `json:"created_at"`
+	DecidedAt       *time.Time `json:"decided_at,omitempty"`
+}
+
+// MyInvitesListRequest stores the authenticated read request for the
+// caller's invites. Empty body.
+type MyInvitesListRequest struct{}
+
+// MyInvitesListResponse stores the caller's invite list.
+type MyInvitesListResponse struct {
+	Items []InviteSummary `json:"items"`
+}
+
+// InviteSummary stores one invite record returned by
+// `lobby.my.invites.list`, `lobby.invite.redeem`, and
+// `lobby.invite.decline`. `InvitedUserID` is empty for code-based
+// invites; `Code` is empty for user-bound invites; `DecidedAt` is nil
+// while the invite is still pending.
+type InviteSummary struct {
+	InviteID      string     `json:"invite_id"`
+	GameID        string     `json:"game_id"`
+	InviterUserID string     `json:"inviter_user_id"`
+	InvitedUserID string     `json:"invited_user_id,omitempty"`
+	Code          string     `json:"code,omitempty"`
+	RaceName      string     `json:"race_name"`
+	Status        string     `json:"status"`
+	CreatedAt     time.Time  `json:"created_at"`
+	ExpiresAt     time.Time  `json:"expires_at"`
+	DecidedAt     *time.Time `json:"decided_at,omitempty"`
 }
 
 // OpenEnrollmentRequest stores the owner-only command that transitions
@@ -55,6 +159,70 @@ type OpenEnrollmentResponse struct {
 	Status string `json:"status"`
 }
 
+// GameCreateRequest stores the create-game command issued by the user
+// surface. Visibility is always `private` here; the gateway rejects any
+// other value before forwarding to backend, mirroring the FUNCTIONAL
+// §3.3 invariant.
+type GameCreateRequest struct {
+	GameName            string    `json:"game_name"`
+	Description         string    `json:"description"`
+	MinPlayers          int       `json:"min_players"`
+	MaxPlayers          int       `json:"max_players"`
+	StartGapHours       int       `json:"start_gap_hours"`
+	StartGapPlayers     int       `json:"start_gap_players"`
+	EnrollmentEndsAt    time.Time `json:"enrollment_ends_at"`
+	TurnSchedule        string    `json:"turn_schedule"`
+	TargetEngineVersion string    `json:"target_engine_version"`
+}
+
+// GameCreateResponse stores the freshly created game projected onto the
+// shared GameSummary shape — the gateway does not expose runtime fields
+// at create time because the game is always in `draft` until the owner
+// transitions it.
+type GameCreateResponse struct {
+	Game GameSummary `json:"game"`
+}
+
+// ApplicationSubmitRequest stores the submit-application command. The
+// game must be public and in `enrollment_open`; backend rejects all
+// other states.
+type ApplicationSubmitRequest struct {
+	GameID   string `json:"game_id"`
+	RaceName string `json:"race_name"`
+}
+
+// ApplicationSubmitResponse wraps the application created by a
+// successful submit-application call.
+type ApplicationSubmitResponse struct {
+	Application ApplicationSummary `json:"application"`
+}
+
+// InviteRedeemRequest accepts a pending invite and creates the
+// corresponding membership at the backend.
+type InviteRedeemRequest struct {
+	GameID   string `json:"game_id"`
+	InviteID string `json:"invite_id"`
+}
+
+// InviteRedeemResponse wraps the invite record updated by a successful
+// redeem (status transitions to `accepted`).
+type InviteRedeemResponse struct {
+	Invite InviteSummary `json:"invite"`
+}
+
+// InviteDeclineRequest terminally declines a pending invite. No
+// membership is created.
+type InviteDeclineRequest struct {
+	GameID   string `json:"game_id"`
+	InviteID string `json:"invite_id"`
+}
+
+// InviteDeclineResponse wraps the invite record updated by a successful
+// decline (status transitions to `declined`).
+type InviteDeclineResponse struct {
+	Invite InviteSummary `json:"invite"`
+}
+
 // ErrorBody stores the canonical Lobby error envelope code/message
 // pair.
 type ErrorBody struct {

pkg/schema/fbs/lobby.fbs

@@ -4,7 +4,8 @@
 // from the verified session and forwards it as `X-User-Id` to lobby.
 namespace lobby;
 
-// GameSummary stores one game record returned by `lobby.my.games.list`.
+// GameSummary stores one game record returned by the lobby list
+// endpoints. owner_user_id is empty for public games (no human owner).
 // The shape matches `lobby/openapi.yaml` `MyGameSummary`.
 table GameSummary {
   game_id:string;
@@ -31,6 +32,71 @@ table MyGamesListResponse {
   items:[GameSummary];
 }
 
+// PublicGamesListRequest stores the paginated read request for joinable
+// public games. Page numbers start at 1; backend caps page_size.
+table PublicGamesListRequest {
+  page:int32;
+  page_size:int32;
+}
+
+// PublicGamesListResponse stores one page of public games together with
+// the pagination metadata.
+table PublicGamesListResponse {
+  items:[GameSummary];
+  page:int32;
+  page_size:int32;
+  total:int32;
+}
+
+// ApplicationSummary stores one application record. decided_at_ms is 0
+// while the application is pending.
+table ApplicationSummary {
+  application_id:string;
+  game_id:string;
+  applicant_user_id:string;
+  race_name:string;
+  status:string;
+  created_at_ms:int64;
+  decided_at_ms:int64;
+}
+
+// MyApplicationsListRequest stores the authenticated read request for
+// the caller's applications. Empty body.
+table MyApplicationsListRequest {
+}
+
+// MyApplicationsListResponse stores the caller's applications in the
+// order the backend returns them.
+table MyApplicationsListResponse {
+  items:[ApplicationSummary];
+}
+
+// InviteSummary stores one invite record. invited_user_id is empty for
+// code-based invites; code is empty for user-bound invites;
+// decided_at_ms is 0 while the invite is still pending.
+table InviteSummary {
+  invite_id:string;
+  game_id:string;
+  inviter_user_id:string;
+  invited_user_id:string;
+  code:string;
+  race_name:string;
+  status:string;
+  created_at_ms:int64;
+  expires_at_ms:int64;
+  decided_at_ms:int64;
+}
+
+// MyInvitesListRequest stores the authenticated read request for the
+// caller's invites. Empty body.
+table MyInvitesListRequest {
+}
+
+// MyInvitesListResponse stores the caller's invite list.
+table MyInvitesListResponse {
+  items:[InviteSummary];
+}
+
 // OpenEnrollmentRequest stores the owner-only command that transitions
 // a game from `draft` to `enrollment_open`.
 table OpenEnrollmentRequest {
@@ -43,6 +109,65 @@ table OpenEnrollmentResponse {
   status:string;
 }
 
+// GameCreateRequest stores the create-game command. Visibility is
+// always `private` for the user surface; the gateway rejects any other
+// value before forwarding to backend.
+table GameCreateRequest {
+  game_name:string;
+  description:string;
+  min_players:int32;
+  max_players:int32;
+  start_gap_hours:int32;
+  start_gap_players:int32;
+  enrollment_ends_at_ms:int64;
+  turn_schedule:string;
+  target_engine_version:string;
+}
+
+// GameCreateResponse wraps the freshly created game projected onto the
+// shared GameSummary shape.
+table GameCreateResponse {
+  game:GameSummary;
+}
+
+// ApplicationSubmitRequest stores the submit-application command for a
+// public game in `enrollment_open`.
+table ApplicationSubmitRequest {
+  game_id:string;
+  race_name:string;
+}
+
+// ApplicationSubmitResponse wraps the freshly created application
+// record.
+table ApplicationSubmitResponse {
+  application:ApplicationSummary;
+}
+
+// InviteRedeemRequest accepts a pending invite and creates the
+// corresponding membership.
+table InviteRedeemRequest {
+  game_id:string;
+  invite_id:string;
+}
+
+// InviteRedeemResponse wraps the updated invite record (status
+// transitioned to `accepted`).
+table InviteRedeemResponse {
+  invite:InviteSummary;
+}
+
+// InviteDeclineRequest terminally declines a pending invite.
+table InviteDeclineRequest {
+  game_id:string;
+  invite_id:string;
+}
+
+// InviteDeclineResponse wraps the updated invite record (status
+// transitioned to `declined`).
+table InviteDeclineResponse {
+  invite:InviteSummary;
+}
+
 // ErrorBody stores the canonical lobby error envelope code/message
 // pair.
 table ErrorBody {

pkg/schema/fbs/lobby/ApplicationSubmitRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ApplicationSubmitRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsApplicationSubmitRequest(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSubmitRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ApplicationSubmitRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishApplicationSubmitRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsApplicationSubmitRequest(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSubmitRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ApplicationSubmitRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedApplicationSubmitRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ApplicationSubmitRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ApplicationSubmitRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ApplicationSubmitRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSubmitRequest) RaceName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ApplicationSubmitRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ApplicationSubmitRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func ApplicationSubmitRequestAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(raceName), 0)
+}
+func ApplicationSubmitRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/ApplicationSubmitResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ApplicationSubmitResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsApplicationSubmitResponse(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSubmitResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ApplicationSubmitResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishApplicationSubmitResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsApplicationSubmitResponse(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSubmitResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ApplicationSubmitResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedApplicationSubmitResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ApplicationSubmitResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ApplicationSubmitResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ApplicationSubmitResponse) Application(obj *ApplicationSummary) *ApplicationSummary {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ApplicationSummary)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func ApplicationSubmitResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func ApplicationSubmitResponseAddApplication(builder *flatbuffers.Builder, application flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(application), 0)
+}
+func ApplicationSubmitResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/ApplicationSummary.go

@@ -0,0 +1,134 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ApplicationSummary struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsApplicationSummary(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ApplicationSummary{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishApplicationSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsApplicationSummary(buf []byte, offset flatbuffers.UOffsetT) *ApplicationSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ApplicationSummary{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedApplicationSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ApplicationSummary) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ApplicationSummary) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ApplicationSummary) ApplicationId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSummary) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSummary) ApplicantUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSummary) RaceName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSummary) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ApplicationSummary) CreatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ApplicationSummary) MutateCreatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func (rcv *ApplicationSummary) DecidedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ApplicationSummary) MutateDecidedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(16, n)
+}
+
+func ApplicationSummaryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(7)
+}
+func ApplicationSummaryAddApplicationId(builder *flatbuffers.Builder, applicationId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(applicationId), 0)
+}
+func ApplicationSummaryAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(gameId), 0)
+}
+func ApplicationSummaryAddApplicantUserId(builder *flatbuffers.Builder, applicantUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(applicantUserId), 0)
+}
+func ApplicationSummaryAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(raceName), 0)
+}
+func ApplicationSummaryAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(status), 0)
+}
+func ApplicationSummaryAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
+	builder.PrependInt64Slot(5, createdAtMs, 0)
+}
+func ApplicationSummaryAddDecidedAtMs(builder *flatbuffers.Builder, decidedAtMs int64) {
+	builder.PrependInt64Slot(6, decidedAtMs, 0)
+}
+func ApplicationSummaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/GameCreateRequest.go

@@ -0,0 +1,168 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GameCreateRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGameCreateRequest(buf []byte, offset flatbuffers.UOffsetT) *GameCreateRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GameCreateRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGameCreateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGameCreateRequest(buf []byte, offset flatbuffers.UOffsetT) *GameCreateRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GameCreateRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGameCreateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GameCreateRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GameCreateRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GameCreateRequest) GameName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameCreateRequest) Description() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameCreateRequest) MinPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameCreateRequest) MutateMinPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(8, n)
+}
+
+func (rcv *GameCreateRequest) MaxPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameCreateRequest) MutateMaxPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *GameCreateRequest) StartGapHours() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameCreateRequest) MutateStartGapHours(n int32) bool {
+	return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func (rcv *GameCreateRequest) StartGapPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameCreateRequest) MutateStartGapPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(14, n)
+}
+
+func (rcv *GameCreateRequest) EnrollmentEndsAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameCreateRequest) MutateEnrollmentEndsAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(16, n)
+}
+
+func (rcv *GameCreateRequest) TurnSchedule() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameCreateRequest) TargetEngineVersion() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func GameCreateRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(9)
+}
+func GameCreateRequestAddGameName(builder *flatbuffers.Builder, gameName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameName), 0)
+}
+func GameCreateRequestAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(description), 0)
+}
+func GameCreateRequestAddMinPlayers(builder *flatbuffers.Builder, minPlayers int32) {
+	builder.PrependInt32Slot(2, minPlayers, 0)
+}
+func GameCreateRequestAddMaxPlayers(builder *flatbuffers.Builder, maxPlayers int32) {
+	builder.PrependInt32Slot(3, maxPlayers, 0)
+}
+func GameCreateRequestAddStartGapHours(builder *flatbuffers.Builder, startGapHours int32) {
+	builder.PrependInt32Slot(4, startGapHours, 0)
+}
+func GameCreateRequestAddStartGapPlayers(builder *flatbuffers.Builder, startGapPlayers int32) {
+	builder.PrependInt32Slot(5, startGapPlayers, 0)
+}
+func GameCreateRequestAddEnrollmentEndsAtMs(builder *flatbuffers.Builder, enrollmentEndsAtMs int64) {
+	builder.PrependInt64Slot(6, enrollmentEndsAtMs, 0)
+}
+func GameCreateRequestAddTurnSchedule(builder *flatbuffers.Builder, turnSchedule flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(turnSchedule), 0)
+}
+func GameCreateRequestAddTargetEngineVersion(builder *flatbuffers.Builder, targetEngineVersion flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(targetEngineVersion), 0)
+}
+func GameCreateRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/GameCreateResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GameCreateResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGameCreateResponse(buf []byte, offset flatbuffers.UOffsetT) *GameCreateResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GameCreateResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGameCreateResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGameCreateResponse(buf []byte, offset flatbuffers.UOffsetT) *GameCreateResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GameCreateResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGameCreateResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GameCreateResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GameCreateResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GameCreateResponse) Game(obj *GameSummary) *GameSummary {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(GameSummary)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func GameCreateResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func GameCreateResponseAddGame(builder *flatbuffers.Builder, game flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(game), 0)
+}
+func GameCreateResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/InviteDeclineRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type InviteDeclineRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsInviteDeclineRequest(buf []byte, offset flatbuffers.UOffsetT) *InviteDeclineRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &InviteDeclineRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishInviteDeclineRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInviteDeclineRequest(buf []byte, offset flatbuffers.UOffsetT) *InviteDeclineRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &InviteDeclineRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedInviteDeclineRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *InviteDeclineRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *InviteDeclineRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *InviteDeclineRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteDeclineRequest) InviteId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func InviteDeclineRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func InviteDeclineRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func InviteDeclineRequestAddInviteId(builder *flatbuffers.Builder, inviteId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(inviteId), 0)
+}
+func InviteDeclineRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/InviteDeclineResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type InviteDeclineResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsInviteDeclineResponse(buf []byte, offset flatbuffers.UOffsetT) *InviteDeclineResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &InviteDeclineResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishInviteDeclineResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInviteDeclineResponse(buf []byte, offset flatbuffers.UOffsetT) *InviteDeclineResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &InviteDeclineResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedInviteDeclineResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *InviteDeclineResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *InviteDeclineResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *InviteDeclineResponse) Invite(obj *InviteSummary) *InviteSummary {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(InviteSummary)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func InviteDeclineResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func InviteDeclineResponseAddInvite(builder *flatbuffers.Builder, invite flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(invite), 0)
+}
+func InviteDeclineResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/InviteRedeemRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type InviteRedeemRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsInviteRedeemRequest(buf []byte, offset flatbuffers.UOffsetT) *InviteRedeemRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &InviteRedeemRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishInviteRedeemRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInviteRedeemRequest(buf []byte, offset flatbuffers.UOffsetT) *InviteRedeemRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &InviteRedeemRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedInviteRedeemRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *InviteRedeemRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *InviteRedeemRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *InviteRedeemRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteRedeemRequest) InviteId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func InviteRedeemRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func InviteRedeemRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func InviteRedeemRequestAddInviteId(builder *flatbuffers.Builder, inviteId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(inviteId), 0)
+}
+func InviteRedeemRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/InviteRedeemResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type InviteRedeemResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsInviteRedeemResponse(buf []byte, offset flatbuffers.UOffsetT) *InviteRedeemResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &InviteRedeemResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishInviteRedeemResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInviteRedeemResponse(buf []byte, offset flatbuffers.UOffsetT) *InviteRedeemResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &InviteRedeemResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedInviteRedeemResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *InviteRedeemResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *InviteRedeemResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *InviteRedeemResponse) Invite(obj *InviteSummary) *InviteSummary {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(InviteSummary)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func InviteRedeemResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func InviteRedeemResponseAddInvite(builder *flatbuffers.Builder, invite flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(invite), 0)
+}
+func InviteRedeemResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/InviteSummary.go

@@ -0,0 +1,171 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type InviteSummary struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsInviteSummary(buf []byte, offset flatbuffers.UOffsetT) *InviteSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &InviteSummary{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishInviteSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInviteSummary(buf []byte, offset flatbuffers.UOffsetT) *InviteSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &InviteSummary{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedInviteSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *InviteSummary) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *InviteSummary) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *InviteSummary) InviteId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) InviterUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) InvitedUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) RaceName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *InviteSummary) CreatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *InviteSummary) MutateCreatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(18, n)
+}
+
+func (rcv *InviteSummary) ExpiresAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *InviteSummary) MutateExpiresAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(20, n)
+}
+
+func (rcv *InviteSummary) DecidedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *InviteSummary) MutateDecidedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(22, n)
+}
+
+func InviteSummaryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func InviteSummaryAddInviteId(builder *flatbuffers.Builder, inviteId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(inviteId), 0)
+}
+func InviteSummaryAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(gameId), 0)
+}
+func InviteSummaryAddInviterUserId(builder *flatbuffers.Builder, inviterUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inviterUserId), 0)
+}
+func InviteSummaryAddInvitedUserId(builder *flatbuffers.Builder, invitedUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(invitedUserId), 0)
+}
+func InviteSummaryAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(code), 0)
+}
+func InviteSummaryAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(raceName), 0)
+}
+func InviteSummaryAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(status), 0)
+}
+func InviteSummaryAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
+	builder.PrependInt64Slot(7, createdAtMs, 0)
+}
+func InviteSummaryAddExpiresAtMs(builder *flatbuffers.Builder, expiresAtMs int64) {
+	builder.PrependInt64Slot(8, expiresAtMs, 0)
+}
+func InviteSummaryAddDecidedAtMs(builder *flatbuffers.Builder, decidedAtMs int64) {
+	builder.PrependInt64Slot(9, decidedAtMs, 0)
+}
+func InviteSummaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/MyApplicationsListRequest.go

@@ -0,0 +1,49 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MyApplicationsListRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyApplicationsListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyApplicationsListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyApplicationsListRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyApplicationsListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyApplicationsListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyApplicationsListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyApplicationsListRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyApplicationsListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyApplicationsListRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyApplicationsListRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func MyApplicationsListRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func MyApplicationsListRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/MyApplicationsListResponse.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MyApplicationsListResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyApplicationsListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyApplicationsListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyApplicationsListResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyApplicationsListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyApplicationsListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyApplicationsListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyApplicationsListResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyApplicationsListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyApplicationsListResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyApplicationsListResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MyApplicationsListResponse) Items(obj *ApplicationSummary, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	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 *MyApplicationsListResponse) ItemsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func MyApplicationsListResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func MyApplicationsListResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
+}
+func MyApplicationsListResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MyApplicationsListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/MyInvitesListRequest.go

@@ -0,0 +1,49 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MyInvitesListRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyInvitesListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyInvitesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyInvitesListRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyInvitesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyInvitesListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyInvitesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyInvitesListRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyInvitesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyInvitesListRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyInvitesListRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func MyInvitesListRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func MyInvitesListRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/MyInvitesListResponse.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MyInvitesListResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyInvitesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyInvitesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyInvitesListResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyInvitesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyInvitesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyInvitesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyInvitesListResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyInvitesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyInvitesListResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyInvitesListResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MyInvitesListResponse) Items(obj *InviteSummary, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	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 *MyInvitesListResponse) ItemsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func MyInvitesListResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func MyInvitesListResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
+}
+func MyInvitesListResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MyInvitesListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/PublicGamesListRequest.go

@@ -0,0 +1,79 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type PublicGamesListRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsPublicGamesListRequest(buf []byte, offset flatbuffers.UOffsetT) *PublicGamesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &PublicGamesListRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishPublicGamesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsPublicGamesListRequest(buf []byte, offset flatbuffers.UOffsetT) *PublicGamesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &PublicGamesListRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedPublicGamesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *PublicGamesListRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *PublicGamesListRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *PublicGamesListRequest) Page() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListRequest) MutatePage(n int32) bool {
+	return rcv._tab.MutateInt32Slot(4, n)
+}
+
+func (rcv *PublicGamesListRequest) PageSize() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListRequest) MutatePageSize(n int32) bool {
+	return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func PublicGamesListRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func PublicGamesListRequestAddPage(builder *flatbuffers.Builder, page int32) {
+	builder.PrependInt32Slot(0, page, 0)
+}
+func PublicGamesListRequestAddPageSize(builder *flatbuffers.Builder, pageSize int32) {
+	builder.PrependInt32Slot(1, pageSize, 0)
+}
+func PublicGamesListRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/PublicGamesListResponse.go

@@ -0,0 +1,120 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type PublicGamesListResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsPublicGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *PublicGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &PublicGamesListResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishPublicGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsPublicGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *PublicGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &PublicGamesListResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedPublicGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *PublicGamesListResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *PublicGamesListResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *PublicGamesListResponse) Items(obj *GameSummary, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	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 *PublicGamesListResponse) ItemsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListResponse) Page() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListResponse) MutatePage(n int32) bool {
+	return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *PublicGamesListResponse) PageSize() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListResponse) MutatePageSize(n int32) bool {
+	return rcv._tab.MutateInt32Slot(8, n)
+}
+
+func (rcv *PublicGamesListResponse) Total() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *PublicGamesListResponse) MutateTotal(n int32) bool {
+	return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func PublicGamesListResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(4)
+}
+func PublicGamesListResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
+}
+func PublicGamesListResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func PublicGamesListResponseAddPage(builder *flatbuffers.Builder, page int32) {
+	builder.PrependInt32Slot(1, page, 0)
+}
+func PublicGamesListResponseAddPageSize(builder *flatbuffers.Builder, pageSize int32) {
+	builder.PrependInt32Slot(2, pageSize, 0)
+}
+func PublicGamesListResponseAddTotal(builder *flatbuffers.Builder, total int32) {
+	builder.PrependInt32Slot(3, total, 0)
+}
+func PublicGamesListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/transcoder/lobby.go

@@ -53,14 +53,7 @@ func MyGamesListResponseToPayload(response *lobbymodel.MyGamesListResponse) ([]b
 		itemOffsets[index] = encodeGameSummary(builder, response.Items[index])
 	}
 
-	var itemsVector flatbuffers.UOffsetT
-	if len(itemOffsets) > 0 {
-		lobbyfbs.MyGamesListResponseStartItemsVector(builder, len(itemOffsets))
-		for index := len(itemOffsets) - 1; index >= 0; index-- {
-			builder.PrependUOffsetT(itemOffsets[index])
-		}
-		itemsVector = builder.EndVector(len(itemOffsets))
-	}
+	itemsVector := finishOffsetVector(builder, itemOffsets)
 
 	lobbyfbs.MyGamesListResponseStart(builder)
 	if itemsVector != 0 {
@@ -96,6 +89,248 @@ func PayloadToMyGamesListResponse(data []byte) (result *lobbymodel.MyGamesListRe
 	return out, nil
 }
 
+// PublicGamesListRequestToPayload converts lobbymodel.PublicGamesListRequest to
+// FlatBuffers bytes.
+func PublicGamesListRequestToPayload(request *lobbymodel.PublicGamesListRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode public games list request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(32)
+	lobbyfbs.PublicGamesListRequestStart(builder)
+	lobbyfbs.PublicGamesListRequestAddPage(builder, int32(request.Page))
+	lobbyfbs.PublicGamesListRequestAddPageSize(builder, int32(request.PageSize))
+	offset := lobbyfbs.PublicGamesListRequestEnd(builder)
+	lobbyfbs.FinishPublicGamesListRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToPublicGamesListRequest converts FlatBuffers payload bytes into
+// lobbymodel.PublicGamesListRequest.
+func PayloadToPublicGamesListRequest(data []byte) (result *lobbymodel.PublicGamesListRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode public games list request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode public games list request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsPublicGamesListRequest(data, 0)
+	return &lobbymodel.PublicGamesListRequest{
+		Page:     int(request.Page()),
+		PageSize: int(request.PageSize()),
+	}, nil
+}
+
+// PublicGamesListResponseToPayload converts lobbymodel.PublicGamesListResponse
+// to FlatBuffers bytes.
+func PublicGamesListResponseToPayload(response *lobbymodel.PublicGamesListResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode public games list response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(512)
+
+	itemOffsets := make([]flatbuffers.UOffsetT, len(response.Items))
+	for index := range response.Items {
+		itemOffsets[index] = encodeGameSummary(builder, response.Items[index])
+	}
+	itemsVector := finishOffsetVector(builder, itemOffsets)
+
+	lobbyfbs.PublicGamesListResponseStart(builder)
+	if itemsVector != 0 {
+		lobbyfbs.PublicGamesListResponseAddItems(builder, itemsVector)
+	}
+	lobbyfbs.PublicGamesListResponseAddPage(builder, int32(response.Page))
+	lobbyfbs.PublicGamesListResponseAddPageSize(builder, int32(response.PageSize))
+	lobbyfbs.PublicGamesListResponseAddTotal(builder, int32(response.Total))
+	offset := lobbyfbs.PublicGamesListResponseEnd(builder)
+	lobbyfbs.FinishPublicGamesListResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToPublicGamesListResponse converts FlatBuffers payload bytes into
+// lobbymodel.PublicGamesListResponse.
+func PayloadToPublicGamesListResponse(data []byte) (result *lobbymodel.PublicGamesListResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode public games list response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode public games list response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsPublicGamesListResponse(data, 0)
+	out := &lobbymodel.PublicGamesListResponse{
+		Items:    make([]lobbymodel.GameSummary, 0, response.ItemsLength()),
+		Page:     int(response.Page()),
+		PageSize: int(response.PageSize()),
+		Total:    int(response.Total()),
+	}
+
+	summary := new(lobbyfbs.GameSummary)
+	for index := 0; index < response.ItemsLength(); index++ {
+		if !response.Items(summary, index) {
+			return nil, fmt.Errorf("decode public games list response payload: items[%d] is missing", index)
+		}
+		out.Items = append(out.Items, decodeGameSummary(summary))
+	}
+	return out, nil
+}
+
+// MyApplicationsListRequestToPayload converts lobbymodel.MyApplicationsListRequest
+// to FlatBuffers bytes.
+func MyApplicationsListRequestToPayload(request *lobbymodel.MyApplicationsListRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode my applications list request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(32)
+	lobbyfbs.MyApplicationsListRequestStart(builder)
+	offset := lobbyfbs.MyApplicationsListRequestEnd(builder)
+	lobbyfbs.FinishMyApplicationsListRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyApplicationsListRequest converts FlatBuffers payload bytes into
+// lobbymodel.MyApplicationsListRequest.
+func PayloadToMyApplicationsListRequest(data []byte) (result *lobbymodel.MyApplicationsListRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my applications list request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my applications list request payload", &result, &err)
+
+	_ = lobbyfbs.GetRootAsMyApplicationsListRequest(data, 0)
+	return &lobbymodel.MyApplicationsListRequest{}, nil
+}
+
+// MyApplicationsListResponseToPayload converts lobbymodel.MyApplicationsListResponse
+// to FlatBuffers bytes.
+func MyApplicationsListResponseToPayload(response *lobbymodel.MyApplicationsListResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode my applications list response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(512)
+
+	itemOffsets := make([]flatbuffers.UOffsetT, len(response.Items))
+	for index := range response.Items {
+		itemOffsets[index] = encodeApplicationSummary(builder, response.Items[index])
+	}
+	itemsVector := finishOffsetVector(builder, itemOffsets)
+
+	lobbyfbs.MyApplicationsListResponseStart(builder)
+	if itemsVector != 0 {
+		lobbyfbs.MyApplicationsListResponseAddItems(builder, itemsVector)
+	}
+	offset := lobbyfbs.MyApplicationsListResponseEnd(builder)
+	lobbyfbs.FinishMyApplicationsListResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyApplicationsListResponse converts FlatBuffers payload bytes into
+// lobbymodel.MyApplicationsListResponse.
+func PayloadToMyApplicationsListResponse(data []byte) (result *lobbymodel.MyApplicationsListResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my applications list response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my applications list response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsMyApplicationsListResponse(data, 0)
+	out := &lobbymodel.MyApplicationsListResponse{
+		Items: make([]lobbymodel.ApplicationSummary, 0, response.ItemsLength()),
+	}
+
+	app := new(lobbyfbs.ApplicationSummary)
+	for index := 0; index < response.ItemsLength(); index++ {
+		if !response.Items(app, index) {
+			return nil, fmt.Errorf("decode my applications list response payload: items[%d] is missing", index)
+		}
+		out.Items = append(out.Items, decodeApplicationSummary(app))
+	}
+	return out, nil
+}
+
+// MyInvitesListRequestToPayload converts lobbymodel.MyInvitesListRequest
+// to FlatBuffers bytes.
+func MyInvitesListRequestToPayload(request *lobbymodel.MyInvitesListRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode my invites list request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(32)
+	lobbyfbs.MyInvitesListRequestStart(builder)
+	offset := lobbyfbs.MyInvitesListRequestEnd(builder)
+	lobbyfbs.FinishMyInvitesListRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyInvitesListRequest converts FlatBuffers payload bytes into
+// lobbymodel.MyInvitesListRequest.
+func PayloadToMyInvitesListRequest(data []byte) (result *lobbymodel.MyInvitesListRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my invites list request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my invites list request payload", &result, &err)
+
+	_ = lobbyfbs.GetRootAsMyInvitesListRequest(data, 0)
+	return &lobbymodel.MyInvitesListRequest{}, nil
+}
+
+// MyInvitesListResponseToPayload converts lobbymodel.MyInvitesListResponse
+// to FlatBuffers bytes.
+func MyInvitesListResponseToPayload(response *lobbymodel.MyInvitesListResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode my invites list response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(512)
+
+	itemOffsets := make([]flatbuffers.UOffsetT, len(response.Items))
+	for index := range response.Items {
+		itemOffsets[index] = encodeInviteSummary(builder, response.Items[index])
+	}
+	itemsVector := finishOffsetVector(builder, itemOffsets)
+
+	lobbyfbs.MyInvitesListResponseStart(builder)
+	if itemsVector != 0 {
+		lobbyfbs.MyInvitesListResponseAddItems(builder, itemsVector)
+	}
+	offset := lobbyfbs.MyInvitesListResponseEnd(builder)
+	lobbyfbs.FinishMyInvitesListResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyInvitesListResponse converts FlatBuffers payload bytes into
+// lobbymodel.MyInvitesListResponse.
+func PayloadToMyInvitesListResponse(data []byte) (result *lobbymodel.MyInvitesListResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my invites list response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my invites list response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsMyInvitesListResponse(data, 0)
+	out := &lobbymodel.MyInvitesListResponse{
+		Items: make([]lobbymodel.InviteSummary, 0, response.ItemsLength()),
+	}
+
+	invite := new(lobbyfbs.InviteSummary)
+	for index := 0; index < response.ItemsLength(); index++ {
+		if !response.Items(invite, index) {
+			return nil, fmt.Errorf("decode my invites list response payload: items[%d] is missing", index)
+		}
+		out.Items = append(out.Items, decodeInviteSummary(invite))
+	}
+	return out, nil
+}
+
 // OpenEnrollmentRequestToPayload converts lobbymodel.OpenEnrollmentRequest to
 // FlatBuffers bytes suitable for the authenticated gateway transport.
 func OpenEnrollmentRequestToPayload(request *lobbymodel.OpenEnrollmentRequest) ([]byte, error) {
@@ -165,6 +400,292 @@ func PayloadToOpenEnrollmentResponse(data []byte) (result *lobbymodel.OpenEnroll
 	}, nil
 }
 
+// GameCreateRequestToPayload converts lobbymodel.GameCreateRequest to
+// FlatBuffers bytes.
+func GameCreateRequestToPayload(request *lobbymodel.GameCreateRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode game create request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(256)
+	gameName := builder.CreateString(request.GameName)
+	description := builder.CreateString(request.Description)
+	turnSchedule := builder.CreateString(request.TurnSchedule)
+	targetEngineVersion := builder.CreateString(request.TargetEngineVersion)
+
+	lobbyfbs.GameCreateRequestStart(builder)
+	lobbyfbs.GameCreateRequestAddGameName(builder, gameName)
+	lobbyfbs.GameCreateRequestAddDescription(builder, description)
+	lobbyfbs.GameCreateRequestAddMinPlayers(builder, int32(request.MinPlayers))
+	lobbyfbs.GameCreateRequestAddMaxPlayers(builder, int32(request.MaxPlayers))
+	lobbyfbs.GameCreateRequestAddStartGapHours(builder, int32(request.StartGapHours))
+	lobbyfbs.GameCreateRequestAddStartGapPlayers(builder, int32(request.StartGapPlayers))
+	lobbyfbs.GameCreateRequestAddEnrollmentEndsAtMs(builder, request.EnrollmentEndsAt.UTC().UnixMilli())
+	lobbyfbs.GameCreateRequestAddTurnSchedule(builder, turnSchedule)
+	lobbyfbs.GameCreateRequestAddTargetEngineVersion(builder, targetEngineVersion)
+	offset := lobbyfbs.GameCreateRequestEnd(builder)
+	lobbyfbs.FinishGameCreateRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGameCreateRequest converts FlatBuffers payload bytes into
+// lobbymodel.GameCreateRequest.
+func PayloadToGameCreateRequest(data []byte) (result *lobbymodel.GameCreateRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode game create request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode game create request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsGameCreateRequest(data, 0)
+	return &lobbymodel.GameCreateRequest{
+		GameName:            string(request.GameName()),
+		Description:         string(request.Description()),
+		MinPlayers:          int(request.MinPlayers()),
+		MaxPlayers:          int(request.MaxPlayers()),
+		StartGapHours:       int(request.StartGapHours()),
+		StartGapPlayers:     int(request.StartGapPlayers()),
+		EnrollmentEndsAt:    time.UnixMilli(request.EnrollmentEndsAtMs()).UTC(),
+		TurnSchedule:        string(request.TurnSchedule()),
+		TargetEngineVersion: string(request.TargetEngineVersion()),
+	}, nil
+}
+
+// GameCreateResponseToPayload converts lobbymodel.GameCreateResponse to
+// FlatBuffers bytes.
+func GameCreateResponseToPayload(response *lobbymodel.GameCreateResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode game create response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(256)
+	gameOffset := encodeGameSummary(builder, response.Game)
+
+	lobbyfbs.GameCreateResponseStart(builder)
+	lobbyfbs.GameCreateResponseAddGame(builder, gameOffset)
+	offset := lobbyfbs.GameCreateResponseEnd(builder)
+	lobbyfbs.FinishGameCreateResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGameCreateResponse converts FlatBuffers payload bytes into
+// lobbymodel.GameCreateResponse.
+func PayloadToGameCreateResponse(data []byte) (result *lobbymodel.GameCreateResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode game create response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode game create response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsGameCreateResponse(data, 0)
+	game := response.Game(nil)
+	if game == nil {
+		return nil, errors.New("decode game create response payload: game is missing")
+	}
+	return &lobbymodel.GameCreateResponse{
+		Game: decodeGameSummary(game),
+	}, nil
+}
+
+// ApplicationSubmitRequestToPayload converts lobbymodel.ApplicationSubmitRequest
+// to FlatBuffers bytes.
+func ApplicationSubmitRequestToPayload(request *lobbymodel.ApplicationSubmitRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode application submit request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(128)
+	gameID := builder.CreateString(request.GameID)
+	raceName := builder.CreateString(request.RaceName)
+
+	lobbyfbs.ApplicationSubmitRequestStart(builder)
+	lobbyfbs.ApplicationSubmitRequestAddGameId(builder, gameID)
+	lobbyfbs.ApplicationSubmitRequestAddRaceName(builder, raceName)
+	offset := lobbyfbs.ApplicationSubmitRequestEnd(builder)
+	lobbyfbs.FinishApplicationSubmitRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToApplicationSubmitRequest converts FlatBuffers payload bytes into
+// lobbymodel.ApplicationSubmitRequest.
+func PayloadToApplicationSubmitRequest(data []byte) (result *lobbymodel.ApplicationSubmitRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode application submit request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode application submit request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsApplicationSubmitRequest(data, 0)
+	return &lobbymodel.ApplicationSubmitRequest{
+		GameID:   string(request.GameId()),
+		RaceName: string(request.RaceName()),
+	}, nil
+}
+
+// ApplicationSubmitResponseToPayload converts lobbymodel.ApplicationSubmitResponse
+// to FlatBuffers bytes.
+func ApplicationSubmitResponseToPayload(response *lobbymodel.ApplicationSubmitResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode application submit response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(256)
+	appOffset := encodeApplicationSummary(builder, response.Application)
+
+	lobbyfbs.ApplicationSubmitResponseStart(builder)
+	lobbyfbs.ApplicationSubmitResponseAddApplication(builder, appOffset)
+	offset := lobbyfbs.ApplicationSubmitResponseEnd(builder)
+	lobbyfbs.FinishApplicationSubmitResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToApplicationSubmitResponse converts FlatBuffers payload bytes into
+// lobbymodel.ApplicationSubmitResponse.
+func PayloadToApplicationSubmitResponse(data []byte) (result *lobbymodel.ApplicationSubmitResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode application submit response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode application submit response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsApplicationSubmitResponse(data, 0)
+	app := response.Application(nil)
+	if app == nil {
+		return nil, errors.New("decode application submit response payload: application is missing")
+	}
+	return &lobbymodel.ApplicationSubmitResponse{
+		Application: decodeApplicationSummary(app),
+	}, nil
+}
+
+// InviteRedeemRequestToPayload converts lobbymodel.InviteRedeemRequest to
+// FlatBuffers bytes.
+func InviteRedeemRequestToPayload(request *lobbymodel.InviteRedeemRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode invite redeem request payload: request is nil")
+	}
+	return encodeInviteAction(request.GameID, request.InviteID, true)
+}
+
+// PayloadToInviteRedeemRequest converts FlatBuffers payload bytes into
+// lobbymodel.InviteRedeemRequest.
+func PayloadToInviteRedeemRequest(data []byte) (result *lobbymodel.InviteRedeemRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode invite redeem request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode invite redeem request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsInviteRedeemRequest(data, 0)
+	return &lobbymodel.InviteRedeemRequest{
+		GameID:   string(request.GameId()),
+		InviteID: string(request.InviteId()),
+	}, nil
+}
+
+// InviteRedeemResponseToPayload converts lobbymodel.InviteRedeemResponse to
+// FlatBuffers bytes.
+func InviteRedeemResponseToPayload(response *lobbymodel.InviteRedeemResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode invite redeem response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(256)
+	inviteOffset := encodeInviteSummary(builder, response.Invite)
+
+	lobbyfbs.InviteRedeemResponseStart(builder)
+	lobbyfbs.InviteRedeemResponseAddInvite(builder, inviteOffset)
+	offset := lobbyfbs.InviteRedeemResponseEnd(builder)
+	lobbyfbs.FinishInviteRedeemResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToInviteRedeemResponse converts FlatBuffers payload bytes into
+// lobbymodel.InviteRedeemResponse.
+func PayloadToInviteRedeemResponse(data []byte) (result *lobbymodel.InviteRedeemResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode invite redeem response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode invite redeem response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsInviteRedeemResponse(data, 0)
+	invite := response.Invite(nil)
+	if invite == nil {
+		return nil, errors.New("decode invite redeem response payload: invite is missing")
+	}
+	return &lobbymodel.InviteRedeemResponse{
+		Invite: decodeInviteSummary(invite),
+	}, nil
+}
+
+// InviteDeclineRequestToPayload converts lobbymodel.InviteDeclineRequest to
+// FlatBuffers bytes.
+func InviteDeclineRequestToPayload(request *lobbymodel.InviteDeclineRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode invite decline request payload: request is nil")
+	}
+	return encodeInviteAction(request.GameID, request.InviteID, false)
+}
+
+// PayloadToInviteDeclineRequest converts FlatBuffers payload bytes into
+// lobbymodel.InviteDeclineRequest.
+func PayloadToInviteDeclineRequest(data []byte) (result *lobbymodel.InviteDeclineRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode invite decline request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode invite decline request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsInviteDeclineRequest(data, 0)
+	return &lobbymodel.InviteDeclineRequest{
+		GameID:   string(request.GameId()),
+		InviteID: string(request.InviteId()),
+	}, nil
+}
+
+// InviteDeclineResponseToPayload converts lobbymodel.InviteDeclineResponse to
+// FlatBuffers bytes.
+func InviteDeclineResponseToPayload(response *lobbymodel.InviteDeclineResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode invite decline response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(256)
+	inviteOffset := encodeInviteSummary(builder, response.Invite)
+
+	lobbyfbs.InviteDeclineResponseStart(builder)
+	lobbyfbs.InviteDeclineResponseAddInvite(builder, inviteOffset)
+	offset := lobbyfbs.InviteDeclineResponseEnd(builder)
+	lobbyfbs.FinishInviteDeclineResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToInviteDeclineResponse converts FlatBuffers payload bytes into
+// lobbymodel.InviteDeclineResponse.
+func PayloadToInviteDeclineResponse(data []byte) (result *lobbymodel.InviteDeclineResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode invite decline response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode invite decline response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsInviteDeclineResponse(data, 0)
+	invite := response.Invite(nil)
+	if invite == nil {
+		return nil, errors.New("decode invite decline response payload: invite is missing")
+	}
+	return &lobbymodel.InviteDeclineResponse{
+		Invite: decodeInviteSummary(invite),
+	}, nil
+}
+
 // LobbyErrorResponseToPayload converts lobbymodel.ErrorResponse to FlatBuffers
 // bytes suitable for the authenticated gateway transport.
 func LobbyErrorResponseToPayload(response *lobbymodel.ErrorResponse) ([]byte, error) {
@@ -212,6 +733,38 @@ func PayloadToLobbyErrorResponse(data []byte) (result *lobbymodel.ErrorResponse,
 	}, nil
 }
 
+func encodeInviteAction(gameID, inviteID string, redeem bool) ([]byte, error) {
+	builder := flatbuffers.NewBuilder(128)
+	gameOffset := builder.CreateString(gameID)
+	inviteOffset := builder.CreateString(inviteID)
+
+	if redeem {
+		lobbyfbs.InviteRedeemRequestStart(builder)
+		lobbyfbs.InviteRedeemRequestAddGameId(builder, gameOffset)
+		lobbyfbs.InviteRedeemRequestAddInviteId(builder, inviteOffset)
+		offset := lobbyfbs.InviteRedeemRequestEnd(builder)
+		lobbyfbs.FinishInviteRedeemRequestBuffer(builder, offset)
+	} else {
+		lobbyfbs.InviteDeclineRequestStart(builder)
+		lobbyfbs.InviteDeclineRequestAddGameId(builder, gameOffset)
+		lobbyfbs.InviteDeclineRequestAddInviteId(builder, inviteOffset)
+		offset := lobbyfbs.InviteDeclineRequestEnd(builder)
+		lobbyfbs.FinishInviteDeclineRequestBuffer(builder, offset)
+	}
+	return builder.FinishedBytes(), nil
+}
+
+func finishOffsetVector(builder *flatbuffers.Builder, offsets []flatbuffers.UOffsetT) flatbuffers.UOffsetT {
+	if len(offsets) == 0 {
+		return 0
+	}
+	builder.StartVector(4, len(offsets), 4)
+	for index := len(offsets) - 1; index >= 0; index-- {
+		builder.PrependUOffsetT(offsets[index])
+	}
+	return builder.EndVector(len(offsets))
+}
+
 func encodeGameSummary(builder *flatbuffers.Builder, summary lobbymodel.GameSummary) flatbuffers.UOffsetT {
 	gameID := builder.CreateString(summary.GameID)
 	gameName := builder.CreateString(summary.GameName)
@@ -248,6 +801,86 @@ func decodeGameSummary(summary *lobbyfbs.GameSummary) lobbymodel.GameSummary {
 	}
 }
 
+func encodeApplicationSummary(builder *flatbuffers.Builder, app lobbymodel.ApplicationSummary) flatbuffers.UOffsetT {
+	applicationID := builder.CreateString(app.ApplicationID)
+	gameID := builder.CreateString(app.GameID)
+	applicantUserID := builder.CreateString(app.ApplicantUserID)
+	raceName := builder.CreateString(app.RaceName)
+	status := builder.CreateString(app.Status)
+
+	lobbyfbs.ApplicationSummaryStart(builder)
+	lobbyfbs.ApplicationSummaryAddApplicationId(builder, applicationID)
+	lobbyfbs.ApplicationSummaryAddGameId(builder, gameID)
+	lobbyfbs.ApplicationSummaryAddApplicantUserId(builder, applicantUserID)
+	lobbyfbs.ApplicationSummaryAddRaceName(builder, raceName)
+	lobbyfbs.ApplicationSummaryAddStatus(builder, status)
+	lobbyfbs.ApplicationSummaryAddCreatedAtMs(builder, app.CreatedAt.UTC().UnixMilli())
+	lobbyfbs.ApplicationSummaryAddDecidedAtMs(builder, unixMilliFromOptional(app.DecidedAt))
+	return lobbyfbs.ApplicationSummaryEnd(builder)
+}
+
+func decodeApplicationSummary(app *lobbyfbs.ApplicationSummary) lobbymodel.ApplicationSummary {
+	return lobbymodel.ApplicationSummary{
+		ApplicationID:   string(app.ApplicationId()),
+		GameID:          string(app.GameId()),
+		ApplicantUserID: string(app.ApplicantUserId()),
+		RaceName:        string(app.RaceName()),
+		Status:          string(app.Status()),
+		CreatedAt:       time.UnixMilli(app.CreatedAtMs()).UTC(),
+		DecidedAt:       optionalUnixMilli(app.DecidedAtMs()),
+	}
+}
+
+func encodeInviteSummary(builder *flatbuffers.Builder, invite lobbymodel.InviteSummary) flatbuffers.UOffsetT {
+	inviteID := builder.CreateString(invite.InviteID)
+	gameID := builder.CreateString(invite.GameID)
+	inviterUserID := builder.CreateString(invite.InviterUserID)
+	invitedUserID := builder.CreateString(invite.InvitedUserID)
+	code := builder.CreateString(invite.Code)
+	raceName := builder.CreateString(invite.RaceName)
+	status := builder.CreateString(invite.Status)
+
+	lobbyfbs.InviteSummaryStart(builder)
+	lobbyfbs.InviteSummaryAddInviteId(builder, inviteID)
+	lobbyfbs.InviteSummaryAddGameId(builder, gameID)
+	lobbyfbs.InviteSummaryAddInviterUserId(builder, inviterUserID)
+	lobbyfbs.InviteSummaryAddInvitedUserId(builder, invitedUserID)
+	lobbyfbs.InviteSummaryAddCode(builder, code)
+	lobbyfbs.InviteSummaryAddRaceName(builder, raceName)
+	lobbyfbs.InviteSummaryAddStatus(builder, status)
+	lobbyfbs.InviteSummaryAddCreatedAtMs(builder, invite.CreatedAt.UTC().UnixMilli())
+	lobbyfbs.InviteSummaryAddExpiresAtMs(builder, invite.ExpiresAt.UTC().UnixMilli())
+	lobbyfbs.InviteSummaryAddDecidedAtMs(builder, unixMilliFromOptional(invite.DecidedAt))
+	return lobbyfbs.InviteSummaryEnd(builder)
+}
+
+func decodeInviteSummary(invite *lobbyfbs.InviteSummary) lobbymodel.InviteSummary {
+	return lobbymodel.InviteSummary{
+		InviteID:      string(invite.InviteId()),
+		GameID:        string(invite.GameId()),
+		InviterUserID: string(invite.InviterUserId()),
+		InvitedUserID: string(invite.InvitedUserId()),
+		Code:          string(invite.Code()),
+		RaceName:      string(invite.RaceName()),
+		Status:        string(invite.Status()),
+		CreatedAt:     time.UnixMilli(invite.CreatedAtMs()).UTC(),
+		ExpiresAt:     time.UnixMilli(invite.ExpiresAtMs()).UTC(),
+		DecidedAt:     optionalUnixMilli(invite.DecidedAtMs()),
+	}
+}
+
+// unixMilliFromOptional returns 0 when the pointer is nil, else the
+// millisecond UTC timestamp. The transcoder uses 0 as the "not set"
+// sentinel because FlatBuffers tables do not carry per-field presence
+// flags, and 0 is unreachable for any realistic decided/redeemed time.
+// optionalUnixMilli (defined in user.go) is the decode counterpart.
+func unixMilliFromOptional(t *time.Time) int64 {
+	if t == nil {
+		return 0
+	}
+	return t.UTC().UnixMilli()
+}
+
 func recoverLobbyDecodePanic[T any](message string, result **T, err *error) {
 	if recovered := recover(); recovered != nil {
 		*result = nil

pkg/transcoder/lobby_test.go

@@ -0,0 +1,517 @@
+package transcoder
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	lobbymodel "galaxy/model/lobby"
+)
+
+// fixedTimes returns deterministic UTC timestamps for round-trip
+// fixtures. Millisecond precision matches the FlatBuffers `*Ms` ints,
+// which is what the transcoder preserves.
+func fixedTimes() (created, updated, ends time.Time) {
+	created = time.Date(2026, time.May, 7, 9, 30, 15, 123_000_000, time.UTC)
+	updated = created.Add(2 * time.Minute)
+	ends = created.Add(48 * time.Hour)
+	return
+}
+
+func TestLobbyMyGamesListRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	created, updated, ends := fixedTimes()
+
+	source := &lobbymodel.MyGamesListResponse{
+		Items: []lobbymodel.GameSummary{
+			{
+				GameID:           "game-private-7c8f",
+				GameName:         "First Contact",
+				GameType:         "private",
+				Status:           "draft",
+				OwnerUserID:      "user-9912",
+				MinPlayers:       2,
+				MaxPlayers:       8,
+				EnrollmentEndsAt: ends,
+				CreatedAt:        created,
+				UpdatedAt:        updated,
+			},
+			{
+				GameID:           "game-public-aabb",
+				GameName:         "Open Lobby",
+				GameType:         "public",
+				Status:           "enrollment_open",
+				OwnerUserID:      "",
+				MinPlayers:       4,
+				MaxPlayers:       12,
+				EnrollmentEndsAt: ends,
+				CreatedAt:        created,
+				UpdatedAt:        updated,
+			},
+		},
+	}
+
+	payload, err := MyGamesListResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+
+	decoded, err := PayloadToMyGamesListResponse(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+
+	requestBytes, err := MyGamesListRequestToPayload(&lobbymodel.MyGamesListRequest{})
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	if _, err := PayloadToMyGamesListRequest(requestBytes); err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+}
+
+func TestLobbyMyGamesListEmpty(t *testing.T) {
+	t.Parallel()
+
+	payload, err := MyGamesListResponseToPayload(&lobbymodel.MyGamesListResponse{Items: nil})
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	decoded, err := PayloadToMyGamesListResponse(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if got := len(decoded.Items); got != 0 {
+		t.Fatalf("expected empty items, got %d", got)
+	}
+}
+
+func TestLobbyPublicGamesListRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	created, updated, ends := fixedTimes()
+
+	requestSource := &lobbymodel.PublicGamesListRequest{Page: 3, PageSize: 25}
+	requestBytes, err := PublicGamesListRequestToPayload(requestSource)
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	requestDecoded, err := PayloadToPublicGamesListRequest(requestBytes)
+	if err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+	if !reflect.DeepEqual(requestSource, requestDecoded) {
+		t.Fatalf("request round-trip mismatch\nsource: %#v\ndecoded:%#v", requestSource, requestDecoded)
+	}
+
+	responseSource := &lobbymodel.PublicGamesListResponse{
+		Items: []lobbymodel.GameSummary{
+			{
+				GameID:           "game-public-aabb",
+				GameName:         "Open Lobby",
+				GameType:         "public",
+				Status:           "enrollment_open",
+				OwnerUserID:      "",
+				MinPlayers:       4,
+				MaxPlayers:       12,
+				EnrollmentEndsAt: ends,
+				CreatedAt:        created,
+				UpdatedAt:        updated,
+			},
+		},
+		Page:     3,
+		PageSize: 25,
+		Total:    51,
+	}
+	responseBytes, err := PublicGamesListResponseToPayload(responseSource)
+	if err != nil {
+		t.Fatalf("encode response: %v", err)
+	}
+	responseDecoded, err := PayloadToPublicGamesListResponse(responseBytes)
+	if err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if !reflect.DeepEqual(responseSource, responseDecoded) {
+		t.Fatalf("response round-trip mismatch\nsource: %#v\ndecoded:%#v", responseSource, responseDecoded)
+	}
+}
+
+func TestLobbyMyApplicationsListRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	created, _, _ := fixedTimes()
+	decided := created.Add(2 * time.Hour)
+
+	requestBytes, err := MyApplicationsListRequestToPayload(&lobbymodel.MyApplicationsListRequest{})
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	if _, err := PayloadToMyApplicationsListRequest(requestBytes); err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+
+	source := &lobbymodel.MyApplicationsListResponse{
+		Items: []lobbymodel.ApplicationSummary{
+			{
+				ApplicationID:   "app-1",
+				GameID:          "game-public-aabb",
+				ApplicantUserID: "user-9912",
+				RaceName:        "Vegan Federation",
+				Status:          "pending",
+				CreatedAt:       created,
+				DecidedAt:       nil,
+			},
+			{
+				ApplicationID:   "app-2",
+				GameID:          "game-public-ccdd",
+				ApplicantUserID: "user-9912",
+				RaceName:        "Lithic Compact",
+				Status:          "approved",
+				CreatedAt:       created,
+				DecidedAt:       &decided,
+			},
+		},
+	}
+	payload, err := MyApplicationsListResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	decoded, err := PayloadToMyApplicationsListResponse(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestLobbyMyInvitesListRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	created, _, _ := fixedTimes()
+	expires := created.Add(72 * time.Hour)
+	decided := created.Add(1 * time.Hour)
+
+	requestBytes, err := MyInvitesListRequestToPayload(&lobbymodel.MyInvitesListRequest{})
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	if _, err := PayloadToMyInvitesListRequest(requestBytes); err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+
+	source := &lobbymodel.MyInvitesListResponse{
+		Items: []lobbymodel.InviteSummary{
+			{
+				InviteID:      "invite-user-bound",
+				GameID:        "game-private-7c8f",
+				InviterUserID: "user-1111",
+				InvitedUserID: "user-9912",
+				Code:          "",
+				RaceName:      "Vegan Federation",
+				Status:        "pending",
+				CreatedAt:     created,
+				ExpiresAt:     expires,
+				DecidedAt:     nil,
+			},
+			{
+				InviteID:      "invite-code-based",
+				GameID:        "game-private-3322",
+				InviterUserID: "user-1111",
+				InvitedUserID: "",
+				Code:          "ABCDEF12",
+				RaceName:      "Lithic Compact",
+				Status:        "accepted",
+				CreatedAt:     created,
+				ExpiresAt:     expires,
+				DecidedAt:     &decided,
+			},
+		},
+	}
+	payload, err := MyInvitesListResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	decoded, err := PayloadToMyInvitesListResponse(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestLobbyOpenEnrollmentRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	requestSource := &lobbymodel.OpenEnrollmentRequest{GameID: "game-private-7c8f"}
+	requestBytes, err := OpenEnrollmentRequestToPayload(requestSource)
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	requestDecoded, err := PayloadToOpenEnrollmentRequest(requestBytes)
+	if err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+	if !reflect.DeepEqual(requestSource, requestDecoded) {
+		t.Fatalf("request round-trip mismatch\nsource: %#v\ndecoded:%#v", requestSource, requestDecoded)
+	}
+
+	responseSource := &lobbymodel.OpenEnrollmentResponse{GameID: "game-private-7c8f", Status: "enrollment_open"}
+	responseBytes, err := OpenEnrollmentResponseToPayload(responseSource)
+	if err != nil {
+		t.Fatalf("encode response: %v", err)
+	}
+	responseDecoded, err := PayloadToOpenEnrollmentResponse(responseBytes)
+	if err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if !reflect.DeepEqual(responseSource, responseDecoded) {
+		t.Fatalf("response round-trip mismatch\nsource: %#v\ndecoded:%#v", responseSource, responseDecoded)
+	}
+}
+
+func TestLobbyGameCreateRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	_, _, ends := fixedTimes()
+
+	requestSource := &lobbymodel.GameCreateRequest{
+		GameName:            "First Contact",
+		Description:         "First Phase 8 sandbox game",
+		MinPlayers:          2,
+		MaxPlayers:          8,
+		StartGapHours:       24,
+		StartGapPlayers:     2,
+		EnrollmentEndsAt:    ends,
+		TurnSchedule:        "0 0 * * *",
+		TargetEngineVersion: "v1",
+	}
+	requestBytes, err := GameCreateRequestToPayload(requestSource)
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	requestDecoded, err := PayloadToGameCreateRequest(requestBytes)
+	if err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+	if !reflect.DeepEqual(requestSource, requestDecoded) {
+		t.Fatalf("request round-trip mismatch\nsource: %#v\ndecoded:%#v", requestSource, requestDecoded)
+	}
+
+	created, updated, _ := fixedTimes()
+	responseSource := &lobbymodel.GameCreateResponse{
+		Game: lobbymodel.GameSummary{
+			GameID:           "game-private-newly-created",
+			GameName:         "First Contact",
+			GameType:         "private",
+			Status:           "draft",
+			OwnerUserID:      "user-9912",
+			MinPlayers:       2,
+			MaxPlayers:       8,
+			EnrollmentEndsAt: ends,
+			CreatedAt:        created,
+			UpdatedAt:        updated,
+		},
+	}
+	responseBytes, err := GameCreateResponseToPayload(responseSource)
+	if err != nil {
+		t.Fatalf("encode response: %v", err)
+	}
+	responseDecoded, err := PayloadToGameCreateResponse(responseBytes)
+	if err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if !reflect.DeepEqual(responseSource, responseDecoded) {
+		t.Fatalf("response round-trip mismatch\nsource: %#v\ndecoded:%#v", responseSource, responseDecoded)
+	}
+}
+
+func TestLobbyApplicationSubmitRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	requestSource := &lobbymodel.ApplicationSubmitRequest{GameID: "game-public-aabb", RaceName: "Vegan Federation"}
+	requestBytes, err := ApplicationSubmitRequestToPayload(requestSource)
+	if err != nil {
+		t.Fatalf("encode request: %v", err)
+	}
+	requestDecoded, err := PayloadToApplicationSubmitRequest(requestBytes)
+	if err != nil {
+		t.Fatalf("decode request: %v", err)
+	}
+	if !reflect.DeepEqual(requestSource, requestDecoded) {
+		t.Fatalf("request round-trip mismatch\nsource: %#v\ndecoded:%#v", requestSource, requestDecoded)
+	}
+
+	created, _, _ := fixedTimes()
+	responseSource := &lobbymodel.ApplicationSubmitResponse{
+		Application: lobbymodel.ApplicationSummary{
+			ApplicationID:   "app-3",
+			GameID:          "game-public-aabb",
+			ApplicantUserID: "user-9912",
+			RaceName:        "Vegan Federation",
+			Status:          "pending",
+			CreatedAt:       created,
+			DecidedAt:       nil,
+		},
+	}
+	responseBytes, err := ApplicationSubmitResponseToPayload(responseSource)
+	if err != nil {
+		t.Fatalf("encode response: %v", err)
+	}
+	responseDecoded, err := PayloadToApplicationSubmitResponse(responseBytes)
+	if err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if !reflect.DeepEqual(responseSource, responseDecoded) {
+		t.Fatalf("response round-trip mismatch\nsource: %#v\ndecoded:%#v", responseSource, responseDecoded)
+	}
+}
+
+func TestLobbyInviteRedeemAndDeclineRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	created, _, _ := fixedTimes()
+	expires := created.Add(72 * time.Hour)
+	decided := created.Add(1 * time.Hour)
+
+	redeemReq := &lobbymodel.InviteRedeemRequest{GameID: "game-private-7c8f", InviteID: "invite-user-bound"}
+	redeemBytes, err := InviteRedeemRequestToPayload(redeemReq)
+	if err != nil {
+		t.Fatalf("encode redeem request: %v", err)
+	}
+	redeemDecoded, err := PayloadToInviteRedeemRequest(redeemBytes)
+	if err != nil {
+		t.Fatalf("decode redeem request: %v", err)
+	}
+	if !reflect.DeepEqual(redeemReq, redeemDecoded) {
+		t.Fatalf("redeem request mismatch")
+	}
+
+	redeemResp := &lobbymodel.InviteRedeemResponse{
+		Invite: lobbymodel.InviteSummary{
+			InviteID:      "invite-user-bound",
+			GameID:        "game-private-7c8f",
+			InviterUserID: "user-1111",
+			InvitedUserID: "user-9912",
+			Code:          "",
+			RaceName:      "Vegan Federation",
+			Status:        "accepted",
+			CreatedAt:     created,
+			ExpiresAt:     expires,
+			DecidedAt:     &decided,
+		},
+	}
+	redeemRespBytes, err := InviteRedeemResponseToPayload(redeemResp)
+	if err != nil {
+		t.Fatalf("encode redeem response: %v", err)
+	}
+	redeemRespDecoded, err := PayloadToInviteRedeemResponse(redeemRespBytes)
+	if err != nil {
+		t.Fatalf("decode redeem response: %v", err)
+	}
+	if !reflect.DeepEqual(redeemResp, redeemRespDecoded) {
+		t.Fatalf("redeem response mismatch")
+	}
+
+	declineReq := &lobbymodel.InviteDeclineRequest{GameID: "game-private-7c8f", InviteID: "invite-user-bound"}
+	declineBytes, err := InviteDeclineRequestToPayload(declineReq)
+	if err != nil {
+		t.Fatalf("encode decline request: %v", err)
+	}
+	declineDecoded, err := PayloadToInviteDeclineRequest(declineBytes)
+	if err != nil {
+		t.Fatalf("decode decline request: %v", err)
+	}
+	if !reflect.DeepEqual(declineReq, declineDecoded) {
+		t.Fatalf("decline request mismatch")
+	}
+
+	declineResp := &lobbymodel.InviteDeclineResponse{
+		Invite: lobbymodel.InviteSummary{
+			InviteID:      "invite-user-bound",
+			GameID:        "game-private-7c8f",
+			InviterUserID: "user-1111",
+			InvitedUserID: "user-9912",
+			Code:          "",
+			RaceName:      "Vegan Federation",
+			Status:        "declined",
+			CreatedAt:     created,
+			ExpiresAt:     expires,
+			DecidedAt:     &decided,
+		},
+	}
+	declineRespBytes, err := InviteDeclineResponseToPayload(declineResp)
+	if err != nil {
+		t.Fatalf("encode decline response: %v", err)
+	}
+	declineRespDecoded, err := PayloadToInviteDeclineResponse(declineRespBytes)
+	if err != nil {
+		t.Fatalf("decode decline response: %v", err)
+	}
+	if !reflect.DeepEqual(declineResp, declineRespDecoded) {
+		t.Fatalf("decline response mismatch")
+	}
+}
+
+func TestLobbyErrorResponseRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	source := &lobbymodel.ErrorResponse{
+		Error: lobbymodel.ErrorBody{
+			Code:    "conflict",
+			Message: "request conflicts with current state",
+		},
+	}
+	payload, err := LobbyErrorResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	decoded, err := PayloadToLobbyErrorResponse(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestLobbyDecodersRecoverFromCorruption(t *testing.T) {
+	t.Parallel()
+
+	garbage := []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
+
+	if _, err := PayloadToMyGamesListResponse(garbage); err == nil {
+		t.Fatal("expected error decoding corrupt my games payload")
+	}
+	if _, err := PayloadToPublicGamesListResponse(garbage); err == nil {
+		t.Fatal("expected error decoding corrupt public games payload")
+	}
+	if _, err := PayloadToApplicationSubmitResponse(garbage); err == nil {
+		t.Fatal("expected error decoding corrupt application submit response")
+	}
+	if _, err := PayloadToInviteRedeemResponse(garbage); err == nil {
+		t.Fatal("expected error decoding corrupt invite redeem response")
+	}
+	if _, err := PayloadToLobbyErrorResponse(garbage); err == nil {
+		t.Fatal("expected error decoding corrupt error payload")
+	}
+}
+
+func TestLobbyDecodersRejectEmptyPayload(t *testing.T) {
+	t.Parallel()
+
+	if _, err := PayloadToMyGamesListRequest(nil); err == nil {
+		t.Fatal("expected error decoding nil request")
+	}
+	if _, err := PayloadToPublicGamesListResponse(nil); err == nil {
+		t.Fatal("expected error decoding nil response")
+	}
+	if _, err := PayloadToInviteDeclineRequest(nil); err == nil {
+		t.Fatal("expected error decoding nil decline request")
+	}
+}