Why isn't this typescript type working?

export type GameModel<T extends boolean = false> = {
  id: string;
} & (T extends true ? { scoreToWin: number } : Record<never, never>);

const a: GameModel = {
  id: 'a',
  scoreToWin: 1, //this errors correctly
}

export type GameModel<T extends boolean = false> = {
  id: string;
} & (T extends true ? { scoreToWin: number } : Record<never, never>);

const a: GameModel = {
  id: 'a',
  scoreToWin: 1, //this errors correctly
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    // <---------------------------------
    // This is now an error because i used the type used to just be 'scoreToWin?: number'
    // but now its correctly checking against TScoring. But I can't test if TScoring is
    // NumericScoreSystem at runtime. I could add discriminators all over the place, but
    // that seems like it would be a crazy number of discriminators given my type heirarchy.
    // Is there a better way to do this?
    game.scoreToWin = round.scoreToWin;

    /* add the game name based on the bracket ID, round number, and incrementing ID */
    //...
  }
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    // <---------------------------------
    // This is now an error because i used the type used to just be 'scoreToWin?: number'
    // but now its correctly checking against TScoring. But I can't test if TScoring is
    // NumericScoreSystem at runtime. I could add discriminators all over the place, but
    // that seems like it would be a crazy number of discriminators given my type heirarchy.
    // Is there a better way to do this?
    game.scoreToWin = round.scoreToWin;

    /* add the game name based on the bracket ID, round number, and incrementing ID */
    //...
  }
}

function checkScoreProgress(tournament: TournamentModel, game: GameModel): GameProgressInfo {
  /*
   * Check that the game is progressable. Some functions that
   * call this are simply looping through a list of game slots
   * that have been updated. This check prevents us from redoing
   * work and ensures we dont double-count wins.
   */
  if (!gameUtils.isActionableState(game.state)) return { advancements: [], gameDone: false };

  /* check for loss conditions */
  for (let i = 0; i < game.slots.length; i++) {
    const slot = game.slots[i];
    const opponentSlot = game.slots[(i + 1) % 2];
    const player = tournamentUtils.getPlayerByID(tournament, slot.playerID!)!;

    if (
      gameSlotUtils.isBye(slot) ||
      (player.isDisqualified && !gameSlotUtils.isBye(opponentSlot)) ||
      scoreUtils.scoreIsLoss(slot.score)
    ) {
      /* for lose conditions we assign a winner without awarding wins / losses */
      slot.isWinner = false;
      opponentSlot.isWinner = true;
      game.state = GameState.DONE;
      if (player.isDisqualified) slot.score = "DQ";

      /* perform special case handling if this is grand finals */
      if (tournamentUtils.isDoubleElim(tournament) && game.id === "W-GF") {
        checkGrandFinals(tournament, game);
      }

      const advancements = [];
      if (game.nextGameSlotIDs?.[0]) {
        advancements.push({
          playerID: opponentSlot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[0],
        });
      }
      if (game.nextGameSlotIDs?.[1]) {
        advancements.push({
          playerID: slot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[1],
        });
      }
      return { advancements, gameDone: true };
    }
  }

  /* check for win conditions */
  for (let i = 0; i < game.slots.length; i++) {
    const slot = game.slots[i];
    const opponentSlot = game.slots[(i + 1) % 2];

    if (typeof slot.score === "number" && slot.score >= game.scoreToWin) { // <---------this is an error now
      /* assign the winner and increment win / loss records */
      slot.isWinner = true;
      opponentSlot.isWinner = false;
      game.state = GameState.DONE;

      /* perform special case handling if this is grand finals */
      if (tournamentUtils.isDoubleElim(tournament) && game.id === "W-GF")
        checkGrandFinals(tournament, game);

      /* Exhibition games don't count towards wins / losses */
      if (!gameUtils.isExhibition(game)) {
        if (slot.playerID) {
          const player = tournamentUtils.getPlayerByID(tournament, slot.playerID)!;
          player.wins++;
        }
        opponentSlot.isWinner = false;
        if (opponentSlot.playerID) {
          const opponent = tournamentUtils.getPlayerByID(tournament, opponentSlot.playerID)!;
          opponent.losses++;
        }
      }

      const advancements = [];
      if (game.nextGameSlotIDs?.[0]) {
        advancements.push({
          playerID: slot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[0],
        });
      }
      if (game.nextGameSlotIDs?.[1]) {
        advancements.push({
          playerID: opponentSlot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[1],
        });
      }
      return { advancements, gameDone: true };
    }
  }

  return { advancements: [], gameDone: false };
}

function checkScoreProgress(tournament: TournamentModel, game: GameModel): GameProgressInfo {
  /*
   * Check that the game is progressable. Some functions that
   * call this are simply looping through a list of game slots
   * that have been updated. This check prevents us from redoing
   * work and ensures we dont double-count wins.
   */
  if (!gameUtils.isActionableState(game.state)) return { advancements: [], gameDone: false };

  /* check for loss conditions */
  for (let i = 0; i < game.slots.length; i++) {
    const slot = game.slots[i];
    const opponentSlot = game.slots[(i + 1) % 2];
    const player = tournamentUtils.getPlayerByID(tournament, slot.playerID!)!;

    if (
      gameSlotUtils.isBye(slot) ||
      (player.isDisqualified && !gameSlotUtils.isBye(opponentSlot)) ||
      scoreUtils.scoreIsLoss(slot.score)
    ) {
      /* for lose conditions we assign a winner without awarding wins / losses */
      slot.isWinner = false;
      opponentSlot.isWinner = true;
      game.state = GameState.DONE;
      if (player.isDisqualified) slot.score = "DQ";

      /* perform special case handling if this is grand finals */
      if (tournamentUtils.isDoubleElim(tournament) && game.id === "W-GF") {
        checkGrandFinals(tournament, game);
      }

      const advancements = [];
      if (game.nextGameSlotIDs?.[0]) {
        advancements.push({
          playerID: opponentSlot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[0],
        });
      }
      if (game.nextGameSlotIDs?.[1]) {
        advancements.push({
          playerID: slot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[1],
        });
      }
      return { advancements, gameDone: true };
    }
  }

  /* check for win conditions */
  for (let i = 0; i < game.slots.length; i++) {
    const slot = game.slots[i];
    const opponentSlot = game.slots[(i + 1) % 2];

    if (typeof slot.score === "number" && slot.score >= game.scoreToWin) { // <---------this is an error now
      /* assign the winner and increment win / loss records */
      slot.isWinner = true;
      opponentSlot.isWinner = false;
      game.state = GameState.DONE;

      /* perform special case handling if this is grand finals */
      if (tournamentUtils.isDoubleElim(tournament) && game.id === "W-GF")
        checkGrandFinals(tournament, game);

      /* Exhibition games don't count towards wins / losses */
      if (!gameUtils.isExhibition(game)) {
        if (slot.playerID) {
          const player = tournamentUtils.getPlayerByID(tournament, slot.playerID)!;
          player.wins++;
        }
        opponentSlot.isWinner = false;
        if (opponentSlot.playerID) {
          const opponent = tournamentUtils.getPlayerByID(tournament, opponentSlot.playerID)!;
          opponent.losses++;
        }
      }

      const advancements = [];
      if (game.nextGameSlotIDs?.[0]) {
        advancements.push({
          playerID: slot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[0],
        });
      }
      if (game.nextGameSlotIDs?.[1]) {
        advancements.push({
          playerID: opponentSlot.playerID!,
          nextGameSlotID: game.nextGameSlotIDs[1],
        });
      }
      return { advancements, gameDone: true };
    }
  }

  return { advancements: [], gameDone: false };
}

export type GameModel<TScoring extends ScoreSystem = ScoreSystem> = {
  id: string;
  name: string;
  round: number;
  slots: GameSlotModel<TScoring>[];
  state: GameState;
  activeSince: number | null;
  availableSince: number | null;
  calledSince: number | null;
  endTime: number | null;
  nextGameSlotIDs: string[] | null;
  locationID: string | null;
  loserPlacement: number | null;
} & (TScoring extends NumericScoreSystem ? { scoreToWin: number } : Record<never, never>);

export type GameModel<TScoring extends ScoreSystem = ScoreSystem> = {
  id: string;
  name: string;
  round: number;
  slots: GameSlotModel<TScoring>[];
  state: GameState;
  activeSince: number | null;
  availableSince: number | null;
  calledSince: number | null;
  endTime: number | null;
  nextGameSlotIDs: string[] | null;
  locationID: string | null;
  loserPlacement: number | null;
} & (TScoring extends NumericScoreSystem ? { scoreToWin: number } : Record<never, never>);

type TournamentModelImpl<
  TScoring extends ScoreSystem,
  TFormat extends FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring>
> = TournamentModelFields & {
  format: TFormat;
  formatOptions: TFormatOpts;
  games: GameModel<TScoring>[];
};

export type AnnotatedSingleElimTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  SingleElimModel<AnnotatedScoreSystem>,
  SingleElimOptionsModel<AnnotatedScoreSystem>
>;
export type AnnotatedDoubleElimTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  DoubleElimModel<AnnotatedScoreSystem>,
  DoubleElimOptionsModel<AnnotatedScoreSystem>
>;
export type AnnotatedBracketedTournamentModel =
  | AnnotatedSingleElimTournamentModel
  | AnnotatedDoubleElimTournamentModel;
export type AnnotatedRoundRobinTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  RoundRobinModel<AnnotatedScoreSystem>,
  RoundRobinOptionsModel<AnnotatedScoreSystem>
>;

export type NumericSingleElimTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  SingleElimModel<NumericScoreSystem>,
  SingleElimOptionsModel<NumericScoreSystem>
>;
export type NumericDoubleElimTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  DoubleElimModel<NumericScoreSystem>,
  DoubleElimOptionsModel<NumericScoreSystem>
>;
export type NumericBracketedTournamentModel =
  | NumericSingleElimTournamentModel
  | NumericDoubleElimTournamentModel;
export type NumericRoundRobinTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  RoundRobinModel<NumericScoreSystem>,
  RoundRobinOptionsModel<NumericScoreSystem>
>;

export type NumericTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  FormatModel<NumericScoreSystem>,
  FormatOptionsModel<NumericScoreSystem>
>;

export type AnnotatedTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  FormatModel<AnnotatedScoreSystem>,
  FormatOptionsModel<AnnotatedScoreSystem>
>;

export type SingleElimTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  SingleElimModel<TScoring>,
  SingleElimOptionsModel<TScoring>
>;
export type DoubleElimTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  DoubleElimModel<TScoring>,
  DoubleElimOptionsModel<TScoring>
>;
export type RoundRobinTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  RoundRobinModel<TScoring>,
  RoundRobinOptionsModel<TScoring>
>;

export type BracketedTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  BracketedFormatModel<TScoring>,
  BracketedFormatOptionsModel<TScoring>
>;

export type TournamentModel<
  TScoring extends ScoreSystem = ScoreSystem,
  TFormat extends FormatModel<TScoring> = FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring> = FormatOptionsModel<TScoring>
> = TournamentModelImpl<TScoring, TFormat, TFormatOpts>;

type TournamentModelImpl<
  TScoring extends ScoreSystem,
  TFormat extends FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring>
> = TournamentModelFields & {
  format: TFormat;
  formatOptions: TFormatOpts;
  games: GameModel<TScoring>[];
};

export type AnnotatedSingleElimTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  SingleElimModel<AnnotatedScoreSystem>,
  SingleElimOptionsModel<AnnotatedScoreSystem>
>;
export type AnnotatedDoubleElimTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  DoubleElimModel<AnnotatedScoreSystem>,
  DoubleElimOptionsModel<AnnotatedScoreSystem>
>;
export type AnnotatedBracketedTournamentModel =
  | AnnotatedSingleElimTournamentModel
  | AnnotatedDoubleElimTournamentModel;
export type AnnotatedRoundRobinTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  RoundRobinModel<AnnotatedScoreSystem>,
  RoundRobinOptionsModel<AnnotatedScoreSystem>
>;

export type NumericSingleElimTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  SingleElimModel<NumericScoreSystem>,
  SingleElimOptionsModel<NumericScoreSystem>
>;
export type NumericDoubleElimTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  DoubleElimModel<NumericScoreSystem>,
  DoubleElimOptionsModel<NumericScoreSystem>
>;
export type NumericBracketedTournamentModel =
  | NumericSingleElimTournamentModel
  | NumericDoubleElimTournamentModel;
export type NumericRoundRobinTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  RoundRobinModel<NumericScoreSystem>,
  RoundRobinOptionsModel<NumericScoreSystem>
>;

export type NumericTournamentModel = TournamentModelImpl<
  NumericScoreSystem,
  FormatModel<NumericScoreSystem>,
  FormatOptionsModel<NumericScoreSystem>
>;

export type AnnotatedTournamentModel = TournamentModelImpl<
  AnnotatedScoreSystem,
  FormatModel<AnnotatedScoreSystem>,
  FormatOptionsModel<AnnotatedScoreSystem>
>;

export type SingleElimTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  SingleElimModel<TScoring>,
  SingleElimOptionsModel<TScoring>
>;
export type DoubleElimTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  DoubleElimModel<TScoring>,
  DoubleElimOptionsModel<TScoring>
>;
export type RoundRobinTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  RoundRobinModel<TScoring>,
  RoundRobinOptionsModel<TScoring>
>;

export type BracketedTournamentModel<TScoring extends ScoreSystem> = TournamentModelImpl<
  TScoring,
  BracketedFormatModel<TScoring>,
  BracketedFormatOptionsModel<TScoring>
>;

export type TournamentModel<
  TScoring extends ScoreSystem = ScoreSystem,
  TFormat extends FormatModel<TScoring> = FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring> = FormatOptionsModel<TScoring>
> = TournamentModelImpl<TScoring, TFormat, TFormatOpts>;

export type GameSlotModel<TScoring extends ScoreSystem = ScoreSystem> = {
  gameID: string;
  slotIdx: number;
  playerID: string | null;
  checkInTime: number | null;
  waitingTime: number | null;
  prevGameID: string | null;
  score: TScoring extends NumericScoreSystem ? NumericScore : AnnotatedScore;
  isWinner: boolean;
};

export type GameSlotModel<TScoring extends ScoreSystem = ScoreSystem> = {
  gameID: string;
  slotIdx: number;
  playerID: string | null;
  checkInTime: number | null;
  waitingTime: number | null;
  prevGameID: string | null;
  score: TScoring extends NumericScoreSystem ? NumericScore : AnnotatedScore;
  isWinner: boolean;
};

type TournamentModelImpl<
  TScoring extends ScoreSystem,
  TFormat extends FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring>
> = TournamentModelFields & {
  format: TFormat;
  formatOptions: TFormatOpts;
  games: GameModel<TScoring>[];
};

type TournamentModelImpl<
  TScoring extends ScoreSystem,
  TFormat extends FormatModel<TScoring>,
  TFormatOpts extends FormatOptionsModel<TScoring>
> = TournamentModelFields & {
  format: TFormat;
  formatOptions: TFormatOpts;
  games: GameModel<TScoring>[];
};

type TournamentModelFields = {
  id: string;
}

type TournamentModelFields = {
  id: string;
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    // <---------------------------------
    // This is now an error because i used the type used to just be 'scoreToWin?: number'
    // but now its correctly checking against TScoring. But I can't test if TScoring is
    // NumericScoreSystem at runtime. I could add discriminators all over the place, but
    // that seems like it would be a crazy number of discriminators given my type heirarchy.
    // Is there a better way to do this?
    game.scoreToWin = round.scoreToWin;

    /* add the game name based on the bracket ID, round number, and incrementing ID */
    //...
  }
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    // <---------------------------------
    // This is now an error because i used the type used to just be 'scoreToWin?: number'
    // but now its correctly checking against TScoring. But I can't test if TScoring is
    // NumericScoreSystem at runtime. I could add discriminators all over the place, but
    // that seems like it would be a crazy number of discriminators given my type heirarchy.
    // Is there a better way to do this?
    game.scoreToWin = round.scoreToWin;

    /* add the game name based on the bracket ID, round number, and incrementing ID */
    //...
  }
}

export type RoundModel<TScoring extends ScoreSystem> = {
  idx: number;
  bracketID: string;
  name: string;
} & (TScoring extends NumericScoreSystem ? { scoreToWin: number } : Record<never, never>);

export type RoundModel<TScoring extends ScoreSystem> = {
  idx: number;
  bracketID: string;
  name: string;
} & (TScoring extends NumericScoreSystem ? { scoreToWin: number } : Record<never, never>);

const zRoundModel = z.object({
  idx: z.number(),
  bracketId: z.string(),
  name: z.string(),
  scoreToWin: z.number().optional()
})

const zRoundModel = z.object({
  idx: z.number(),
  bracketId: z.string(),
  name: z.string(),
  scoreToWin: z.number().optional()
})

export type RoundModel = {
  idx: number;
  bracketID: string;
  name: string;
  scoreToWin?: number
}

export type RoundModel = {
  idx: number;
  bracketID: string;
  name: string;
  scoreToWin?: number
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    game.scoreToWin = round.scoreToWin; //<----------- I still dont know how to make this work

   ...
  }
}

function applyBracketMetadata<TScoring extends ScoreSystem>(
  bracket: BracketModel<TScoring>,
  games: GameModel<TScoring>[]
) {
  let currentHumanGameID = 0;

  for (let i = 0; i < games.length; i++) {
    const game = games[i];
    const round = bracket.rounds[game.round];

    /* add score to win based on the round */
    game.scoreToWin = round.scoreToWin; //<----------- I still dont know how to make this work

   ...
  }
}

export type TournamentUnion =
  | (TournamentFields & {
      scoreSystem: "numeric";
      format: NumericFormat;
      games: NumericGame[];
    })
  | {
      scoreSystem: "annotated";
      format: AnnotatedFormat;
      games: AnnotatedGame[];
    };

export type TournamentUnion =
  | (TournamentFields & {
      scoreSystem: "numeric";
      format: NumericFormat;
      games: NumericGame[];
    })
  | {
      scoreSystem: "annotated";
      format: AnnotatedFormat;
      games: AnnotatedGame[];
    };

interface BaseBracket {
  type: "anon_bracket" | "named_bracket";
  id: string;
  rounds: Round[];
  userOptions: RoundOptions[];
}

interface BaseBracket {
  type: "anon_bracket" | "named_bracket";
  id: string;
  rounds: Round[];
  userOptions: RoundOptions[];
}

interface BaseBracket {
  type: "anon_bracket" | "named_bracket";
  id: string;
  rounds: AnnotatedRound[] | NumericRound[];
  userOptions: AnnotatedRoundOptions[] | NumericRoundOptions[];
}

interface BaseBracket {
  type: "anon_bracket" | "named_bracket";
  id: string;
  rounds: AnnotatedRound[] | NumericRound[];
  userOptions: AnnotatedRoundOptions[] | NumericRoundOptions[];
}

import { z } from "zod"

export const annotatedRoundSchema = z.object({
  scoreSystem: z.literal("annotated"),
  idx: z.number(),
  bracketID: z.string(),
  name: z.string()
})

export const numericRoundSchema = z.object({
  scoreSystem: z.literal("numeric"),
  idx: z.number(),
  bracketID: z.string(),
  name: z.string(),
  scoreToWin: z.number()
})

export const annotatedRoundOptionsSchema = z.object({
  scoreSystem: z.literal("annotated"),
  name: z.string()
})

export const numericRoundOptionsSchema = z.object({
  scoreSystem: z.literal("numeric"),
  name: z.string(),
  scoreToWin: z.number()
})

const baseBracketSchema = z.object({
  type: z.union([z.literal("anon_bracket"), z.literal("named_bracket")]),
  id: z.string(),
  rounds: z.union([z.array(annotatedRoundSchema), z.array(numericRoundSchema)]),
  userOptions: z.union([
    z.array(annotatedRoundOptionsSchema),
    z.array(numericRoundOptionsSchema)
  ])
})

export const anonBracketSchema = baseBracketSchema.extend({
  type: z.literal("anon_bracket")
})

export const namedBracketSchema = baseBracketSchema.extend({
  type: z.literal("named_bracket"),
  name: z.string()
})

export const roundSchema = z.union([annotatedRoundSchema, numericRoundSchema])

export const roundOptionsSchema = z.union([
  annotatedRoundOptionsSchema,
  numericRoundOptionsSchema
])

export const bracketSchema = z.union([anonBracketSchema, namedBracketSchema])