diff --git a/app/components/sport-season/RegularSeasonStandings.tsx b/app/components/sport-season/RegularSeasonStandings.tsx
index 202c136..8bd5b4d 100644
--- a/app/components/sport-season/RegularSeasonStandings.tsx
+++ b/app/components/sport-season/RegularSeasonStandings.tsx
@@ -14,6 +14,11 @@ interface StandingRow {
   wins: number;
   losses: number;
   otLosses: number | null;
+  ties?: number | null;
+  tablePoints?: number | null;
+  goalsFor?: number | null;
+  goalsAgainst?: number | null;
+  goalDifference?: number | null;
   winPct: string | null;
   gamesPlayed: number;
   gamesBack: string | null;
@@ -41,6 +46,7 @@ interface Props {
   teamOwnerships: Record<string, TeamOwnership>;
   userParticipantIds: string[];
   showOtLosses?: boolean;
+  showSoccerTable?: boolean;
   /** How many teams per conference qualify for playoffs (flat mode only). 0 = no line. */
   playoffSpots?: number;
   /** "flat" = single ranked list per conference (NBA). "nhl-divisions" = div top-3 + wild card. "mlb-divisions" = same structure with 3 WC spots, uses "League" label. */
@@ -222,15 +228,18 @@ function StandingsTable({
   teamOwnerships,
   userParticipantIds,
   showOtLosses,
+  showSoccerTable = false,
 }: {
   sections: TableSection[];
   teamOwnerships: Record<string, TeamOwnership>;
   userParticipantIds: string[];
   showOtLosses: boolean;
+  showSoccerTable?: boolean;
 }) {
   // # Team GP W L [OTL] [PTS] PCT GB L10 STK Mgr
-  // OTL and PTS are both shown for hockey (showOtLosses = true)
-  const totalCols = 10 + (showOtLosses ? 2 : 0);
+  // OTL and PTS are both shown for hockey (showOtLosses = true).
+  // Soccer table mode shows D/GF/GA/GD/Pts instead of PCT/GB/form columns.
+  const totalCols = showSoccerTable ? 11 : 10 + (showOtLosses ? 2 : 0);
 
   return (
     <div className="overflow-x-auto -mx-6 px-6">
@@ -241,13 +250,18 @@ function StandingsTable({
             <th className="text-left py-1.5">Team</th>
             <th className="text-right py-1.5 px-2 w-10">GP</th>
             <th className="text-right py-1.5 px-2 w-8">W</th>
+            {showSoccerTable && <th className="text-right py-1.5 px-2 w-8">D</th>}
             <th className="text-right py-1.5 px-2 w-8">L</th>
+            {showSoccerTable && <th className="text-right py-1.5 px-2 w-10">GF</th>}
+            {showSoccerTable && <th className="text-right py-1.5 px-2 w-10">GA</th>}
+            {showSoccerTable && <th className="text-right py-1.5 px-2 w-10">GD</th>}
+            {showSoccerTable && <th className="text-right py-1.5 px-2 w-10">PTS</th>}
             {showOtLosses && <th className="text-right py-1.5 px-2 w-10">OTL</th>}
             {showOtLosses && <th className="text-right py-1.5 px-2 w-10">PTS</th>}
-            <th className="text-right py-1.5 px-2 w-12">PCT</th>
-            <th className="text-right py-1.5 px-2 w-10">GB</th>
-            <th className="text-right py-1.5 px-2 w-12">L10</th>
-            <th className="text-right py-1.5 px-2 w-12">STK</th>
+            {!showSoccerTable && <th className="text-right py-1.5 px-2 w-12">PCT</th>}
+            {!showSoccerTable && <th className="text-right py-1.5 px-2 w-10">GB</th>}
+            {!showSoccerTable && <th className="text-right py-1.5 px-2 w-12">L10</th>}
+            {!showSoccerTable && <th className="text-right py-1.5 px-2 w-12">STK</th>}
             <th className="text-right py-1.5 pl-4 w-40">Mgr</th>
           </tr>
         </thead>
@@ -316,7 +330,22 @@ function StandingsTable({
                     {row.gamesPlayed}
                   </td>
                   <td className="py-2 px-2 text-right tabular-nums font-medium">{row.wins}</td>
+                  {showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums">{row.ties ?? 0}</td>
+                  )}
                   <td className="py-2 px-2 text-right tabular-nums">{row.losses}</td>
+                  {showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">{row.goalsFor ?? "—"}</td>
+                  )}
+                  {showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">{row.goalsAgainst ?? "—"}</td>
+                  )}
+                  {showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">{row.goalDifference ?? "—"}</td>
+                  )}
+                  {showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums font-medium">{row.tablePoints ?? row.wins * 3 + (row.ties ?? 0)}</td>
+                  )}
                   {showOtLosses && (
                     <td className="py-2 px-2 text-right tabular-nums">{row.otLosses ?? 0}</td>
                   )}
@@ -325,30 +354,38 @@ function StandingsTable({
                       {row.wins * 2 + (row.otLosses ?? 0)}
                     </td>
                   )}
-                  <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
-                    {formatWinPct(row.winPct, row.wins, row.gamesPlayed)}
-                  </td>
-                  <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
-                    {formatGB(row.gamesBack)}
-                  </td>
-                  <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
-                    {row.lastTen ?? "—"}
-                  </td>
-                  <td className="py-2 px-2 text-right tabular-nums">
-                    {row.streak ? (
-                      <span
-                        className={
-                          row.streak.startsWith("W")
-                            ? "text-emerald-500"
-                            : "text-destructive/80"
-                        }
-                      >
-                        {row.streak}
-                      </span>
-                    ) : (
-                      <span className="text-muted-foreground">—</span>
-                    )}
-                  </td>
+                  {!showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
+                      {formatWinPct(row.winPct, row.wins, row.gamesPlayed)}
+                    </td>
+                  )}
+                  {!showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
+                      {formatGB(row.gamesBack)}
+                    </td>
+                  )}
+                  {!showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums text-muted-foreground">
+                      {row.lastTen ?? "—"}
+                    </td>
+                  )}
+                  {!showSoccerTable && (
+                    <td className="py-2 px-2 text-right tabular-nums">
+                      {row.streak ? (
+                        <span
+                          className={
+                            row.streak.startsWith("W")
+                              ? "text-emerald-500"
+                              : "text-destructive/80"
+                          }
+                        >
+                          {row.streak}
+                        </span>
+                      ) : (
+                        <span className="text-muted-foreground">—</span>
+                      )}
+                    </td>
+                  )}
                   <td className="py-2 pl-4 text-right">
                     {ownership ? (
                       <div className="flex justify-end">
@@ -381,6 +418,7 @@ export function RegularSeasonStandings({
   teamOwnerships,
   userParticipantIds,
   showOtLosses = false,
+  showSoccerTable = false,
   playoffSpots = 8,
   displayMode = "flat",
 }: Props) {
@@ -399,7 +437,7 @@ export function RegularSeasonStandings({
       ? buildMlbSections(standings)
       : buildFlatSections(standings, playoffSpots);
 
-  const tableProps = { teamOwnerships, userParticipantIds, showOtLosses };
+  const tableProps = { teamOwnerships, userParticipantIds, showOtLosses, showSoccerTable };
 
   return (
     <Card>
diff --git a/app/components/sport-season/__tests__/RegularSeasonStandings.test.tsx b/app/components/sport-season/__tests__/RegularSeasonStandings.test.tsx
index cdc325c..4d9e681 100644
--- a/app/components/sport-season/__tests__/RegularSeasonStandings.test.tsx
+++ b/app/components/sport-season/__tests__/RegularSeasonStandings.test.tsx
@@ -8,6 +8,11 @@ function makeRow(overrides: Partial<{
   wins: number;
   losses: number;
   otLosses: number | null;
+  ties: number | null;
+  tablePoints: number | null;
+  goalsFor: number | null;
+  goalsAgainst: number | null;
+  goalDifference: number | null;
   gamesPlayed: number;
   winPct: string | null;
   gamesBack: string | null;
@@ -29,6 +34,11 @@ function makeRow(overrides: Partial<{
     wins: overrides.wins ?? 40,
     losses: overrides.losses ?? 28,
     otLosses: overrides.otLosses ?? null,
+    ties: overrides.ties ?? null,
+    tablePoints: overrides.tablePoints ?? null,
+    goalsFor: overrides.goalsFor ?? null,
+    goalsAgainst: overrides.goalsAgainst ?? null,
+    goalDifference: overrides.goalDifference ?? null,
     gamesPlayed: overrides.gamesPlayed ?? 68,
     winPct: overrides.winPct ?? "0.5882",
     gamesBack: overrides.gamesBack ?? null,
@@ -99,6 +109,38 @@ describe("RegularSeasonStandings", () => {
     expect(screen.queryByText("OTL")).not.toBeInTheDocument();
   });
 
+
+  it("shows soccer table columns when showSoccerTable=true", () => {
+    render(
+      <RegularSeasonStandings
+        standings={[
+          makeRow({
+            participant: { id: "p-1", name: "Arsenal" },
+            gamesPlayed: 30,
+            wins: 21,
+            ties: 6,
+            losses: 3,
+            goalsFor: 72,
+            goalsAgainst: 25,
+            goalDifference: 47,
+            tablePoints: 69,
+          }),
+        ]}
+        teamOwnerships={NO_OWNERSHIPS}
+        userParticipantIds={NO_USER_IDS}
+        showSoccerTable={true}
+      />
+    );
+
+    expect(screen.getByText("D")).toBeInTheDocument();
+    expect(screen.getByText("GF")).toBeInTheDocument();
+    expect(screen.getByText("GA")).toBeInTheDocument();
+    expect(screen.getByText("GD")).toBeInTheDocument();
+    expect(screen.getByText("PTS")).toBeInTheDocument();
+    expect(screen.getByText("Arsenal")).toBeInTheDocument();
+    expect(screen.getByText("69")).toBeInTheDocument();
+  });
+
   it("renders conference headings and inline division labels when present", () => {
     render(
       <RegularSeasonStandings
diff --git a/app/models/regular-season-standings.ts b/app/models/regular-season-standings.ts
index 9dbf8f7..bdc8358 100644
--- a/app/models/regular-season-standings.ts
+++ b/app/models/regular-season-standings.ts
@@ -9,6 +9,10 @@ export interface UpsertRegularSeasonStandingData {
   losses: number;
   otLosses?: number | null;
   ties?: number | null;
+  tablePoints?: number | null;
+  goalsFor?: number | null;
+  goalsAgainst?: number | null;
+  goalDifference?: number | null;
   winPct?: number | null;
   gamesPlayed: number;
   gamesBack?: number | null;
@@ -47,6 +51,10 @@ export async function upsertRegularSeasonStandings(
     losses: r.losses,
     otLosses: r.otLosses ?? null,
     ties: r.ties ?? null,
+    tablePoints: r.tablePoints ?? null,
+    goalsFor: r.goalsFor ?? null,
+    goalsAgainst: r.goalsAgainst ?? null,
+    goalDifference: r.goalDifference ?? null,
     winPct: r.winPct !== null && r.winPct !== undefined ? r.winPct.toString() : null,
     gamesPlayed: r.gamesPlayed,
     gamesBack: r.gamesBack !== null && r.gamesBack !== undefined ? r.gamesBack.toString() : null,
@@ -79,6 +87,10 @@ export async function upsertRegularSeasonStandings(
           losses: sql`excluded.losses`,
           otLosses: sql`excluded.ot_losses`,
           ties: sql`excluded.ties`,
+          tablePoints: sql`excluded.table_points`,
+          goalsFor: sql`excluded.goals_for`,
+          goalsAgainst: sql`excluded.goals_against`,
+          goalDifference: sql`excluded.goal_difference`,
           winPct: sql`excluded.win_pct`,
           gamesPlayed: sql`excluded.games_played`,
           gamesBack: sql`excluded.games_back`,
diff --git a/app/routes/admin.sports-seasons.$id.elo-ratings.tsx b/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
index 8536efe..02fa134 100644
--- a/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
+++ b/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
@@ -32,7 +32,12 @@ import { useState } from 'react';
 import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
 import { normalizeName } from '~/lib/fuzzy-match';
 import { getSimulatorConfig, supportsProjectedWins } from '~/services/simulations/simulator-config';
-import { eloToProjectedWins, projectedWinsToElo } from '~/services/probability-engine';
+import {
+  eloToProjectedTablePoints,
+  eloToProjectedWins,
+  projectedTablePointsToElo,
+  projectedWinsToElo,
+} from '~/services/probability-engine';
 
 // Simulator types that use worldRanking in addition to sourceElo
 const RANKING_SIMULATOR_TYPES = new Set(['darts_bracket', 'cs2_major_qualifying_points']);
@@ -102,15 +107,18 @@ export async function action({ request, params }: Route.ActionArgs) {
   if (inputMode === 'projectedWins' && sportsSeason.sport?.simulatorType) {
     const config = getSimulatorConfig(sportsSeason.sport.simulatorType as SimulatorType);
     if (!config) {
-      return { success: false, message: 'This sport does not support projected wins input.' };
+      return { success: false, message: 'This sport does not support projection input.' };
     }
 
     for (const participant of participants) {
       const winsVal = formData.get(`wins_${participant.id}`) as string;
       if (winsVal && winsVal.trim() !== '') {
         const projectedWins = parseFloat(winsVal);
-        if (!isNaN(projectedWins) && projectedWins >= 0 && projectedWins <= config.seasonGames) {
-          const elo = projectedWinsToElo(projectedWins, config.seasonGames, config.parityFactor, config.averageOpponentElo);
+        const projectionMax = config.projectionInput === 'tablePoints' ? config.seasonGames * 3 : config.seasonGames;
+        if (!isNaN(projectedWins) && projectedWins >= 0 && projectedWins <= projectionMax) {
+          const elo = config.projectionInput === 'tablePoints'
+            ? projectedTablePointsToElo(projectedWins, config.seasonGames, config.parityFactor, config.averageOpponentElo)
+            : projectedWinsToElo(projectedWins, config.seasonGames, config.parityFactor, config.averageOpponentElo);
           eloInputs.push({ participantId: participant.id, sportsSeasonId, sourceElo: elo });
         }
       }
@@ -141,7 +149,7 @@ export async function action({ request, params }: Route.ActionArgs) {
 
   if (eloInputs.length === 0) {
     return { success: false, message: inputMode === 'projectedWins'
-      ? 'Please enter projected wins for at least one participant'
+      ? 'Please enter projections for at least one participant'
       : 'Please enter an Elo rating for at least one participant' };
   }
 
@@ -234,6 +242,13 @@ export default function AdminSportsSeasonEloRatings() {
   const navigation = useNavigation();
 
   const [inputMode, setInputMode] = useState<'elo' | 'projectedWins'>('elo');
+  const projectionLabel = simulatorConfig?.projectionInput === 'tablePoints' ? 'Projected Points' : 'Projected Wins';
+  const projectionUnit = simulatorConfig?.projectionInput === 'tablePoints' ? 'points' : 'wins';
+  const projectionMax = simulatorConfig
+    ? simulatorConfig.projectionInput === 'tablePoints'
+      ? simulatorConfig.seasonGames * 3
+      : simulatorConfig.seasonGames
+    : 0;
 
   const [eloValues, setEloValues] = useState<Record<string, string>>(() => {
     const initial: Record<string, string> = {};
@@ -259,8 +274,9 @@ export default function AdminSportsSeasonEloRatings() {
       participants.forEach(p => {
         const d = existingData[p.id];
         if (d?.elo !== null && d?.elo !== undefined) {
-          initial[p.id] = eloToProjectedWins(
-            d.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo
+          initial[p.id] = (simulatorConfig.projectionInput === 'tablePoints'
+            ? eloToProjectedTablePoints(d.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo)
+            : eloToProjectedWins(d.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo)
           ).toFixed(1);
         }
       });
@@ -311,9 +327,11 @@ export default function AdminSportsSeasonEloRatings() {
         const inputName = match[1].trim();
         const projectedWins = parseFloat(match[2]);
 
-        if (isNaN(projectedWins) || projectedWins < 0 || projectedWins > simulatorConfig.seasonGames) continue;
+        if (isNaN(projectedWins) || projectedWins < 0 || projectedWins > projectionMax) continue;
 
-        const elo = projectedWinsToElo(projectedWins, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo);
+        const elo = simulatorConfig.projectionInput === 'tablePoints'
+          ? projectedTablePointsToElo(projectedWins, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo)
+          : projectedWinsToElo(projectedWins, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo);
 
         const participant = findParticipantMatch(inputName);
         if (participant && !seen.has(participant.id)) {
@@ -356,8 +374,9 @@ export default function AdminSportsSeasonEloRatings() {
       newElos[m.participantId] = m.elo.toString();
       if (m.ranking !== null) newRanks[m.participantId] = m.ranking.toString();
       if (inputMode === 'projectedWins' && simulatorConfig) {
-        newWins[m.participantId] = eloToProjectedWins(
-          m.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo
+        newWins[m.participantId] = (simulatorConfig.projectionInput === 'tablePoints'
+          ? eloToProjectedTablePoints(m.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo)
+          : eloToProjectedWins(m.elo, simulatorConfig.seasonGames, simulatorConfig.parityFactor, simulatorConfig.averageOpponentElo)
         ).toFixed(1);
       }
     }
@@ -408,7 +427,7 @@ export default function AdminSportsSeasonEloRatings() {
             variant={inputMode === 'projectedWins' ? 'default' : 'outline'}
             onClick={() => setInputMode('projectedWins')}
           >
-            Projected Wins
+            {projectionLabel}
           </Button>
         </div>
       )}
@@ -420,8 +439,8 @@ export default function AdminSportsSeasonEloRatings() {
           <CardDescription>
             {inputMode === 'projectedWins' && simulatorConfig ? (
               <>
-                Paste projected season wins one per line. Format: <code>Team Name, 15.6</code>.
-                Wins are automatically converted to Elo ratings using {simulatorConfig.seasonGames} total games
+                Paste projected season {projectionUnit} one per line. Format: <code>Team Name, {simulatorConfig.projectionInput === 'tablePoints' ? '76.5' : '15.6'}</code>.
+                Projections are automatically converted to Elo ratings using {simulatorConfig.seasonGames} total games
                 and parity factor {simulatorConfig.parityFactor}. Names are fuzzy-matched to participants.
               </>
             ) : usesRanking ? (
@@ -442,7 +461,9 @@ export default function AdminSportsSeasonEloRatings() {
           <Textarea
             placeholder={
               inputMode === 'projectedWins'
-                ? `Team Name, 15.6\nTeam Name, 14.5\nTeam Name, 13.8`
+                ? simulatorConfig?.projectionInput === 'tablePoints'
+                  ? `Team Name, 76.5\nTeam Name, 68.0\nTeam Name, 54.5`
+                  : `Team Name, 15.6\nTeam Name, 14.5\nTeam Name, 13.8`
                 : usesRanking
                   ? simulatorType === 'cs2_major_qualifying_points'
                     ? `Natus Vincere, 1850, 1\nFaZe Clan, 1820, 2\nVitality, 1810, 3`
@@ -515,14 +536,14 @@ export default function AdminSportsSeasonEloRatings() {
           <CardHeader>
             <CardTitle>
               {inputMode === 'projectedWins'
-                ? `Projected Season Wins (out of ${simulatorConfig?.seasonGames ?? '?'})`
+                ? `${projectionLabel} (out of ${projectionMax || '?'})`
                 : usesRanking
                   ? `Player Elo & ${rankLabel}s`
                   : 'Player Elo Ratings'}
             </CardTitle>
             <CardDescription>
               {inputMode === 'projectedWins'
-                ? 'Enter each team\'s projected total season wins. Converted to Elo automatically. Saving will run the simulation and update expected values.'
+                ? `Enter each team's projected total season ${projectionUnit}. Converted to Elo automatically. Saving will run the simulation and update expected values.`
                 : usesRanking
                   ? `Enter each player's Elo and ${rankLabel}. Saving will automatically run the simulation and update expected values.`
                   : 'Enter each player\'s current Elo rating. Saving will automatically run the simulation and update expected values.'}
@@ -541,7 +562,7 @@ export default function AdminSportsSeasonEloRatings() {
               {inputMode === 'projectedWins' && (
                 <div className="grid grid-cols-[1fr_100px] gap-x-3 gap-y-1 items-center text-xs font-medium text-muted-foreground">
                   <span>Team</span>
-                  <span>Proj Wins</span>
+                  <span>{simulatorConfig?.projectionInput === 'tablePoints' ? 'Proj Pts' : 'Proj Wins'}</span>
                 </div>
               )}
               <div className="space-y-2">
@@ -557,7 +578,7 @@ export default function AdminSportsSeasonEloRatings() {
                           step="0.1"
                           id={`wins_${participant.id}`}
                           name={`wins_${participant.id}`}
-                          placeholder={`${(simulatorConfig.seasonGames / 2).toFixed(1)}`}
+                          placeholder={`${(projectionMax / 2).toFixed(1)}`}
                           value={winsValues[participant.id] ?? ''}
                           onChange={e =>
                             setWinsValues(prev => ({ ...prev, [participant.id]: e.target.value }))
@@ -625,8 +646,8 @@ export default function AdminSportsSeasonEloRatings() {
           <CardContent className="text-sm space-y-2">
             {inputMode === 'projectedWins' ? (
               <ol className="list-decimal list-inside space-y-2">
-                <li>Enter each team's projected total season wins</li>
-                <li>Wins are converted to Elo ratings using the inverse Elo formula</li>
+                <li>Enter each team's projected total season {projectionUnit}</li>
+                <li>Projections are converted to Elo ratings using the inverse Elo formula</li>
                 <li>Elo ratings are saved and the simulation runs automatically</li>
                 <li>Results: probability distributions across 1st–8th place buckets</li>
                 <li>Expected fantasy value is calculated per team</li>
@@ -648,8 +669,8 @@ export default function AdminSportsSeasonEloRatings() {
             )}
             {inputMode === 'projectedWins' && simulatorConfig && (
               <div className="mt-4 text-muted-foreground text-xs">
-                Conversion: Elo = {simulatorConfig.averageOpponentElo} &minus; {simulatorConfig.parityFactor} &times; log&#8321;&#8320;((1 &minus; winRate) / winRate),
-                where winRate = projectedWins / {simulatorConfig.seasonGames}.
+                Conversion: Elo = {simulatorConfig.averageOpponentElo} &minus; {simulatorConfig.parityFactor} &times; log&#8321;&#8320;((1 &minus; rate) / rate),
+                where rate = projection / {projectionMax}.
               </div>
             )}
           </CardContent>
diff --git a/app/routes/admin.sports-seasons.$id.regular-standings.tsx b/app/routes/admin.sports-seasons.$id.regular-standings.tsx
index 83e45ac..cc47060 100644
--- a/app/routes/admin.sports-seasons.$id.regular-standings.tsx
+++ b/app/routes/admin.sports-seasons.$id.regular-standings.tsx
@@ -35,7 +35,7 @@ export async function loader({ params }: Route.LoaderArgs) {
   );
 
   return {
-    sportsSeason: sportsSeason as typeof sportsSeason & { sport: { id: string; name: string; type: string } },
+    sportsSeason: sportsSeason as typeof sportsSeason & { sport: { id: string; name: string; type: string; simulatorType: string | null } },
     participants,
     standingsMap,
   };
@@ -44,13 +44,20 @@ export async function loader({ params }: Route.LoaderArgs) {
 export async function action({ request, params }: Route.ActionArgs) {
   const formData = await request.formData();
 
-  // Parse updates from form fields: wins_<id>, losses_<id>, otLosses_<id>, conference_<id>, division_<id>
+  // Parse updates from form fields: wins_<id>, losses_<id>, ties_<id>, otLosses_<id>, etc.
   const byId = new Map<
     string,
     {
       wins?: number;
       losses?: number;
       otLosses?: number | null;
+      ties?: number | null;
+      gamesPlayed?: number | null;
+      leagueRank?: number | null;
+      tablePoints?: number | null;
+      goalsFor?: number | null;
+      goalsAgainst?: number | null;
+      goalDifference?: number | null;
       conference?: string | null;
       division?: string | null;
     }
@@ -60,6 +67,13 @@ export async function action({ request, params }: Route.ActionArgs) {
     const winsMatch = key.match(/^wins_(.+)$/);
     const lossesMatch = key.match(/^losses_(.+)$/);
     const otMatch = key.match(/^otLosses_(.+)$/);
+    const tiesMatch = key.match(/^ties_(.+)$/);
+    const gpMatch = key.match(/^gamesPlayed_(.+)$/);
+    const rankMatch = key.match(/^leagueRank_(.+)$/);
+    const pointsMatch = key.match(/^tablePoints_(.+)$/);
+    const gfMatch = key.match(/^goalsFor_(.+)$/);
+    const gaMatch = key.match(/^goalsAgainst_(.+)$/);
+    const gdMatch = key.match(/^goalDifference_(.+)$/);
     const confMatch = key.match(/^conference_(.+)$/);
     const divMatch = key.match(/^division_(.+)$/);
 
@@ -75,6 +89,34 @@ export async function action({ request, params }: Route.ActionArgs) {
       const id = otMatch[1];
       const otLosses = value === "" ? null : parseInt(value as string, 10);
       byId.set(id, { ...byId.get(id), otLosses: isNaN(otLosses as number) ? null : otLosses });
+    } else if (tiesMatch) {
+      const id = tiesMatch[1];
+      const ties = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), ties: isNaN(ties as number) ? null : ties });
+    } else if (gpMatch) {
+      const id = gpMatch[1];
+      const gamesPlayed = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), gamesPlayed: isNaN(gamesPlayed as number) ? null : gamesPlayed });
+    } else if (rankMatch) {
+      const id = rankMatch[1];
+      const leagueRank = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), leagueRank: isNaN(leagueRank as number) ? null : leagueRank });
+    } else if (pointsMatch) {
+      const id = pointsMatch[1];
+      const tablePoints = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), tablePoints: isNaN(tablePoints as number) ? null : tablePoints });
+    } else if (gfMatch) {
+      const id = gfMatch[1];
+      const goalsFor = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), goalsFor: isNaN(goalsFor as number) ? null : goalsFor });
+    } else if (gaMatch) {
+      const id = gaMatch[1];
+      const goalsAgainst = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), goalsAgainst: isNaN(goalsAgainst as number) ? null : goalsAgainst });
+    } else if (gdMatch) {
+      const id = gdMatch[1];
+      const goalDifference = value === "" ? null : parseInt(value as string, 10);
+      byId.set(id, { ...byId.get(id), goalDifference: isNaN(goalDifference as number) ? null : goalDifference });
     } else if (confMatch) {
       const id = confMatch[1];
       byId.set(id, { ...byId.get(id), conference: (value as string).trim() || null });
@@ -89,14 +131,25 @@ export async function action({ request, params }: Route.ActionArgs) {
       if (data.wins === null && data.losses === null) continue;
       const wins = data.wins ?? 0;
       const losses = data.losses ?? 0;
-      const gamesPlayed = wins + losses + (data.otLosses ?? 0);
+      const ties = data.ties ?? 0;
+      const gamesPlayed = data.gamesPlayed ?? wins + losses + ties + (data.otLosses ?? 0);
       const winPct = gamesPlayed > 0 ? wins / gamesPlayed : 0;
+      const goalsFor = data.goalsFor ?? null;
+      const goalsAgainst = data.goalsAgainst ?? null;
+      const goalDifference = data.goalDifference ?? (goalsFor !== null && goalsAgainst !== null ? goalsFor - goalsAgainst : null);
+      const tablePoints = data.tablePoints ?? wins * 3 + ties;
 
       await upsertManualStanding(participantId, params.id, {
         wins,
         losses,
         otLosses: data.otLosses ?? null,
+        ties: data.ties ?? null,
+        tablePoints,
+        goalsFor,
+        goalsAgainst,
+        goalDifference,
         gamesPlayed,
+        leagueRank: data.leagueRank ?? null,
         winPct,
         conference: data.conference ?? null,
         division: data.division ?? null,
@@ -113,12 +166,16 @@ export default function ManageRegularStandings({ loaderData, actionData }: Route
   const { sportsSeason, participants, standingsMap } = loaderData;
   const isNhl = sportsSeason.sport?.name?.toLowerCase().includes("nhl") ||
     sportsSeason.sport?.name?.toLowerCase().includes("hockey");
+  const isEpl = sportsSeason.sport?.simulatorType === "epl_standings";
 
   // Sort participants: those with records first (by wins desc), then unrecorded
   const sorted = [...participants].toSorted((a, b) => {
     const recA = standingsMap[a.id];
     const recB = standingsMap[b.id];
-    if (recA && recB) return (recB.wins ?? 0) - (recA.wins ?? 0);
+    if (recA && recB) {
+      if (isEpl) return (recA.leagueRank ?? 999) - (recB.leagueRank ?? 999);
+      return (recB.wins ?? 0) - (recA.wins ?? 0);
+    }
     if (recA) return -1;
     if (recB) return 1;
     return a.name.localeCompare(b.name);
@@ -139,7 +196,7 @@ export default function ManageRegularStandings({ loaderData, actionData }: Route
             {sportsSeason.sport.name} — {sportsSeason.name}
           </p>
           <p className="text-sm text-muted-foreground mt-1">
-            Manually enter W/L records. These will be overwritten on the next auto-sync unless you use this page again afterward.
+            Manually enter current standings. These will be overwritten on the next auto-sync unless you use this page again afterward.
           </p>
         </div>
 
@@ -162,7 +219,9 @@ export default function ManageRegularStandings({ loaderData, actionData }: Route
                 W/L Records
               </CardTitle>
               <CardDescription>
-                Enter wins, losses{isNhl ? ", and OT losses" : ""} for each team. Conference and division are optional but improve the standings display.
+                {isEpl
+                  ? "Enter Premier League table rows. Points, GP, and GD are auto-derived if left blank."
+                  : <>Enter wins, losses{isNhl ? ", and OT losses" : ""} for each team. Conference and division are optional but improve the standings display.</>}
               </CardDescription>
             </CardHeader>
             <CardContent>
@@ -170,18 +229,58 @@ export default function ManageRegularStandings({ loaderData, actionData }: Route
                 <input type="hidden" name="_isNhl" value={isNhl ? "true" : "false"} />
 
                 <div className="space-y-1 mb-4">
-                  <div className={`grid gap-2 px-2 pb-1 text-xs font-medium text-muted-foreground uppercase tracking-wide border-b ${isNhl ? "grid-cols-[1fr_3.5rem_3.5rem_3.5rem_6rem_6rem]" : "grid-cols-[1fr_3.5rem_3.5rem_6rem_6rem]"}`}>
-                    <span>Team</span>
-                    <span>W</span>
-                    <span>L</span>
-                    {isNhl && <span>OTL</span>}
-                    <span>Conference</span>
-                    <span>Division</span>
-                  </div>
+                  {isEpl ? (
+                    <div className="grid grid-cols-[1fr_3rem_3rem_3rem_3rem_3rem_3rem_3rem_3rem_3rem] gap-2 px-2 pb-1 text-xs font-medium text-muted-foreground uppercase tracking-wide border-b">
+                      <span>Team</span>
+                      <span>Pos</span>
+                      <span>GP</span>
+                      <span>W</span>
+                      <span>D</span>
+                      <span>L</span>
+                      <span>GF</span>
+                      <span>GA</span>
+                      <span>GD</span>
+                      <span>Pts</span>
+                    </div>
+                  ) : (
+                    <div className={`grid gap-2 px-2 pb-1 text-xs font-medium text-muted-foreground uppercase tracking-wide border-b ${isNhl ? "grid-cols-[1fr_3.5rem_3.5rem_3.5rem_6rem_6rem]" : "grid-cols-[1fr_3.5rem_3.5rem_6rem_6rem]"}`}>
+                      <span>Team</span>
+                      <span>W</span>
+                      <span>L</span>
+                      {isNhl && <span>OTL</span>}
+                      <span>Conference</span>
+                      <span>Division</span>
+                    </div>
+                  )}
 
                   {sorted.map((participant) => {
                     const record = standingsMap[participant.id];
                     const isSynced = record && record.syncedAt !== null;
+                    if (isEpl) {
+                      return (
+                        <div
+                          key={participant.id}
+                          className="grid grid-cols-[1fr_3rem_3rem_3rem_3rem_3rem_3rem_3rem_3rem_3rem] gap-2 items-center px-2 py-1.5 rounded hover:bg-muted/40"
+                        >
+                          <span className="text-sm font-medium truncate flex items-center gap-1.5">
+                            {participant.name}
+                            {isSynced && (
+                              <span className="text-xs text-muted-foreground font-normal">(synced)</span>
+                            )}
+                          </span>
+                          <Input name={`leagueRank_${participant.id}`} type="number" min="1" defaultValue={record?.leagueRank ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`gamesPlayed_${participant.id}`} type="number" min="0" defaultValue={record?.gamesPlayed ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`wins_${participant.id}`} type="number" min="0" defaultValue={record?.wins ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`ties_${participant.id}`} type="number" min="0" defaultValue={record?.ties ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`losses_${participant.id}`} type="number" min="0" defaultValue={record?.losses ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`goalsFor_${participant.id}`} type="number" min="0" defaultValue={record?.goalsFor ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`goalsAgainst_${participant.id}`} type="number" min="0" defaultValue={record?.goalsAgainst ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`goalDifference_${participant.id}`} type="number" defaultValue={record?.goalDifference ?? ""} placeholder="—" className="h-8 text-sm" />
+                          <Input name={`tablePoints_${participant.id}`} type="number" min="0" defaultValue={record?.tablePoints ?? ""} placeholder="—" className="h-8 text-sm" />
+                        </div>
+                      );
+                    }
+
                     return (
                       <div
                         key={participant.id}
diff --git a/app/routes/leagues/$leagueId.sports-seasons.$sportsSeasonId.tsx b/app/routes/leagues/$leagueId.sports-seasons.$sportsSeasonId.tsx
index 0ee8ce7..93a32dd 100644
--- a/app/routes/leagues/$leagueId.sports-seasons.$sportsSeasonId.tsx
+++ b/app/routes/leagues/$leagueId.sports-seasons.$sportsSeasonId.tsx
@@ -115,6 +115,7 @@ export default function SportSeasonDetail({
       teamOwnerships={ownershipMap}
       userParticipantIds={userParticipantIds}
       showOtLosses={showOtLosses}
+      showSoccerTable={simulatorType === "epl_standings"}
       displayMode={standingsDisplayMode as "flat" | "nhl-divisions" | "mlb-divisions"}
       playoffSpots={playoffSpots}
     />
diff --git a/app/services/probability-engine.ts b/app/services/probability-engine.ts
index e7c7629..11008f2 100644
--- a/app/services/probability-engine.ts
+++ b/app/services/probability-engine.ts
@@ -202,8 +202,16 @@ export function mapToElo(
  * eloWinProbability(1648, 1324)  // 0.828 (82.8%)
  * eloWinProbability(1500, 1500)  // 0.5 (50%)
  */
+export function eloWinProbabilityWithParity(
+  eloA: number,
+  eloB: number,
+  parityFactor = 400
+): number {
+  return 1 / (1 + Math.pow(10, (eloB - eloA) / parityFactor));
+}
+
 export function eloWinProbability(eloA: number, eloB: number): number {
-  return 1 / (1 + Math.pow(10, (eloB - eloA) / 400));
+  return eloWinProbabilityWithParity(eloA, eloB, 400);
 }
 
 /**
@@ -368,3 +376,53 @@ export function eloToProjectedWins(
   const winProb = 1 / (1 + Math.pow(10, (averageElo - elo) / parityFactor));
   return winProb * totalGames;
 }
+/**
+ * Convert projected league table points to an Elo rating.
+ *
+ * For soccer-style standings where each match offers up to `maxPointsPerGame`
+ * table points (EPL: 3), this maps projected points-per-game onto the same
+ * inverse-logit Elo scale used by projectedWinsToElo.
+ */
+export function projectedTablePointsToElo(
+  projectedPoints: number,
+  totalGames: number,
+  parityFactor = 400,
+  averageElo = 1500,
+  maxPointsPerGame = 3
+): number {
+  if (totalGames <= 0) {
+    throw new Error('Total games must be positive');
+  }
+  if (parityFactor <= 0) {
+    throw new Error('Parity factor must be positive');
+  }
+  if (maxPointsPerGame <= 0) {
+    throw new Error('Max points per game must be positive');
+  }
+
+  const maxPoints = totalGames * maxPointsPerGame;
+  if (projectedPoints < 0 || projectedPoints > maxPoints) {
+    throw new Error(
+      `Projected points (${projectedPoints}) must be between 0 and maximum points (${maxPoints})`
+    );
+  }
+
+  const pointsShare = projectedPoints / maxPoints;
+  if (pointsShare >= 1.0) return averageElo + parityFactor * 3;
+  if (pointsShare <= 0.0) return averageElo - parityFactor * 3;
+
+  const elo = averageElo - parityFactor * Math.log10((1 - pointsShare) / pointsShare);
+  return Math.round(elo);
+}
+
+/** Convert Elo back to projected soccer-style table points. */
+export function eloToProjectedTablePoints(
+  elo: number,
+  totalGames: number,
+  parityFactor = 400,
+  averageElo = 1500,
+  maxPointsPerGame = 3
+): number {
+  const pointsShare = 1 / (1 + Math.pow(10, (averageElo - elo) / parityFactor));
+  return pointsShare * totalGames * maxPointsPerGame;
+}
diff --git a/app/services/simulations/__tests__/epl-simulator.test.ts b/app/services/simulations/__tests__/epl-simulator.test.ts
new file mode 100644
index 0000000..607a9a8
--- /dev/null
+++ b/app/services/simulations/__tests__/epl-simulator.test.ts
@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, beforeEach, type MockInstance } from "vitest";
+import { EPLSimulator, eplWinProbability, simEplMatch } from "../epl-simulator";
+
+vi.mock("~/database/context", () => ({
+  database: vi.fn(),
+}));
+
+vi.mock("~/models/regular-season-standings", () => ({
+  getRegularSeasonStandings: vi.fn(),
+}));
+
+const EPL_TEAMS = [
+  "Arsenal", "Manchester City", "Liverpool", "Chelsea", "Tottenham Hotspur",
+  "Manchester United", "Newcastle United", "Aston Villa", "Brighton & Hove Albion", "West Ham United",
+  "Crystal Palace", "Fulham", "Everton", "Bournemouth", "Brentford",
+  "Wolverhampton Wanderers", "Nottingham Forest", "Leeds United", "Burnley", "Sunderland",
+];
+
+const PARTICIPANT_ROWS = EPL_TEAMS.map((name, i) => ({ id: `team-${i + 1}`, name }));
+const EV_ROWS = PARTICIPANT_ROWS.map((team, i) => ({
+  participantId: team.id,
+  sourceElo: 1760 - i * 25,
+  sourceOdds: null,
+}));
+
+function mockSelects(participantRows = PARTICIPANT_ROWS, evRows = EV_ROWS) {
+  let selectCallCount = 0;
+  return vi.fn().mockImplementation(() => {
+    selectCallCount++;
+    if (selectCallCount === 1) {
+      return { from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(participantRows) }) };
+    }
+    return { from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(evRows) }) };
+  });
+}
+
+describe("EPL match helpers", () => {
+  it("returns 0.5 win probability for equal Elo ratings", () => {
+    expect(eplWinProbability(1500, 1500)).toBeCloseTo(0.5, 6);
+  });
+
+  it("equal Elo teams draw at a realistic rate", () => {
+    let draws = 0;
+    const N = 5000;
+    for (let i = 0; i < N; i++) {
+      if (simEplMatch(1500, 1500) === "draw") draws++;
+    }
+    const drawRate = draws / N;
+    expect(drawRate).toBeGreaterThan(0.21);
+    expect(drawRate).toBeLessThan(0.31);
+  });
+});
+
+describe("EPLSimulator.simulate()", () => {
+  let mockDb: { select: MockInstance };
+
+  beforeEach(async () => {
+    const { database } = await import("~/database/context");
+    const { getRegularSeasonStandings } = await import("~/models/regular-season-standings");
+
+    mockDb = { select: mockSelects() };
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
+    (getRegularSeasonStandings as unknown as MockInstance).mockResolvedValue([]);
+  });
+
+  it("throws if no participants found", async () => {
+    mockDb.select = mockSelects([], []);
+    await expect(new EPLSimulator().simulate("season-1")).rejects.toThrow(/No participants found/);
+  });
+
+  it("returns one result per EPL club and normalizes top-eight columns", async () => {
+    const results = await new EPLSimulator().simulate("season-1");
+    expect(results).toHaveLength(20);
+
+    const keys = [
+      "probFirst", "probSecond", "probThird", "probFourth",
+      "probFifth", "probSixth", "probSeventh", "probEighth",
+    ] as const;
+
+    for (const key of keys) {
+      const colSum = results.reduce((sum, result) => sum + result.probabilities[key], 0);
+      expect(colSum, `${key} column sum`).toBeCloseTo(1.0, 8);
+    }
+
+    for (const result of results) {
+      expect(result.source).toBe("epl_standings_monte_carlo");
+      for (const value of Object.values(result.probabilities)) {
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(1);
+      }
+    }
+  });
+
+  it("higher Elo teams have stronger title probability", async () => {
+    const results = await new EPLSimulator().simulate("season-1");
+    const top = results.find((result) => result.participantId === "team-1");
+    const bottom = results.find((result) => result.participantId === "team-20");
+    if (!top || !bottom) throw new Error("Expected test teams not found");
+
+    expect(top.probabilities.probFirst).toBeGreaterThan(bottom.probabilities.probFirst);
+  });
+
+  it("uses current EPL standings when present", async () => {
+    const { getRegularSeasonStandings } = await import("~/models/regular-season-standings");
+    (getRegularSeasonStandings as unknown as MockInstance).mockResolvedValue([
+      {
+        participantId: "team-20",
+        wins: 25,
+        ties: 5,
+        losses: 0,
+        gamesPlayed: 30,
+        tablePoints: 80,
+        goalsFor: 80,
+        goalsAgainst: 20,
+        goalDifference: 60,
+        leagueRank: 1,
+      },
+      ...PARTICIPANT_ROWS.slice(0, 19).map((team) => ({
+        participantId: team.id,
+        wins: 8,
+        ties: 5,
+        losses: 17,
+        gamesPlayed: 30,
+        tablePoints: 29,
+        goalsFor: 35,
+        goalsAgainst: 55,
+        goalDifference: -20,
+        leagueRank: 10,
+      })),
+    ]);
+
+    const results = await new EPLSimulator().simulate("season-1");
+    const leader = results.find((result) => result.participantId === "team-20");
+    if (!leader) throw new Error("Expected standings leader not found");
+
+    expect(leader.probabilities.probFirst).toBeGreaterThan(0.95);
+  });
+
+  it("throws when Elo/projected points are missing", async () => {
+    mockDb.select = mockSelects(PARTICIPANT_ROWS, []);
+    await expect(new EPLSimulator().simulate("season-1")).rejects.toThrow(/Missing Elo\/projected points/);
+  });
+});
diff --git a/app/services/simulations/afl-simulator.ts b/app/services/simulations/afl-simulator.ts
index 9168c17..b041bcf 100644
--- a/app/services/simulations/afl-simulator.ts
+++ b/app/services/simulations/afl-simulator.ts
@@ -68,6 +68,7 @@ import type { Simulator, SimulationResult } from "./types";
 import { normalizeTeamName } from "~/lib/normalize-team-name";
 import { logger } from "~/lib/logger";
 import { getRegularSeasonStandings } from "~/models/regular-season-standings";
+import { eloWinProbabilityWithParity } from "~/services/probability-engine";
 
 // ─── Simulation parameters ────────────────────────────────────────────────────
 
@@ -161,7 +162,7 @@ export function getTeamData(name: string): AflTeamData | undefined {
  * Exported for unit testing.
  */
 export function eloWinProbability(eloA: number, eloB: number): number {
-  return 1 / (1 + Math.pow(10, (eloB - eloA) / PARITY_FACTOR));
+  return eloWinProbabilityWithParity(eloA, eloB, PARITY_FACTOR);
 }
 
 // ─── Internal types ───────────────────────────────────────────────────────────
diff --git a/app/services/simulations/epl-simulator.ts b/app/services/simulations/epl-simulator.ts
new file mode 100644
index 0000000..3c728c0
--- /dev/null
+++ b/app/services/simulations/epl-simulator.ts
@@ -0,0 +1,201 @@
+/**
+ * EPL Season Standings Simulator
+ *
+ * Monte Carlo simulation of a Premier League table. Reads current actual
+ * standings when present and simulates only the remaining season; if no current
+ * standings exist, simulates a full 38-match season from 0 points.
+ *
+ * Results persist only placement probabilities (P1–P8) through the existing EV
+ * pipeline. Simulated W/D/L/GF/GA/GD rows are internal and discarded.
+ */
+
+import { database } from "~/database/context";
+import { eq } from "drizzle-orm";
+import * as schema from "~/database/schema";
+import type { Simulator, SimulationResult } from "./types";
+import { getRegularSeasonStandings } from "~/models/regular-season-standings";
+import { convertFuturesToElo, eloWinProbabilityWithParity } from "~/services/probability-engine";
+import { normalizeSimulationResultColumns } from "./simulation-probabilities";
+import { simulateEloSoccerMatch, simulateSimpleSoccerGoals } from "./soccer-helpers";
+
+const NUM_SIMULATIONS = 10_000;
+const EPL_REGULAR_SEASON_GAMES = 38;
+const AVERAGE_OPPONENT_ELO = 1500;
+const PARITY_FACTOR = 400;
+const BASE_DRAW_RATE = 0.26;
+const DRAW_DECAY = 0.002;
+
+interface TeamEntry {
+  id: string;
+  elo: number;
+  currentPoints: number;
+  currentGoalsFor: number;
+  currentGoalsAgainst: number;
+  currentGoalDifference: number;
+  remainingGames: number;
+}
+
+interface SimulatedTableRow {
+  team: TeamEntry;
+  points: number;
+  goalsFor: number;
+  goalsAgainst: number;
+  goalDifference: number;
+  tiebreaker: number;
+}
+
+/** EPL single-match win probability using the sport-specific parity factor. */
+export function eplWinProbability(eloA: number, eloB: number): number {
+  return eloWinProbabilityWithParity(eloA, eloB, PARITY_FACTOR);
+}
+
+/** Simulate an EPL match result for team A vs team B. Exported for tests. */
+export function simEplMatch(eloA: number, eloB: number): "win" | "draw" | "loss" {
+  return simulateEloSoccerMatch(eloA, eloB, {
+    baseDrawRate: BASE_DRAW_RATE,
+    drawDecay: DRAW_DECAY,
+    parityFactor: PARITY_FACTOR,
+  });
+}
+
+export class EPLSimulator implements Simulator {
+  async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
+    const db = database();
+
+    const [participantRows, evRows, standings] = await Promise.all([
+      db
+        .select({ id: schema.seasonParticipants.id, name: schema.seasonParticipants.name })
+        .from(schema.seasonParticipants)
+        .where(eq(schema.seasonParticipants.sportsSeasonId, sportsSeasonId)),
+      db
+        .select({
+          participantId: schema.seasonParticipantExpectedValues.participantId,
+          sourceElo: schema.seasonParticipantExpectedValues.sourceElo,
+          sourceOdds: schema.seasonParticipantExpectedValues.sourceOdds,
+        })
+        .from(schema.seasonParticipantExpectedValues)
+        .where(eq(schema.seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId)),
+      getRegularSeasonStandings(sportsSeasonId),
+    ]);
+
+    if (participantRows.length === 0) {
+      throw new Error(
+        `No participants found for sports season ${sportsSeasonId}. Add all 20 EPL clubs before running simulation.`
+      );
+    }
+
+    if (participantRows.length < 8) {
+      throw new Error(
+        `EPL simulation requires at least 8 participants to fill top-eight probabilities (got ${participantRows.length}).`
+      );
+    }
+
+    const dbEloMap = new Map<string, number>();
+    for (const row of evRows) {
+      if (row.sourceElo !== null && row.sourceElo !== undefined) {
+        dbEloMap.set(row.participantId, row.sourceElo);
+      }
+    }
+
+    if (dbEloMap.size === 0) {
+      const oddsInput = evRows
+        .filter((row) => row.sourceOdds !== null && row.sourceOdds !== undefined)
+        .map((row) => ({ participantId: row.participantId, odds: row.sourceOdds as number }));
+      const converted = convertFuturesToElo(oddsInput);
+      for (const [participantId, elo] of converted) dbEloMap.set(participantId, elo);
+    }
+
+    const missingElo = participantRows.filter((row) => !dbEloMap.has(row.id));
+    if (missingElo.length > 0) {
+      throw new Error(
+        `Missing Elo/projected points for ${missingElo.length} EPL participants: ${missingElo.map((p) => p.name).join(", ")}. ` +
+          `Enter Elo ratings or projected points via Admin → Elo Ratings before simulating.`
+      );
+    }
+
+    const standingsMap = new Map(standings.map((standing) => [standing.participantId, standing]));
+    const participantIds = participantRows.map((row) => row.id);
+
+    const teams: TeamEntry[] = participantRows.map((row) => {
+      const standing = standingsMap.get(row.id);
+      const wins = standing?.wins ?? 0;
+      const draws = standing?.ties ?? 0;
+      const losses = standing?.losses ?? 0;
+      const gamesPlayed = standing?.gamesPlayed ?? wins + draws + losses;
+      const goalsFor = standing?.goalsFor ?? 0;
+      const goalsAgainst = standing?.goalsAgainst ?? 0;
+      const goalDifference = standing?.goalDifference ?? goalsFor - goalsAgainst;
+
+      return {
+        id: row.id,
+        elo: dbEloMap.get(row.id) as number,
+        currentPoints: standing?.tablePoints ?? wins * 3 + draws,
+        currentGoalsFor: goalsFor,
+        currentGoalsAgainst: goalsAgainst,
+        currentGoalDifference: goalDifference,
+        remainingGames: Math.max(0, EPL_REGULAR_SEASON_GAMES - gamesPlayed),
+      };
+    });
+
+    const rankCounts = new Map<string, number[]>(
+      participantIds.map((id) => [id, Array.from({ length: 8 }, () => 0)])
+    );
+
+    for (let sim = 0; sim < NUM_SIMULATIONS; sim++) {
+      const tableRows: SimulatedTableRow[] = teams.map((team) => ({
+        team,
+        points: team.currentPoints,
+        goalsFor: team.currentGoalsFor,
+        goalsAgainst: team.currentGoalsAgainst,
+        goalDifference: team.currentGoalDifference,
+        tiebreaker: Math.random(),
+      }));
+
+      for (const row of tableRows) {
+        for (let game = 0; game < row.team.remainingGames; game++) {
+          const result = simEplMatch(row.team.elo, AVERAGE_OPPONENT_ELO);
+          const goals = simulateSimpleSoccerGoals(result);
+          row.goalsFor += goals.gf;
+          row.goalsAgainst += goals.ga;
+          row.goalDifference = row.goalsFor - row.goalsAgainst;
+
+          if (result === "win") row.points += 3;
+          else if (result === "draw") row.points += 1;
+        }
+      }
+
+      const finalTable = tableRows.toSorted((a, b) =>
+        b.points - a.points ||
+        b.goalDifference - a.goalDifference ||
+        b.goalsFor - a.goalsFor ||
+        b.tiebreaker - a.tiebreaker
+      );
+
+      for (let rank = 0; rank < Math.min(8, finalTable.length); rank++) {
+        const counts = rankCounts.get(finalTable[rank].team.id);
+        if (counts) counts[rank]++;
+      }
+    }
+
+    const results: SimulationResult[] = participantIds.map((participantId) => {
+      const counts = rankCounts.get(participantId) ?? Array.from({ length: 8 }, () => 0);
+      return {
+        participantId,
+        probabilities: {
+          probFirst: counts[0] / NUM_SIMULATIONS,
+          probSecond: counts[1] / NUM_SIMULATIONS,
+          probThird: counts[2] / NUM_SIMULATIONS,
+          probFourth: counts[3] / NUM_SIMULATIONS,
+          probFifth: counts[4] / NUM_SIMULATIONS,
+          probSixth: counts[5] / NUM_SIMULATIONS,
+          probSeventh: counts[6] / NUM_SIMULATIONS,
+          probEighth: counts[7] / NUM_SIMULATIONS,
+        },
+        source: "epl_standings_monte_carlo",
+      };
+    });
+
+    normalizeSimulationResultColumns(results);
+    return results;
+  }
+}
diff --git a/app/services/simulations/registry.ts b/app/services/simulations/registry.ts
index 14e4f6b..fcd8fef 100644
--- a/app/services/simulations/registry.ts
+++ b/app/services/simulations/registry.ts
@@ -16,6 +16,7 @@ import { NCAAWSimulator } from "./ncaaw-simulator";
 import { NBASimulator } from "./nba-simulator";
 import { NHLSimulator } from "./nhl-simulator";
 import { AFLSimulator } from "./afl-simulator";
+import { EPLSimulator } from "./epl-simulator";
 import { SnookerSimulator } from "./snooker-simulator";
 import { TennisSimulator } from "./tennis-simulator";
 import { DartsSimulator } from "./darts-simulator";
@@ -40,6 +41,7 @@ export const SIMULATOR_TYPES = [
   "nhl_bracket",
   "nfl_bracket",
   "afl_bracket",
+  "epl_standings",
   "snooker_bracket",
   "tennis_qualifying_points",
   "mlb_bracket",
@@ -121,6 +123,10 @@ const REGISTRY: Record<SimulatorType, { info: SimulatorInfo; create: () => Simul
     info: { name: "AFL Season + Finals Monte Carlo", description: "Projects AFL regular season standings via Elo, then simulates the 10-team finals series (Wildcard → QF/EF → SF → PF → Grand Final). Reads current standings from DB; falls back to full-season projection pre-season." },
     create: () => new AFLSimulator(),
   },
+  epl_standings: {
+    info: { name: "EPL Season Standings Monte Carlo", description: "Projects the English Premier League table using current standings and Elo/projected-points inputs. Simulates draws correctly and returns top-eight placement probabilities." },
+    create: () => new EPLSimulator(),
+  },
   snooker_bracket: {
     info: { name: "Snooker World Championship Monte Carlo", description: "Simulates the 32-player World Championship bracket using frame-by-frame Bernoulli win probability and direct Elo ratings. Pre-bracket path simulates qualifying (ranks 17-48) and randomly draws qualifiers vs top 16 seeds." },
     create: () => new SnookerSimulator(),
diff --git a/app/services/simulations/simulation-probabilities.ts b/app/services/simulations/simulation-probabilities.ts
new file mode 100644
index 0000000..1fa4e2b
--- /dev/null
+++ b/app/services/simulations/simulation-probabilities.ts
@@ -0,0 +1,31 @@
+import type { SimulationProbabilities, SimulationResult } from "./types";
+
+export const SIMULATION_PROBABILITY_KEYS = [
+  "probFirst",
+  "probSecond",
+  "probThird",
+  "probFourth",
+  "probFifth",
+  "probSixth",
+  "probSeventh",
+  "probEighth",
+] as const satisfies ReadonlyArray<keyof SimulationProbabilities>;
+
+/**
+ * Normalize each placement-probability column so every finishing position sums
+ * to exactly 1.0 across all participants after Monte Carlo floating-point math.
+ */
+export function normalizeSimulationResultColumns(results: SimulationResult[]): void {
+  if (results.length === 0) return;
+
+  for (const key of SIMULATION_PROBABILITY_KEYS) {
+    const colSum = results.reduce((sum, result) => sum + result.probabilities[key], 0);
+    const residual = 1.0 - colSum;
+    if (residual !== 0) {
+      const maxResult = results.reduce((best, result) =>
+        result.probabilities[key] > best.probabilities[key] ? result : best
+      );
+      maxResult.probabilities[key] += residual;
+    }
+  }
+}
diff --git a/app/services/simulations/simulator-config.ts b/app/services/simulations/simulator-config.ts
index 5e9733c..4b2c122 100644
--- a/app/services/simulations/simulator-config.ts
+++ b/app/services/simulations/simulator-config.ts
@@ -18,6 +18,8 @@ export interface SimulatorConfig {
   parityFactor: number;
   /** Average opponent Elo — used for season projections against a generic opponent. */
   averageOpponentElo: number;
+  /** Label/type for the admin projection input. Defaults to projected wins. */
+  projectionInput?: "wins" | "tablePoints";
 }
 
 const CONFIG: Record<SimulatorType, SimulatorConfig | null> = {
@@ -50,6 +52,12 @@ const CONFIG: Record<SimulatorType, SimulatorConfig | null> = {
     parityFactor: 400,
     averageOpponentElo: 1500,
   },
+  epl_standings: {
+    seasonGames: 38,
+    parityFactor: 400,
+    averageOpponentElo: 1500,
+    projectionInput: "tablePoints",
+  },
   wnba_bracket: {
     seasonGames: 44,
     parityFactor: 400,
diff --git a/app/services/simulations/soccer-helpers.ts b/app/services/simulations/soccer-helpers.ts
new file mode 100644
index 0000000..ef434f3
--- /dev/null
+++ b/app/services/simulations/soccer-helpers.ts
@@ -0,0 +1,49 @@
+import { eloWinProbabilityWithParity } from "~/services/probability-engine";
+
+export type SoccerMatchResult = "win" | "draw" | "loss";
+
+export interface EloSoccerMatchOptions {
+  baseDrawRate: number;
+  drawDecay: number;
+  parityFactor?: number;
+}
+
+export function soccerDrawProbability(
+  eloA: number,
+  eloB: number,
+  baseDrawRate: number,
+  drawDecay: number
+): number {
+  return baseDrawRate * Math.exp(-drawDecay * Math.abs(eloA - eloB));
+}
+
+/**
+ * Simulate a soccer-style Elo match with an explicit draw probability.
+ * Returns the result from team A's perspective.
+ */
+export function simulateEloSoccerMatch(
+  eloA: number,
+  eloB: number,
+  { baseDrawRate, drawDecay, parityFactor = 400 }: EloSoccerMatchOptions
+): SoccerMatchResult {
+  const pDraw = soccerDrawProbability(eloA, eloB, baseDrawRate, drawDecay);
+  const pWinNoDraw = eloWinProbabilityWithParity(eloA, eloB, parityFactor);
+  const pWin = (1 - pDraw) * pWinNoDraw;
+  const rand = Math.random();
+  if (rand < pWin) return "win";
+  if (rand < pWin + pDraw) return "draw";
+  return "loss";
+}
+
+/** Generate simple low-scoring goals for table tiebreakers after a result is known. */
+export function simulateSimpleSoccerGoals(result: SoccerMatchResult): { gf: number; ga: number } {
+  if (result === "draw") {
+    const goals = Math.random() < 0.55 ? 1 : Math.random() < 0.75 ? 0 : 2;
+    return { gf: goals, ga: goals };
+  }
+
+  const winnerGoals = Math.random() < 0.55 ? 2 : Math.random() < 0.75 ? 1 : 3;
+  const loserGoals = winnerGoals === 1 ? 0 : Math.random() < 0.35 ? 1 : 0;
+  if (result === "win") return { gf: winnerGoals, ga: loserGoals };
+  return { gf: loserGoals, ga: winnerGoals };
+}
diff --git a/app/services/simulations/world-cup-simulator.ts b/app/services/simulations/world-cup-simulator.ts
index 8e7b681..e7e8ddb 100644
--- a/app/services/simulations/world-cup-simulator.ts
+++ b/app/services/simulations/world-cup-simulator.ts
@@ -39,6 +39,7 @@ import { database } from "~/database/context";
 import { eq, and } from "drizzle-orm";
 import * as schema from "~/database/schema";
 import { convertFuturesToElo, eloWinProbability } from "~/services/probability-engine";
+import { simulateEloSoccerMatch } from "./soccer-helpers";
 import { logger } from "~/lib/logger";
 import type { Simulator, SimulationResult, SimulationProbabilities } from "./types";
 
@@ -161,14 +162,10 @@ function getTeamElo(name: string, fallback = 1500): number {
  * Returns "win" (team A wins), "draw", or "loss" (team B wins).
  */
 export function simGroupMatch(eloA: number, eloB: number): "win" | "draw" | "loss" {
-  const eloDiff = eloA - eloB;
-  const pDraw = BASE_DRAW_RATE * Math.exp(-DRAW_DECAY * Math.abs(eloDiff));
-  const eloWin = eloWinProbability(eloA, eloB);
-  const pWin = (1 - pDraw) * eloWin;
-  const rand = Math.random();
-  if (rand < pWin) return "win";
-  if (rand < pWin + pDraw) return "draw";
-  return "loss";
+  return simulateEloSoccerMatch(eloA, eloB, {
+    baseDrawRate: BASE_DRAW_RATE,
+    drawDecay: DRAW_DECAY,
+  });
 }
 
 interface TeamStats {
diff --git a/app/services/standings-sync/__tests__/epl.test.ts b/app/services/standings-sync/__tests__/epl.test.ts
new file mode 100644
index 0000000..f18bfaa
--- /dev/null
+++ b/app/services/standings-sync/__tests__/epl.test.ts
@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EplStandingsAdapter } from "../epl";
+
+const SAMPLE_RESPONSE = {
+  standings: [
+    {
+      type: "TOTAL",
+      table: [
+        {
+          position: 1,
+          team: { id: 57, name: "Arsenal FC" },
+          playedGames: 30,
+          form: "W,W,D,W,L",
+          won: 21,
+          draw: 6,
+          lost: 3,
+          points: 69,
+          goalsFor: 72,
+          goalsAgainst: 25,
+          goalDifference: 47,
+        },
+        {
+          position: 2,
+          team: { id: 65, name: "Manchester City FC" },
+          playedGames: 30,
+          form: "W,W,W,D,W",
+          won: 20,
+          draw: 7,
+          lost: 3,
+          points: 67,
+          goalsFor: 70,
+          goalsAgainst: 28,
+          goalDifference: 42,
+        },
+      ],
+    },
+    { type: "HOME", table: [] },
+  ],
+};
+
+describe("EplStandingsAdapter", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", vi.fn());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("maps football-data.org TOTAL standings to FetchedStandingsRecord[]", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => SAMPLE_RESPONSE,
+    } as Response);
+
+    const records = await new EplStandingsAdapter("test-token").fetchStandings();
+    expect(records).toHaveLength(2);
+
+    const arsenal = records[0];
+    expect(arsenal.teamName).toBe("Arsenal FC");
+    expect(arsenal.externalTeamId).toBe("57");
+    expect(arsenal.wins).toBe(21);
+    expect(arsenal.ties).toBe(6);
+    expect(arsenal.losses).toBe(3);
+    expect(arsenal.gamesPlayed).toBe(30);
+    expect(arsenal.tablePoints).toBe(69);
+    expect(arsenal.goalsFor).toBe(72);
+    expect(arsenal.goalsAgainst).toBe(25);
+    expect(arsenal.goalDifference).toBe(47);
+    expect(arsenal.leagueRank).toBe(1);
+    expect(arsenal.lastTen).toBe("W,W,D,W,L");
+  });
+
+  it("sends the football-data.org auth token", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => SAMPLE_RESPONSE,
+    } as Response);
+
+    await new EplStandingsAdapter("abc123").fetchStandings();
+    expect(fetch).toHaveBeenCalledWith(
+      "https://api.football-data.org/v4/competitions/PL/standings",
+      { headers: { "X-Auth-Token": "abc123" } }
+    );
+  });
+
+  it("throws when no API key is configured", async () => {
+    await expect(new EplStandingsAdapter("").fetchStandings()).rejects.toThrow(/FOOTBALL_DATA_API_KEY/);
+  });
+
+  it("throws on non-ok response", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      statusText: "Too Many Requests",
+    } as Response);
+
+    await expect(new EplStandingsAdapter("test-token").fetchStandings()).rejects.toThrow("429");
+  });
+});
diff --git a/app/services/standings-sync/epl.ts b/app/services/standings-sync/epl.ts
new file mode 100644
index 0000000..9ef2330
--- /dev/null
+++ b/app/services/standings-sync/epl.ts
@@ -0,0 +1,91 @@
+import type { FetchedStandingsRecord, StandingsSyncAdapter } from "./types";
+
+const EPL_STANDINGS_URL = "https://api.football-data.org/v4/competitions/PL/standings";
+
+interface FootballDataTeam {
+  id: number;
+  name: string;
+  shortName?: string;
+  tla?: string;
+}
+
+interface FootballDataTableEntry {
+  position: number;
+  team: FootballDataTeam;
+  playedGames: number;
+  form?: string | null;
+  won: number;
+  draw: number;
+  lost: number;
+  points: number;
+  goalsFor: number;
+  goalsAgainst: number;
+  goalDifference: number;
+}
+
+interface FootballDataStanding {
+  type: "TOTAL" | "HOME" | "AWAY" | string;
+  table: FootballDataTableEntry[];
+}
+
+interface FootballDataStandingsResponse {
+  standings: FootballDataStanding[];
+}
+
+/**
+ * English Premier League standings adapter backed by football-data.org.
+ *
+ * Endpoint: GET /v4/competitions/PL/standings
+ * Required env var: FOOTBALL_DATA_API_KEY
+ */
+export class EplStandingsAdapter implements StandingsSyncAdapter {
+  constructor(private readonly apiKey = process.env.FOOTBALL_DATA_API_KEY) {}
+
+  async fetchStandings(): Promise<FetchedStandingsRecord[]> {
+    if (!this.apiKey) {
+      throw new Error(
+        "FOOTBALL_DATA_API_KEY is required to sync EPL standings from football-data.org."
+      );
+    }
+
+    const response = await fetch(EPL_STANDINGS_URL, {
+      headers: {
+        "X-Auth-Token": this.apiKey,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `football-data.org EPL standings API returned ${response.status}: ${response.statusText}`
+      );
+    }
+
+    const json = (await response.json()) as FootballDataStandingsResponse;
+    const total = json.standings?.find((standing) => standing.type === "TOTAL");
+    const table = total?.table ?? [];
+
+    if (table.length === 0) {
+      throw new Error(
+        "football-data.org EPL standings API returned no TOTAL table entries — response shape may have changed"
+      );
+    }
+
+    return table
+      .toSorted((a, b) => a.position - b.position)
+      .map((entry): FetchedStandingsRecord => ({
+        teamName: entry.team.name,
+        externalTeamId: String(entry.team.id),
+        wins: entry.won,
+        losses: entry.lost,
+        ties: entry.draw,
+        tablePoints: entry.points,
+        goalsFor: entry.goalsFor,
+        goalsAgainst: entry.goalsAgainst,
+        goalDifference: entry.goalDifference,
+        winPct: entry.playedGames > 0 ? entry.won / entry.playedGames : 0,
+        gamesPlayed: entry.playedGames,
+        leagueRank: entry.position,
+        lastTen: entry.form ?? undefined,
+      }));
+  }
+}
diff --git a/app/services/standings-sync/index.ts b/app/services/standings-sync/index.ts
index fecb74f..e451314 100644
--- a/app/services/standings-sync/index.ts
+++ b/app/services/standings-sync/index.ts
@@ -10,6 +10,7 @@ import { NbaStandingsAdapter } from "./nba";
 import { AflStandingsAdapter } from "./afl";
 import { MlbStandingsAdapter } from "./mlb";
 import { WnbaStandingsAdapter } from "./wnba";
+import { EplStandingsAdapter } from "./epl";
 import type { StandingsSyncAdapter, SyncResult, UnmatchedTeam } from "./types";
 
 /**
@@ -25,6 +26,8 @@ function getAdapter(simulatorType: string): StandingsSyncAdapter {
       return new NhlStandingsAdapter();
     case "afl_bracket":
       return new AflStandingsAdapter();
+    case "epl_standings":
+      return new EplStandingsAdapter();
     case "mlb_bracket":
       return new MlbStandingsAdapter();
     case "wnba_bracket":
@@ -40,7 +43,7 @@ function getAdapter(simulatorType: string): StandingsSyncAdapter {
     default:
       throw new Error(
         `No standings sync adapter available for simulator type "${simulatorType}". ` +
-          "Only NBA and NHL are currently supported."
+          "NBA, NHL, AFL, MLB, WNBA, and EPL are currently supported."
       );
   }
 }
@@ -113,6 +116,10 @@ export async function syncStandings(sportsSeasonId: string): Promise<SyncResult>
       losses: record.losses,
       otLosses: record.otLosses ?? null,
       ties: record.ties ?? null,
+      tablePoints: record.tablePoints ?? null,
+      goalsFor: record.goalsFor ?? null,
+      goalsAgainst: record.goalsAgainst ?? null,
+      goalDifference: record.goalDifference ?? null,
       winPct: record.winPct,
       gamesPlayed: record.gamesPlayed,
       gamesBack: record.gamesBack ?? null,
diff --git a/app/services/standings-sync/types.ts b/app/services/standings-sync/types.ts
index ae5274d..347c725 100644
--- a/app/services/standings-sync/types.ts
+++ b/app/services/standings-sync/types.ts
@@ -5,6 +5,10 @@ export interface FetchedStandingsRecord {
   losses: number;
   otLosses?: number;
   ties?: number;
+  tablePoints?: number;
+  goalsFor?: number;
+  goalsAgainst?: number;
+  goalDifference?: number;
   winPct: number;
   gamesPlayed: number;
   gamesBack?: number;
diff --git a/database/schema.ts b/database/schema.ts
index adf0b35..7bcd9ca 100644
--- a/database/schema.ts
+++ b/database/schema.ts
@@ -142,6 +142,7 @@ export const simulatorTypeEnum = pgEnum("simulator_type", [
   "nhl_bracket",
   "nfl_bracket",
   "afl_bracket",
+  "epl_standings",
   "snooker_bracket",
   "tennis_qualifying_points",
   "mlb_bracket",
@@ -1336,7 +1337,11 @@ export const regularSeasonStandings = pgTable("regular_season_standings", {
   wins: integer("wins").notNull().default(0),
   losses: integer("losses").notNull().default(0),
   otLosses: integer("ot_losses"),            // NHL overtime losses; null for NBA
-  ties: integer("ties"),                      // future sports (e.g. soccer)
+  ties: integer("ties"),                      // draws/ties (e.g. soccer, AFL)
+  tablePoints: integer("table_points"),          // league table points (e.g. EPL: 3W + D, including deductions)
+  goalsFor: integer("goals_for"),
+  goalsAgainst: integer("goals_against"),
+  goalDifference: integer("goal_difference"),
   winPct: decimal("win_pct", { precision: 5, scale: 4 }),
   gamesPlayed: integer("games_played").notNull().default(0),
   gamesBack: decimal("games_back", { precision: 5, scale: 1 }),
diff --git a/drizzle/0096_demonic_vulture.sql b/drizzle/0096_demonic_vulture.sql
new file mode 100644
index 0000000..8d117c6
--- /dev/null
+++ b/drizzle/0096_demonic_vulture.sql
@@ -0,0 +1,5 @@
+ALTER TYPE "public"."simulator_type" ADD VALUE 'epl_standings' BEFORE 'snooker_bracket';--> statement-breakpoint
+ALTER TABLE "regular_season_standings" ADD COLUMN "table_points" integer;--> statement-breakpoint
+ALTER TABLE "regular_season_standings" ADD COLUMN "goals_for" integer;--> statement-breakpoint
+ALTER TABLE "regular_season_standings" ADD COLUMN "goals_against" integer;--> statement-breakpoint
+ALTER TABLE "regular_season_standings" ADD COLUMN "goal_difference" integer;
\ No newline at end of file
diff --git a/drizzle/meta/0096_snapshot.json b/drizzle/meta/0096_snapshot.json
new file mode 100644
index 0000000..9897402
--- /dev/null
+++ b/drizzle/meta/0096_snapshot.json
@@ -0,0 +1,5780 @@
+{
+  "id": "e7ddc5eb-c82e-4bdb-9da2-918238f4d95e",
+  "prevId": "bccadfbd-9150-4041-9d26-9d846eb2947e",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.accounts": {
+      "name": "accounts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "accounts_user_id_users_id_fk": {
+          "name": "accounts_user_id_users_id_fk",
+          "tableFrom": "accounts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.autodraft_settings": {
+      "name": "autodraft_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_enabled": {
+          "name": "is_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "mode": {
+          "name": "mode",
+          "type": "autodraft_mode",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'next_pick'"
+        },
+        "queue_only": {
+          "name": "queue_only",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "autodraft_settings_season_id_seasons_id_fk": {
+          "name": "autodraft_settings_season_id_seasons_id_fk",
+          "tableFrom": "autodraft_settings",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "autodraft_settings_team_id_teams_id_fk": {
+          "name": "autodraft_settings_team_id_teams_id_fk",
+          "tableFrom": "autodraft_settings",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.commissioner_audit_log": {
+      "name": "commissioner_audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "league_id": {
+          "name": "league_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_user_id": {
+          "name": "actor_user_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_display_name": {
+          "name": "actor_display_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "action": {
+          "name": "action",
+          "type": "audit_action",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "affected_team_ids": {
+          "name": "affected_team_ids",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "details": {
+          "name": "details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "audit_log_season_id_idx": {
+          "name": "audit_log_season_id_idx",
+          "columns": [
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "commissioner_audit_log_season_id_seasons_id_fk": {
+          "name": "commissioner_audit_log_season_id_seasons_id_fk",
+          "tableFrom": "commissioner_audit_log",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "commissioner_audit_log_league_id_leagues_id_fk": {
+          "name": "commissioner_audit_log_league_id_leagues_id_fk",
+          "tableFrom": "commissioner_audit_log",
+          "tableTo": "leagues",
+          "columnsFrom": [
+            "league_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.commissioners": {
+      "name": "commissioners",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "league_id": {
+          "name": "league_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "commissioners_league_id_leagues_id_fk": {
+          "name": "commissioners_league_id_leagues_id_fk",
+          "tableFrom": "commissioners",
+          "tableTo": "leagues",
+          "columnsFrom": [
+            "league_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.cs2_major_stage_results": {
+      "name": "cs2_major_stage_results",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "scoring_event_id": {
+          "name": "scoring_event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stage_entry": {
+          "name": "stage_entry",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stage_eliminated": {
+          "name": "stage_eliminated",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stage_eliminated_wins": {
+          "name": "stage_eliminated_wins",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "final_placement": {
+          "name": "final_placement",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "cs2_major_stage_results_unique": {
+          "name": "cs2_major_stage_results_unique",
+          "columns": [
+            {
+              "expression": "scoring_event_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "cs2_major_stage_results_scoring_event_id_scoring_events_id_fk": {
+          "name": "cs2_major_stage_results_scoring_event_id_scoring_events_id_fk",
+          "tableFrom": "cs2_major_stage_results",
+          "tableTo": "scoring_events",
+          "columnsFrom": [
+            "scoring_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "cs2_major_stage_results_participant_id_season_participants_id_fk": {
+          "name": "cs2_major_stage_results_participant_id_season_participants_id_fk",
+          "tableFrom": "cs2_major_stage_results",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.draft_picks": {
+      "name": "draft_picks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pick_number": {
+          "name": "pick_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "round": {
+          "name": "round",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pick_in_round": {
+          "name": "pick_in_round",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "picked_by_user_id": {
+          "name": "picked_by_user_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "picked_by_type": {
+          "name": "picked_by_type",
+          "type": "picked_by_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_used": {
+          "name": "time_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "draft_picks_season_pick_unique": {
+          "name": "draft_picks_season_pick_unique",
+          "columns": [
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "pick_number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "draft_picks_season_id_seasons_id_fk": {
+          "name": "draft_picks_season_id_seasons_id_fk",
+          "tableFrom": "draft_picks",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_picks_team_id_teams_id_fk": {
+          "name": "draft_picks_team_id_teams_id_fk",
+          "tableFrom": "draft_picks",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_picks_participant_id_season_participants_id_fk": {
+          "name": "draft_picks_participant_id_season_participants_id_fk",
+          "tableFrom": "draft_picks",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.draft_queue": {
+      "name": "draft_queue",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "queue_position": {
+          "name": "queue_position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "draft_queue_season_id_seasons_id_fk": {
+          "name": "draft_queue_season_id_seasons_id_fk",
+          "tableFrom": "draft_queue",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_queue_team_id_teams_id_fk": {
+          "name": "draft_queue_team_id_teams_id_fk",
+          "tableFrom": "draft_queue",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_queue_participant_id_season_participants_id_fk": {
+          "name": "draft_queue_participant_id_season_participants_id_fk",
+          "tableFrom": "draft_queue",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.draft_slots": {
+      "name": "draft_slots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "draft_order": {
+          "name": "draft_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "draft_slots_season_id_seasons_id_fk": {
+          "name": "draft_slots_season_id_seasons_id_fk",
+          "tableFrom": "draft_slots",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_slots_team_id_teams_id_fk": {
+          "name": "draft_slots_team_id_teams_id_fk",
+          "tableFrom": "draft_slots",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.draft_timers": {
+      "name": "draft_timers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_remaining": {
+          "name": "time_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "draft_timers_season_id_seasons_id_fk": {
+          "name": "draft_timers_season_id_seasons_id_fk",
+          "tableFrom": "draft_timers",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "draft_timers_team_id_teams_id_fk": {
+          "name": "draft_timers_team_id_teams_id_fk",
+          "tableFrom": "draft_timers",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.event_results": {
+      "name": "event_results",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "scoring_event_id": {
+          "name": "scoring_event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "season_participant_id": {
+          "name": "season_participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "placement": {
+          "name": "placement",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "qualifying_points_awarded": {
+          "name": "qualifying_points_awarded",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "eliminated": {
+          "name": "eliminated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_score": {
+          "name": "raw_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "event_results_event_participant_unique": {
+          "name": "event_results_event_participant_unique",
+          "columns": [
+            {
+              "expression": "scoring_event_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season_participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "event_results_scoring_event_id_scoring_events_id_fk": {
+          "name": "event_results_scoring_event_id_scoring_events_id_fk",
+          "tableFrom": "event_results",
+          "tableTo": "scoring_events",
+          "columnsFrom": [
+            "scoring_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "event_results_season_participant_id_season_participants_id_fk": {
+          "name": "event_results_season_participant_id_season_participants_id_fk",
+          "tableFrom": "event_results",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "season_participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.group_stage_matches": {
+      "name": "group_stage_matches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "tournament_group_id": {
+          "name": "tournament_group_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant1_id": {
+          "name": "participant1_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant2_id": {
+          "name": "participant2_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant1_score": {
+          "name": "participant1_score",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participant2_score": {
+          "name": "participant2_score",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_complete": {
+          "name": "is_complete",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "matchday": {
+          "name": "matchday",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scheduled_at": {
+          "name": "scheduled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "group_stage_matches_group_pair_unique": {
+          "name": "group_stage_matches_group_pair_unique",
+          "columns": [
+            {
+              "expression": "tournament_group_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "participant1_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "participant2_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "group_stage_matches_tournament_group_id_tournament_groups_id_fk": {
+          "name": "group_stage_matches_tournament_group_id_tournament_groups_id_fk",
+          "tableFrom": "group_stage_matches",
+          "tableTo": "tournament_groups",
+          "columnsFrom": [
+            "tournament_group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "group_stage_matches_participant1_id_season_participants_id_fk": {
+          "name": "group_stage_matches_participant1_id_season_participants_id_fk",
+          "tableFrom": "group_stage_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant1_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "group_stage_matches_participant2_id_season_participants_id_fk": {
+          "name": "group_stage_matches_participant2_id_season_participants_id_fk",
+          "tableFrom": "group_stage_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant2_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.leagues": {
+      "name": "leagues",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "current_season_id": {
+          "name": "current_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_public_draft_board": {
+          "name": "is_public_draft_board",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "discord_webhook_url": {
+          "name": "discord_webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_ev_snapshots": {
+      "name": "participant_ev_snapshots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "snapshot_date": {
+          "name": "snapshot_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prob_first": {
+          "name": "prob_first",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_second": {
+          "name": "prob_second",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_third": {
+          "name": "prob_third",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_fourth": {
+          "name": "prob_fourth",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_fifth": {
+          "name": "prob_fifth",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_sixth": {
+          "name": "prob_sixth",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_seventh": {
+          "name": "prob_seventh",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_eighth": {
+          "name": "prob_eighth",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "calculated_ev": {
+          "name": "calculated_ev",
+          "type": "numeric(10, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participant_ev_snapshots_unique": {
+          "name": "participant_ev_snapshots_unique",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "snapshot_date",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "participant_ev_snapshots_participant_id_season_participants_id_fk": {
+          "name": "participant_ev_snapshots_participant_id_season_participants_id_fk",
+          "tableFrom": "participant_ev_snapshots",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "participant_ev_snapshots_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_ev_snapshots_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_ev_snapshots",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_golf_skills": {
+      "name": "participant_golf_skills",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sg_total": {
+          "name": "sg_total",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "datagolf_rank": {
+          "name": "datagolf_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "masters_odds": {
+          "name": "masters_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "us_open_odds": {
+          "name": "us_open_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_championship_odds": {
+          "name": "open_championship_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pga_championship_odds": {
+          "name": "pga_championship_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participant_golf_skills_participant_unique": {
+          "name": "participant_golf_skills_participant_unique",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "participant_golf_skills_participant_id_participants_id_fk": {
+          "name": "participant_golf_skills_participant_id_participants_id_fk",
+          "tableFrom": "participant_golf_skills",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_season_results": {
+      "name": "participant_season_results",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "current_points": {
+          "name": "current_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "current_position": {
+          "name": "current_position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "participant_season_results_participant_id_season_participants_id_fk": {
+          "name": "participant_season_results_participant_id_season_participants_id_fk",
+          "tableFrom": "participant_season_results",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "participant_season_results_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_season_results_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_season_results",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_surface_elos": {
+      "name": "participant_surface_elos",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "world_ranking": {
+          "name": "world_ranking",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "elo_hard": {
+          "name": "elo_hard",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "elo_clay": {
+          "name": "elo_clay",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "elo_grass": {
+          "name": "elo_grass",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participant_surface_elos_participant_unique": {
+          "name": "participant_surface_elos_participant_unique",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "participant_surface_elos_participant_id_participants_id_fk": {
+          "name": "participant_surface_elos_participant_id_participants_id_fk",
+          "tableFrom": "participant_surface_elos",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participants": {
+      "name": "participants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sport_id": {
+          "name": "sport_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_key": {
+          "name": "external_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participants_sport_name_unique": {
+          "name": "participants_sport_name_unique",
+          "columns": [
+            {
+              "expression": "sport_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "participants_sport_id_sports_id_fk": {
+          "name": "participants_sport_id_sports_id_fk",
+          "tableFrom": "participants",
+          "tableTo": "sports",
+          "columnsFrom": [
+            "sport_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pending_standings_mappings": {
+      "name": "pending_standings_mappings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_team_id": {
+          "name": "external_team_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_name": {
+          "name": "team_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "standing_data": {
+          "name": "standing_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "psm_season_external_id_idx": {
+          "name": "psm_season_external_id_idx",
+          "columns": [
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pending_standings_mappings_sports_season_id_sports_seasons_id_fk": {
+          "name": "pending_standings_mappings_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "pending_standings_mappings",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.playoff_match_games": {
+      "name": "playoff_match_games",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "playoff_match_id": {
+          "name": "playoff_match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "game_number": {
+          "name": "game_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scheduled_at": {
+          "name": "scheduled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "playoff_match_game_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'scheduled'"
+        },
+        "participant1_score": {
+          "name": "participant1_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participant2_score": {
+          "name": "participant2_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "winner_id": {
+          "name": "winner_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "playoff_match_games_playoff_match_id_playoff_matches_id_fk": {
+          "name": "playoff_match_games_playoff_match_id_playoff_matches_id_fk",
+          "tableFrom": "playoff_match_games",
+          "tableTo": "playoff_matches",
+          "columnsFrom": [
+            "playoff_match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "playoff_match_games_winner_id_season_participants_id_fk": {
+          "name": "playoff_match_games_winner_id_season_participants_id_fk",
+          "tableFrom": "playoff_match_games",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "winner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.playoff_match_odds": {
+      "name": "playoff_match_odds",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "playoff_match_id": {
+          "name": "playoff_match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "moneyline_odds": {
+          "name": "moneyline_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "implied_probability": {
+          "name": "implied_probability",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "odds_source": {
+          "name": "odds_source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "recorded_at": {
+          "name": "recorded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "playoff_match_odds_playoff_match_id_playoff_matches_id_fk": {
+          "name": "playoff_match_odds_playoff_match_id_playoff_matches_id_fk",
+          "tableFrom": "playoff_match_odds",
+          "tableTo": "playoff_matches",
+          "columnsFrom": [
+            "playoff_match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "playoff_match_odds_participant_id_season_participants_id_fk": {
+          "name": "playoff_match_odds_participant_id_season_participants_id_fk",
+          "tableFrom": "playoff_match_odds",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.playoff_matches": {
+      "name": "playoff_matches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "scoring_event_id": {
+          "name": "scoring_event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "round": {
+          "name": "round",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_number": {
+          "name": "match_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant1_id": {
+          "name": "participant1_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participant2_id": {
+          "name": "participant2_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "winner_id": {
+          "name": "winner_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "loser_id": {
+          "name": "loser_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_complete": {
+          "name": "is_complete",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "participant1_score": {
+          "name": "participant1_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participant2_score": {
+          "name": "participant2_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_scoring": {
+          "name": "is_scoring",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "template_round": {
+          "name": "template_round",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "seed_info": {
+          "name": "seed_info",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "playoff_matches_scoring_event_id_scoring_events_id_fk": {
+          "name": "playoff_matches_scoring_event_id_scoring_events_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "scoring_events",
+          "columnsFrom": [
+            "scoring_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_participant1_id_season_participants_id_fk": {
+          "name": "playoff_matches_participant1_id_season_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant1_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_participant2_id_season_participants_id_fk": {
+          "name": "playoff_matches_participant2_id_season_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant2_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_winner_id_season_participants_id_fk": {
+          "name": "playoff_matches_winner_id_season_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "winner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_loser_id_season_participants_id_fk": {
+          "name": "playoff_matches_loser_id_season_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "loser_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.qualifying_point_config": {
+      "name": "qualifying_point_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "placement": {
+          "name": "placement",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "points": {
+          "name": "points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "qualifying_point_config_sports_season_id_sports_seasons_id_fk": {
+          "name": "qualifying_point_config_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "qualifying_point_config",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.regular_season_standings": {
+      "name": "regular_season_standings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "wins": {
+          "name": "wins",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "losses": {
+          "name": "losses",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "ot_losses": {
+          "name": "ot_losses",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ties": {
+          "name": "ties",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "table_points": {
+          "name": "table_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "goals_for": {
+          "name": "goals_for",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "goals_against": {
+          "name": "goals_against",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "goal_difference": {
+          "name": "goal_difference",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "win_pct": {
+          "name": "win_pct",
+          "type": "numeric(5, 4)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "games_played": {
+          "name": "games_played",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "games_back": {
+          "name": "games_back",
+          "type": "numeric(5, 1)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "conference": {
+          "name": "conference",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "division": {
+          "name": "division",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "conference_rank": {
+          "name": "conference_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "division_rank": {
+          "name": "division_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "league_rank": {
+          "name": "league_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "streak": {
+          "name": "streak",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_ten": {
+          "name": "last_ten",
+          "type": "varchar(15)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "home_record": {
+          "name": "home_record",
+          "type": "varchar(15)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "away_record": {
+          "name": "away_record",
+          "type": "varchar(15)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_team_id": {
+          "name": "external_team_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "srs": {
+          "name": "srs",
+          "type": "numeric(6, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "synced_at": {
+          "name": "synced_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "rss_participant_season_idx": {
+          "name": "rss_participant_season_idx",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "regular_season_standings_participant_id_season_participants_id_fk": {
+          "name": "regular_season_standings_participant_id_season_participants_id_fk",
+          "tableFrom": "regular_season_standings",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "regular_season_standings_sports_season_id_sports_seasons_id_fk": {
+          "name": "regular_season_standings_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "regular_season_standings",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scoring_events": {
+      "name": "scoring_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tournament_id": {
+          "name": "tournament_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event_date": {
+          "name": "event_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_starts_at": {
+          "name": "event_starts_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "event_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "playoff_round": {
+          "name": "playoff_round",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_qualifying_event": {
+          "name": "is_qualifying_event",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "bracket_template_id": {
+          "name": "bracket_template_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scoring_starts_at_round": {
+          "name": "scoring_starts_at_round",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bracket_region_config": {
+          "name": "bracket_region_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_complete": {
+          "name": "is_complete",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "scoring_events_sports_season_id_sports_seasons_id_fk": {
+          "name": "scoring_events_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "scoring_events",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "scoring_events_tournament_id_tournaments_id_fk": {
+          "name": "scoring_events_tournament_id_tournaments_id_fk",
+          "tableFrom": "scoring_events",
+          "tableTo": "tournaments",
+          "columnsFrom": [
+            "tournament_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "scoring_events_qualifying_require_tournament": {
+          "name": "scoring_events_qualifying_require_tournament",
+          "value": "NOT \"scoring_events\".\"is_qualifying_event\" OR \"scoring_events\".\"tournament_id\" IS NOT NULL"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.season_participant_expected_values": {
+      "name": "season_participant_expected_values",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prob_first": {
+          "name": "prob_first",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_second": {
+          "name": "prob_second",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_third": {
+          "name": "prob_third",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_fourth": {
+          "name": "prob_fourth",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_fifth": {
+          "name": "prob_fifth",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_sixth": {
+          "name": "prob_sixth",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_seventh": {
+          "name": "prob_seventh",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "prob_eighth": {
+          "name": "prob_eighth",
+          "type": "numeric(6, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "expected_value": {
+          "name": "expected_value",
+          "type": "numeric(10, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "source": {
+          "name": "source",
+          "type": "probability_source",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'manual'"
+        },
+        "source_odds": {
+          "name": "source_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_elo": {
+          "name": "source_elo",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "world_ranking": {
+          "name": "world_ranking",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "calculated_at": {
+          "name": "calculated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participant_ev_participant_season_unique": {
+          "name": "participant_ev_participant_season_unique",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "season_participant_expected_values_participant_id_season_participants_id_fk": {
+          "name": "season_participant_expected_values_participant_id_season_participants_id_fk",
+          "tableFrom": "season_participant_expected_values",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_participant_expected_values_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_participant_expected_values_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_participant_expected_values",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_participant_golf_skills": {
+      "name": "season_participant_golf_skills",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sg_total": {
+          "name": "sg_total",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "datagolf_rank": {
+          "name": "datagolf_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "masters_odds": {
+          "name": "masters_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "us_open_odds": {
+          "name": "us_open_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_championship_odds": {
+          "name": "open_championship_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pga_championship_odds": {
+          "name": "pga_championship_odds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "season_participant_golf_skills_unique": {
+          "name": "season_participant_golf_skills_unique",
+          "columns": [
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "season_participant_golf_skills_participant_id_season_participants_id_fk": {
+          "name": "season_participant_golf_skills_participant_id_season_participants_id_fk",
+          "tableFrom": "season_participant_golf_skills",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_participant_golf_skills_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_participant_golf_skills_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_participant_golf_skills",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_participant_qualifying_totals": {
+      "name": "season_participant_qualifying_totals",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_qualifying_points": {
+          "name": "total_qualifying_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "events_scored": {
+          "name": "events_scored",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "final_ranking": {
+          "name": "final_ranking",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "season_participant_qualifying_totals_participant_id_season_participants_id_fk": {
+          "name": "season_participant_qualifying_totals_participant_id_season_participants_id_fk",
+          "tableFrom": "season_participant_qualifying_totals",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_participant_qualifying_totals_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_participant_qualifying_totals_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_participant_qualifying_totals",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_participant_results": {
+      "name": "season_participant_results",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "final_position": {
+          "name": "final_position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_partial_score": {
+          "name": "is_partial_score",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "qualifying_points": {
+          "name": "qualifying_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "season_participant_results_participant_id_season_participants_id_fk": {
+          "name": "season_participant_results_participant_id_season_participants_id_fk",
+          "tableFrom": "season_participant_results",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_participant_results_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_participant_results_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_participant_results",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_participants": {
+      "name": "season_participants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "short_name": {
+          "name": "short_name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expected_value": {
+          "name": "expected_value",
+          "type": "numeric(10, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "vorp_value": {
+          "name": "vorp_value",
+          "type": "numeric(10, 4)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "participants_sports_season_name_unique": {
+          "name": "participants_sports_season_name_unique",
+          "columns": [
+            {
+              "expression": "sports_season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "season_participants_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_participants_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_participants",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_participants_participant_id_participants_id_fk": {
+          "name": "season_participants_participant_id_participants_id_fk",
+          "tableFrom": "season_participants",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_sports": {
+      "name": "season_sports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "season_sports_season_id_seasons_id_fk": {
+          "name": "season_sports_season_id_seasons_id_fk",
+          "tableFrom": "season_sports",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_sports_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_sports_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_sports",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_template_sports": {
+      "name": "season_template_sports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "season_template_sports_template_id_season_templates_id_fk": {
+          "name": "season_template_sports_template_id_season_templates_id_fk",
+          "tableFrom": "season_template_sports",
+          "tableTo": "season_templates",
+          "columnsFrom": [
+            "template_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "season_template_sports_sports_season_id_sports_seasons_id_fk": {
+          "name": "season_template_sports_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "season_template_sports",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.season_templates": {
+      "name": "season_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year": {
+          "name": "year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seasons": {
+      "name": "seasons",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "league_id": {
+          "name": "league_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "year": {
+          "name": "year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "season_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pre_draft'"
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "draft_rounds": {
+          "name": "draft_rounds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 20
+        },
+        "flex_spots": {
+          "name": "flex_spots",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "draft_date_time": {
+          "name": "draft_date_time",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "draft_initial_time": {
+          "name": "draft_initial_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 120
+        },
+        "draft_increment_time": {
+          "name": "draft_increment_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 30
+        },
+        "draft_timer_mode": {
+          "name": "draft_timer_mode",
+          "type": "draft_timer_mode",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'chess_clock'"
+        },
+        "current_pick_number": {
+          "name": "current_pick_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1
+        },
+        "draft_started_at": {
+          "name": "draft_started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "draft_completed_at": {
+          "name": "draft_completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "draft_paused": {
+          "name": "draft_paused",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "overnight_pause_mode": {
+          "name": "overnight_pause_mode",
+          "type": "overnight_pause_mode",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "overnight_pause_start": {
+          "name": "overnight_pause_start",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "overnight_pause_end": {
+          "name": "overnight_pause_end",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "overnight_pause_timezone": {
+          "name": "overnight_pause_timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "invite_code": {
+          "name": "invite_code",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "points_for_1st": {
+          "name": "points_for_1st",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "points_for_2nd": {
+          "name": "points_for_2nd",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 70
+        },
+        "points_for_3rd": {
+          "name": "points_for_3rd",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 50
+        },
+        "points_for_4th": {
+          "name": "points_for_4th",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 40
+        },
+        "points_for_5th": {
+          "name": "points_for_5th",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 25
+        },
+        "points_for_6th": {
+          "name": "points_for_6th",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 25
+        },
+        "points_for_7th": {
+          "name": "points_for_7th",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 15
+        },
+        "points_for_8th": {
+          "name": "points_for_8th",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 15
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "seasons_league_id_leagues_id_fk": {
+          "name": "seasons_league_id_leagues_id_fk",
+          "tableFrom": "seasons",
+          "tableTo": "leagues",
+          "columnsFrom": [
+            "league_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "seasons_template_id_season_templates_id_fk": {
+          "name": "seasons_template_id_season_templates_id_fk",
+          "tableFrom": "seasons",
+          "tableTo": "season_templates",
+          "columnsFrom": [
+            "template_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seasons_invite_code_unique": {
+          "name": "seasons_invite_code_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "invite_code"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "sessions_user_id_users_id_fk": {
+          "name": "sessions_user_id_users_id_fk",
+          "tableFrom": "sessions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_unique": {
+          "name": "sessions_token_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sports": {
+      "name": "sports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "sport_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon_url": {
+          "name": "icon_url",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "simulator_type": {
+          "name": "simulator_type",
+          "type": "simulator_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sports_slug_unique": {
+          "name": "sports_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sports_seasons": {
+      "name": "sports_seasons",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sport_id": {
+          "name": "sport_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "fantasy_season_id": {
+          "name": "fantasy_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "year": {
+          "name": "year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_date": {
+          "name": "start_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "end_date": {
+          "name": "end_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "sports_season_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'upcoming'"
+        },
+        "scoring_type": {
+          "name": "scoring_type",
+          "type": "scoring_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scoring_pattern": {
+          "name": "scoring_pattern",
+          "type": "scoring_pattern",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_majors": {
+          "name": "total_majors",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "majors_completed": {
+          "name": "majors_completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "qualifying_points_finalized": {
+          "name": "qualifying_points_finalized",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "elo_calibration_exponent": {
+          "name": "elo_calibration_exponent",
+          "type": "numeric(3, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "elo_min_rating": {
+          "name": "elo_min_rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1250
+        },
+        "elo_max_rating": {
+          "name": "elo_max_rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1750
+        },
+        "simulation_status": {
+          "name": "simulation_status",
+          "type": "simulation_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "draft_on": {
+          "name": "draft_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "draft_off": {
+          "name": "draft_off",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "sports_seasons_sport_id_sports_id_fk": {
+          "name": "sports_seasons_sport_id_sports_id_fk",
+          "tableFrom": "sports_seasons",
+          "tableTo": "sports",
+          "columnsFrom": [
+            "sport_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "sports_seasons_fantasy_season_id_seasons_id_fk": {
+          "name": "sports_seasons_fantasy_season_id_seasons_id_fk",
+          "tableFrom": "sports_seasons",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "fantasy_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.team_ev_snapshots": {
+      "name": "team_ev_snapshots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "snapshot_date": {
+          "name": "snapshot_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "projected_points": {
+          "name": "projected_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "actual_points": {
+          "name": "actual_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "team_ev_snapshots_unique": {
+          "name": "team_ev_snapshots_unique",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "snapshot_date",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "team_ev_snapshots_team_id_teams_id_fk": {
+          "name": "team_ev_snapshots_team_id_teams_id_fk",
+          "tableFrom": "team_ev_snapshots",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_ev_snapshots_season_id_seasons_id_fk": {
+          "name": "team_ev_snapshots_season_id_seasons_id_fk",
+          "tableFrom": "team_ev_snapshots",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.team_score_events": {
+      "name": "team_score_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scoring_event_id": {
+          "name": "scoring_event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scoring_event_name": {
+          "name": "scoring_event_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sport_name": {
+          "name": "sport_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_id": {
+          "name": "match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participant_ids": {
+          "name": "participant_ids",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "points_delta": {
+          "name": "points_delta",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "occurred_at": {
+          "name": "occurred_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "team_score_events_match_unique": {
+          "name": "team_score_events_match_unique",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "match_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "match_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "team_score_events_event_unique": {
+          "name": "team_score_events_event_unique",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scoring_event_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "match_id IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "team_score_events_team_id_teams_id_fk": {
+          "name": "team_score_events_team_id_teams_id_fk",
+          "tableFrom": "team_score_events",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_score_events_season_id_seasons_id_fk": {
+          "name": "team_score_events_season_id_seasons_id_fk",
+          "tableFrom": "team_score_events",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_score_events_scoring_event_id_scoring_events_id_fk": {
+          "name": "team_score_events_scoring_event_id_scoring_events_id_fk",
+          "tableFrom": "team_score_events",
+          "tableTo": "scoring_events",
+          "columnsFrom": [
+            "scoring_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "team_score_events_match_id_playoff_matches_id_fk": {
+          "name": "team_score_events_match_id_playoff_matches_id_fk",
+          "tableFrom": "team_score_events",
+          "tableTo": "playoff_matches",
+          "columnsFrom": [
+            "match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.team_sport_scores": {
+      "name": "team_sport_scores",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_points": {
+          "name": "total_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "participants_completed": {
+          "name": "participants_completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "participants_total": {
+          "name": "participants_total",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "calculated_at": {
+          "name": "calculated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "team_sport_scores_team_id_teams_id_fk": {
+          "name": "team_sport_scores_team_id_teams_id_fk",
+          "tableFrom": "team_sport_scores",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_sport_scores_sports_season_id_sports_seasons_id_fk": {
+          "name": "team_sport_scores_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "team_sport_scores",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.team_standings": {
+      "name": "team_standings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_points": {
+          "name": "total_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "current_rank": {
+          "name": "current_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "previous_rank": {
+          "name": "previous_rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "first_place_count": {
+          "name": "first_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "second_place_count": {
+          "name": "second_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "third_place_count": {
+          "name": "third_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "fourth_place_count": {
+          "name": "fourth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "fifth_place_count": {
+          "name": "fifth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sixth_place_count": {
+          "name": "sixth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "seventh_place_count": {
+          "name": "seventh_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "eighth_place_count": {
+          "name": "eighth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "participants_remaining": {
+          "name": "participants_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "actual_points": {
+          "name": "actual_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "projected_points": {
+          "name": "projected_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participants_finished": {
+          "name": "participants_finished",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "calculated_at": {
+          "name": "calculated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "team_standings_team_id_teams_id_fk": {
+          "name": "team_standings_team_id_teams_id_fk",
+          "tableFrom": "team_standings",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_standings_season_id_seasons_id_fk": {
+          "name": "team_standings_season_id_seasons_id_fk",
+          "tableFrom": "team_standings",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.team_standings_snapshots": {
+      "name": "team_standings_snapshots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "snapshot_date": {
+          "name": "snapshot_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_points": {
+          "name": "total_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'0'"
+        },
+        "rank": {
+          "name": "rank",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "first_place_count": {
+          "name": "first_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "second_place_count": {
+          "name": "second_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "third_place_count": {
+          "name": "third_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "fourth_place_count": {
+          "name": "fourth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "fifth_place_count": {
+          "name": "fifth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sixth_place_count": {
+          "name": "sixth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "seventh_place_count": {
+          "name": "seventh_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "eighth_place_count": {
+          "name": "eighth_place_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "participants_remaining": {
+          "name": "participants_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "actual_points": {
+          "name": "actual_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "projected_points": {
+          "name": "projected_points",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "participants_finished": {
+          "name": "participants_finished",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "team_standings_snapshots_unique": {
+          "name": "team_standings_snapshots_unique",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "snapshot_date",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "team_standings_snapshots_team_id_teams_id_fk": {
+          "name": "team_standings_snapshots_team_id_teams_id_fk",
+          "tableFrom": "team_standings_snapshots",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_standings_snapshots_season_id_seasons_id_fk": {
+          "name": "team_standings_snapshots_season_id_seasons_id_fk",
+          "tableFrom": "team_standings_snapshots",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.teams": {
+      "name": "teams",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "logo_url": {
+          "name": "logo_url",
+          "type": "varchar(512)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "flag_config": {
+          "name": "flag_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_type": {
+          "name": "avatar_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'owner'"
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "teams_season_id_seasons_id_fk": {
+          "name": "teams_season_id_seasons_id_fk",
+          "tableFrom": "teams",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tournament_group_members": {
+      "name": "tournament_group_members",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "tournament_group_id": {
+          "name": "tournament_group_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "eliminated": {
+          "name": "eliminated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "tournament_group_members_tournament_group_id_tournament_groups_id_fk": {
+          "name": "tournament_group_members_tournament_group_id_tournament_groups_id_fk",
+          "tableFrom": "tournament_group_members",
+          "tableTo": "tournament_groups",
+          "columnsFrom": [
+            "tournament_group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tournament_group_members_participant_id_season_participants_id_fk": {
+          "name": "tournament_group_members_participant_id_season_participants_id_fk",
+          "tableFrom": "tournament_group_members",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tournament_groups": {
+      "name": "tournament_groups",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "scoring_event_id": {
+          "name": "scoring_event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "group_name": {
+          "name": "group_name",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "tournament_groups_scoring_event_id_scoring_events_id_fk": {
+          "name": "tournament_groups_scoring_event_id_scoring_events_id_fk",
+          "tableFrom": "tournament_groups",
+          "tableTo": "scoring_events",
+          "columnsFrom": [
+            "scoring_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tournament_results": {
+      "name": "tournament_results",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "tournament_id": {
+          "name": "tournament_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "placement": {
+          "name": "placement",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_score": {
+          "name": "raw_score",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tournament_results_tournament_participant_unique": {
+          "name": "tournament_results_tournament_participant_unique",
+          "columns": [
+            {
+              "expression": "tournament_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tournament_results_tournament_id_tournaments_id_fk": {
+          "name": "tournament_results_tournament_id_tournaments_id_fk",
+          "tableFrom": "tournament_results",
+          "tableTo": "tournaments",
+          "columnsFrom": [
+            "tournament_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tournament_results_participant_id_participants_id_fk": {
+          "name": "tournament_results_participant_id_participants_id_fk",
+          "tableFrom": "tournament_results",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tournaments": {
+      "name": "tournaments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "sport_id": {
+          "name": "sport_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "year": {
+          "name": "year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "surface": {
+          "name": "surface",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "tournament_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'scheduled'"
+        },
+        "external_key": {
+          "name": "external_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tournaments_sport_name_year_unique": {
+          "name": "tournaments_sport_name_year_unique",
+          "columns": [
+            {
+              "expression": "sport_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "year",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tournaments_sport_id_sports_id_fk": {
+          "name": "tournaments_sport_id_sports_id_fk",
+          "tableFrom": "tournaments",
+          "tableTo": "sports",
+          "columnsFrom": [
+            "sport_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "clerk_id": {
+          "name": "clerk_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "first_name": {
+          "name": "first_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_name": {
+          "name": "last_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image_url": {
+          "name": "image_url",
+          "type": "varchar(512)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "flag_config": {
+          "name": "flag_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "custom_avatar_url": {
+          "name": "custom_avatar_url",
+          "type": "varchar(512)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_type": {
+          "name": "avatar_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'flag'"
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_clerk_id_unique": {
+          "name": "users_clerk_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "clerk_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verifications": {
+      "name": "verifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.watchlist": {
+      "name": "watchlist",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "season_id": {
+          "name": "season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "participant_id": {
+          "name": "participant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "watchlist_season_team_participant_unique": {
+          "name": "watchlist_season_team_participant_unique",
+          "columns": [
+            {
+              "expression": "season_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "participant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "watchlist_season_id_seasons_id_fk": {
+          "name": "watchlist_season_id_seasons_id_fk",
+          "tableFrom": "watchlist",
+          "tableTo": "seasons",
+          "columnsFrom": [
+            "season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "watchlist_team_id_teams_id_fk": {
+          "name": "watchlist_team_id_teams_id_fk",
+          "tableFrom": "watchlist",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "team_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "watchlist_participant_id_season_participants_id_fk": {
+          "name": "watchlist_participant_id_season_participants_id_fk",
+          "tableFrom": "watchlist",
+          "tableTo": "season_participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.audit_action": {
+      "name": "audit_action",
+      "schema": "public",
+      "values": [
+        "league_settings_changed",
+        "draft_settings_changed",
+        "scoring_rules_changed",
+        "sports_changed",
+        "draft_order_set",
+        "draft_order_randomized",
+        "draft_started",
+        "draft_paused",
+        "draft_resumed",
+        "draft_reset",
+        "draft_rollback",
+        "force_autopick",
+        "force_manual_pick",
+        "draft_pick_changed",
+        "time_bank_edited",
+        "brackt_resolved"
+      ]
+    },
+    "public.autodraft_mode": {
+      "name": "autodraft_mode",
+      "schema": "public",
+      "values": [
+        "next_pick",
+        "while_on"
+      ]
+    },
+    "public.draft_timer_mode": {
+      "name": "draft_timer_mode",
+      "schema": "public",
+      "values": [
+        "chess_clock",
+        "standard"
+      ]
+    },
+    "public.event_type": {
+      "name": "event_type",
+      "schema": "public",
+      "values": [
+        "playoff_game",
+        "major_tournament",
+        "final_standings",
+        "schedule_event"
+      ]
+    },
+    "public.overnight_pause_mode": {
+      "name": "overnight_pause_mode",
+      "schema": "public",
+      "values": [
+        "none",
+        "league",
+        "per_user"
+      ]
+    },
+    "public.picked_by_type": {
+      "name": "picked_by_type",
+      "schema": "public",
+      "values": [
+        "owner",
+        "commissioner",
+        "admin",
+        "auto"
+      ]
+    },
+    "public.playoff_match_game_status": {
+      "name": "playoff_match_game_status",
+      "schema": "public",
+      "values": [
+        "scheduled",
+        "complete",
+        "postponed"
+      ]
+    },
+    "public.probability_source": {
+      "name": "probability_source",
+      "schema": "public",
+      "values": [
+        "manual",
+        "futures_odds",
+        "elo_simulation",
+        "performance_model"
+      ]
+    },
+    "public.scoring_pattern": {
+      "name": "scoring_pattern",
+      "schema": "public",
+      "values": [
+        "playoff_bracket",
+        "season_standings",
+        "qualifying_points"
+      ]
+    },
+    "public.scoring_type": {
+      "name": "scoring_type",
+      "schema": "public",
+      "values": [
+        "playoffs",
+        "regular_season",
+        "majors"
+      ]
+    },
+    "public.season_status": {
+      "name": "season_status",
+      "schema": "public",
+      "values": [
+        "pre_draft",
+        "draft",
+        "active",
+        "completed"
+      ]
+    },
+    "public.simulation_status": {
+      "name": "simulation_status",
+      "schema": "public",
+      "values": [
+        "idle",
+        "running",
+        "failed"
+      ]
+    },
+    "public.simulator_type": {
+      "name": "simulator_type",
+      "schema": "public",
+      "values": [
+        "f1_standings",
+        "indycar_standings",
+        "golf_qualifying_points",
+        "playoff_bracket",
+        "ucl_bracket",
+        "ncaam_bracket",
+        "ncaaw_bracket",
+        "nba_bracket",
+        "nhl_bracket",
+        "nfl_bracket",
+        "afl_bracket",
+        "epl_standings",
+        "snooker_bracket",
+        "tennis_qualifying_points",
+        "mlb_bracket",
+        "wnba_bracket",
+        "world_cup",
+        "darts_bracket",
+        "cs2_major_qualifying_points",
+        "ncaa_football_bracket",
+        "llws_bracket",
+        "brackt"
+      ]
+    },
+    "public.sport_type": {
+      "name": "sport_type",
+      "schema": "public",
+      "values": [
+        "team",
+        "individual"
+      ]
+    },
+    "public.sports_season_status": {
+      "name": "sports_season_status",
+      "schema": "public",
+      "values": [
+        "upcoming",
+        "active",
+        "completed"
+      ]
+    },
+    "public.tournament_status": {
+      "name": "tournament_status",
+      "schema": "public",
+      "values": [
+        "scheduled",
+        "in_progress",
+        "completed"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index c2d7c39..8f77026 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -673,6 +673,13 @@
       "when": 1778043585280,
       "tag": "0095_lucky_madrox",
       "breakpoints": true
+    },
+    {
+      "idx": 96,
+      "version": "7",
+      "when": 1778177368941,
+      "tag": "0096_demonic_vulture",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file