xpt-shared-types 1.3.1 → 1.4.1

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

@@ -14,6 +14,8 @@ export type MatchRound = "Round 128" | "Round 64" | "Round 32" | "Round 16" | "Q
 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, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, MatchLobbyStatus, 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;
@@ -48,6 +48,8 @@ export interface GameInput {
     user_game_stats?: RelationInput | RelationInput[];
     team_game_stats?: RelationInput | RelationInput[];
     imgMainPosition?: string;
+    platforms?: RelationInput | RelationInput[];
+    game_accounts?: RelationInput | RelationInput[];
 }
 /** Write payload for `game-account`. */
 export interface GameAccountInput {
@@ -55,6 +57,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 {
@@ -148,7 +152,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, GameRequestCustomLobbies, GameRequestGenre, GameRequestTeamPlay, MatchLobbyStatus, 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;
@@ -48,6 +48,8 @@ export interface Game extends StrapiDocument {
     user_game_stats?: UserGameStat[];
     team_game_stats?: TeamGameStat[];
     imgMainPosition?: string | null;
+    platforms?: Platform[];
+    game_accounts?: GameAccount[];
 }
 /** `game-account` */
 export interface GameAccount extends StrapiDocument {
@@ -55,6 +57,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 {
@@ -148,7 +152,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,5 @@ export * from './generated';
 export * from './contracts';
 export * from './manual';
 export * from './bracket';
+export * from './gameCatalogue';
 export * from './data/countriesList';

package/dist/index.js

@@ -22,5 +22,8 @@ __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);

package/package.json

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

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

@@ -64,6 +64,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

@@ -16,6 +16,7 @@ import type {
   MatchRound,
   MatchStreamPlatform,
   MatchWinnerSlot,
+  PlatformCode,
   ReferralStatus,
   TeamCurrentStatus,
   TeamInviteStatus,
@@ -85,6 +86,8 @@ export interface GameInput {
   user_game_stats?: RelationInput | RelationInput[];
   team_game_stats?: RelationInput | RelationInput[];
   imgMainPosition?: string;
+  platforms?: RelationInput | RelationInput[];
+  game_accounts?: RelationInput | RelationInput[];
 }
 
 /** Write payload for `game-account`. */
@@ -93,6 +96,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`. */
@@ -194,7 +199,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

@@ -17,6 +17,7 @@ import type {
   MatchRound,
   MatchStreamPlatform,
   MatchWinnerSlot,
+  PlatformCode,
   ReferralStatus,
   TeamCurrentStatus,
   TeamInviteStatus,
@@ -86,6 +87,8 @@ export interface Game extends StrapiDocument {
   user_game_stats?: UserGameStat[];
   team_game_stats?: TeamGameStat[];
   imgMainPosition?: string | null;
+  platforms?: Platform[];
+  game_accounts?: GameAccount[];
 }
 
 /** `game-account` */
@@ -94,6 +97,8 @@ export interface GameAccount extends StrapiDocument {
   tournaments?: Tournament[];
   user_game_accounts?: UserGameAccount[];
   imgThumb?: StrapiMedia | null;
+  games?: Game[];
+  platforms?: Platform[];
 }
 
 /** `game-request` */
@@ -195,7 +200,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,18 @@
-// 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';