feat: runtime manager

pkg/model/lobby/lobby.go

@@ -0,0 +1,68 @@
+// Package lobby defines the public typed command and response payloads
+// exposed at the authenticated Gateway -> Game Lobby boundary.
+package lobby
+
+import "time"
+
+const (
+	// MessageTypeMyGamesList is the authenticated gateway message type
+	// used to read the calling user's own games.
+	MessageTypeMyGamesList = "lobby.my.games.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"
+)
+
+// MyGamesListRequest stores the authenticated read request for the
+// caller's games. The request body is intentionally empty; gateway
+// derives the calling user identity from the verified session.
+type MyGamesListRequest struct{}
+
+// MyGamesListResponse stores the list of games the caller participates
+// in, ordered as Lobby returns them.
+type MyGamesListResponse struct {
+	Items []GameSummary `json:"items"`
+}
+
+// GameSummary stores one game record returned by `lobby.my.games.list`.
+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"`
+}
+
+// OpenEnrollmentRequest stores the owner-only command that transitions
+// a game from `draft` to `enrollment_open`.
+type OpenEnrollmentRequest struct {
+	// GameID identifies the game whose enrollment the caller wants to
+	// open. The owner check is enforced by Lobby.
+	GameID string `json:"game_id"`
+}
+
+// OpenEnrollmentResponse stores the resulting game record after a
+// successful open-enrollment transition.
+type OpenEnrollmentResponse struct {
+	GameID string `json:"game_id"`
+	Status string `json:"status"`
+}
+
+// ErrorBody stores the canonical Lobby error envelope code/message
+// pair.
+type ErrorBody struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+// ErrorResponse wraps ErrorBody for the FlatBuffers payload boundary.
+type ErrorResponse struct {
+	Error ErrorBody `json:"error"`
+}

pkg/notificationintent/intent.go

@@ -118,6 +118,24 @@ const (
 	// Game Lobby when capability evaluation at game finish releases a
 	// reservation because the member did not meet the capability rule.
 	NotificationTypeLobbyRaceNameRegistrationDenied NotificationType = "lobby.race_name.registration_denied"
+
+	// NotificationTypeRuntimeImagePullFailed identifies the
+	// `runtime.image_pull_failed` administrator notification published by
+	// Runtime Manager when the engine image cannot be pulled during a
+	// start operation.
+	NotificationTypeRuntimeImagePullFailed NotificationType = "runtime.image_pull_failed"
+
+	// NotificationTypeRuntimeContainerStartFailed identifies the
+	// `runtime.container_start_failed` administrator notification published
+	// by Runtime Manager when `docker create` or `docker start` returns an
+	// error during a start operation.
+	NotificationTypeRuntimeContainerStartFailed NotificationType = "runtime.container_start_failed"
+
+	// NotificationTypeRuntimeStartConfigInvalid identifies the
+	// `runtime.start_config_invalid` administrator notification published by
+	// Runtime Manager when start configuration validation fails (invalid
+	// `image_ref`, missing Docker network, unwritable state directory).
+	NotificationTypeRuntimeStartConfigInvalid NotificationType = "runtime.start_config_invalid"
 )
 
 // String returns the wire value for notificationType.
@@ -142,7 +160,10 @@ func (notificationType NotificationType) IsKnown() bool {
 		NotificationTypeLobbyInviteExpired,
 		NotificationTypeLobbyRaceNameRegistrationEligible,
 		NotificationTypeLobbyRaceNameRegistered,
-		NotificationTypeLobbyRaceNameRegistrationDenied:
+		NotificationTypeLobbyRaceNameRegistrationDenied,
+		NotificationTypeRuntimeImagePullFailed,
+		NotificationTypeRuntimeContainerStartFailed,
+		NotificationTypeRuntimeStartConfigInvalid:
 		return true
 	default:
 		return false
@@ -170,6 +191,10 @@ func (notificationType NotificationType) ExpectedProducer() Producer {
 		NotificationTypeLobbyRaceNameRegistered,
 		NotificationTypeLobbyRaceNameRegistrationDenied:
 		return ProducerGameLobby
+	case NotificationTypeRuntimeImagePullFailed,
+		NotificationTypeRuntimeContainerStartFailed,
+		NotificationTypeRuntimeStartConfigInvalid:
+		return ProducerRuntimeManager
 	default:
 		return ""
 	}
@@ -180,7 +205,10 @@ func (notificationType NotificationType) SupportsAudience(audienceKind AudienceK
 	switch notificationType {
 	case NotificationTypeGeoReviewRecommended,
 		NotificationTypeGameGenerationFailed,
-		NotificationTypeLobbyRuntimePausedAfterStart:
+		NotificationTypeLobbyRuntimePausedAfterStart,
+		NotificationTypeRuntimeImagePullFailed,
+		NotificationTypeRuntimeContainerStartFailed,
+		NotificationTypeRuntimeStartConfigInvalid:
 		return audienceKind == AudienceKindAdminEmail
 	case NotificationTypeLobbyApplicationSubmitted:
 		return audienceKind == AudienceKindUser || audienceKind == AudienceKindAdminEmail
@@ -195,7 +223,10 @@ func (notificationType NotificationType) SupportsChannel(audienceKind AudienceKi
 	switch notificationType {
 	case NotificationTypeGeoReviewRecommended,
 		NotificationTypeGameGenerationFailed,
-		NotificationTypeLobbyRuntimePausedAfterStart:
+		NotificationTypeLobbyRuntimePausedAfterStart,
+		NotificationTypeRuntimeImagePullFailed,
+		NotificationTypeRuntimeContainerStartFailed,
+		NotificationTypeRuntimeStartConfigInvalid:
 		return audienceKind == AudienceKindAdminEmail && channel == ChannelEmail
 	case NotificationTypeLobbyApplicationSubmitted:
 		if audienceKind == AudienceKindAdminEmail {
@@ -222,6 +253,9 @@ const (
 
 	// ProducerGameLobby identifies Game Lobby.
 	ProducerGameLobby Producer = "game_lobby"
+
+	// ProducerRuntimeManager identifies Runtime Manager.
+	ProducerRuntimeManager Producer = "runtime_manager"
 )
 
 // String returns the wire value for producer.
@@ -232,7 +266,7 @@ func (producer Producer) String() string {
 // IsKnown reports whether producer belongs to the frozen producer set.
 func (producer Producer) IsKnown() bool {
 	switch producer {
-	case ProducerGeoProfile, ProducerGameMaster, ProducerGameLobby:
+	case ProducerGeoProfile, ProducerGameMaster, ProducerGameLobby, ProducerRuntimeManager:
 		return true
 	default:
 		return false
@@ -801,6 +835,13 @@ func validatePayloadObject(notificationType NotificationType, payload map[string
 		return validateStringFields(payload, "race_name")
 	case NotificationTypeLobbyRaceNameRegistrationDenied:
 		return validateStringFields(payload, "game_id", "game_name", "race_name", "reason")
+	case NotificationTypeRuntimeImagePullFailed,
+		NotificationTypeRuntimeContainerStartFailed,
+		NotificationTypeRuntimeStartConfigInvalid:
+		if err := validateStringFields(payload, "game_id", "image_ref", "error_code", "error_message"); err != nil {
+			return err
+		}
+		return validatePositiveIntFields(payload, "attempted_at_ms")
 	default:
 		return fmt.Errorf("payload_json notification type %q is unsupported", notificationType)
 	}

pkg/notificationintent/intent_test.go

@@ -269,6 +269,54 @@ func TestConstructorsBuildExpectedIntentValues(t *testing.T) {
 			recipientUserIDs: []string{"user-9"},
 			payloadJSON:      `{"game_id":"game-1","game_name":"Nebula Clash","race_name":"Skylancer","reason":"capability_not_met"}`,
 		},
+		{
+			name: "runtime image pull failed",
+			build: func() (Intent, error) {
+				return NewRuntimeImagePullFailedIntent(metadata, RuntimeImagePullFailedPayload{
+					GameID:        "game-1",
+					ImageRef:      "galaxy/game:1.4.7",
+					ErrorCode:     "image_pull_failed",
+					ErrorMessage:  "manifest unknown",
+					AttemptedAtMs: 1775121700000,
+				})
+			},
+			notificationType: NotificationTypeRuntimeImagePullFailed,
+			producer:         ProducerRuntimeManager,
+			audienceKind:     AudienceKindAdminEmail,
+			payloadJSON:      `{"game_id":"game-1","image_ref":"galaxy/game:1.4.7","error_code":"image_pull_failed","error_message":"manifest unknown","attempted_at_ms":1775121700000}`,
+		},
+		{
+			name: "runtime container start failed",
+			build: func() (Intent, error) {
+				return NewRuntimeContainerStartFailedIntent(metadata, RuntimeContainerStartFailedPayload{
+					GameID:        "game-1",
+					ImageRef:      "galaxy/game:1.4.7",
+					ErrorCode:     "container_start_failed",
+					ErrorMessage:  "OCI runtime create failed",
+					AttemptedAtMs: 1775121700001,
+				})
+			},
+			notificationType: NotificationTypeRuntimeContainerStartFailed,
+			producer:         ProducerRuntimeManager,
+			audienceKind:     AudienceKindAdminEmail,
+			payloadJSON:      `{"game_id":"game-1","image_ref":"galaxy/game:1.4.7","error_code":"container_start_failed","error_message":"OCI runtime create failed","attempted_at_ms":1775121700001}`,
+		},
+		{
+			name: "runtime start config invalid",
+			build: func() (Intent, error) {
+				return NewRuntimeStartConfigInvalidIntent(metadata, RuntimeStartConfigInvalidPayload{
+					GameID:        "game-1",
+					ImageRef:      "galaxy/game:1.4.7",
+					ErrorCode:     "start_config_invalid",
+					ErrorMessage:  "docker network galaxy-net not found",
+					AttemptedAtMs: 1775121700002,
+				})
+			},
+			notificationType: NotificationTypeRuntimeStartConfigInvalid,
+			producer:         ProducerRuntimeManager,
+			audienceKind:     AudienceKindAdminEmail,
+			payloadJSON:      `{"game_id":"game-1","image_ref":"galaxy/game:1.4.7","error_code":"start_config_invalid","error_message":"docker network galaxy-net not found","attempted_at_ms":1775121700002}`,
+		},
 	}
 
 	for _, tt := range tests {
@@ -335,6 +383,26 @@ func TestConstructorsRejectInvalidPayloads(t *testing.T) {
 	})
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "payload_json.turn_number must be at least 1")
+
+	_, err = NewRuntimeImagePullFailedIntent(defaultMetadata(), RuntimeImagePullFailedPayload{
+		GameID:        "game-1",
+		ImageRef:      "galaxy/game:1.4.7",
+		ErrorCode:     "",
+		ErrorMessage:  "manifest unknown",
+		AttemptedAtMs: 1775121700000,
+	})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "payload_json.error_code must not be empty")
+
+	_, err = NewRuntimeContainerStartFailedIntent(defaultMetadata(), RuntimeContainerStartFailedPayload{
+		GameID:        "game-1",
+		ImageRef:      "galaxy/game:1.4.7",
+		ErrorCode:     "container_start_failed",
+		ErrorMessage:  "OCI runtime create failed",
+		AttemptedAtMs: 0,
+	})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "payload_json.attempted_at_ms must be at least 1")
 }
 
 func TestDecodeIntentRejectsMissingRequiredTopLevelField(t *testing.T) {

pkg/notificationintent/payloads.go

@@ -127,6 +127,39 @@ type LobbyRaceNameRegistrationDeniedPayload struct {
 	Reason   string `json:"reason"`
 }
 
+// RuntimeImagePullFailedPayload stores the normalized payload for
+// `runtime.image_pull_failed`. AttemptedAtMs carries Unix milliseconds in
+// UTC of the failed pull attempt.
+type RuntimeImagePullFailedPayload struct {
+	GameID        string `json:"game_id"`
+	ImageRef      string `json:"image_ref"`
+	ErrorCode     string `json:"error_code"`
+	ErrorMessage  string `json:"error_message"`
+	AttemptedAtMs int64  `json:"attempted_at_ms"`
+}
+
+// RuntimeContainerStartFailedPayload stores the normalized payload for
+// `runtime.container_start_failed`. AttemptedAtMs carries Unix milliseconds
+// in UTC of the failed start attempt.
+type RuntimeContainerStartFailedPayload struct {
+	GameID        string `json:"game_id"`
+	ImageRef      string `json:"image_ref"`
+	ErrorCode     string `json:"error_code"`
+	ErrorMessage  string `json:"error_message"`
+	AttemptedAtMs int64  `json:"attempted_at_ms"`
+}
+
+// RuntimeStartConfigInvalidPayload stores the normalized payload for
+// `runtime.start_config_invalid`. AttemptedAtMs carries Unix milliseconds
+// in UTC of the rejected start attempt.
+type RuntimeStartConfigInvalidPayload struct {
+	GameID        string `json:"game_id"`
+	ImageRef      string `json:"image_ref"`
+	ErrorCode     string `json:"error_code"`
+	ErrorMessage  string `json:"error_message"`
+	AttemptedAtMs int64  `json:"attempted_at_ms"`
+}
+
 // NewGeoReviewRecommendedIntent builds the admin-email intent published by Geo
 // Profile Service when a user becomes review-worthy.
 func NewGeoReviewRecommendedIntent(metadata Metadata, payload GeoReviewRecommendedPayload) (Intent, error) {
@@ -226,3 +259,25 @@ func NewLobbyRaceNameRegisteredIntent(metadata Metadata, recipientUserID string,
 func NewLobbyRaceNameRegistrationDeniedIntent(metadata Metadata, recipientUserID string, payload LobbyRaceNameRegistrationDeniedPayload) (Intent, error) {
 	return newIntent(NotificationTypeLobbyRaceNameRegistrationDenied, ProducerGameLobby, AudienceKindUser, []string{recipientUserID}, metadata, payload)
 }
+
+// NewRuntimeImagePullFailedIntent builds the administrator-email intent
+// published by Runtime Manager when a start operation fails because the
+// engine image cannot be pulled.
+func NewRuntimeImagePullFailedIntent(metadata Metadata, payload RuntimeImagePullFailedPayload) (Intent, error) {
+	return newIntent(NotificationTypeRuntimeImagePullFailed, ProducerRuntimeManager, AudienceKindAdminEmail, nil, metadata, payload)
+}
+
+// NewRuntimeContainerStartFailedIntent builds the administrator-email
+// intent published by Runtime Manager when a start operation fails because
+// `docker create` or `docker start` returns an error.
+func NewRuntimeContainerStartFailedIntent(metadata Metadata, payload RuntimeContainerStartFailedPayload) (Intent, error) {
+	return newIntent(NotificationTypeRuntimeContainerStartFailed, ProducerRuntimeManager, AudienceKindAdminEmail, nil, metadata, payload)
+}
+
+// NewRuntimeStartConfigInvalidIntent builds the administrator-email intent
+// published by Runtime Manager when start configuration validation rejects
+// the request (invalid image reference, missing Docker network, unwritable
+// state directory).
+func NewRuntimeStartConfigInvalidIntent(metadata Metadata, payload RuntimeStartConfigInvalidPayload) (Intent, error) {
+	return newIntent(NotificationTypeRuntimeStartConfigInvalid, ProducerRuntimeManager, AudienceKindAdminEmail, nil, metadata, payload)
+}

pkg/schema/fbs/lobby.fbs

@@ -0,0 +1,58 @@
+// lobby contains FlatBuffers payloads used by the authenticated gateway
+// boundary for Game Lobby. The wire shapes here mirror the trusted
+// internal lobby REST surface; gateway derives the calling `user_id`
+// 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`.
+// The shape matches `lobby/openapi.yaml` `MyGameSummary`.
+table GameSummary {
+  game_id:string;
+  game_name:string;
+  game_type:string;
+  status:string;
+  owner_user_id:string;
+  min_players:int32;
+  max_players:int32;
+  enrollment_ends_at_ms:int64;
+  created_at_ms:int64;
+  updated_at_ms:int64;
+}
+
+// MyGamesListRequest stores the authenticated read request for the
+// caller's games. Empty body — gateway derives identity from the
+// authenticated session.
+table MyGamesListRequest {
+}
+
+// MyGamesListResponse stores the list of games the caller participates
+// in.
+table MyGamesListResponse {
+  items:[GameSummary];
+}
+
+// OpenEnrollmentRequest stores the owner-only command that transitions
+// a game from `draft` to `enrollment_open`.
+table OpenEnrollmentRequest {
+  game_id:string;
+}
+
+// OpenEnrollmentResponse stores the resulting game status.
+table OpenEnrollmentResponse {
+  game_id:string;
+  status:string;
+}
+
+// ErrorBody stores the canonical lobby error envelope code/message
+// pair.
+table ErrorBody {
+  code:string;
+  message:string;
+}
+
+// ErrorResponse wraps ErrorBody for the FlatBuffers payload boundary.
+table ErrorResponse {
+  error:ErrorBody;
+}
+
+root_type MyGamesListResponse;

pkg/schema/fbs/lobby/ErrorBody.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ErrorBody struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorBody) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorBody) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorBody) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ErrorBody) Message() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ErrorBodyStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ErrorBodyAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(code), 0)
+}
+func ErrorBodyAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(message), 0)
+}
+func ErrorBodyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/ErrorResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ErrorResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorResponse) Error(obj *ErrorBody) *ErrorBody {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ErrorBody)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func ErrorResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func ErrorResponseAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(error), 0)
+}
+func ErrorResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/GameSummary.go

@@ -0,0 +1,179 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GameSummary struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGameSummary(buf []byte, offset flatbuffers.UOffsetT) *GameSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GameSummary{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGameSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGameSummary(buf []byte, offset flatbuffers.UOffsetT) *GameSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GameSummary{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGameSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GameSummary) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GameSummary) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GameSummary) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) GameName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) GameType() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) OwnerUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) MinPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateMinPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(14, n)
+}
+
+func (rcv *GameSummary) MaxPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateMaxPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(16, n)
+}
+
+func (rcv *GameSummary) EnrollmentEndsAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateEnrollmentEndsAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(18, n)
+}
+
+func (rcv *GameSummary) CreatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateCreatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(20, n)
+}
+
+func (rcv *GameSummary) UpdatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateUpdatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(22, n)
+}
+
+func GameSummaryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func GameSummaryAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func GameSummaryAddGameName(builder *flatbuffers.Builder, gameName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(gameName), 0)
+}
+func GameSummaryAddGameType(builder *flatbuffers.Builder, gameType flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(gameType), 0)
+}
+func GameSummaryAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(status), 0)
+}
+func GameSummaryAddOwnerUserId(builder *flatbuffers.Builder, ownerUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(ownerUserId), 0)
+}
+func GameSummaryAddMinPlayers(builder *flatbuffers.Builder, minPlayers int32) {
+	builder.PrependInt32Slot(5, minPlayers, 0)
+}
+func GameSummaryAddMaxPlayers(builder *flatbuffers.Builder, maxPlayers int32) {
+	builder.PrependInt32Slot(6, maxPlayers, 0)
+}
+func GameSummaryAddEnrollmentEndsAtMs(builder *flatbuffers.Builder, enrollmentEndsAtMs int64) {
+	builder.PrependInt64Slot(7, enrollmentEndsAtMs, 0)
+}
+func GameSummaryAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
+	builder.PrependInt64Slot(8, createdAtMs, 0)
+}
+func GameSummaryAddUpdatedAtMs(builder *flatbuffers.Builder, updatedAtMs int64) {
+	builder.PrependInt64Slot(9, updatedAtMs, 0)
+}
+func GameSummaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/MyGamesListRequest.go

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

pkg/schema/fbs/lobby/MyGamesListResponse.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type MyGamesListResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyGamesListResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyGamesListResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyGamesListResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyGamesListResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MyGamesListResponse) 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 *MyGamesListResponse) ItemsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func MyGamesListResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func MyGamesListResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
+}
+func MyGamesListResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MyGamesListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/OpenEnrollmentRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OpenEnrollmentRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOpenEnrollmentRequest(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OpenEnrollmentRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOpenEnrollmentRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOpenEnrollmentRequest(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OpenEnrollmentRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOpenEnrollmentRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OpenEnrollmentRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OpenEnrollmentRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OpenEnrollmentRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func OpenEnrollmentRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func OpenEnrollmentRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func OpenEnrollmentRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby/OpenEnrollmentResponse.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OpenEnrollmentResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOpenEnrollmentResponse(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OpenEnrollmentResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOpenEnrollmentResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOpenEnrollmentResponse(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OpenEnrollmentResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOpenEnrollmentResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OpenEnrollmentResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OpenEnrollmentResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OpenEnrollmentResponse) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OpenEnrollmentResponse) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func OpenEnrollmentResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func OpenEnrollmentResponseAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func OpenEnrollmentResponseAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(status), 0)
+}
+func OpenEnrollmentResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/lobby_generated.go

@@ -0,0 +1,522 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package lobby
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GameSummary struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGameSummary(buf []byte, offset flatbuffers.UOffsetT) *GameSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GameSummary{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGameSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGameSummary(buf []byte, offset flatbuffers.UOffsetT) *GameSummary {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GameSummary{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGameSummaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GameSummary) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GameSummary) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *GameSummary) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) GameName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) GameType() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) OwnerUserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *GameSummary) MinPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateMinPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(14, n)
+}
+
+func (rcv *GameSummary) MaxPlayers() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateMaxPlayers(n int32) bool {
+	return rcv._tab.MutateInt32Slot(16, n)
+}
+
+func (rcv *GameSummary) EnrollmentEndsAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateEnrollmentEndsAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(18, n)
+}
+
+func (rcv *GameSummary) CreatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateCreatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(20, n)
+}
+
+func (rcv *GameSummary) UpdatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *GameSummary) MutateUpdatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(22, n)
+}
+
+func GameSummaryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func GameSummaryAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func GameSummaryAddGameName(builder *flatbuffers.Builder, gameName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(gameName), 0)
+}
+func GameSummaryAddGameType(builder *flatbuffers.Builder, gameType flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(gameType), 0)
+}
+func GameSummaryAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(status), 0)
+}
+func GameSummaryAddOwnerUserId(builder *flatbuffers.Builder, ownerUserId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(ownerUserId), 0)
+}
+func GameSummaryAddMinPlayers(builder *flatbuffers.Builder, minPlayers int32) {
+	builder.PrependInt32Slot(5, minPlayers, 0)
+}
+func GameSummaryAddMaxPlayers(builder *flatbuffers.Builder, maxPlayers int32) {
+	builder.PrependInt32Slot(6, maxPlayers, 0)
+}
+func GameSummaryAddEnrollmentEndsAtMs(builder *flatbuffers.Builder, enrollmentEndsAtMs int64) {
+	builder.PrependInt64Slot(7, enrollmentEndsAtMs, 0)
+}
+func GameSummaryAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
+	builder.PrependInt64Slot(8, createdAtMs, 0)
+}
+func GameSummaryAddUpdatedAtMs(builder *flatbuffers.Builder, updatedAtMs int64) {
+	builder.PrependInt64Slot(9, updatedAtMs, 0)
+}
+func GameSummaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type MyGamesListRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyGamesListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyGamesListRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyGamesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyGamesListRequest(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyGamesListRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyGamesListRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyGamesListRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyGamesListRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func MyGamesListRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func MyGamesListRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type MyGamesListResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsMyGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &MyGamesListResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishMyGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMyGamesListResponse(buf []byte, offset flatbuffers.UOffsetT) *MyGamesListResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &MyGamesListResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedMyGamesListResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *MyGamesListResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *MyGamesListResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *MyGamesListResponse) 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 *MyGamesListResponse) ItemsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func MyGamesListResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func MyGamesListResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
+}
+func MyGamesListResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func MyGamesListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type OpenEnrollmentRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOpenEnrollmentRequest(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OpenEnrollmentRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOpenEnrollmentRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOpenEnrollmentRequest(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OpenEnrollmentRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOpenEnrollmentRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OpenEnrollmentRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OpenEnrollmentRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OpenEnrollmentRequest) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func OpenEnrollmentRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func OpenEnrollmentRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func OpenEnrollmentRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type OpenEnrollmentResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOpenEnrollmentResponse(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OpenEnrollmentResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOpenEnrollmentResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOpenEnrollmentResponse(buf []byte, offset flatbuffers.UOffsetT) *OpenEnrollmentResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OpenEnrollmentResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOpenEnrollmentResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OpenEnrollmentResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OpenEnrollmentResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OpenEnrollmentResponse) GameId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OpenEnrollmentResponse) Status() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func OpenEnrollmentResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func OpenEnrollmentResponseAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
+}
+func OpenEnrollmentResponseAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(status), 0)
+}
+func OpenEnrollmentResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type ErrorBody struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorBody) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorBody) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorBody) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ErrorBody) Message() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ErrorBodyStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ErrorBodyAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(code), 0)
+}
+func ErrorBodyAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(message), 0)
+}
+func ErrorBodyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
+type ErrorResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorResponse) Error(obj *ErrorBody) *ErrorBody {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ErrorBody)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func ErrorResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func ErrorResponseAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(error), 0)
+}
+func ErrorResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/transcoder/lobby.go

@@ -0,0 +1,256 @@
+package transcoder
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	lobbymodel "galaxy/model/lobby"
+	lobbyfbs "galaxy/schema/fbs/lobby"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+// MyGamesListRequestToPayload converts a typed lobbymodel.MyGamesListRequest
+// to FlatBuffers bytes suitable for the authenticated gateway transport.
+func MyGamesListRequestToPayload(request *lobbymodel.MyGamesListRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode my games list request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(32)
+	lobbyfbs.MyGamesListRequestStart(builder)
+	offset := lobbyfbs.MyGamesListRequestEnd(builder)
+	lobbyfbs.FinishMyGamesListRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyGamesListRequest converts FlatBuffers payload bytes into
+// lobbymodel.MyGamesListRequest.
+func PayloadToMyGamesListRequest(data []byte) (result *lobbymodel.MyGamesListRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my games list request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my games list request payload", &result, &err)
+
+	_ = lobbyfbs.GetRootAsMyGamesListRequest(data, 0)
+	return &lobbymodel.MyGamesListRequest{}, nil
+}
+
+// MyGamesListResponseToPayload converts lobbymodel.MyGamesListResponse to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func MyGamesListResponseToPayload(response *lobbymodel.MyGamesListResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode my 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])
+	}
+
+	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))
+	}
+
+	lobbyfbs.MyGamesListResponseStart(builder)
+	if itemsVector != 0 {
+		lobbyfbs.MyGamesListResponseAddItems(builder, itemsVector)
+	}
+	offset := lobbyfbs.MyGamesListResponseEnd(builder)
+	lobbyfbs.FinishMyGamesListResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToMyGamesListResponse converts FlatBuffers payload bytes into
+// lobbymodel.MyGamesListResponse.
+func PayloadToMyGamesListResponse(data []byte) (result *lobbymodel.MyGamesListResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode my games list response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode my games list response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsMyGamesListResponse(data, 0)
+	out := &lobbymodel.MyGamesListResponse{
+		Items: make([]lobbymodel.GameSummary, 0, response.ItemsLength()),
+	}
+
+	summary := new(lobbyfbs.GameSummary)
+	for index := 0; index < response.ItemsLength(); index++ {
+		if !response.Items(summary, index) {
+			return nil, fmt.Errorf("decode my games list response payload: items[%d] is missing", index)
+		}
+		out.Items = append(out.Items, decodeGameSummary(summary))
+	}
+	return out, nil
+}
+
+// OpenEnrollmentRequestToPayload converts lobbymodel.OpenEnrollmentRequest to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func OpenEnrollmentRequestToPayload(request *lobbymodel.OpenEnrollmentRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode open enrollment request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(64)
+	gameID := builder.CreateString(request.GameID)
+
+	lobbyfbs.OpenEnrollmentRequestStart(builder)
+	lobbyfbs.OpenEnrollmentRequestAddGameId(builder, gameID)
+	offset := lobbyfbs.OpenEnrollmentRequestEnd(builder)
+	lobbyfbs.FinishOpenEnrollmentRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToOpenEnrollmentRequest converts FlatBuffers payload bytes into
+// lobbymodel.OpenEnrollmentRequest.
+func PayloadToOpenEnrollmentRequest(data []byte) (result *lobbymodel.OpenEnrollmentRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode open enrollment request payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode open enrollment request payload", &result, &err)
+
+	request := lobbyfbs.GetRootAsOpenEnrollmentRequest(data, 0)
+	return &lobbymodel.OpenEnrollmentRequest{
+		GameID: string(request.GameId()),
+	}, nil
+}
+
+// OpenEnrollmentResponseToPayload converts lobbymodel.OpenEnrollmentResponse to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func OpenEnrollmentResponseToPayload(response *lobbymodel.OpenEnrollmentResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode open enrollment response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(64)
+	gameID := builder.CreateString(response.GameID)
+	status := builder.CreateString(response.Status)
+
+	lobbyfbs.OpenEnrollmentResponseStart(builder)
+	lobbyfbs.OpenEnrollmentResponseAddGameId(builder, gameID)
+	lobbyfbs.OpenEnrollmentResponseAddStatus(builder, status)
+	offset := lobbyfbs.OpenEnrollmentResponseEnd(builder)
+	lobbyfbs.FinishOpenEnrollmentResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToOpenEnrollmentResponse converts FlatBuffers payload bytes into
+// lobbymodel.OpenEnrollmentResponse.
+func PayloadToOpenEnrollmentResponse(data []byte) (result *lobbymodel.OpenEnrollmentResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode open enrollment response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode open enrollment response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsOpenEnrollmentResponse(data, 0)
+	return &lobbymodel.OpenEnrollmentResponse{
+		GameID: string(response.GameId()),
+		Status: string(response.Status()),
+	}, nil
+}
+
+// LobbyErrorResponseToPayload converts lobbymodel.ErrorResponse to FlatBuffers
+// bytes suitable for the authenticated gateway transport.
+func LobbyErrorResponseToPayload(response *lobbymodel.ErrorResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode lobby error response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(128)
+	code := builder.CreateString(response.Error.Code)
+	message := builder.CreateString(response.Error.Message)
+
+	lobbyfbs.ErrorBodyStart(builder)
+	lobbyfbs.ErrorBodyAddCode(builder, code)
+	lobbyfbs.ErrorBodyAddMessage(builder, message)
+	errorOffset := lobbyfbs.ErrorBodyEnd(builder)
+
+	lobbyfbs.ErrorResponseStart(builder)
+	lobbyfbs.ErrorResponseAddError(builder, errorOffset)
+	offset := lobbyfbs.ErrorResponseEnd(builder)
+	lobbyfbs.FinishErrorResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyErrorResponse converts FlatBuffers payload bytes into
+// lobbymodel.ErrorResponse.
+func PayloadToLobbyErrorResponse(data []byte) (result *lobbymodel.ErrorResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby error response payload: data is empty")
+	}
+
+	defer recoverLobbyDecodePanic("decode lobby error response payload", &result, &err)
+
+	response := lobbyfbs.GetRootAsErrorResponse(data, 0)
+	body := response.Error(nil)
+	if body == nil {
+		return nil, errors.New("decode lobby error response payload: error is missing")
+	}
+
+	return &lobbymodel.ErrorResponse{
+		Error: lobbymodel.ErrorBody{
+			Code:    string(body.Code()),
+			Message: string(body.Message()),
+		},
+	}, nil
+}
+
+func encodeGameSummary(builder *flatbuffers.Builder, summary lobbymodel.GameSummary) flatbuffers.UOffsetT {
+	gameID := builder.CreateString(summary.GameID)
+	gameName := builder.CreateString(summary.GameName)
+	gameType := builder.CreateString(summary.GameType)
+	status := builder.CreateString(summary.Status)
+	ownerUserID := builder.CreateString(summary.OwnerUserID)
+
+	lobbyfbs.GameSummaryStart(builder)
+	lobbyfbs.GameSummaryAddGameId(builder, gameID)
+	lobbyfbs.GameSummaryAddGameName(builder, gameName)
+	lobbyfbs.GameSummaryAddGameType(builder, gameType)
+	lobbyfbs.GameSummaryAddStatus(builder, status)
+	lobbyfbs.GameSummaryAddOwnerUserId(builder, ownerUserID)
+	lobbyfbs.GameSummaryAddMinPlayers(builder, int32(summary.MinPlayers))
+	lobbyfbs.GameSummaryAddMaxPlayers(builder, int32(summary.MaxPlayers))
+	lobbyfbs.GameSummaryAddEnrollmentEndsAtMs(builder, summary.EnrollmentEndsAt.UTC().UnixMilli())
+	lobbyfbs.GameSummaryAddCreatedAtMs(builder, summary.CreatedAt.UTC().UnixMilli())
+	lobbyfbs.GameSummaryAddUpdatedAtMs(builder, summary.UpdatedAt.UTC().UnixMilli())
+	return lobbyfbs.GameSummaryEnd(builder)
+}
+
+func decodeGameSummary(summary *lobbyfbs.GameSummary) lobbymodel.GameSummary {
+	return lobbymodel.GameSummary{
+		GameID:           string(summary.GameId()),
+		GameName:         string(summary.GameName()),
+		GameType:         string(summary.GameType()),
+		Status:           string(summary.Status()),
+		OwnerUserID:      string(summary.OwnerUserId()),
+		MinPlayers:       int(summary.MinPlayers()),
+		MaxPlayers:       int(summary.MaxPlayers()),
+		EnrollmentEndsAt: time.UnixMilli(summary.EnrollmentEndsAtMs()).UTC(),
+		CreatedAt:        time.UnixMilli(summary.CreatedAtMs()).UTC(),
+		UpdatedAt:        time.UnixMilli(summary.UpdatedAtMs()).UTC(),
+	}
+}
+
+func recoverLobbyDecodePanic[T any](message string, result **T, err *error) {
+	if recovered := recover(); recovered != nil {
+		*result = nil
+		*err = fmt.Errorf("%s: panic recovered: %v", message, recovered)
+	}
+}