xpt-shared-types 1.3.1 → 1.6.1

package/dist/data/gameGenres.d.ts

@@ -0,0 +1,8 @@
+import type { GameGenre } from "../generated/enums";
+/**
+ * Every genre a game can carry, in the order the games page offers them as
+ * filter chips. Typed against the generated enum so a schema change that
+ * adds or renames a value fails here at compile time rather than leaving a
+ * chip that matches nothing.
+ */
+export declare const GAME_GENRES: readonly GameGenre[];

package/dist/data/gameGenres.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAME_GENRES = void 0;
+/**
+ * Every genre a game can carry, in the order the games page offers them as
+ * filter chips. Typed against the generated enum so a schema change that
+ * adds or renames a value fails here at compile time rather than leaving a
+ * chip that matches nothing.
+ */
+exports.GAME_GENRES = [
+    "FPS",
+    "MOBA",
+    "Battle Royale",
+    "Fighting (FGC)",
+    "Sports",
+    "Strategy/RTS",
+    "Sim Racing",
+    "Card Game",
+    "Retro",
+    "Other",
+];

package/dist/gameCatalogue.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Which platforms a game runs on, and which account networks a player needs
+ * on each of them.
+ *
+ * A tournament carries three catalogue relations — `game`, `platform` and
+ * `gameAccount` — and until these functions existed they were three
+ * unconnected choices. A host could put Super Smash Bros on PlayStation, or
+ * ask for a Steam ID in an Xbox tournament, and nothing anywhere objected.
+ *
+ * The chain is game -> platform -> account, each step narrowing the next:
+ *
+ *   - a game is tagged with the platforms it runs on, and with the account
+ *     networks it uses (`Valorant` -> Riot, `Counter-Strike 2` -> Steam);
+ *   - a platform is tagged with the networks that exist on that box
+ *     (PlayStation -> PSN, EA, Epic, Riot);
+ *   - the accounts valid for a tournament are the *intersection* of the two.
+ *
+ * Neither list is derivable from the other. PC hosts {Steam, Epic, Battle.net,
+ * Riot, EA}, but Overwatch 2 on PC is only Battle.net or Steam — so the
+ * platform alone over-generates. And a game's platforms are not the union of
+ * its networks' platforms: 2XKO is PC-only, yet Riot must be tagged with
+ * PlayStation and Xbox for Valorant, which would wrongly put 2XKO on consoles.
+ * Both edges are real; the intersection is the answer.
+ *
+ * Lives here rather than in xpt-strapi because the client filters its radio
+ * groups with the identical rule. Two implementations of an intersection is
+ * two chances to disagree about what a host is allowed to pick.
+ *
+ * Pure on purpose: no Strapi, no I/O, so the rules are unit-tested directly
+ * (see xpt-strapi `tests/unit/utils/gameCatalogue.test.ts`).
+ */
+/** The identifying fields of a populated Strapi relation, all optional. */
+export interface CatalogueRef {
+    id?: number | string | null;
+    documentId?: string | null;
+    name?: string | null;
+}
+/** A platform, with the account networks that exist on it. */
+export interface CataloguePlatformLike extends CatalogueRef {
+    game_accounts?: readonly CatalogueRef[] | null;
+}
+/** A game, with the platforms it runs on and the networks it uses. */
+export interface CatalogueGameLike extends CatalogueRef {
+    title?: string | null;
+    platforms?: readonly CatalogueRef[] | null;
+    game_accounts?: readonly CatalogueRef[] | null;
+}
+/**
+ * Whether two relation references point at the same row.
+ *
+ * `documentId` wins when both sides carry one, because a numeric `id` differs
+ * between a draft and its published entry while the documentId does not. Two
+ * references that share *neither* field are never equal — the tempting
+ * shorthand `a.id === b.id` reads as true when both are `undefined`, which is
+ * how `hasGameAccountFor` used to admit any player to a tournament that had no
+ * account set at all.
+ */
+export declare function sameRef(a?: CatalogueRef | null, b?: CatalogueRef | null): boolean;
+/**
+ * The platforms a game can be played on.
+ *
+ * An untagged game returns the whole catalogue — see `isTagged`. Results keep
+ * the order of `allPlatforms` so the radio group a host sees is stable and
+ * matches the unfiltered list they saw before any tagging happened.
+ */
+export declare function platformsForGame<P extends CataloguePlatformLike>(game: CatalogueGameLike | null | undefined, allPlatforms: readonly P[]): P[];
+/**
+ * The account networks valid for a game on a platform.
+ *
+ * With no platform chosen yet the game's own list is returned unfiltered —
+ * that is what lets a single-network game (Fortnite, Valorant, Dota 2) resolve
+ * its account at creation time, before a platform exists.
+ *
+ * An empty result when both sides *are* tagged is returned as-is rather than
+ * falling back to the full catalogue. It means the two tag lists disagree,
+ * which is a data bug: surfacing it as "no account type available" gets it
+ * fixed, whereas quietly showing all ten hides it forever.
+ */
+export declare function gameAccountsFor<A extends CatalogueRef>(game: CatalogueGameLike | null | undefined, platform: CataloguePlatformLike | null | undefined, allGameAccounts: readonly A[]): A[];
+/**
+ * The one candidate, when there is exactly one.
+ *
+ * Drives auto-connect: a single valid option is not a choice, so the server
+ * connects it and the host is never shown a dialog with one radio in it.
+ */
+export declare function soleCandidate<T>(candidates: readonly T[]): T | null;
+/**
+ * The candidate platforms that carry this account network — the chain read
+ * backwards.
+ *
+ * Most networks answer the platform question by themselves: a PSN ID only
+ * exists on a PlayStation, a Steam ID only on PC. Pair that with
+ * `soleCandidate` and choosing the account fills the platform in, which is the
+ * other half of what makes these two cards feel like one decision.
+ *
+ * The four cross-platform networks (EA, Epic, Battle.net, Riot) match several
+ * and so infer nothing — correctly, because an EA ID really does not say which
+ * box you are on.
+ *
+ * An **untagged** platform is excluded rather than treated as permissive. That
+ * is the opposite of `gameAccountsFor`, and deliberate: not knowing what a
+ * platform carries is a reason to stay quiet, not a licence to claim it carries
+ * this.
+ */
+export declare function platformsCarrying<P extends CataloguePlatformLike>(gameAccount: CatalogueRef | null | undefined, candidates: readonly P[]): P[];
+/** Whether this platform is one the game actually runs on. */
+export declare function isPlatformValidForGame(game: CatalogueGameLike | null | undefined, platform: CatalogueRef | null | undefined, allPlatforms: readonly CataloguePlatformLike[]): boolean;
+/** Whether this account network is one the game uses on this platform. */
+export declare function isGameAccountValidFor(game: CatalogueGameLike | null | undefined, platform: CataloguePlatformLike | null | undefined, gameAccount: CatalogueRef | null | undefined, allGameAccounts: readonly CatalogueRef[]): boolean;

package/dist/gameCatalogue.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Which platforms a game runs on, and which account networks a player needs
+ * on each of them.
+ *
+ * A tournament carries three catalogue relations — `game`, `platform` and
+ * `gameAccount` — and until these functions existed they were three
+ * unconnected choices. A host could put Super Smash Bros on PlayStation, or
+ * ask for a Steam ID in an Xbox tournament, and nothing anywhere objected.
+ *
+ * The chain is game -> platform -> account, each step narrowing the next:
+ *
+ *   - a game is tagged with the platforms it runs on, and with the account
+ *     networks it uses (`Valorant` -> Riot, `Counter-Strike 2` -> Steam);
+ *   - a platform is tagged with the networks that exist on that box
+ *     (PlayStation -> PSN, EA, Epic, Riot);
+ *   - the accounts valid for a tournament are the *intersection* of the two.
+ *
+ * Neither list is derivable from the other. PC hosts {Steam, Epic, Battle.net,
+ * Riot, EA}, but Overwatch 2 on PC is only Battle.net or Steam — so the
+ * platform alone over-generates. And a game's platforms are not the union of
+ * its networks' platforms: 2XKO is PC-only, yet Riot must be tagged with
+ * PlayStation and Xbox for Valorant, which would wrongly put 2XKO on consoles.
+ * Both edges are real; the intersection is the answer.
+ *
+ * Lives here rather than in xpt-strapi because the client filters its radio
+ * groups with the identical rule. Two implementations of an intersection is
+ * two chances to disagree about what a host is allowed to pick.
+ *
+ * Pure on purpose: no Strapi, no I/O, so the rules are unit-tested directly
+ * (see xpt-strapi `tests/unit/utils/gameCatalogue.test.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sameRef = sameRef;
+exports.platformsForGame = platformsForGame;
+exports.gameAccountsFor = gameAccountsFor;
+exports.soleCandidate = soleCandidate;
+exports.platformsCarrying = platformsCarrying;
+exports.isPlatformValidForGame = isPlatformValidForGame;
+exports.isGameAccountValidFor = isGameAccountValidFor;
+/**
+ * Whether two relation references point at the same row.
+ *
+ * `documentId` wins when both sides carry one, because a numeric `id` differs
+ * between a draft and its published entry while the documentId does not. Two
+ * references that share *neither* field are never equal — the tempting
+ * shorthand `a.id === b.id` reads as true when both are `undefined`, which is
+ * how `hasGameAccountFor` used to admit any player to a tournament that had no
+ * account set at all.
+ */
+function sameRef(a, b) {
+    if (!a || !b)
+        return false;
+    if (a.documentId && b.documentId)
+        return a.documentId === b.documentId;
+    const aId = a.id;
+    const bId = b.id;
+    if (aId === null || aId === undefined)
+        return false;
+    if (bId === null || bId === undefined)
+        return false;
+    return String(aId) === String(bId);
+}
+/**
+ * Whether a catalogue tag list says anything.
+ *
+ * An absent list and an empty one mean the same thing: nobody has tagged this
+ * row yet. Strapi serialises an unpopulated relation and a populated-but-empty
+ * one identically once it reaches the client, so there is no way to tell them
+ * apart and no reason to try — either way we have no opinion, and an untagged
+ * row must never lock a host out of a game we simply forgot to configure.
+ */
+function isTagged(list) {
+    return Array.isArray(list) && list.length > 0;
+}
+/** The master list, minus any row that repeats one already seen. */
+function dedupe(rows) {
+    const seen = [];
+    for (const row of rows) {
+        if (!seen.some((kept) => sameRef(kept, row)))
+            seen.push(row);
+    }
+    return seen;
+}
+/**
+ * The platforms a game can be played on.
+ *
+ * An untagged game returns the whole catalogue — see `isTagged`. Results keep
+ * the order of `allPlatforms` so the radio group a host sees is stable and
+ * matches the unfiltered list they saw before any tagging happened.
+ */
+function platformsForGame(game, allPlatforms) {
+    const all = dedupe(allPlatforms);
+    if (!game || !isTagged(game.platforms))
+        return all;
+    return all.filter((platform) => game.platforms.some((tag) => sameRef(tag, platform)));
+}
+/**
+ * The account networks valid for a game on a platform.
+ *
+ * With no platform chosen yet the game's own list is returned unfiltered —
+ * that is what lets a single-network game (Fortnite, Valorant, Dota 2) resolve
+ * its account at creation time, before a platform exists.
+ *
+ * An empty result when both sides *are* tagged is returned as-is rather than
+ * falling back to the full catalogue. It means the two tag lists disagree,
+ * which is a data bug: surfacing it as "no account type available" gets it
+ * fixed, whereas quietly showing all ten hides it forever.
+ */
+function gameAccountsFor(game, platform, allGameAccounts) {
+    const all = dedupe(allGameAccounts);
+    const byGame = !game || !isTagged(game.game_accounts)
+        ? all
+        : all.filter((account) => game.game_accounts.some((tag) => sameRef(tag, account)));
+    // No platform yet, or a platform nobody has tagged: the game is the only
+    // authority we have.
+    if (!platform || !isTagged(platform.game_accounts))
+        return byGame;
+    return byGame.filter((account) => platform.game_accounts.some((tag) => sameRef(tag, account)));
+}
+/**
+ * The one candidate, when there is exactly one.
+ *
+ * Drives auto-connect: a single valid option is not a choice, so the server
+ * connects it and the host is never shown a dialog with one radio in it.
+ */
+function soleCandidate(candidates) {
+    return candidates.length === 1 ? candidates[0] : null;
+}
+/**
+ * The candidate platforms that carry this account network — the chain read
+ * backwards.
+ *
+ * Most networks answer the platform question by themselves: a PSN ID only
+ * exists on a PlayStation, a Steam ID only on PC. Pair that with
+ * `soleCandidate` and choosing the account fills the platform in, which is the
+ * other half of what makes these two cards feel like one decision.
+ *
+ * The four cross-platform networks (EA, Epic, Battle.net, Riot) match several
+ * and so infer nothing — correctly, because an EA ID really does not say which
+ * box you are on.
+ *
+ * An **untagged** platform is excluded rather than treated as permissive. That
+ * is the opposite of `gameAccountsFor`, and deliberate: not knowing what a
+ * platform carries is a reason to stay quiet, not a licence to claim it carries
+ * this.
+ */
+function platformsCarrying(gameAccount, candidates) {
+    if (!gameAccount)
+        return [];
+    return dedupe(candidates).filter((platform) => { var _a; return ((_a = platform.game_accounts) !== null && _a !== void 0 ? _a : []).some((tag) => sameRef(tag, gameAccount)); });
+}
+/** Whether this platform is one the game actually runs on. */
+function isPlatformValidForGame(game, platform, allPlatforms) {
+    if (!platform)
+        return false;
+    return platformsForGame(game, allPlatforms).some((valid) => sameRef(valid, platform));
+}
+/** Whether this account network is one the game uses on this platform. */
+function isGameAccountValidFor(game, platform, gameAccount, allGameAccounts) {
+    if (!gameAccount)
+        return false;
+    return gameAccountsFor(game, platform, allGameAccounts).some((valid) => sameRef(valid, gameAccount));
+}

package/dist/generated/enums.d.ts

@@ -1,19 +1,29 @@
 /** `Friendship.status` */
 export type FriendshipStatus = "pending" | "accepted";
+/** `Game.genre` */
+export type GameGenre = "FPS" | "MOBA" | "Battle Royale" | "Fighting (FGC)" | "Sports" | "Strategy/RTS" | "Sim Racing" | "Card Game" | "Retro" | "Other";
 /** `GameRequest.customLobbies` */
 export type GameRequestCustomLobbies = "Yes" | "No" | "Not sure";
 /** `GameRequest.genre` */
 export type GameRequestGenre = "FPS" | "MOBA" | "Battle Royale" | "Fighting (FGC)" | "Sports" | "Strategy/RTS" | "Sim Racing" | "Card Game" | "Other";
 /** `GameRequest.teamPlay` */
 export type GameRequestTeamPlay = "No (solo)" | "Yes, 2v2" | "Yes, 3v3" | "Yes, 4v4+" | "Don't know";
+/** `Game.visibility` */
+export type GameVisibility = "listed" | "searchOnly" | "archived";
+/** `Match.disputeReason` */
+export type MatchDisputeReason = "scoreMismatch" | "opponentNoShow" | "opponentLaggedOut" | "rulesViolation" | "other";
 /** `Match.lobbyStatus` */
 export type MatchLobbyStatus = "waiting" | "ready" | "disputed" | "completed";
+/** `Match.resultType` */
+export type MatchResultType = "reported" | "hostRecorded" | "bye" | "noShowHome" | "noShowAway" | "forfeitHome" | "forfeitAway" | "disputeResolved" | "adminOverride";
 /** `Match.round` */
 export type MatchRound = "Round 128" | "Round 64" | "Round 32" | "Round 16" | "Quarter Final" | "Semi-Final" | "Third Round" | "Finals" | "League";
 /** `Match.streamPlatform` */
 export type MatchStreamPlatform = "twitch" | "youtube" | "kick" | "other";
 /** `Match.winnerSlot` */
 export type MatchWinnerSlot = "home" | "away";
+/** `Platform.code` */
+export type PlatformCode = "pc" | "playstation" | "xbox" | "nintendo" | "mobile";
 /** `Referral.status` */
 export type ReferralStatus = "pending" | "completed";
 /** `Team.current_status` */

package/dist/generated/inputs.d.ts

@@ -1,5 +1,5 @@
 import type { BlocksContent, MediaInput, RelationInput } from '../contracts';
-import type { FriendshipStatus, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, MatchLobbyStatus, MatchRound, MatchStreamPlatform, MatchWinnerSlot, ReferralStatus, TeamCurrentStatus, TeamInviteStatus, TeamInviteTeamRole, TeamPlayerTeamRole, TournamentCurrentStatus, TournamentParticipantEntryType, TournamentParticipantStatus, TournamentRoleRole, TournamentTeamSize, TournamentType, UserTransactionStripeStatus, UserTransactionType } from './enums';
+import type { FriendshipStatus, GameGenre, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, GameVisibility, MatchDisputeReason, MatchLobbyStatus, MatchResultType, MatchRound, MatchStreamPlatform, MatchWinnerSlot, PlatformCode, ReferralStatus, TeamCurrentStatus, TeamInviteStatus, TeamInviteTeamRole, TeamPlayerTeamRole, TournamentCurrentStatus, TournamentParticipantEntryType, TournamentParticipantStatus, TournamentRoleRole, TournamentTeamSize, TournamentType, UserTransactionStripeStatus, UserTransactionType } from './enums';
 /** Write payload for `about`. */
 export interface AboutInput {
     heroTitle?: string;
@@ -44,10 +44,14 @@ export interface GameInput {
     imgThumb?: MediaInput;
     imgMain?: MediaInput;
     tournaments?: RelationInput | RelationInput[];
-    isTrending?: boolean;
     user_game_stats?: RelationInput | RelationInput[];
     team_game_stats?: RelationInput | RelationInput[];
     imgMainPosition?: string;
+    visibility?: GameVisibility;
+    genre?: GameGenre;
+    sortOrder?: number;
+    platforms?: RelationInput | RelationInput[];
+    game_accounts?: RelationInput | RelationInput[];
 }
 /** Write payload for `game-account`. */
 export interface GameAccountInput {
@@ -55,6 +59,8 @@ export interface GameAccountInput {
     tournaments?: RelationInput | RelationInput[];
     user_game_accounts?: RelationInput | RelationInput[];
     imgThumb?: MediaInput;
+    games?: RelationInput | RelationInput[];
+    platforms?: RelationInput | RelationInput[];
 }
 /** Write payload for `game-request`. */
 export interface GameRequestInput {
@@ -126,6 +132,13 @@ export interface MatchInput {
     isStreaming?: boolean;
     streamHandle?: string;
     streamPlatform?: MatchStreamPlatform;
+    startedAt?: string;
+    endedAt?: string;
+    resultType?: MatchResultType;
+    resultNote?: string;
+    disputeReason?: MatchDisputeReason;
+    disputeNote?: string;
+    disputedBy?: RelationInput;
 }
 /** Write payload for `match-message`. */
 export interface MatchMessageInput {
@@ -148,7 +161,10 @@ export interface NotificationInput {
 /** Write payload for `platform`. */
 export interface PlatformInput {
     name?: string;
+    code?: PlatformCode;
     tournaments?: RelationInput | RelationInput[];
+    games?: RelationInput | RelationInput[];
+    game_accounts?: RelationInput | RelationInput[];
 }
 /** Write payload for `preset-avatar`. */
 export interface PresetAvatarInput {

package/dist/generated/models.d.ts

@@ -1,5 +1,5 @@
 import type { BlocksContent, StrapiDocument, StrapiMedia, UserRole } from '../contracts';
-import type { FriendshipStatus, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, MatchLobbyStatus, MatchRound, MatchStreamPlatform, MatchWinnerSlot, ReferralStatus, TeamCurrentStatus, TeamInviteStatus, TeamInviteTeamRole, TeamPlayerTeamRole, TournamentCurrentStatus, TournamentParticipantEntryType, TournamentParticipantStatus, TournamentRoleRole, TournamentTeamSize, TournamentType, UserTransactionStripeStatus, UserTransactionType } from './enums';
+import type { FriendshipStatus, GameGenre, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, GameVisibility, MatchDisputeReason, MatchLobbyStatus, MatchResultType, MatchRound, MatchStreamPlatform, MatchWinnerSlot, PlatformCode, ReferralStatus, TeamCurrentStatus, TeamInviteStatus, TeamInviteTeamRole, TeamPlayerTeamRole, TournamentCurrentStatus, TournamentParticipantEntryType, TournamentParticipantStatus, TournamentRoleRole, TournamentTeamSize, TournamentType, UserTransactionStripeStatus, UserTransactionType } from './enums';
 /** `about` */
 export interface About extends StrapiDocument {
     heroTitle?: string | null;
@@ -44,10 +44,14 @@ export interface Game extends StrapiDocument {
     imgThumb?: StrapiMedia | null;
     imgMain?: StrapiMedia | null;
     tournaments?: Tournament[];
-    isTrending?: boolean | null;
     user_game_stats?: UserGameStat[];
     team_game_stats?: TeamGameStat[];
     imgMainPosition?: string | null;
+    visibility?: GameVisibility | null;
+    genre?: GameGenre | null;
+    sortOrder?: number | null;
+    platforms?: Platform[];
+    game_accounts?: GameAccount[];
 }
 /** `game-account` */
 export interface GameAccount extends StrapiDocument {
@@ -55,6 +59,8 @@ export interface GameAccount extends StrapiDocument {
     tournaments?: Tournament[];
     user_game_accounts?: UserGameAccount[];
     imgThumb?: StrapiMedia | null;
+    games?: Game[];
+    platforms?: Platform[];
 }
 /** `game-request` */
 export interface GameRequest extends StrapiDocument {
@@ -126,6 +132,13 @@ export interface Match extends StrapiDocument {
     isStreaming?: boolean | null;
     streamHandle?: string | null;
     streamPlatform?: MatchStreamPlatform | null;
+    startedAt?: string | null;
+    endedAt?: string | null;
+    resultType?: MatchResultType | null;
+    resultNote?: string | null;
+    disputeReason?: MatchDisputeReason | null;
+    disputeNote?: string | null;
+    disputedBy?: User | null;
 }
 /** `match-message` */
 export interface MatchMessage extends StrapiDocument {
@@ -148,7 +161,10 @@ export interface Notification extends StrapiDocument {
 /** `platform` */
 export interface Platform extends StrapiDocument {
     name?: string | null;
+    code?: PlatformCode | null;
     tournaments?: Tournament[];
+    games?: Game[];
+    game_accounts?: GameAccount[];
 }
 /** `preset-avatar` */
 export interface PresetAvatar extends StrapiDocument {

package/dist/index.d.ts

@@ -2,4 +2,6 @@ export * from './generated';
 export * from './contracts';
 export * from './manual';
 export * from './bracket';
+export * from './gameCatalogue';
 export * from './data/countriesList';
+export * from './data/gameGenres';

package/dist/index.js

@@ -22,5 +22,9 @@ __exportStar(require("./contracts"), exports);
 __exportStar(require("./manual"), exports);
 // Bracket shape — shared by the backend generator and Storybook fixtures
 __exportStar(require("./bracket"), exports);
+// Game/platform/account catalogue — the game -> platform -> account chain,
+// applied identically by the backend resolver and the client's pickers
+__exportStar(require("./gameCatalogue"), exports);
 // Data
 __exportStar(require("./data/countriesList"), exports);
+__exportStar(require("./data/gameGenres"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xpt-shared-types",
-  "version": "1.3.1",
+  "version": "1.6.1",
   "description": "Shared types and data for XPT projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/data/gameGenres.ts

@@ -0,0 +1,20 @@
+import type { GameGenre } from "../generated/enums";
+
+/**
+ * Every genre a game can carry, in the order the games page offers them as
+ * filter chips. Typed against the generated enum so a schema change that
+ * adds or renames a value fails here at compile time rather than leaving a
+ * chip that matches nothing.
+ */
+export const GAME_GENRES: readonly GameGenre[] = [
+  "FPS",
+  "MOBA",
+  "Battle Royale",
+  "Fighting (FGC)",
+  "Sports",
+  "Strategy/RTS",
+  "Sim Racing",
+  "Card Game",
+  "Retro",
+  "Other",
+];

package/src/gameCatalogue.ts

@@ -0,0 +1,217 @@
+/**
+ * Which platforms a game runs on, and which account networks a player needs
+ * on each of them.
+ *
+ * A tournament carries three catalogue relations — `game`, `platform` and
+ * `gameAccount` — and until these functions existed they were three
+ * unconnected choices. A host could put Super Smash Bros on PlayStation, or
+ * ask for a Steam ID in an Xbox tournament, and nothing anywhere objected.
+ *
+ * The chain is game -> platform -> account, each step narrowing the next:
+ *
+ *   - a game is tagged with the platforms it runs on, and with the account
+ *     networks it uses (`Valorant` -> Riot, `Counter-Strike 2` -> Steam);
+ *   - a platform is tagged with the networks that exist on that box
+ *     (PlayStation -> PSN, EA, Epic, Riot);
+ *   - the accounts valid for a tournament are the *intersection* of the two.
+ *
+ * Neither list is derivable from the other. PC hosts {Steam, Epic, Battle.net,
+ * Riot, EA}, but Overwatch 2 on PC is only Battle.net or Steam — so the
+ * platform alone over-generates. And a game's platforms are not the union of
+ * its networks' platforms: 2XKO is PC-only, yet Riot must be tagged with
+ * PlayStation and Xbox for Valorant, which would wrongly put 2XKO on consoles.
+ * Both edges are real; the intersection is the answer.
+ *
+ * Lives here rather than in xpt-strapi because the client filters its radio
+ * groups with the identical rule. Two implementations of an intersection is
+ * two chances to disagree about what a host is allowed to pick.
+ *
+ * Pure on purpose: no Strapi, no I/O, so the rules are unit-tested directly
+ * (see xpt-strapi `tests/unit/utils/gameCatalogue.test.ts`).
+ */
+
+/** The identifying fields of a populated Strapi relation, all optional. */
+export interface CatalogueRef {
+  id?: number | string | null;
+  documentId?: string | null;
+  name?: string | null;
+}
+
+/** A platform, with the account networks that exist on it. */
+export interface CataloguePlatformLike extends CatalogueRef {
+  game_accounts?: readonly CatalogueRef[] | null;
+}
+
+/** A game, with the platforms it runs on and the networks it uses. */
+export interface CatalogueGameLike extends CatalogueRef {
+  title?: string | null;
+  platforms?: readonly CatalogueRef[] | null;
+  game_accounts?: readonly CatalogueRef[] | null;
+}
+
+/**
+ * Whether two relation references point at the same row.
+ *
+ * `documentId` wins when both sides carry one, because a numeric `id` differs
+ * between a draft and its published entry while the documentId does not. Two
+ * references that share *neither* field are never equal — the tempting
+ * shorthand `a.id === b.id` reads as true when both are `undefined`, which is
+ * how `hasGameAccountFor` used to admit any player to a tournament that had no
+ * account set at all.
+ */
+export function sameRef(
+  a?: CatalogueRef | null,
+  b?: CatalogueRef | null
+): boolean {
+  if (!a || !b) return false;
+
+  if (a.documentId && b.documentId) return a.documentId === b.documentId;
+
+  const aId = a.id;
+  const bId = b.id;
+  if (aId === null || aId === undefined) return false;
+  if (bId === null || bId === undefined) return false;
+
+  return String(aId) === String(bId);
+}
+
+/**
+ * Whether a catalogue tag list says anything.
+ *
+ * An absent list and an empty one mean the same thing: nobody has tagged this
+ * row yet. Strapi serialises an unpopulated relation and a populated-but-empty
+ * one identically once it reaches the client, so there is no way to tell them
+ * apart and no reason to try — either way we have no opinion, and an untagged
+ * row must never lock a host out of a game we simply forgot to configure.
+ */
+function isTagged(list?: readonly CatalogueRef[] | null): boolean {
+  return Array.isArray(list) && list.length > 0;
+}
+
+/** The master list, minus any row that repeats one already seen. */
+function dedupe<T extends CatalogueRef>(rows: readonly T[]): T[] {
+  const seen: T[] = [];
+  for (const row of rows) {
+    if (!seen.some((kept) => sameRef(kept, row))) seen.push(row);
+  }
+  return seen;
+}
+
+/**
+ * The platforms a game can be played on.
+ *
+ * An untagged game returns the whole catalogue — see `isTagged`. Results keep
+ * the order of `allPlatforms` so the radio group a host sees is stable and
+ * matches the unfiltered list they saw before any tagging happened.
+ */
+export function platformsForGame<P extends CataloguePlatformLike>(
+  game: CatalogueGameLike | null | undefined,
+  allPlatforms: readonly P[]
+): P[] {
+  const all = dedupe(allPlatforms);
+
+  if (!game || !isTagged(game.platforms)) return all;
+
+  return all.filter((platform) =>
+    game.platforms!.some((tag) => sameRef(tag, platform))
+  );
+}
+
+/**
+ * The account networks valid for a game on a platform.
+ *
+ * With no platform chosen yet the game's own list is returned unfiltered —
+ * that is what lets a single-network game (Fortnite, Valorant, Dota 2) resolve
+ * its account at creation time, before a platform exists.
+ *
+ * An empty result when both sides *are* tagged is returned as-is rather than
+ * falling back to the full catalogue. It means the two tag lists disagree,
+ * which is a data bug: surfacing it as "no account type available" gets it
+ * fixed, whereas quietly showing all ten hides it forever.
+ */
+export function gameAccountsFor<A extends CatalogueRef>(
+  game: CatalogueGameLike | null | undefined,
+  platform: CataloguePlatformLike | null | undefined,
+  allGameAccounts: readonly A[]
+): A[] {
+  const all = dedupe(allGameAccounts);
+
+  const byGame =
+    !game || !isTagged(game.game_accounts)
+      ? all
+      : all.filter((account) =>
+          game.game_accounts!.some((tag) => sameRef(tag, account))
+        );
+
+  // No platform yet, or a platform nobody has tagged: the game is the only
+  // authority we have.
+  if (!platform || !isTagged(platform.game_accounts)) return byGame;
+
+  return byGame.filter((account) =>
+    platform.game_accounts!.some((tag) => sameRef(tag, account))
+  );
+}
+
+/**
+ * The one candidate, when there is exactly one.
+ *
+ * Drives auto-connect: a single valid option is not a choice, so the server
+ * connects it and the host is never shown a dialog with one radio in it.
+ */
+export function soleCandidate<T>(candidates: readonly T[]): T | null {
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+/**
+ * The candidate platforms that carry this account network — the chain read
+ * backwards.
+ *
+ * Most networks answer the platform question by themselves: a PSN ID only
+ * exists on a PlayStation, a Steam ID only on PC. Pair that with
+ * `soleCandidate` and choosing the account fills the platform in, which is the
+ * other half of what makes these two cards feel like one decision.
+ *
+ * The four cross-platform networks (EA, Epic, Battle.net, Riot) match several
+ * and so infer nothing — correctly, because an EA ID really does not say which
+ * box you are on.
+ *
+ * An **untagged** platform is excluded rather than treated as permissive. That
+ * is the opposite of `gameAccountsFor`, and deliberate: not knowing what a
+ * platform carries is a reason to stay quiet, not a licence to claim it carries
+ * this.
+ */
+export function platformsCarrying<P extends CataloguePlatformLike>(
+  gameAccount: CatalogueRef | null | undefined,
+  candidates: readonly P[]
+): P[] {
+  if (!gameAccount) return [];
+
+  return dedupe(candidates).filter((platform) =>
+    (platform.game_accounts ?? []).some((tag) => sameRef(tag, gameAccount))
+  );
+}
+
+/** Whether this platform is one the game actually runs on. */
+export function isPlatformValidForGame(
+  game: CatalogueGameLike | null | undefined,
+  platform: CatalogueRef | null | undefined,
+  allPlatforms: readonly CataloguePlatformLike[]
+): boolean {
+  if (!platform) return false;
+  return platformsForGame(game, allPlatforms).some((valid) =>
+    sameRef(valid, platform)
+  );
+}
+
+/** Whether this account network is one the game uses on this platform. */
+export function isGameAccountValidFor(
+  game: CatalogueGameLike | null | undefined,
+  platform: CataloguePlatformLike | null | undefined,
+  gameAccount: CatalogueRef | null | undefined,
+  allGameAccounts: readonly CatalogueRef[]
+): boolean {
+  if (!gameAccount) return false;
+  return gameAccountsFor(game, platform, allGameAccounts).some((valid) =>
+    sameRef(valid, gameAccount)
+  );
+}

package/src/generated/enums.ts

@@ -7,6 +7,19 @@ export type FriendshipStatus =
   | "pending"
   | "accepted";
 
+/** `Game.genre` */
+export type GameGenre =
+  | "FPS"
+  | "MOBA"
+  | "Battle Royale"
+  | "Fighting (FGC)"
+  | "Sports"
+  | "Strategy/RTS"
+  | "Sim Racing"
+  | "Card Game"
+  | "Retro"
+  | "Other";
+
 /** `GameRequest.customLobbies` */
 export type GameRequestCustomLobbies =
   | "Yes"
@@ -33,6 +46,20 @@ export type GameRequestTeamPlay =
   | "Yes, 4v4+"
   | "Don't know";
 
+/** `Game.visibility` */
+export type GameVisibility =
+  | "listed"
+  | "searchOnly"
+  | "archived";
+
+/** `Match.disputeReason` */
+export type MatchDisputeReason =
+  | "scoreMismatch"
+  | "opponentNoShow"
+  | "opponentLaggedOut"
+  | "rulesViolation"
+  | "other";
+
 /** `Match.lobbyStatus` */
 export type MatchLobbyStatus =
   | "waiting"
@@ -40,6 +67,18 @@ export type MatchLobbyStatus =
   | "disputed"
   | "completed";
 
+/** `Match.resultType` */
+export type MatchResultType =
+  | "reported"
+  | "hostRecorded"
+  | "bye"
+  | "noShowHome"
+  | "noShowAway"
+  | "forfeitHome"
+  | "forfeitAway"
+  | "disputeResolved"
+  | "adminOverride";
+
 /** `Match.round` */
 export type MatchRound =
   | "Round 128"
@@ -64,6 +103,14 @@ export type MatchWinnerSlot =
   | "home"
   | "away";
 
+/** `Platform.code` */
+export type PlatformCode =
+  | "pc"
+  | "playstation"
+  | "xbox"
+  | "nintendo"
+  | "mobile";
+
 /** `Referral.status` */
 export type ReferralStatus =
   | "pending"

package/src/generated/inputs.ts

@@ -9,13 +9,18 @@ import type {
 } from '../contracts';
 import type {
   FriendshipStatus,
+  GameGenre,
   GameRequestCustomLobbies,
   GameRequestGenre,
   GameRequestTeamPlay,
+  GameVisibility,
+  MatchDisputeReason,
   MatchLobbyStatus,
+  MatchResultType,
   MatchRound,
   MatchStreamPlatform,
   MatchWinnerSlot,
+  PlatformCode,
   ReferralStatus,
   TeamCurrentStatus,
   TeamInviteStatus,
@@ -81,10 +86,14 @@ export interface GameInput {
   imgThumb?: MediaInput;
   imgMain?: MediaInput;
   tournaments?: RelationInput | RelationInput[];
-  isTrending?: boolean;
   user_game_stats?: RelationInput | RelationInput[];
   team_game_stats?: RelationInput | RelationInput[];
   imgMainPosition?: string;
+  visibility?: GameVisibility;
+  genre?: GameGenre;
+  sortOrder?: number;
+  platforms?: RelationInput | RelationInput[];
+  game_accounts?: RelationInput | RelationInput[];
 }
 
 /** Write payload for `game-account`. */
@@ -93,6 +102,8 @@ export interface GameAccountInput {
   tournaments?: RelationInput | RelationInput[];
   user_game_accounts?: RelationInput | RelationInput[];
   imgThumb?: MediaInput;
+  games?: RelationInput | RelationInput[];
+  platforms?: RelationInput | RelationInput[];
 }
 
 /** Write payload for `game-request`. */
@@ -169,6 +180,13 @@ export interface MatchInput {
   isStreaming?: boolean;
   streamHandle?: string;
   streamPlatform?: MatchStreamPlatform;
+  startedAt?: string;
+  endedAt?: string;
+  resultType?: MatchResultType;
+  resultNote?: string;
+  disputeReason?: MatchDisputeReason;
+  disputeNote?: string;
+  disputedBy?: RelationInput;
 }
 
 /** Write payload for `match-message`. */
@@ -194,7 +212,10 @@ export interface NotificationInput {
 /** Write payload for `platform`. */
 export interface PlatformInput {
   name?: string;
+  code?: PlatformCode;
   tournaments?: RelationInput | RelationInput[];
+  games?: RelationInput | RelationInput[];
+  game_accounts?: RelationInput | RelationInput[];
 }
 
 /** Write payload for `preset-avatar`. */

package/src/generated/models.ts

@@ -10,13 +10,18 @@ import type {
 } from '../contracts';
 import type {
   FriendshipStatus,
+  GameGenre,
   GameRequestCustomLobbies,
   GameRequestGenre,
   GameRequestTeamPlay,
+  GameVisibility,
+  MatchDisputeReason,
   MatchLobbyStatus,
+  MatchResultType,
   MatchRound,
   MatchStreamPlatform,
   MatchWinnerSlot,
+  PlatformCode,
   ReferralStatus,
   TeamCurrentStatus,
   TeamInviteStatus,
@@ -82,10 +87,14 @@ export interface Game extends StrapiDocument {
   imgThumb?: StrapiMedia | null;
   imgMain?: StrapiMedia | null;
   tournaments?: Tournament[];
-  isTrending?: boolean | null;
   user_game_stats?: UserGameStat[];
   team_game_stats?: TeamGameStat[];
   imgMainPosition?: string | null;
+  visibility?: GameVisibility | null;
+  genre?: GameGenre | null;
+  sortOrder?: number | null;
+  platforms?: Platform[];
+  game_accounts?: GameAccount[];
 }
 
 /** `game-account` */
@@ -94,6 +103,8 @@ export interface GameAccount extends StrapiDocument {
   tournaments?: Tournament[];
   user_game_accounts?: UserGameAccount[];
   imgThumb?: StrapiMedia | null;
+  games?: Game[];
+  platforms?: Platform[];
 }
 
 /** `game-request` */
@@ -170,6 +181,13 @@ export interface Match extends StrapiDocument {
   isStreaming?: boolean | null;
   streamHandle?: string | null;
   streamPlatform?: MatchStreamPlatform | null;
+  startedAt?: string | null;
+  endedAt?: string | null;
+  resultType?: MatchResultType | null;
+  resultNote?: string | null;
+  disputeReason?: MatchDisputeReason | null;
+  disputeNote?: string | null;
+  disputedBy?: User | null;
 }
 
 /** `match-message` */
@@ -195,7 +213,10 @@ export interface Notification extends StrapiDocument {
 /** `platform` */
 export interface Platform extends StrapiDocument {
   name?: string | null;
+  code?: PlatformCode | null;
   tournaments?: Tournament[];
+  games?: Game[];
+  game_accounts?: GameAccount[];
 }
 
 /** `preset-avatar` */

package/src/index.ts

@@ -1,14 +1,19 @@
-// Generated from the Strapi schemas — see scripts/sync-from-strapi.js
-export * from './generated';
-
-// Hand-written contract primitives (response envelopes, Populated, media)
-export * from './contracts';
-
-// Hand-written types with no Strapi content type behind them
-export * from './manual';
-
-// Bracket shape — shared by the backend generator and Storybook fixtures
-export * from './bracket';
-
-// Data
-export * from './data/countriesList';
+// Generated from the Strapi schemas — see scripts/sync-from-strapi.js
+export * from './generated';
+
+// Hand-written contract primitives (response envelopes, Populated, media)
+export * from './contracts';
+
+// Hand-written types with no Strapi content type behind them
+export * from './manual';
+
+// Bracket shape — shared by the backend generator and Storybook fixtures
+export * from './bracket';
+
+// Game/platform/account catalogue — the game -> platform -> account chain,
+// applied identically by the backend resolver and the client's pickers
+export * from './gameCatalogue';
+
+// Data
+export * from './data/countriesList';
+export * from './data/gameGenres';