@diffenderfer-games/hub-contract 2.0.0-next.1 → 2.0.0-next.3

package/dist/index.js

@@ -96,7 +96,7 @@ const CORE_CODES = [
 ];
 //#endregion
 //#region src/errors/codes/multiplayer.ts
-/** Error codes from invites, parties, hub rooms, races and the socket envelope. */
+/** Error codes from invites, invite links, parties, hub rooms, races, tournaments and the socket envelope. */
 const MULTIPLAYER_CODES = [
 	"unknown_op",
 	"hello_required",
@@ -113,6 +113,9 @@ const MULTIPLAYER_CODES = [
 	"bad_info",
 	"launch_invalid",
 	"not_joinable",
+	"link_invalid",
+	"link_room_gone",
+	"too_many_links",
 	"bad_quick",
 	"room_not_found",
 	"not_in_room",
@@ -131,7 +134,15 @@ const MULTIPLAYER_CODES = [
 	"race_over",
 	"too_fast",
 	"bad_stats",
-	"bad_param"
+	"bad_param",
+	"tournament_not_found",
+	"tournament_closed",
+	"tournament_full",
+	"tournament_over",
+	"not_creator",
+	"not_entered",
+	"cannot_join",
+	"match_not_ready"
 ];
 //#endregion
 //#region src/errors/codes/play.ts
@@ -605,6 +616,30 @@ const MANIFEST_LIMITS = {
 	/** Largest `game.race.minMs`, in ms (10 minutes). */
 	raceMinMsMax: 6e5
 };
+/** What a tournament may be (batch-2026-10 R15). The server enforces each one. */
+const TOURNAMENT_LIMITS = {
+	/** Longest title, in characters. */
+	titleMax: 48,
+	/** Fewest players. */
+	playersMin: 2,
+	/** Most players. */
+	playersMax: 64,
+	/** Most games in the set a tournament picks from. */
+	gamesMax: 8,
+	/** Lives per player: 1 single, 2 double, 3 triple elimination. */
+	livesMax: 3,
+	/** The default and the longest window to join a ready match before forfeiting, in minutes. */
+	readyMinutesDefault: 10,
+	readyMinutesMax: 60,
+	/** The longest "remind me before it starts", in minutes (one day). */
+	leadMinutesMax: 1440,
+	/** The default reminder for players who signed up for a scheduled tournament, in minutes. */
+	leadMinutesDefault: 10,
+	/** The furthest ahead a tournament may be scheduled, in days. */
+	scheduleDaysMax: 30,
+	/** Most friends invited in one call. */
+	invitesMax: 50
+};
 //#endregion
 //#region src/api/mp/races.ts
 /**
@@ -926,9 +961,65 @@ const RaceBlock = z.strictObject({
 */
 const GameRace = z.preprocess((v) => v === true ? {} : v === false ? void 0 : v, RaceBlock.optional()).optional();
 //#endregion
+//#region src/api/catalog-activity.ts
+/**
+* Who is in each game right now (aggregate head counts only: never who), and
+* the signed-in player's own activity in one game. The catalog's cards, the
+* menu's game list and the game sheet show them.
+*/
+/** A non-negative head count. */
+const HeadCount$1 = z.number().int().nonnegative();
+/**
+* How many people have a game open right now: claimed accounts and guests.
+* Counts only, so no player is ever identified.
+*/
+const GamePlayerCount = z.object({
+	accounts: HeadCount$1,
+	guests: HeadCount$1
+});
+/** Head counts per game slug; games nobody has open are absent. */
+const GamePlayerCounts = z.record(Slug, GamePlayerCount);
+/** The caller's activity in one game, within the analytics retention window. */
+const MyGameActivity = z.object({
+	/** Times the game was opened. */
+	plays: HeadCount$1,
+	/** Minutes with the game open and visible (one heartbeat a minute). */
+	minutesPlayed: HeadCount$1,
+	/** The first and latest event in the window, epoch ms; `null` when there are none. */
+	firstPlayedAt: Millis.nullable(),
+	lastPlayedAt: Millis.nullable(),
+	/** How many days back the counts reach. */
+	windowDays: z.number().int().positive()
+});
+/** The activity endpoints (part of the catalog area). */
+const catalogActivityEndpoints = {
+	...session.group({ getGamePlayerCounts: {
+		method: "GET",
+		path: "/catalog/players",
+		response: z.object({ games: GamePlayerCounts }),
+		doc: {
+			summary: "How many accounts and guests have each game open right now (counts only)",
+			tags: ["catalog"]
+		}
+	} }),
+	...use(requireUser, game).path("/games/:slug").group({ getMyGameActivity: {
+		method: "GET",
+		path: "/me/activity",
+		response: MyGameActivity,
+		errors: {
+			401: ErrorBody,
+			404: ErrorBody
+		},
+		doc: {
+			summary: "The caller's plays and time played in this game",
+			tags: ["catalog"]
+		}
+	} })
+};
+//#endregion
 //#region src/api/catalog.ts
 /**
-* The game catalog, favorites and What's new notes.
+* The game catalog, favorites, What's new notes, and who is playing what (counts only).
 */
 /** A `[min, max]` player count, each 1 to 8. */
 const PlayerRange = z.tuple([z.number().int().min(1).max(8), z.number().int().min(1).max(8)]);
@@ -987,7 +1078,9 @@ const GameInfo = z.object({
 	/** `null` for single-player games. */
 	multiplayer: MultiplayerSummary.nullable(),
 	/** `null` unless the game supports races. */
-	race: RaceSummary.nullable()
+	race: RaceSummary.nullable(),
+	/** Present (and `true`) when tournaments can be played in this game: it races, or declares `multiplayer.tournaments`. */
+	tournaments: z.literal(true).optional()
 });
 /** `{ games }`: the caller's starred slugs, oldest star first. */
 const Favorites = z.object({ games: z.array(Slug) });
@@ -1006,6 +1099,7 @@ const ChangeNote = z.object({
 });
 /** The catalog endpoints. */
 const catalogEndpoints = {
+	...catalogActivityEndpoints,
 	...session.group({
 		listGames: {
 			method: "GET",
@@ -1926,6 +2020,182 @@ upTo: requiredId("upTo must be a message id.") }),
 	}
 }) };
 //#endregion
+//#region src/api/tournaments/shapes.ts
+/**
+* Tournaments (batch-2026-10 R15): brackets of 1v1 matches in one game or a
+* set of games. Single elimination, or double/triple elimination with
+* redemption brackets; seeded by rank in the game or at random; started at a
+* scheduled time or once enough players sign up. Open tournaments are
+* listed for anyone; closed ones only for the players invited.
+*
+* A match is an ordinary launch into the game (`host` for the better seed,
+* `guest` for the other, sharing a two-player party), carrying
+* {@link TournamentLaunch}; the game reports the winner the way it already
+* ends a match.
+*/
+/** A tournament's id. */
+const TournamentId = z.number().int().positive();
+/** `open`: listed, anyone can sign up or follow. `closed`: only invited players see it. */
+const TournamentVisibility = z.enum(["open", "closed"]);
+/** How the bracket is seeded: by each player's wins in the tournament's games, or at random. */
+const TournamentSeeding = z.enum(["rank", "random"]);
+/** Which game each match is: the one game, one random pick from the set for the whole tournament, or a random pick per match. */
+const TournamentGamePick = z.enum([
+	"fixed",
+	"random-once",
+	"random-each"
+]);
+/** When a tournament starts: at a set time (with whoever signed up), or as soon as `minPlayers` sign up. */
+const TournamentStart = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("scheduled"),
+	at: Millis
+}), z.object({ kind: z.literal("filled") })]);
+/** `signup` → `running` → `done`; or `cancelled` (by its creator, or too few players at the start). */
+const TournamentPhase = z.enum([
+	"signup",
+	"running",
+	"done",
+	"cancelled"
+]);
+/** Where a match sits: the winners bracket, a redemption bracket (players with losses), or the final ladder. */
+const TournamentStage = z.enum([
+	"winners",
+	"redemption",
+	"final"
+]);
+/** How a match was decided. */
+const TournamentDecision = z.enum([
+	"played",
+	"forfeit",
+	"bye",
+	"timeout",
+	"withdrawn"
+]);
+/** A player count within the tournament limits. */
+const PlayerCount = z.number().int().min(TOURNAMENT_LIMITS.playersMin).max(TOURNAMENT_LIMITS.playersMax);
+/** `POST /tournaments`. Everything but `games` has a default: the quick "public 1v1, single elimination". */
+const TournamentCreate = z.object({
+	/** Shown to everyone who can see the tournament; checked by the content filter. Default: made from the game's title. */
+	title: z.string().trim().min(1).max(TOURNAMENT_LIMITS.titleMax).optional(),
+	/** The game, or the set to pick from; each must support tournaments. */
+	games: z.array(Slug).min(1).max(TOURNAMENT_LIMITS.gamesMax),
+	pick: TournamentGamePick.default("fixed"),
+	/** Lives per player: 1 single (default), 2 double, 3 triple elimination. */
+	lives: z.number().int().min(1).max(TOURNAMENT_LIMITS.livesMax).default(1),
+	seeding: TournamentSeeding.default("random"),
+	visibility: TournamentVisibility.default("open"),
+	start: TournamentStart.default({ kind: "filled" }),
+	/** Players needed to start (a `filled` start), or to go ahead at the scheduled time. Default 2. */
+	minPlayers: PlayerCount.default(2),
+	/** Most players who can sign up. Default 2. */
+	maxPlayers: PlayerCount.default(2),
+	/** Minutes a ready match waits for its players before the absent side forfeits. */
+	readyMinutes: z.number().int().min(1).max(TOURNAMENT_LIMITS.readyMinutesMax).default(TOURNAMENT_LIMITS.readyMinutesDefault),
+	/** Friends to invite now (closed tournaments, or a nudge for open ones). */
+	invite: z.array(UserId).max(TOURNAMENT_LIMITS.invitesMax).optional()
+});
+/** One entrant, as the bracket shows them. */
+const TournamentPlayer = z.object({
+	user: PlayerLite,
+	/** 1 is the top seed; `null` until the bracket is drawn. */
+	seed: z.number().int().positive().nullable(),
+	wins: z.number().int().nonnegative(),
+	losses: z.number().int().nonnegative(),
+	/** Knocked out (lost every life, or withdrew). */
+	out: z.boolean()
+});
+/** One match in the bracket. Sides are user ids (see the detail's `players`). */
+const TournamentMatch = z.object({
+	id: z.string(),
+	stage: TournamentStage,
+	/** Redemption bracket number (losses), 0 elsewhere. */
+	level: z.number().int().nonnegative(),
+	round: z.number().int().positive(),
+	slot: z.number().int().nonnegative(),
+	/** `null` while unknown, or the empty side of a bye. */
+	a: UserId.nullable(),
+	b: UserId.nullable(),
+	status: z.enum([
+		"waiting",
+		"ready",
+		"done"
+	]),
+	winnerId: UserId.nullable(),
+	decision: TournamentDecision.nullable(),
+	/** The game this match is played in, once known. */
+	game: Slug.nullable(),
+	/** Ready matches: when the absent side forfeits, epoch ms. */
+	deadlineAt: Millis.nullable(),
+	/** Whether the match has started in the game. */
+	started: z.boolean()
+});
+/** A ready match of mine: who against, in which game, and until when. */
+const MyTournamentMatch = z.object({
+	id: z.string(),
+	opponent: PlayerLite.nullable(),
+	game: Slug,
+	gameTitle: z.string(),
+	deadlineAt: Millis,
+	started: z.boolean()
+});
+/** The viewer's own relation to a tournament. */
+const TournamentMe = z.object({
+	joined: z.boolean(),
+	/** Invited and not yet signed up. */
+	invited: z.boolean(),
+	following: z.boolean(),
+	/** Minutes before a scheduled start to remind me; `null` for no reminder. */
+	leadMinutes: z.number().int().nonnegative().nullable(),
+	isCreator: z.boolean(),
+	/** Still in (signed up and not knocked out). */
+	stillIn: z.boolean(),
+	nextMatch: MyTournamentMatch.nullable()
+});
+/** A tournament in lists. */
+const TournamentSummary = z.object({
+	id: TournamentId,
+	title: z.string(),
+	creator: PlayerLite.nullable(),
+	visibility: TournamentVisibility,
+	phase: TournamentPhase,
+	/** The game set (one game for `fixed`). */
+	games: z.array(Slug),
+	pick: TournamentGamePick,
+	/** The game every match is in, once known (`fixed`, or `random-once` after the start); `null` for `random-each`. */
+	game: Slug.nullable(),
+	/** A title per game slug. */
+	gameTitles: z.record(Slug, z.string()),
+	lives: z.number().int().min(1),
+	seeding: TournamentSeeding,
+	start: TournamentStart,
+	minPlayers: z.number().int(),
+	maxPlayers: z.number().int(),
+	readyMinutes: z.number().int(),
+	/** How many have signed up. */
+	entrants: z.number().int().nonnegative(),
+	createdAt: Millis,
+	startedAt: Millis.nullable(),
+	endedAt: Millis.nullable(),
+	champion: PlayerLite.nullable(),
+	me: TournamentMe
+});
+/** A tournament with its players and bracket. */
+const TournamentDetail = TournamentSummary.extend({
+	players: z.array(TournamentPlayer),
+	matches: z.array(TournamentMatch),
+	/** The creator's link that lets friends of friends in (closed tournaments, creator only). */
+	inviteUrl: z.string().nullable()
+});
+/** What a launch into a tournament match carries (`launch.tournament`). */
+const TournamentLaunch = z.object({
+	id: TournamentId,
+	title: z.string(),
+	/** The match id within the tournament; own-server games send it back with the result. */
+	match: z.string(),
+	/** Who to play. */
+	opponent: PlayerLite.nullable()
+});
+//#endregion
 //#region src/api/mp/parties.ts
 /**
 * Invites, parties and launches (multiplayer-impl.md §5.6): the shapes the
@@ -2010,9 +2280,44 @@ const Launch = z.object({
 	/** Guest launches: the party leader (`null` if the account is gone). */
 	host: PlayerLite.nullable().optional(),
 	/** Join and watch launches: the friend being joined (`null` if the account is gone). */
-	target: PlayerLite.nullable().optional()
+	target: PlayerLite.nullable().optional(),
+	/** `link`: opened from an invite link; `rejoin`: taking back a seat I still hold (both are join or watch launches). */
+	via: z.enum(["link", "rejoin"]).optional(),
+	/** Host and guest launches into a tournament match: which tournament, which match, and who to play. */
+	tournament: TournamentLaunch.optional()
 });
 //#endregion
+//#region src/api/mp/invite-links.ts
+/**
+* Invite links (batch-2026-10 R13): a link any room member can share that
+* drops whoever opens it into that room, as a player when a seat is free,
+* otherwise as a spectator. A link is an unguessable token kept by the hub;
+* it expires (24 h) and its creator or the room's host can revoke it. Link
+* joiners get the room's usual chat rules and are not friended.
+*/
+/** An invite link's token (base64url). */
+const InviteLinkToken = z.string().regex(/^[A-Za-z0-9_-]{16,64}$/);
+/** A live invite link. */
+const InviteLink = z.object({
+	token: InviteLinkToken,
+	/** `/<slug>/<lobby>?hub_link=<token>`, relative to the site origin. */
+	url: z.string(),
+	game: Slug,
+	mode: GameMode.optional(),
+	/** The room it opens: a hub room code, or an own-server game's room id from presence. */
+	room: z.string(),
+	/** Who made it. */
+	createdBy: UserId,
+	/** Epoch ms. */
+	expiresAt: Millis
+});
+/** `:token` of an invite link. */
+const InviteLinkParams = z.object({ token: InviteLinkToken });
+/** `POST /mp/links` body: a link to the room I'm in, in this game. */
+const InviteLinkCreate = z.object({ game: Slug });
+/** `GET /mp/links` query: my links in a game (and the links to rooms I host). */
+const InviteLinkQuery = z.object({ game: Slug });
+//#endregion
 //#region src/api/mp/chat.ts
 /**
 * Group chat in hub rooms and parties (multiplayer.md §4.3, §4.8): what a
@@ -2066,6 +2371,14 @@ const RoomPhase = z.enum([
 * included.
 */
 const RoomModel = z.enum(["host", "relay"]);
+/**
+* When the host role moves on mid-game. `grace` (default): only once the
+* host's seat is freed (they left, or their reconnect grace ran out), so a
+* host whose browser holds hidden state can come back and carry on. `drop`:
+* as soon as the host drops, for games whose whole truth is in the shared
+* state, so the match never waits.
+*/
+const HostMigration = z.enum(["grace", "drop"]);
 /** A seat in a room, keyed by user (any tab of that user reclaims it). */
 const RoomSeat = z.object({
 	userId: UserId,
@@ -2076,6 +2389,8 @@ const RoomSeat = z.object({
 	ready: z.boolean(),
 	/** `false` while the seat is held for a dropped player's reconnect grace. */
 	connected: z.boolean(),
+	/** While the seat is held (`connected: false`): when the grace runs out and the seat is freed (epoch ms). */
+	graceEndsAt: Millis.optional(),
 	/** Small per-seat game data (team, colour…), at most 2 KB of JSON. */
 	data: Json.optional()
 });
@@ -2127,12 +2442,32 @@ const RoomClosedReason = z.enum([
 	"other_tab",
 	"removed"
 ]);
-/** Why a seat was freed (`room.abandoned`). */
+/** Why a seat was freed (`room.abandoned`, `room.seat` `gone`). */
 const SeatGoneReason = z.enum([
 	"left",
 	"abandoned",
 	"kicked"
 ]);
+/**
+* What happened to a seat (`room.seat`): `away` (the player dropped; the seat
+* is held until `graceEndsAt`, so the game can hand it to its computer
+* player), `back` (they reclaimed it: give control back), `gone` (freed for
+* good: left, kicked, or the grace ran out).
+*/
+const SeatStatus = z.enum([
+	"away",
+	"back",
+	"gone"
+]);
+/** A seat change (`room.seat`). */
+const SeatChange = z.object({
+	userId: UserId,
+	status: SeatStatus,
+	/** `away`: when the held seat is freed (epoch ms). */
+	graceEndsAt: Millis.optional(),
+	/** `gone`: why. */
+	reason: SeatGoneReason.optional()
+});
 //#endregion
 //#region src/api/mp/snapshot.ts
 /** The multiplayer part of the socket `hello` snapshot (multiplayer-impl.md §4.5). */
@@ -2226,6 +2561,53 @@ const mpEndpoints = {
 				tags: ["mp"]
 			}
 		},
+		createInviteLink: {
+			method: "POST",
+			path: "/mp/links",
+			body: InviteLinkCreate,
+			response: InviteLink,
+			errors: {
+				400: ErrorBody,
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody,
+				429: ErrorBody
+			},
+			doc: {
+				summary: "An invite link to the room I'm in (reused while it lives): anyone who opens it joins, or watches when it's full",
+				tags: ["mp"]
+			}
+		},
+		listInviteLinks: {
+			method: "GET",
+			path: "/mp/links",
+			query: InviteLinkQuery,
+			response: z.object({ links: z.array(InviteLink) }),
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody
+			},
+			doc: {
+				summary: "My live invite links in a game, plus the links to rooms I host",
+				tags: ["mp"]
+			}
+		},
+		revokeInviteLink: {
+			method: "DELETE",
+			path: "/mp/links/:token",
+			params: InviteLinkParams,
+			response: Ok,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody
+			},
+			doc: {
+				summary: "Revoke an invite link (its creator, or the host of the room it opens)",
+				tags: ["mp"]
+			}
+		},
 		cancelGameInvite: {
 			method: "DELETE",
 			path: "/mp/invites/:id",
@@ -2258,6 +2640,23 @@ const mpEndpoints = {
 				tags: ["mp"]
 			}
 		},
+		openInviteLink: {
+			method: "POST",
+			path: "/mp/links/:token/open",
+			params: InviteLinkParams,
+			response: LaunchTicket,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody,
+				429: ErrorBody
+			},
+			doc: {
+				summary: "Open an invite link: a join launch when a seat is free, else a watch launch",
+				tags: ["mp"]
+			}
+		},
 		setPartyJoinInfo: {
 			method: "POST",
 			path: "/mp/parties/:id/join-info",
@@ -2351,7 +2750,10 @@ const NotifyPrefs = z.object({
 	friendOnlineAll: z.boolean(),
 	/** Friends whose bell is on, ascending. */
 	friendOnline: z.array(UserId),
-	/** Games followed for "someone's waiting in a lobby", sorted. */
+	/**
+	* Games followed for "someone wants to play" (the game sheet's notify toggle):
+	* an open public lobby or race, or a tournament opening, sorted.
+	*/
 	lobbyOpen: z.array(Slug)
 });
 /** The preference kinds `PUT /social/notify` can flip. */
@@ -3507,6 +3909,263 @@ players: z.array(RecentPlayer) }),
 	})
 };
 //#endregion
+//#region src/api/tournaments/endpoints.ts
+/**
+* The tournament endpoints (batch-2026-10 R15). Anyone may look at open
+* tournaments; a closed one answers 404 to everyone it wasn't shared with.
+* Creating, inviting and following need a claimed account; guests may sign
+* up for open tournaments (and for closed ones they were invited to) and
+* play their matches.
+*/
+/** `:id` of a tournament. */
+const TournamentParams = z.object({ id: IdParam });
+/** `:id` and `:match` of a tournament match. */
+const MatchParams = z.object({
+	id: IdParam,
+	match: z.string().regex(/^m\d{1,4}$/)
+});
+/** The invite key from a shared link (`?hub_key=`), letting its opener into a closed tournament. */
+const InviteKey = z.string().regex(/^[A-Za-z0-9_-]{8,64}$/);
+/** `GET /tournaments` filters. */
+const TournamentListQuery = z.object({ 
+/** Only tournaments in this game. */
+game: z.union([z.literal(""), Slug]).optional() });
+/** The tournament endpoints. */
+const tournamentEndpoints = {
+	...session.group({
+		listTournaments: {
+			method: "GET",
+			path: "/tournaments",
+			query: TournamentListQuery,
+			response: z.object({ tournaments: z.array(TournamentSummary) }),
+			doc: {
+				summary: "Open tournaments plus the ones I am in, invited to or follow, soonest first",
+				tags: ["tournaments"]
+			}
+		},
+		getTournament: {
+			method: "GET",
+			path: "/tournaments/:id",
+			params: TournamentParams,
+			query: z.object({ key: InviteKey.optional() }),
+			response: TournamentDetail,
+			errors: { 404: ErrorBody },
+			doc: {
+				summary: "A tournament with its players and bracket (404 for a closed one not shared with me)",
+				tags: ["tournaments"]
+			}
+		}
+	}),
+	...requireClaimed.group({
+		createTournament: {
+			method: "POST",
+			path: "/tournaments",
+			body: TournamentCreate,
+			response: TournamentDetail,
+			errors: {
+				400: ErrorBody,
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				422: ErrorBody,
+				429: ErrorBody
+			},
+			doc: {
+				summary: "Create a tournament (I am signed up to it); the title goes through the content filter",
+				tags: ["tournaments"]
+			}
+		},
+		inviteToTournament: {
+			method: "POST",
+			path: "/tournaments/:id/invites",
+			params: TournamentParams,
+			body: z.object({ userIds: z.array(UserId).min(1).max(TOURNAMENT_LIMITS.invitesMax) }),
+			response: z.object({ invited: z.number().int().nonnegative() }),
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody,
+				429: ErrorBody
+			},
+			doc: {
+				summary: "Creator: invite friends (others are skipped without saying why)",
+				tags: ["tournaments"]
+			}
+		},
+		followTournament: {
+			method: "PUT",
+			path: "/tournaments/:id/follow",
+			params: TournamentParams,
+			body: z.object({ leadMinutes: z.number().int().min(0).max(TOURNAMENT_LIMITS.leadMinutesMax).nullish() }),
+			response: TournamentSummary,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody
+			},
+			doc: {
+				summary: "Follow a tournament (hear when it opens, starts and ends); leadMinutes: remind me that long before a scheduled start (absent: no reminder)",
+				tags: ["tournaments"]
+			}
+		},
+		unfollowTournament: {
+			method: "DELETE",
+			path: "/tournaments/:id/follow",
+			params: TournamentParams,
+			response: Ok,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody
+			},
+			doc: {
+				summary: "Stop following a tournament",
+				tags: ["tournaments"]
+			}
+		},
+		startTournament: {
+			method: "POST",
+			path: "/tournaments/:id/start",
+			params: TournamentParams,
+			response: TournamentDetail,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody
+			},
+			doc: {
+				summary: "Creator: start now with whoever signed up (at least two)",
+				tags: ["tournaments"]
+			}
+		},
+		cancelTournament: {
+			method: "DELETE",
+			path: "/tournaments/:id",
+			params: TournamentParams,
+			response: Ok,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody
+			},
+			doc: {
+				summary: "Creator (or an admin): cancel a tournament that has not finished",
+				tags: ["tournaments"]
+			}
+		}
+	}),
+	...requireActive.group({
+		joinTournament: {
+			method: "POST",
+			path: "/tournaments/:id/join",
+			params: TournamentParams,
+			body: z.object({ key: InviteKey.optional() }),
+			response: TournamentDetail,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody,
+				429: ErrorBody
+			},
+			doc: {
+				summary: "Sign up (open tournaments, or closed ones I was invited to or have the link for)",
+				tags: ["tournaments"]
+			}
+		},
+		leaveTournament: {
+			method: "POST",
+			path: "/tournaments/:id/leave",
+			params: TournamentParams,
+			response: TournamentDetail,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody
+			},
+			doc: {
+				summary: "Drop out: before the start my place is freed; after it I forfeit what is left",
+				tags: ["tournaments"]
+			}
+		},
+		launchTournamentMatch: {
+			method: "POST",
+			path: "/tournaments/:id/matches/:match/launch",
+			params: MatchParams,
+			response: LaunchTicket,
+			errors: {
+				401: ErrorBody,
+				403: ErrorBody,
+				404: ErrorBody,
+				409: ErrorBody
+			},
+			doc: {
+				summary: "A launch into my ready match: host for the better seed, guest for the other",
+				tags: ["tournaments"]
+			}
+		}
+	})
+};
+//#endregion
+//#region src/api/tournaments/play-online.ts
+/**
+* "Play online" (batch-2026-10 R15): everything the viewer could play with
+* someone, now and later, for the home page card and its modal. Public
+* lobbies and races waiting for a player (joined through
+* `POST /mp/join { userId, fromLobbyOpen: true }`), invites to the viewer,
+* the tournaments they are in or follow (with a ready match first), and open
+* tournaments still taking sign-ups.
+*/
+/** A public lobby or race waiting for players right now. */
+const OpenLobbyEntry = z.object({
+	/** Who is waiting (join them with `POST /mp/join`). */
+	host: PlayerLite,
+	game: Slug,
+	gameTitle: z.string(),
+	/** `race` for a race waiting for racers, otherwise the lobby's mode when it has one. */
+	mode: GameMode.optional(),
+	openSeats: z.number().int().positive(),
+	/** When they started waiting, epoch ms. */
+	since: Millis
+});
+/** The counts on the home card. */
+const PlayOnlineCounts = z.object({
+	/** Lobbies to join now, plus my matches that are ready. */
+	now: z.number().int().nonnegative(),
+	/** Game invites and tournament invites waiting for me. */
+	invites: z.number().int().nonnegative(),
+	/** Tournaments I signed up for or follow, not over. */
+	mine: z.number().int().nonnegative(),
+	/** Open tournaments still taking sign-ups. */
+	upcoming: z.number().int().nonnegative()
+});
+/** Everything playable online for the viewer. */
+const PlayOnline = z.object({
+	counts: PlayOnlineCounts,
+	lobbies: z.array(OpenLobbyEntry),
+	gameInvites: z.array(Invite),
+	/** Closed tournaments I'm invited to and haven't joined. */
+	tournamentInvites: z.array(TournamentSummary),
+	/** Mine: a ready match first, then the soonest. */
+	mine: z.array(TournamentSummary),
+	/** Open, taking sign-ups, not mine. */
+	upcoming: z.array(TournamentSummary)
+});
+/** The play-online endpoint. Signed-out visitors get the open tournaments only. */
+const playOnlineEndpoints = { ...session.group({ getPlayOnline: {
+	method: "GET",
+	path: "/play-online",
+	response: PlayOnline,
+	doc: {
+		summary: "Lobbies to join now, invites, my tournaments and upcoming open ones (the home page card and modal)",
+		tags: ["tournaments"]
+	}
+} }) };
+//#endregion
 //#region src/api/version.ts
 /**
 * `GET /version`: which client versions this hub serves (plan §4.3.3). Games'
@@ -3541,6 +4200,41 @@ const versionEndpoints = { ...session.group({ getHubVersion: {
 	}
 } }) };
 //#endregion
+//#region src/api/offline.ts
+/**
+* Offline replay metadata: which public endpoints a client may queue while
+* offline and send later, and how the hub makes a replay land exactly once.
+*
+* A replayable call carries a client-made operation key in the
+* {@link OFFLINE_OP_HEADER} header. The hub remembers the reply to each key
+* for {@link OFFLINE_DEDUPE_TTL_MS}; a second request with the same key gets
+* that reply again without running the endpoint twice. Endpoints left out
+* are online-only (social, multiplayer, trades) or replay on their own terms
+* (analytics events are buffered and sent at least once, without a key).
+*/
+/** The request header that carries a replayable call's operation key. */
+const OFFLINE_OP_HEADER = "x-hub-op";
+/** An operation key: letters, digits and `_ . : -`, 1 to 100 characters. */
+const OfflineOpKey = z.string().regex(/^[A-Za-z0-9_.:-]{1,100}$/);
+/** How long the hub remembers an operation key's reply: 7 days. */
+const OFFLINE_DEDUPE_TTL_MS = 6048e5;
+/** The public endpoints that support offline replay, by name. */
+const OFFLINE_REPLAY_ENDPOINTS = {
+	writeSave: "replay",
+	deleteSave: "replay",
+	updateGameStat: "replay",
+	setGameProfile: "replay",
+	submitScore: "replay",
+	completeDailyChallenge: "replay",
+	grantInventoryItems: "replay",
+	exchangeInventoryItems: "replay",
+	setGameFavorite: "replay"
+};
+/** Whether endpoint `name` supports offline replay. */
+function isOfflineReplayEndpoint(name) {
+	return Object.hasOwn(OFFLINE_REPLAY_ENDPOINTS, name);
+}
+//#endregion
 //#region src/api/index.ts
 /**
 * The public REST API: every endpoint a game, the menu or the social runtime
@@ -3561,6 +4255,8 @@ const publicEndpoints = {
 	...reportsEndpoints,
 	...mpEndpoints,
 	...raceEndpoints,
+	...tournamentEndpoints,
+	...playOnlineEndpoints,
 	...versionEndpoints
 };
 /** The public API spec (paths relative to `/_api`). */
@@ -3662,7 +4358,7 @@ const roomEvents = {
 	}),
 	"room.closed": event({
 		d: z.object({ reason: RoomClosedReason }),
-		doc: "The room is gone for this tab (emptied, ended, host left, moved, another tab took the seat, removed)."
+		doc: "The room is gone for this tab (emptied, ended, moved, another tab took the seat, removed). `host_left` is no longer sent: the host role passes on."
 	}),
 	"room.abandoned": event({
 		d: z.object({
@@ -3670,15 +4366,28 @@ const roomEvents = {
 			reason: SeatGoneReason
 		}),
 		doc: "A player left mid-game (or their reconnect grace ran out); the game decides what that means."
+	}),
+	"room.seat": event({
+		d: SeatChange,
+		doc: "A seat went away (held for the grace period), came back (reclaimed) or is gone. The game hands an away seat to its computer player and gives it back on `back`."
 	})
 };
 //#endregion
+//#region src/realtime/events/tournaments.ts
+/** Tournament events (batch-2026-10 R15). */
+/** The tournament events, by event name. */
+const tournamentEvents = { tournament: event({
+	d: z.object({ tournament: TournamentSummary }),
+	doc: "A tournament you are in, follow, created or were invited to changed (sign-ups, the start, a match ready or decided, the end)."
+}) };
+//#endregion
 //#region src/realtime/events/multiplayer.ts
 /** The multiplayer events, by event name. */
 const multiplayerEvents = {
 	...partyEvents,
 	...roomEvents,
-	...raceEvents
+	...raceEvents,
+	...tournamentEvents
 };
 //#endregion
 //#region src/realtime/events/social.ts
@@ -3687,7 +4396,7 @@ const multiplayerEvents = {
 * and suspension (multiplayer-impl.md §4.6). Every event goes to all of the
 * recipient's tabs.
 */
-/** What kind of thing a notice is about. `renamed`: an admin changed your username. */
+/** What kind of thing a notice is about. `renamed`: an admin changed your username; `tournament`: a match is ready, a start is near, a forfeit warning. */
 const NoticeKind = z.enum([
 	"dm",
 	"friend_request",
@@ -3695,7 +4404,8 @@ const NoticeKind = z.enum([
 	"lobby_open",
 	"invite",
 	"suggestion",
-	"renamed"
+	"renamed",
+	"tournament"
 ]);
 /** A toast (`ev:notice`), sent instead of a push when the player has a visible tab. */
 const Notice = z.object({
@@ -3944,6 +4654,13 @@ params: RaceParams.optional() }),
 */
 /** A per-room sequence number ack (`room.send`, `room.state`). */
 const SeqAck = z.object({ seq: z.number().int().positive() });
+/** A join's ack: the room, its state and the history this member may replay. */
+const RoomJoinAck = z.object({
+	room: RoomInfo,
+	state: RoomState,
+	/** Recent messages this member may see, oldest first. */
+	history: z.array(RoomMessage)
+});
 /** The room ops, by op name. */
 const roomOps = {
 	"room.create": op({
@@ -3956,6 +4673,8 @@ const roomOps = {
 			/** Seats; clamped to the game's max (and 8). Defaults to the max. */
 			maxPlayers: z.number().optional(),
 			model: RoomModel.optional(),
+			/** When the host role moves on mid-game (default `grace`). */
+			hostMigration: HostMigration.optional(),
 			/** The caller's party: when they lead it, its join info becomes `{ room: code }`. */
 			partyId: OpaqueId.optional()
 		}),
@@ -3973,12 +4692,7 @@ const roomOps = {
 	}),
 	"room.join": op({
 		d: RoomTarget,
-		ack: z.object({
-			room: RoomInfo,
-			state: RoomState,
-			/** Recent messages this member may see, oldest first. */
-			history: z.array(RoomMessage)
-		}),
+		ack: RoomJoinAck,
 		errors: [
 			"room_not_found",
 			"banned",
@@ -3989,6 +4703,14 @@ const roomOps = {
 		],
 		doc: "Take a seat (lobby only), reclaim your own seat (any phase, any tab), or watch."
 	}),
+	"room.reclaim": op({
+		d: z.object({ game: Slug }),
+		ack: z.object({ 
+		/** The seat I still hold in this game, now reclaimed by this tab; `null` when there is none. */
+held: RoomJoinAck.nullable() }),
+		errors: [],
+		doc: "Take back the seat I still hold in this game (after a reload or from another tab); the room hears `room.seat` `back`."
+	}),
 	"room.leave": op({
 		d: NoInput,
 		ack: EmptyAck,
@@ -4315,6 +5037,114 @@ const GameControls = ControlMap.extend({
 /** Per-player maps, by gamepad order; pads past the end use the first. Overrides the shared map. */
 players: z.array(ControlMap).min(1).max(SEAT_LIMITS.maxSeats).optional() });
 //#endregion
+//#region src/manifest/labels.ts
+/**
+* `game.labels`: what kind of game it is, from one fixed vocabulary, so the
+* catalog can filter by them. Labels are grouped (genre, look, where it
+* plays, how many play); a game lists every label that fits.
+*
+* Authoring is lenient: an unknown label is a warning (`hub-doctor`, the
+* host's boot log), never an error, and the catalog ignores it.
+*/
+/** The vocabulary, by group. */
+const GAME_LABEL_GROUPS = {
+	/** What kind of game. */
+	genre: [
+		"cards",
+		"board",
+		"puzzle",
+		"arcade",
+		"platformer",
+		"real-time-strategy",
+		"physics",
+		"typing",
+		"word",
+		"sports",
+		"racing"
+	],
+	/** How it looks. */
+	form: ["2d", "3d"],
+	/** Where it plays: `phone` (touch controls), `controller` (gamepad support), `desktop` (keyboard or mouse only). */
+	platform: [
+		"phone",
+		"controller",
+		"desktop"
+	],
+	/** How many play. */
+	play: ["multiplayer", "single-player"]
+};
+/** The groups in display order. */
+const GAME_LABEL_GROUP_ORDER = [
+	"genre",
+	"form",
+	"platform",
+	"play"
+];
+/** Every label, in display order (group by group). */
+const GAME_LABELS = [
+	...GAME_LABEL_GROUPS.genre,
+	...GAME_LABEL_GROUPS.form,
+	...GAME_LABEL_GROUPS.platform,
+	...GAME_LABEL_GROUPS.play
+];
+/** One known label. */
+const GameLabel = z.enum(GAME_LABELS);
+/** Each label's display name. */
+const GAME_LABEL_TITLES = {
+	cards: "Cards",
+	board: "Board",
+	puzzle: "Puzzle",
+	arcade: "Arcade",
+	platformer: "Platformer",
+	"real-time-strategy": "Real-time strategy",
+	physics: "Physics",
+	typing: "Typing",
+	word: "Word",
+	sports: "Sports",
+	racing: "Racing",
+	"2d": "2D",
+	"3d": "3D",
+	phone: "Phone",
+	controller: "Controller",
+	desktop: "Desktop only",
+	multiplayer: "Multiplayer",
+	"single-player": "Single player"
+};
+/** Each group's display name. */
+const GAME_LABEL_GROUP_TITLES = {
+	genre: "Genre",
+	form: "Look",
+	platform: "Plays on",
+	play: "Players"
+};
+/** Whether `text` is a known label. */
+function isGameLabel(text) {
+	return GameLabel.safeParse(text).success;
+}
+/** The group a label belongs to. */
+function groupOfLabel(label) {
+	return GAME_LABEL_GROUP_ORDER.find((group) => GAME_LABEL_GROUPS[group].some((member) => member === label)) ?? "genre";
+}
+/**
+* `game.labels` as written: short strings. Unknown ones parse (they are a
+* warning, see {@link splitGameLabels}).
+*/
+const GameLabels = z.array(z.string().trim().min(1).max(40)).max(24);
+/** Known labels (trimmed, lower-cased, de-duplicated, in vocabulary order) and the unknown ones as written. */
+function splitGameLabels(written) {
+	const known = /* @__PURE__ */ new Set();
+	const unknown = [];
+	for (const text of written) {
+		const candidate = text.trim().toLowerCase();
+		if (isGameLabel(candidate)) known.add(candidate);
+		else unknown.push(text);
+	}
+	return {
+		labels: GAME_LABELS.filter((label) => known.has(label)),
+		unknown
+	};
+}
+//#endregion
 //#region src/manifest/leaderboards.ts
 /**
 * `game.leaderboards`: boards declared up front, so they show on the catalog
@@ -4384,6 +5214,14 @@ const GameMultiplayer = z.strictObject({
 	spectate: z.boolean().default(false),
 	/** Offer quick match. Default `false`. */
 	quickMatch: z.boolean().default(false),
+	/**
+	* Tournaments can be played in this game (docs/multiplayer.md §15). Default
+	* `false`. The game must play a 1v1 match from a `host`/`guest` launch that
+	* carries `launch.tournament`, and report its winner: hub rooms end with
+	* `room.end({ winnerId })`, own-server games post results with
+	* `tournament`. Race games need no flag: their races are the matches.
+	*/
+	tournaments: z.boolean().default(false),
 	/** Modes players can be invited into (at most 16, unique keys). */
 	modes: z.array(MultiplayerMode).max(MANIFEST_LIMITS.modesMax).refine(hasUniqueKeys, "mode keys must be unique").default([]),
 	/**
@@ -4455,6 +5293,12 @@ const commonFields = {
 	menuPosition: MenuPosition.optional(),
 	/** Push the menu button away from its corner, px: a number (vertical) or `{ x, y }`. */
 	menuOffset: MenuOffset.optional(),
+	/**
+	* What kind of game it is, from the fixed vocabulary in `labels.ts` (genre, look,
+	* where it plays, how many play), for the catalog's label filter. Unknown labels
+	* are a warning, not an error.
+	*/
+	labels: GameLabels.optional(),
 	/** `true` opts into the shared daily challenges (`hub.daily.define(...)`). */
 	dailyChallenges: z.boolean().optional(),
 	/** Boards to create up front, so they show before the first score. */
@@ -4850,6 +5694,6 @@ function historyBadge(racerResult) {
 	}
 }
 //#endregion
-export { ACCOUNT_LIMITS, AckFrame, AppFilePath, Audience, AuthResult, AuthUser, Board, Bundle, BundleInput, ButtonIndex, CHAT_ERRORS, COMMAND_PLACEHOLDERS, ChangeEntry, ChangeNote, ChangeText, ChatAllowWord, ChatLine, ChatLineEvent, ChatMode, ChatSend, CloseCode, Command, ContentRejected, ControlMap, Conversation, Counts, Credentials, DailyCompletion, DailyCompletions, DayKey, ENVELOPE_ERRORS, ErrAckFrame, ErrorBody, ErrorCode, EvFrame, FriendChange, FriendEntry, FriendRequestInput, FriendRequestStatus, FriendRequests, FriendsList, GameChanges, GameControls, GameInfo, GameLeaderboardDecls, GameLeaderboards, GameManifest, GameMode, GameMultiplayer, GamePackageJson, GameRace, GameRecords, GameSnapshot, GameTicket, HexColor, HostManifest, HubInject, HubVersion, IdParam, Inventory, Invite, InviteCreated, InviteStatus, JoinInfo, Json, Key, KeyCode, Launch, LaunchKind, LaunchTicket, LeaderboardDecl, LeaderboardEntry, LobbySuffix, MANIFEST_LIMITS, MAX_BUNDLE_ITEMS, MAX_ITEM_QTY, MenuOffset, MenuOffsetXY, MenuPosition, Message, MessageId, MessagesPage, Metrics, Millis, ModeKey, MultiplayerMode, MultiplayerSnapshot, MultiplayerSummary, NotifyChange, NotifyPrefKind, NotifyPrefs, Ok, OkAckFrame, OpFrame, OpaqueId, PRE_HELLO_OPS, Party, PlayerCard, PlayerLite, PlayerRange, Presence, PresenceInput, PresenceKind, PresenceMode, PresenceRoom, ProcessGame, Profile, PushSubscriptionJson, QuickId, RACE_STATS_LIMITS, RaceBlock, RaceHistory, RaceHistoryQuery, RaceKey, RaceOption, RaceOutcome, RaceParam, RaceParamValue, RaceParams, RacePhase, RaceProgress, RaceRecord, RaceRecordPlayer, RaceResult, RaceResultPlayer, RaceStart, RaceStat, RaceStatFormat, RaceStatValue, RaceState, RaceStats, RaceSummary, Racer, RacerResult, RacerState, Rank, RecentPlayer, RejectReason, Relation, ReportInput, ReportKind, ReportReason, ReportSnapshot, ReportedMessage, Role, RoomClosedReason, RoomCode, RoomInfo, RoomMessage, RoomModel, RoomPhase, RoomSeat, RoomState, RoomTarget, SEAT_LIMITS, Save, SaveMeta, SeatGoneReason, SendMessageInput, ServerFrame, SessionUser, Slug, SocialConfig, SocialLimits, SocialMe, SocialMeResult, SortDir, StatMode, StaticGame, StaticGameMultiplayer, Stats, Suggestion, SuggestionId, SuggestionStatus, TopQuery, TradeOffer, TradePlayer, TradeStatus, Transport, UI_LIMIT_DEFAULTS, UNSUPPORTED_SUBSCRIPTION, USERNAME_PATTERN, UiLimits, UnreadSummary, UserId, UserIdParam, VersionRange, VoteResult, analyticsEndpoints, authEndpoints, badgeText, bundleInput, catalogEndpoints, countdown, dailyEndpoints, dayKey, economyEndpoints, elapsed, event, events, formatStat, game, hasOwnTime, headerLine, historyBadge, historyVerb, inWindow, leaderboardsEndpoints, messagesEndpoints, mpEndpoints, nameList, normalizeChangeText, notifyEndpoints, op, ops, outcomeLine, paramsText, progressEndpoints, publicApi, publicEndpoints, raceClock, raceEndpoints, racerStateTag, relativeTime, reportsEndpoints, requireActive, requireClaimed, requireTrader, requireUser, resultLabel, resultTitle, seedForDay, session, shownStats, socialEndpoints, statusParts, statusText, untilText, versionEndpoints, windowDays };
+export { ACCOUNT_LIMITS, AckFrame, AppFilePath, Audience, AuthResult, AuthUser, Board, Bundle, BundleInput, ButtonIndex, CHAT_ERRORS, COMMAND_PLACEHOLDERS, ChangeEntry, ChangeNote, ChangeText, ChatAllowWord, ChatLine, ChatLineEvent, ChatMode, ChatSend, CloseCode, Command, ContentRejected, ControlMap, Conversation, Counts, Credentials, DailyCompletion, DailyCompletions, DayKey, ENVELOPE_ERRORS, ErrAckFrame, ErrorBody, ErrorCode, EvFrame, FriendChange, FriendEntry, FriendRequestInput, FriendRequestStatus, FriendRequests, FriendsList, GAME_LABELS, GAME_LABEL_GROUPS, GAME_LABEL_GROUP_ORDER, GAME_LABEL_GROUP_TITLES, GAME_LABEL_TITLES, GameChanges, GameControls, GameInfo, GameLabel, GameLabels, GameLeaderboardDecls, GameLeaderboards, GameManifest, GameMode, GameMultiplayer, GamePackageJson, GamePlayerCount, GamePlayerCounts, GameRace, GameRecords, GameSnapshot, GameTicket, HexColor, HostManifest, HostMigration, HubInject, HubVersion, IdParam, Inventory, Invite, InviteCreated, InviteLink, InviteLinkCreate, InviteLinkParams, InviteLinkQuery, InviteLinkToken, InviteStatus, JoinInfo, Json, Key, KeyCode, Launch, LaunchKind, LaunchTicket, LeaderboardDecl, LeaderboardEntry, LobbySuffix, MANIFEST_LIMITS, MAX_BUNDLE_ITEMS, MAX_ITEM_QTY, MenuOffset, MenuOffsetXY, MenuPosition, Message, MessageId, MessagesPage, Metrics, Millis, ModeKey, MultiplayerMode, MultiplayerSnapshot, MultiplayerSummary, MyGameActivity, MyTournamentMatch, NotifyChange, NotifyPrefKind, NotifyPrefs, OFFLINE_DEDUPE_TTL_MS, OFFLINE_OP_HEADER, OFFLINE_REPLAY_ENDPOINTS, OfflineOpKey, Ok, OkAckFrame, OpFrame, OpaqueId, OpenLobbyEntry, PRE_HELLO_OPS, Party, PlayOnline, PlayOnlineCounts, PlayerCard, PlayerLite, PlayerRange, Presence, PresenceInput, PresenceKind, PresenceMode, PresenceRoom, ProcessGame, Profile, PushSubscriptionJson, QuickId, RACE_STATS_LIMITS, RaceBlock, RaceHistory, RaceHistoryQuery, RaceKey, RaceOption, RaceOutcome, RaceParam, RaceParamValue, RaceParams, RacePhase, RaceProgress, RaceRecord, RaceRecordPlayer, RaceResult, RaceResultPlayer, RaceStart, RaceStat, RaceStatFormat, RaceStatValue, RaceState, RaceStats, RaceSummary, Racer, RacerResult, RacerState, Rank, RecentPlayer, RejectReason, Relation, ReportInput, ReportKind, ReportReason, ReportSnapshot, ReportedMessage, Role, RoomClosedReason, RoomCode, RoomInfo, RoomMessage, RoomModel, RoomPhase, RoomSeat, RoomState, RoomTarget, SEAT_LIMITS, Save, SaveMeta, SeatChange, SeatGoneReason, SeatStatus, SendMessageInput, ServerFrame, SessionUser, Slug, SocialConfig, SocialLimits, SocialMe, SocialMeResult, SortDir, StatMode, StaticGame, StaticGameMultiplayer, Stats, Suggestion, SuggestionId, SuggestionStatus, TOURNAMENT_LIMITS, TopQuery, TournamentCreate, TournamentDecision, TournamentDetail, TournamentGamePick, TournamentId, TournamentLaunch, TournamentListQuery, TournamentMatch, TournamentMe, TournamentPhase, TournamentPlayer, TournamentSeeding, TournamentStage, TournamentStart, TournamentSummary, TournamentVisibility, TradeOffer, TradePlayer, TradeStatus, Transport, UI_LIMIT_DEFAULTS, UNSUPPORTED_SUBSCRIPTION, USERNAME_PATTERN, UiLimits, UnreadSummary, UserId, UserIdParam, VersionRange, VoteResult, analyticsEndpoints, authEndpoints, badgeText, bundleInput, catalogActivityEndpoints, catalogEndpoints, countdown, dailyEndpoints, dayKey, economyEndpoints, elapsed, event, events, formatStat, game, groupOfLabel, hasOwnTime, headerLine, historyBadge, historyVerb, inWindow, isGameLabel, isOfflineReplayEndpoint, leaderboardsEndpoints, messagesEndpoints, mpEndpoints, nameList, normalizeChangeText, notifyEndpoints, op, ops, outcomeLine, paramsText, playOnlineEndpoints, progressEndpoints, publicApi, publicEndpoints, raceClock, raceEndpoints, racerStateTag, relativeTime, reportsEndpoints, requireActive, requireClaimed, requireTrader, requireUser, resultLabel, resultTitle, seedForDay, session, shownStats, socialEndpoints, splitGameLabels, statusParts, statusText, tournamentEndpoints, untilText, versionEndpoints, windowDays };
 
 //# sourceMappingURL=index.js.map