diff --git a/app/lib/bracket-templates.ts b/app/lib/bracket-templates.ts
index c985c0b..e0a6f53 100644
--- a/app/lib/bracket-templates.ts
+++ b/app/lib/bracket-templates.ts
@@ -302,6 +302,73 @@ export const SIMPLE_32: BracketTemplate = {
   ],
 };
 
+/**
+ * PDC World Darts Championship (128 players)
+ * R1 (128) → R2 (64) → R3 (32) → R4 (16) → Quarterfinals → Semifinals → Final
+ * Only Quarterfinals and beyond score points.
+ *
+ * Match formats:
+ *   R1:  best-of-3 sets (first to 2)
+ *   R2:  best-of-5 sets (first to 3)
+ *   R3:  best-of-5 sets (first to 3)
+ *   R4:  best-of-7 sets (first to 4)
+ *   QF:  best-of-7 sets (first to 4)
+ *   SF:  best-of-11 sets (first to 6)
+ *   Final: best-of-13 sets (first to 7)
+ *
+ * Seeding: top 32 seeds placed in fixed positions; remaining 96 randomly drawn.
+ */
+export const DARTS_128: BracketTemplate = {
+  id: "darts_128",
+  name: "PDC World Darts Championship (128 Players)",
+  totalTeams: 128,
+  scoringStartsAtRound: "Quarterfinals",
+  rounds: [
+    {
+      name: "Round 1",
+      matchCount: 64,
+      feedsInto: "Round 2",
+      isScoring: false,
+    },
+    {
+      name: "Round 2",
+      matchCount: 32,
+      feedsInto: "Round 3",
+      isScoring: false,
+    },
+    {
+      name: "Round 3",
+      matchCount: 16,
+      feedsInto: "Round 4",
+      isScoring: false,
+    },
+    {
+      name: "Round 4",
+      matchCount: 8,
+      feedsInto: "Quarterfinals",
+      isScoring: false,
+    },
+    {
+      name: "Quarterfinals",
+      matchCount: 4,
+      feedsInto: "Semi-Finals",
+      isScoring: true, // QF losers share 5th–8th
+    },
+    {
+      name: "Semi-Finals",
+      matchCount: 2,
+      feedsInto: "Final",
+      isScoring: true, // SF losers share 3rd–4th
+    },
+    {
+      name: "Final",
+      matchCount: 1,
+      feedsInto: null,
+      isScoring: true, // Winner 1st, Loser 2nd
+    },
+  ],
+};
+
 /**
  * NCAA March Madness (68 teams)
  * First Four (play-in) → Round of 64 → Round of 32 → Sweet Sixteen → Elite Eight → Final Four → Championship
@@ -578,6 +645,7 @@ export const BRACKET_TEMPLATES: Record<string, BracketTemplate> = {
   nfl_14: NFL_14,
   afl_10: AFL_10,
   fifa_48: FIFA_48,
+  darts_128: DARTS_128,
 };
 
 /**
diff --git a/app/models/participant-expected-value.ts b/app/models/participant-expected-value.ts
index da99c33..405b06f 100644
--- a/app/models/participant-expected-value.ts
+++ b/app/models/participant-expected-value.ts
@@ -29,6 +29,7 @@ export interface ParticipantEV {
   source: ProbabilitySource | null;
   sourceOdds: number | null;
   sourceElo?: number | null;
+  worldRanking?: number | null;
   calculatedAt: Date;
   updatedAt: Date;
 }
@@ -362,12 +363,13 @@ export async function batchSaveSourceOdds(
 }
 
 /**
- * Persist raw Elo ratings for a batch of participants (used by Elo-based simulators like snooker_bracket).
+ * Persist raw Elo ratings (and optional world rankings) for a batch of participants.
+ * Used by Elo-based simulators like snooker_bracket and darts_bracket.
  * Creates stub records if none exist; does not touch probabilities or EV.
  * Uses INSERT ... ON CONFLICT DO UPDATE to avoid N+1 queries.
  */
 export async function batchSaveSourceElos(
-  inputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number }>
+  inputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }>
 ): Promise<void> {
   if (inputs.length === 0) return;
   const db = database();
@@ -376,7 +378,7 @@ export async function batchSaveSourceElos(
   await db
     .insert(participantExpectedValues)
     .values(
-      inputs.map(({ participantId, sportsSeasonId, sourceElo }) => ({
+      inputs.map(({ participantId, sportsSeasonId, sourceElo, worldRanking }) => ({
         participantId,
         sportsSeasonId,
         probFirst: "0",
@@ -390,6 +392,7 @@ export async function batchSaveSourceElos(
         expectedValue: "0",
         source: "elo_simulation" as const,
         sourceElo,
+        worldRanking: worldRanking ?? null,
         calculatedAt: now,
         updatedAt: now,
       }))
@@ -398,6 +401,7 @@ export async function batchSaveSourceElos(
       target: [participantExpectedValues.participantId, participantExpectedValues.sportsSeasonId],
       set: {
         sourceElo: sql`excluded.source_elo`,
+        worldRanking: sql`excluded.world_ranking`,
         updatedAt: sql`excluded.updated_at`,
       },
     });
diff --git a/app/routes.ts b/app/routes.ts
index 50e4959..cf108fa 100644
--- a/app/routes.ts
+++ b/app/routes.ts
@@ -95,6 +95,10 @@ export default [
       "sports-seasons/:id/surface-elo",
       "routes/admin.sports-seasons.$id.surface-elo.tsx"
     ),
+    route(
+      "sports-seasons/:id/darts-elo",
+      "routes/admin.sports-seasons.$id.darts-elo.tsx"
+    ),
     route(
       "sports-seasons/:id/golf-skills",
       "routes/admin.sports-seasons.$id.golf-skills.tsx"
diff --git a/app/routes/admin.sports-seasons.$id.darts-elo.tsx b/app/routes/admin.sports-seasons.$id.darts-elo.tsx
new file mode 100644
index 0000000..52cd5f4
--- /dev/null
+++ b/app/routes/admin.sports-seasons.$id.darts-elo.tsx
@@ -0,0 +1,470 @@
+import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
+import type { Route } from './+types/admin.sports-seasons.$id.darts-elo';
+
+import { logger } from '~/lib/logger';
+import { findSportsSeasonById, updateSportsSeason } from '~/models/sports-season';
+import { findParticipantsBySportsSeasonId } from '~/models/participant';
+import {
+  getAllParticipantEVsForSeason,
+  batchSaveSourceElos,
+  batchUpsertParticipantEVs,
+} from '~/models/participant-expected-value';
+import { batchUpsertParticipantEvSnapshots } from '~/models/ev-snapshot';
+import { getSimulator, type SimulatorType } from '~/services/simulations/registry';
+import { calculateEV } from '~/services/ev-calculator';
+import { DEFAULT_SCORING_RULES } from '~/lib/scoring-types';
+import { recalculateStandings } from '~/models/scoring-calculator';
+import { database } from '~/database/context';
+import * as schema from '~/database/schema';
+import { eq } from 'drizzle-orm';
+import { Button } from '~/components/ui/button';
+import { Input } from '~/components/ui/input';
+import { Label } from '~/components/ui/label';
+import { Textarea } from '~/components/ui/textarea';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '~/components/ui/card';
+import { useState } from 'react';
+import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
+import { normalizeName } from '~/lib/fuzzy-match';
+
+export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
+  return [{ title: `Darts Elo & Rankings — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
+}
+
+export async function loader({ params }: Route.LoaderArgs) {
+  const sportsSeasonId = params.id;
+
+  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
+  if (!sportsSeason) {
+    throw new Response('Sports season not found', { status: 404 });
+  }
+
+  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
+  const existingEVs = await getAllParticipantEVsForSeason(sportsSeasonId);
+
+  const existingData: Record<string, { elo: number | null; ranking: number | null }> = {};
+  for (const ev of existingEVs) {
+    existingData[ev.participantId] = {
+      elo: ev.sourceElo ?? null,
+      ranking: ev.worldRanking ?? null,
+    };
+  }
+
+  return { sportsSeason, participants, existingData };
+}
+
+interface ActionData {
+  success?: boolean;
+  message?: string;
+}
+
+export async function action({ request, params }: Route.ActionArgs) {
+  const sportsSeasonId = params.id;
+  const formData = await request.formData();
+
+  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
+  if (!sportsSeason) {
+    return { success: false, message: 'Sports season not found' };
+  }
+
+  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
+
+  // Parse Elo ratings and world rankings from form
+  const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }> = [];
+  for (const participant of participants) {
+    const eloVal = formData.get(`elo_${participant.id}`) as string;
+    const rankVal = formData.get(`rank_${participant.id}`) as string;
+
+    if (eloVal && eloVal.trim() !== '') {
+      const elo = Number(eloVal);
+      if (!isNaN(elo) && elo > 0) {
+        const ranking = rankVal && rankVal.trim() !== '' ? Number(rankVal) : null;
+        eloInputs.push({
+          participantId: participant.id,
+          sportsSeasonId,
+          sourceElo: elo,
+          worldRanking: ranking && !isNaN(ranking) && ranking > 0 ? ranking : null,
+        });
+      }
+    }
+  }
+
+  if (eloInputs.length === 0) {
+    return { success: false, message: 'Please enter an Elo rating for at least one participant' };
+  }
+
+  if (!sportsSeason.sport?.simulatorType) {
+    return { success: false, message: 'This sport has no simulator type configured. Set one on the sport in the admin panel.' };
+  }
+
+  if (sportsSeason.simulationStatus === 'running') {
+    return { success: false, message: 'A simulation is already running. Please wait.' };
+  }
+
+  // Persist Elo ratings and world rankings
+  await batchSaveSourceElos(eloInputs);
+
+  // Auto-run simulation
+  await updateSportsSeason(sportsSeasonId, { simulationStatus: 'running' });
+
+  try {
+    const simulator = getSimulator(sportsSeason.sport.simulatorType as SimulatorType);
+    const results = await simulator.simulate(sportsSeasonId);
+
+    if (results.length === 0) {
+      throw new Error('Simulation returned no results.');
+    }
+
+    // Zero out any participants not in simulation results
+    const simulatedIds = new Set(results.map(r => r.participantId));
+    const ZERO_PROBS = {
+      probFirst: 0, probSecond: 0, probThird: 0, probFourth: 0,
+      probFifth: 0, probSixth: 0, probSeventh: 0, probEighth: 0,
+    };
+    const evInputs = [
+      ...results.map(r => ({
+        participantId: r.participantId,
+        sportsSeasonId,
+        probabilities: r.probabilities,
+        scoringRules: DEFAULT_SCORING_RULES,
+        source: 'elo_simulation' as const,
+      })),
+      ...participants
+        .filter(p => !simulatedIds.has(p.id))
+        .map(p => ({
+          participantId: p.id,
+          sportsSeasonId,
+          probabilities: ZERO_PROBS,
+          scoringRules: DEFAULT_SCORING_RULES,
+          source: 'elo_simulation' as const,
+        })),
+    ];
+
+    await batchUpsertParticipantEVs(evInputs);
+
+    // Refresh projected points in team standings
+    const seasonSports = await database().query.seasonSports.findMany({
+      where: eq(schema.seasonSports.sportsSeasonId, sportsSeasonId),
+    });
+    await Promise.all(seasonSports.map(({ seasonId }) => recalculateStandings(seasonId)));
+
+    // EV snapshot
+    const today = new Date().toISOString().slice(0, 10);
+    await batchUpsertParticipantEvSnapshots(
+      results.map(r => ({
+        participantId: r.participantId,
+        sportsSeasonId,
+        snapshotDate: today,
+        probFirst: r.probabilities.probFirst,
+        probSecond: r.probabilities.probSecond,
+        probThird: r.probabilities.probThird,
+        probFourth: r.probabilities.probFourth,
+        probFifth: r.probabilities.probFifth,
+        probSixth: r.probabilities.probSixth,
+        probSeventh: r.probabilities.probSeventh,
+        probEighth: r.probabilities.probEighth,
+        calculatedEV: calculateEV(r.probabilities, DEFAULT_SCORING_RULES),
+        source: r.source,
+      }))
+    );
+
+    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'idle' });
+  } catch (error) {
+    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'failed' });
+    logger.error('Error running darts simulation:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Simulation failed',
+    };
+  }
+
+  return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
+}
+
+export default function AdminSportsSeasonDartsElo() {
+  const { sportsSeason, participants, existingData } = useLoaderData<typeof loader>();
+  const actionData = useActionData<ActionData>();
+  const navigation = useNavigation();
+
+  const [eloValues, setEloValues] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    participants.forEach(p => {
+      const d = existingData[p.id];
+      if (d?.elo !== null && d?.elo !== undefined) initial[p.id] = d.elo.toString();
+    });
+    return initial;
+  });
+
+  const [rankValues, setRankValues] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    participants.forEach(p => {
+      const d = existingData[p.id];
+      if (d?.ranking !== null && d?.ranking !== undefined) initial[p.id] = d.ranking.toString();
+    });
+    return initial;
+  });
+
+  // Bulk import state: "Player Name, 2099, 1" format (name, elo, optional world ranking)
+  const [bulkText, setBulkText] = useState('');
+  const [parseResults, setParseResults] = useState<{
+    matched: Array<{ participantId: string; name: string; elo: number; ranking: number | null; inputName: string }>;
+    unmatched: Array<{ inputName: string; elo: number; ranking: number | null }>;
+  } | null>(null);
+
+  function findParticipantMatch(inputName: string) {
+    const normalizedInput = normalizeName(inputName);
+    const normalized = participants.map(p => ({ p, n: normalizeName(p.name) }));
+
+    const exact = normalized.find(({ n }) => n === normalizedInput);
+    if (exact) return exact.p;
+
+    const contains = normalized.find(({ n }) => n.includes(normalizedInput) || normalizedInput.includes(n));
+    if (contains) return contains.p;
+
+    const inputWords = normalizedInput.split(' ').filter(w => w.length > 2);
+    const overlap = normalized.find(({ n }) => {
+      const pWords = n.split(' ').filter(w => w.length > 2);
+      const shared = inputWords.filter(w => pWords.includes(w));
+      return shared.length > 0 && shared.length >= Math.min(inputWords.length, pWords.length) * 0.5;
+    });
+
+    return overlap?.p ?? null;
+  }
+
+  function parseBulkText() {
+    // Formats supported:
+    //   "Player Name, 2099, 1"   (name, elo, world ranking)
+    //   "Player Name, 2099"      (name, elo — ranking omitted)
+    //   "Player Name: 2099: 1"   (colon-separated)
+    const lines = bulkText.split('\n');
+    const matched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['matched'] = [];
+    const unmatched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['unmatched'] = [];
+    const seen = new Set<string>();
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      // Match "Name, Elo" or "Name, Elo, Ranking" (comma, colon, or tab separated)
+      const match = /^(.+?)[\s,:\t]+(\d{3,5})(?:[\s,:\t]+(\d{1,3}))?\s*$/.exec(trimmed);
+      if (!match) continue;
+
+      const inputName = match[1].trim();
+      const elo = parseInt(match[2], 10);
+      const ranking = match[3] ? parseInt(match[3], 10) : null;
+
+      if (isNaN(elo) || elo < 500 || elo > 5000) continue;
+      if (ranking !== null && (isNaN(ranking) || ranking < 1 || ranking > 256)) continue;
+
+      const participant = findParticipantMatch(inputName);
+      if (participant && !seen.has(participant.id)) {
+        seen.add(participant.id);
+        matched.push({ participantId: participant.id, name: participant.name, elo, ranking, inputName });
+      } else if (!participant) {
+        unmatched.push({ inputName, elo, ranking });
+      }
+    }
+
+    setParseResults({ matched, unmatched });
+  }
+
+  function applyMatches() {
+    if (!parseResults) return;
+    const newElos = { ...eloValues };
+    const newRanks = { ...rankValues };
+    for (const m of parseResults.matched) {
+      newElos[m.participantId] = m.elo.toString();
+      if (m.ranking !== null) {
+        newRanks[m.participantId] = m.ranking.toString();
+      }
+    }
+    setEloValues(newElos);
+    setRankValues(newRanks);
+    setParseResults(null);
+    setBulkText('');
+  }
+
+  const isSubmitting = navigation.state === 'submitting';
+
+  // Sort participants for display: by current rank (ascending), then unranked alphabetically
+  const sortedParticipants = [...participants].toSorted((a, b) => {
+    const rankA = rankValues[a.id] ? parseInt(rankValues[a.id], 10) : null;
+    const rankB = rankValues[b.id] ? parseInt(rankValues[b.id], 10) : null;
+    if (rankA !== null && rankB !== null) return rankA - rankB;
+    if (rankA !== null) return -1;
+    if (rankB !== null) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return (
+    <div className="container mx-auto py-8">
+      <div className="mb-8">
+        <h1 className="text-3xl font-bold mb-2">Darts Elo &amp; World Rankings</h1>
+        <p className="text-muted-foreground">
+          {sportsSeason.sport.name} — {sportsSeason.name}
+        </p>
+      </div>
+
+      {/* Bulk Import */}
+      <Card className="mb-6">
+        <CardHeader>
+          <CardTitle>Bulk Import</CardTitle>
+          <CardDescription>
+            Paste one player per line. Format:{' '}
+            <code>Player Name, 2099, 1</code> (name, Elo, world ranking).
+            World ranking is optional — omit it and the simulator will use Elo order for seeding.
+            Player names are fuzzy-matched to participants.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <Textarea
+            placeholder={`Luke Littler, 2099, 1\nMichael van Gerwen, 1950, 2\nLuke Humphries, 1947, 3`}
+            value={bulkText}
+            onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
+            rows={10}
+            className="font-mono text-sm"
+          />
+          <Button type="button" variant="outline" onClick={parseBulkText} disabled={!bulkText.trim()}>
+            Parse
+          </Button>
+
+          {parseResults && (
+            <div className="space-y-3">
+              {parseResults.matched.length > 0 && (
+                <div>
+                  <div className="flex items-center gap-2 text-sm font-medium text-emerald-400 mb-2">
+                    <CheckCircle2 className="h-4 w-4" />
+                    Matched ({parseResults.matched.length})
+                  </div>
+                  <div className="rounded-md border border-emerald-500/30 bg-emerald-500/10 divide-y divide-emerald-500/20 text-sm">
+                    {parseResults.matched.map(m => (
+                      <div key={m.participantId} className="flex justify-between px-3 py-1.5">
+                        <span className="text-muted-foreground">{m.inputName}</span>
+                        <span className="font-medium">
+                          {m.name} &rarr; Elo {m.elo}{m.ranking !== null ? `, Rank #${m.ranking}` : ''}
+                        </span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+
+              {parseResults.unmatched.length > 0 && (
+                <div>
+                  <div className="flex items-center gap-2 text-sm font-medium text-amber-700 mb-2">
+                    <AlertCircle className="h-4 w-4" />
+                    Not matched ({parseResults.unmatched.length}) — enter manually below
+                  </div>
+                  <div className="rounded-md border border-amber-200 bg-amber-50 divide-y divide-amber-100 text-sm">
+                    {parseResults.unmatched.map(u => (
+                      <div key={u.inputName} className="flex justify-between px-3 py-1.5">
+                        <span>{u.inputName}</span>
+                        <span className="font-medium">
+                          Elo {u.elo}{u.ranking !== null ? `, Rank #${u.ranking}` : ''}
+                        </span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+
+              {parseResults.matched.length > 0 && (
+                <Button type="button" onClick={applyMatches}>
+                  Apply {parseResults.matched.length} matched entries to form
+                </Button>
+              )}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      <div className="grid gap-6 lg:grid-cols-2">
+        <Card>
+          <CardHeader>
+            <CardTitle>Player Elo &amp; Rankings</CardTitle>
+            <CardDescription>
+              Enter each player's Darts Elo and world ranking. World ranking determines bracket seeding
+              (top 32 seeded, rest randomly drawn). Saving will automatically run the simulation and
+              update expected values.
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Form method="post" className="space-y-4">
+              <div className="grid grid-cols-[1fr_100px_80px] gap-x-3 gap-y-2 items-center text-xs font-medium text-muted-foreground mb-1">
+                <span>Player</span>
+                <span>Elo</span>
+                <span>Rank #</span>
+              </div>
+              <div className="space-y-2">
+                {sortedParticipants.map(participant => (
+                  <div key={participant.id} className="grid grid-cols-[1fr_100px_80px] gap-x-3 items-center">
+                    <Label htmlFor={`elo_${participant.id}`} className="truncate text-sm">
+                      {participant.name}
+                    </Label>
+                    <Input
+                      type="number"
+                      id={`elo_${participant.id}`}
+                      name={`elo_${participant.id}`}
+                      placeholder="1800"
+                      value={eloValues[participant.id] ?? ''}
+                      onChange={e =>
+                        setEloValues(prev => ({ ...prev, [participant.id]: e.target.value }))
+                      }
+                      className="h-8 text-sm"
+                    />
+                    <Input
+                      type="number"
+                      name={`rank_${participant.id}`}
+                      placeholder="—"
+                      value={rankValues[participant.id] ?? ''}
+                      onChange={e =>
+                        setRankValues(prev => ({ ...prev, [participant.id]: e.target.value }))
+                      }
+                      className="h-8 text-sm"
+                    />
+                  </div>
+                ))}
+              </div>
+
+              {actionData && !actionData.success && actionData.message && (
+                <div className="text-sm text-destructive">{actionData.message}</div>
+              )}
+
+              <Button type="submit" disabled={isSubmitting}>
+                {isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+                {isSubmitting ? 'Saving & Running Simulation...' : 'Save & Run Simulation'}
+              </Button>
+            </Form>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader>
+            <CardTitle>How It Works</CardTitle>
+          </CardHeader>
+          <CardContent className="text-sm space-y-2">
+            <ol className="list-decimal list-inside space-y-2">
+              <li>Save Elo ratings and world rankings for all 128 players</li>
+              <li>Top 32 seeds placed in fixed bracket positions; remaining 96 randomly drawn per simulation</li>
+              <li>Per-set win probability: p = 1 / (1 + e^(−ΔElo/500))</li>
+              <li>Match win probability via Bernoulli sets model for each round's best-of length</li>
+              <li>Run 50,000 Monte Carlo simulations of the full bracket</li>
+              <li>Distribute probabilities across 1st–8th place buckets</li>
+              <li>Calculate expected fantasy value per player</li>
+            </ol>
+            <div className="mt-4 text-muted-foreground text-xs space-y-1">
+              <div>Round formats: R1 bo3, R2/R3 bo5, R4/QF bo7, SF bo11, Final bo13</div>
+              <div>If world ranking is omitted, players are seeded by Elo order.</div>
+              <div>Once the bracket draw is announced, add players to the bracket event for live simulation.</div>
+            </div>
+          </CardContent>
+        </Card>
+      </div>
+    </div>
+  );
+}
diff --git a/app/services/simulations/__tests__/darts-simulator.test.ts b/app/services/simulations/__tests__/darts-simulator.test.ts
new file mode 100644
index 0000000..804ba8e
--- /dev/null
+++ b/app/services/simulations/__tests__/darts-simulator.test.ts
@@ -0,0 +1,455 @@
+import { describe, it, expect, vi, beforeEach, type MockInstance } from "vitest";
+import {
+  setWinProb,
+  matchWinProb,
+  getSeededMatchOrder,
+  buildR1Bracket,
+  DartsSimulator,
+} from "../darts-simulator";
+
+// ─── Pure math: setWinProb ────────────────────────────────────────────────────
+
+describe("setWinProb", () => {
+  it("returns 0.5 for equal Elo", () => {
+    expect(setWinProb(1800, 1800)).toBeCloseTo(0.5, 5);
+    expect(setWinProb(2000, 2000)).toBeCloseTo(0.5, 5);
+  });
+
+  it("returns > 0.5 for positive Elo advantage, < 0.5 for negative", () => {
+    expect(setWinProb(2000, 1700)).toBeGreaterThan(0.5);
+    expect(setWinProb(1700, 2000)).toBeLessThan(0.5);
+  });
+
+  it("is symmetric: setWinProb(a, b) + setWinProb(b, a) = 1", () => {
+    expect(setWinProb(2000, 1700) + setWinProb(1700, 2000)).toBeCloseTo(1.0, 5);
+    expect(setWinProb(2099, 1952) + setWinProb(1952, 2099)).toBeCloseTo(1.0, 5);
+  });
+
+  it("larger Elo gap → higher win probability (monotonic)", () => {
+    const p100 = setWinProb(1900, 1800);
+    const p300 = setWinProb(2100, 1800);
+    const p500 = setWinProb(2300, 1800);
+    expect(p300).toBeGreaterThan(p100);
+    expect(p500).toBeGreaterThan(p300);
+  });
+
+  it("returns value strictly in (0, 1) for any finite Elo", () => {
+    expect(setWinProb(3000, 1000)).toBeLessThan(1);
+    expect(setWinProb(3000, 1000)).toBeGreaterThan(0);
+    expect(setWinProb(1000, 3000)).toBeLessThan(1);
+    expect(setWinProb(1000, 3000)).toBeGreaterThan(0);
+  });
+
+  it("calibration: 100-pt gap → ~55% per set (ELO_DIVISOR=500)", () => {
+    // 1 / (1 + e^(-100/500)) ≈ 0.5499
+    expect(setWinProb(1900, 1800)).toBeCloseTo(0.5499, 2);
+  });
+});
+
+// ─── Pure math: matchWinProb ──────────────────────────────────────────────────
+
+describe("matchWinProb", () => {
+  it("returns 0.5 for equal players (p=0.5) at any match length", () => {
+    // PDC formats: bo3 (S=2), bo5 (S=3), bo7 (S=4), bo11 (S=6), bo13 (S=7)
+    expect(matchWinProb(0.5, 2)).toBeCloseTo(0.5, 3);
+    expect(matchWinProb(0.5, 3)).toBeCloseTo(0.5, 3);
+    expect(matchWinProb(0.5, 4)).toBeCloseTo(0.5, 3);
+    expect(matchWinProb(0.5, 6)).toBeCloseTo(0.5, 3);
+    expect(matchWinProb(0.5, 7)).toBeCloseTo(0.5, 3);
+  });
+
+  it("approaches 1.0 as p → 1.0", () => {
+    expect(matchWinProb(0.9999, 2)).toBeCloseTo(1.0, 3);
+    expect(matchWinProb(0.9999, 7)).toBeCloseTo(1.0, 3);
+  });
+
+  it("approaches 0.0 as p → 0.0", () => {
+    expect(matchWinProb(0.0001, 2)).toBeCloseTo(0.0, 3);
+    expect(matchWinProb(0.0001, 7)).toBeCloseTo(0.0, 3);
+  });
+
+  it("longer matches amplify stronger player's advantage", () => {
+    // p=0.6: win prob should be higher in best-of-13 than best-of-3
+    const bo3  = matchWinProb(0.6, 2);
+    const bo13 = matchWinProb(0.6, 7);
+    expect(bo13).toBeGreaterThan(bo3);
+  });
+
+  it("match win prob + opponent win prob sums to 1.0", () => {
+    const p = 0.63;
+    expect(matchWinProb(p, 3) + matchWinProb(1 - p, 3)).toBeCloseTo(1.0, 5);
+    expect(matchWinProb(p, 6) + matchWinProb(1 - p, 6)).toBeCloseTo(1.0, 5);
+  });
+
+  it("best-of-3 (S=2): reference check for p=0.6 → ~0.648", () => {
+    // P(2-0) = 0.6^2 = 0.36; P(2-1) = 2 * 0.6^2 * 0.4 = 0.288; total = 0.648
+    expect(matchWinProb(0.6, 2)).toBeCloseTo(0.648, 3);
+  });
+});
+
+// ─── Bracket structure: getSeededMatchOrder ──────────────────────────────────
+
+describe("getSeededMatchOrder", () => {
+  it("for n=2, returns [1, 2]", () => {
+    expect(getSeededMatchOrder(2)).toEqual([1, 2]);
+  });
+
+  it("for n=4, seed 1 vs 4 in top half, seed 2 vs 3 in bottom half", () => {
+    // Algorithm: start [1,2] → expand to [1,4,2,3]
+    expect(getSeededMatchOrder(4)).toEqual([1, 4, 2, 3]);
+  });
+
+  it("for n=8, seed 1 and seed 2 are in opposite halves", () => {
+    const order = getSeededMatchOrder(8);
+    expect(order).toHaveLength(8);
+    const idx1 = order.indexOf(1);
+    const idx2 = order.indexOf(2);
+    // Seeds 1 and 2 should be in different halves (0-3 vs 4-7)
+    expect(Math.floor(idx1 / 4)).not.toBe(Math.floor(idx2 / 4));
+  });
+
+  it("for n=32, contains all seeds 1–32 exactly once", () => {
+    const order = getSeededMatchOrder(32);
+    expect(order).toHaveLength(32);
+    const sorted = [...order].toSorted((a, b) => a - b);
+    expect(sorted).toEqual(Array.from({ length: 32 }, (_, i) => i + 1));
+  });
+
+  it("for n=32, seed 1 and seed 2 are in opposite halves", () => {
+    const order = getSeededMatchOrder(32);
+    const idx1 = order.indexOf(1);
+    const idx2 = order.indexOf(2);
+    // Opposite halves: one in [0,15], other in [16,31]
+    expect(Math.floor(idx1 / 16)).not.toBe(Math.floor(idx2 / 16));
+  });
+});
+
+// ─── Bracket structure: buildR1Bracket ───────────────────────────────────────
+
+describe("buildR1Bracket", () => {
+  const seeded   = Array.from({ length: 32 }, (_, i) => `seed-${i + 1}`);
+  const unseeded = Array.from({ length: 96 }, (_, i) => `unseed-${i}`);
+
+  it("returns exactly 64 pairs", () => {
+    const pairs = buildR1Bracket(seeded, unseeded);
+    expect(pairs).toHaveLength(64);
+  });
+
+  it("covers all 128 players (32 seeded + 96 unseeded)", () => {
+    const pairs = buildR1Bracket(seeded, unseeded);
+    const allPlayers = pairs.flat();
+    expect(allPlayers).toHaveLength(128);
+
+    for (const [a, b] of pairs) {
+      expect(a).toBeTruthy();
+      expect(b).toBeTruthy();
+    }
+
+    // All seeded players appear exactly once
+    for (const s of seeded) {
+      expect(allPlayers.filter(p => p === s)).toHaveLength(1);
+    }
+
+    // All unseeded players appear exactly once
+    for (const u of unseeded) {
+      expect(allPlayers.filter(p => p === u)).toHaveLength(1);
+    }
+  });
+
+  it("each of the 32 seeded players faces an unseeded opponent in their R1 match", () => {
+    const pairs = buildR1Bracket(seeded, unseeded);
+    const seededSet = new Set(seeded);
+
+    // First 32 pairs: seeded vs unseeded
+    for (let i = 0; i < 32; i++) {
+      const [a, b] = pairs[i];
+      const aSeeded = seededSet.has(a);
+      const bSeeded = seededSet.has(b);
+      // One must be seeded, the other unseeded
+      expect(aSeeded !== bSeeded).toBe(true);
+    }
+  });
+
+  it("last 32 pairs: all unseeded vs unseeded", () => {
+    const pairs = buildR1Bracket(seeded, unseeded);
+    const seededSet = new Set(seeded);
+
+    for (let i = 32; i < 64; i++) {
+      const [a, b] = pairs[i];
+      expect(seededSet.has(a)).toBe(false);
+      expect(seededSet.has(b)).toBe(false);
+    }
+  });
+});
+
+// ─── Integration tests with mocked DB ────────────────────────────────────────
+
+const PARTICIPANT_IDS = Array.from({ length: 128 }, (_, i) => `player-${i + 1}`);
+const ELO_BASE = 1750;
+
+function makeMatch(
+  round: string,
+  matchNumber: number,
+  p1Index: number,
+  p2Index: number,
+  opts: { winnerId?: string; loserId?: string; isComplete?: boolean } = {}
+) {
+  return {
+    id: `${round}-match-${matchNumber}`,
+    scoringEventId: "event-1",
+    round,
+    matchNumber,
+    participant1Id: PARTICIPANT_IDS[p1Index],
+    participant2Id: PARTICIPANT_IDS[p2Index],
+    winnerId: opts.winnerId ?? null,
+    loserId: opts.loserId ?? null,
+    isComplete: opts.isComplete ?? false,
+    isScoring: true,
+    templateRound: round,
+    seedInfo: null,
+    participant1Score: null,
+    participant2Score: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+}
+
+/** Build a full 7-round bracket (128 players, 127 matches). */
+function makeFullBracket(): ReturnType<typeof makeMatch>[] {
+  const matches: ReturnType<typeof makeMatch>[] = [];
+  for (let i = 0; i < 64; i++) matches.push(makeMatch("Round 1", i + 1, i * 2, i * 2 + 1));
+  for (let i = 0; i < 32; i++) matches.push(makeMatch("Round 2", i + 1, 0, 1));
+  for (let i = 0; i < 16; i++) matches.push(makeMatch("Round 3", i + 1, 0, 1));
+  for (let i = 0; i < 8;  i++) matches.push(makeMatch("Round 4", i + 1, 0, 1));
+  for (let i = 0; i < 4;  i++) matches.push(makeMatch("Quarter-Finals", i + 1, 0, 1));
+  for (let i = 0; i < 2;  i++) matches.push(makeMatch("Semi-Finals", i + 1, 0, 1));
+  matches.push(makeMatch("Final", 1, 0, 1));
+  return matches;
+}
+
+function makeEVRows(eloOverride?: Map<string, number>) {
+  return PARTICIPANT_IDS.map((participantId) => ({
+    participantId,
+    sourceElo: eloOverride?.get(participantId) ?? ELO_BASE,
+    worldRanking: null,
+  }));
+}
+
+vi.mock("~/database/context", () => ({
+  database: vi.fn(),
+}));
+
+describe("DartsSimulator.simulate() — Path A (bracket populated)", () => {
+  let mockDb: {
+    query: {
+      scoringEvents: { findFirst: MockInstance };
+      playoffMatches: { findMany: MockInstance };
+    };
+    select: MockInstance;
+  };
+
+  beforeEach(async () => {
+    const { database } = await import("~/database/context");
+
+    mockDb = {
+      query: {
+        scoringEvents: { findFirst: vi.fn() },
+        playoffMatches: { findMany: vi.fn() },
+      },
+      select: vi.fn().mockReturnValue({
+        from: vi.fn().mockReturnValue({
+          where: vi.fn().mockResolvedValue(makeEVRows()),
+        }),
+      }),
+    };
+
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
+
+    mockDb.query.scoringEvents.findFirst.mockResolvedValue({
+      id: "event-1",
+      sportsSeasonId: "season-1",
+      eventType: "playoff_game",
+    });
+  });
+
+  it("throws if bracket does not have exactly 7 rounds", async () => {
+    // Only 6 rounds (missing Final)
+    const matches = [
+      ...Array.from({ length: 64 }, (_, i) => makeMatch("Round 1", i + 1, i * 2, i * 2 + 1)),
+      ...Array.from({ length: 32 }, (_, i) => makeMatch("Round 2", i + 1, 0, 1)),
+      ...Array.from({ length: 16 }, (_, i) => makeMatch("Round 3", i + 1, 0, 1)),
+      ...Array.from({ length: 8  }, (_, i) => makeMatch("Round 4", i + 1, 0, 1)),
+      ...Array.from({ length: 4  }, (_, i) => makeMatch("Quarter-Finals", i + 1, 0, 1)),
+      ...Array.from({ length: 2  }, (_, i) => makeMatch("Semi-Finals", i + 1, 0, 1)),
+    ];
+    mockDb.query.playoffMatches.findMany.mockResolvedValue(matches);
+
+    const sim = new DartsSimulator();
+    await expect(sim.simulate("season-1")).rejects.toThrow(/Expected 7 rounds/);
+  });
+
+  it("throws if R1 does not have 64 matches", async () => {
+    const matches = [
+      ...Array.from({ length: 32 }, (_, i) => makeMatch("Round 1", i + 1, i * 2, i * 2 + 1)),
+      ...Array.from({ length: 32 }, (_, i) => makeMatch("Round 2", i + 1, 0, 1)),
+      ...Array.from({ length: 16 }, (_, i) => makeMatch("Round 3", i + 1, 0, 1)),
+      ...Array.from({ length: 8  }, (_, i) => makeMatch("Round 4", i + 1, 0, 1)),
+      ...Array.from({ length: 4  }, (_, i) => makeMatch("Quarter-Finals", i + 1, 0, 1)),
+      ...Array.from({ length: 2  }, (_, i) => makeMatch("Semi-Finals", i + 1, 0, 1)),
+      makeMatch("Final", 1, 0, 1),
+    ];
+    mockDb.query.playoffMatches.findMany.mockResolvedValue(matches);
+
+    const sim = new DartsSimulator();
+    await expect(sim.simulate("season-1")).rejects.toThrow(/Expected 64 R1 matches/);
+  });
+
+  it("returns 128 results with valid probability distributions", async () => {
+    mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
+
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    expect(results).toHaveLength(128);
+    for (const r of results) {
+      const p = r.probabilities;
+      expect(p.probFirst).toBeGreaterThanOrEqual(0);
+      expect(p.probFirst).toBeLessThanOrEqual(1);
+      const sum = p.probFirst + p.probSecond + p.probThird + p.probFourth +
+        p.probFifth + p.probSixth + p.probSeventh + p.probEighth;
+      expect(sum).toBeGreaterThanOrEqual(0);
+      expect(sum).toBeLessThanOrEqual(1.001);
+    }
+  });
+
+  it("each probability column sums to 1.0 across all 128 participants", async () => {
+    mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
+
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    const keys = [
+      "probFirst", "probSecond", "probThird", "probFourth",
+      "probFifth", "probSixth", "probSeventh", "probEighth",
+    ] as const;
+    for (const key of keys) {
+      const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
+      expect(colSum).toBeCloseTo(1.0, 2);
+    }
+  });
+
+  it("labels results with darts_world_championship_monte_carlo source", async () => {
+    mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
+
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    expect(results.every(r => r.source === "darts_world_championship_monte_carlo")).toBe(true);
+  });
+});
+
+// ─── Path B: pre-bracket simulation ──────────────────────────────────────────
+
+describe("DartsSimulator.simulate() — Path B (pre-bracket)", () => {
+  let mockDb: {
+    query: {
+      scoringEvents: { findFirst: MockInstance };
+      playoffMatches: { findMany: MockInstance };
+    };
+    select: MockInstance;
+  };
+
+  // 128 participants with world rankings
+  const SEASON_PARTICIPANTS = Array.from({ length: 128 }, (_, i) => ({
+    id: `player-${i + 1}`,
+    name: `Player ${i + 1}`,
+  }));
+
+  function makeEVRowsWithRankings() {
+    return SEASON_PARTICIPANTS.map((p, i) => ({
+      participantId: p.id,
+      sourceElo: ELO_BASE - i * 2, // higher seed = higher Elo
+      worldRanking: i + 1,
+    }));
+  }
+
+  beforeEach(async () => {
+    const { database } = await import("~/database/context");
+
+    const eloRows = makeEVRowsWithRankings();
+    const participantRows = SEASON_PARTICIPANTS;
+
+    mockDb = {
+      query: {
+        scoringEvents: { findFirst: vi.fn() },
+        playoffMatches: { findMany: vi.fn() },
+      },
+      select: vi.fn()
+        .mockReturnValueOnce({
+          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(eloRows) }),
+        })
+        .mockReturnValueOnce({
+          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(participantRows) }),
+        }),
+    };
+
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
+
+    mockDb.query.scoringEvents.findFirst.mockResolvedValue(null);
+    mockDb.query.playoffMatches.findMany.mockResolvedValue([]);
+  });
+
+  it("returns 128 results when bracket is not yet populated", async () => {
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    expect(results).toHaveLength(128);
+  });
+
+  it("each probability column sums to 1.0 across all 128 participants", async () => {
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    const keys = [
+      "probFirst", "probSecond", "probThird", "probFourth",
+      "probFifth", "probSixth", "probSeventh", "probEighth",
+    ] as const;
+    for (const key of keys) {
+      const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
+      expect(colSum).toBeCloseTo(1.0, 2);
+    }
+  });
+
+  it("world #1 (highest Elo) has the highest probFirst", async () => {
+    const sim = new DartsSimulator();
+    const results = await sim.simulate("season-1");
+
+    const sorted = [...results].toSorted((a, b) => b.probabilities.probFirst - a.probabilities.probFirst);
+    // player-1 is world #1 with the highest Elo — should have highest win probability
+    expect(sorted[0].participantId).toBe("player-1");
+  });
+
+  it("throws if fewer than 2 participants exist", async () => {
+    const { database } = await import("~/database/context");
+    const tooFew = [{ id: "player-1", name: "Solo" }];
+    const eloRowsFew = [{ participantId: "player-1", sourceElo: ELO_BASE, worldRanking: 1 }];
+
+    (database as unknown as MockInstance).mockReturnValue({
+      ...mockDb,
+      query: {
+        scoringEvents: { findFirst: vi.fn().mockResolvedValue(null) },
+        playoffMatches: { findMany: vi.fn().mockResolvedValue([]) },
+      },
+      select: vi.fn()
+        .mockReturnValueOnce({
+          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(eloRowsFew) }),
+        })
+        .mockReturnValueOnce({
+          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(tooFew) }),
+        }),
+    });
+
+    const sim = new DartsSimulator();
+    await expect(sim.simulate("season-1")).rejects.toThrow(/at least 2 participants/);
+  });
+});
diff --git a/app/services/simulations/darts-simulator.ts b/app/services/simulations/darts-simulator.ts
new file mode 100644
index 0000000..922e6ba
--- /dev/null
+++ b/app/services/simulations/darts-simulator.ts
@@ -0,0 +1,629 @@
+/**
+ * PDC World Darts Championship Simulator
+ *
+ * Monte Carlo simulation of the PDC World Darts Championship.
+ * The tournament is a 128-player single-elimination bracket with 7 rounds,
+ * using best-of-sets formats that increase in length each round.
+ *
+ * Algorithm:
+ *   1. Load all participants and their Elo + world ranking from participantExpectedValues.
+ *   2. Two simulation paths:
+ *      a. Bracket populated: simulate from actual draw, respecting completed matches.
+ *      b. Pre-bracket: top 32 seeds placed into fixed balanced bracket positions;
+ *         remaining 96 players randomly drawn into unseeded slots each simulation.
+ *   3. Compute per-set win probability using the logistic sigmoid:
+ *        p_set = 1 / (1 + e^(-(Elo1 - Elo2) / ELO_DIVISOR))
+ *   4. Compute match win probability using the Bernoulli sets model:
+ *        P(win) = sum_{w2=0}^{S-1} C(S-1+w2, w2) * p^S * (1-p)^w2
+ *      where S = sets to win, which varies by round.
+ *   5. Track integer placement counts per tier across 50,000 simulations.
+ *   6. Convert to probability distributions using exact denominators (column sums = 1.0).
+ *
+ * Round format (PDC World Championship):
+ *   R1  (R128): best-of-3  sets, first to 2
+ *   R2  (R64):  best-of-5  sets, first to 3
+ *   R3  (R32):  best-of-5  sets, first to 3
+ *   R4  (R16):  best-of-7  sets, first to 4
+ *   QF:         best-of-7  sets, first to 4
+ *   SF:         best-of-11 sets, first to 6
+ *   Final:      best-of-13 sets, first to 7
+ *
+ * Seeding (pre-bracket path):
+ *   Top 32 players (by world ranking) are seeded into fixed bracket positions
+ *   using the standard balanced bracket structure:
+ *     R1 seeds: 1v32, 16v17, 9v24, 8v25 (top half) + 5v28, 12v21, 13v20, 4v29
+ *               3v30, 14v19, 11v22, 6v27 (bottom half) + 7v26, 10v23, 15v18, 2v31
+ *   Each seed's unseeded opponent slot is randomly filled from the 96 unseeded players
+ *   in each simulation run — spreading the draw uncertainty across all simulations.
+ *
+ * Placement bucketing (8-slot probability model):
+ *   probFirst          → Champion
+ *   probSecond         → Finalist
+ *   probThird/Fourth   → SF losers (2/sim)
+ *   probFifth–Eighth   → QF losers (4/sim)
+ *   Earlier rounds     → all 0
+ */
+
+import { database } from "~/database/context";
+import { eq, and } from "drizzle-orm";
+import * as schema from "~/database/schema";
+import type { Simulator, SimulationResult } from "./types";
+
+// ─── Simulation parameters ────────────────────────────────────────────────────
+
+const NUM_SIMULATIONS = 50000;
+
+/**
+ * Controls how much Elo gaps affect per-set win probability.
+ * Higher = softer probabilities (more randomness).
+ * Lower  = sharper (Elo differences matter more).
+ *
+ * Standard chess uses 400. Snooker (more random than chess) uses 700.
+ * Darts is moderately volatile; 500 gives:
+ *   100-pt gap → ~55% per set
+ *   300-pt gap → ~63% per set
+ *   500-pt gap → ~73% per set
+ */
+const ELO_DIVISOR = 500;
+
+/**
+ * Sets needed to win per round, in bracket order (R1 first, Final last).
+ * Index 0 = R1/R128  (64 matches, best-of-3,  need 2)
+ * Index 1 = R2/R64   (32 matches, best-of-5,  need 3)
+ * Index 2 = R3/R32   (16 matches, best-of-5,  need 3)
+ * Index 3 = R4/R16   (8  matches, best-of-7,  need 4)
+ * Index 4 = QF       (4  matches, best-of-7,  need 4)
+ * Index 5 = SF       (2  matches, best-of-11, need 6)
+ * Index 6 = Final    (1  match,   best-of-13, need 7)
+ */
+const SETS_TO_WIN = [2, 3, 3, 4, 4, 6, 7] as const;
+
+/**
+ * Number of seeds that get fixed bracket positions.
+ * The remaining (128 - TOP_SEEDS) players are randomly drawn.
+ */
+const TOP_SEEDS = 32;
+
+// ─── Math helpers ──────────────────────────────────────────────────────────────
+
+/**
+ * Per-set win probability for player 1 vs player 2 based on Elo.
+ * Exported for unit testing.
+ */
+export function setWinProb(elo1: number, elo2: number): number {
+  return 1 / (1 + Math.exp(-(elo1 - elo2) / ELO_DIVISOR));
+}
+
+/**
+ * Match win probability for player 1 using the Bernoulli sets model.
+ * For a best-of-(2S-1) match (first to S sets):
+ *   P(win) = sum_{w2=0}^{S-1} C(S-1+w2, w2) * p^S * (1-p)^w2
+ * Exported for unit testing.
+ */
+export function matchWinProb(p: number, setsToWin: number): number {
+  const S = setsToWin;
+  let prob = 0;
+  for (let w2 = 0; w2 < S; w2++) {
+    prob += binomialCoeff(S - 1 + w2, w2) * Math.pow(p, S) * Math.pow(1 - p, w2);
+  }
+  return prob;
+}
+
+/** Binomial coefficient C(n, k) via iterative multiplication. */
+function binomialCoeff(n: number, k: number): number {
+  if (k === 0) return 1;
+  if (k > n - k) k = n - k;
+  let result = 1;
+  for (let i = 0; i < k; i++) {
+    result = (result * (n - i)) / (i + 1);
+  }
+  return result;
+}
+
+/**
+ * Returns the 128-player seeded bracket R1 pair list.
+ * Each entry is [participantIdA, participantIdB].
+ * Top 32 seeded players fill fixed positions; 96 unseeded players are randomly
+ * shuffled and assigned to the remaining slots.
+ *
+ * Structure:
+ *   - 32 seeded-vs-unseeded matches (seeds 1–32 each face a randomly drawn unseeded opponent)
+ *   - 32 unseeded-vs-unseeded matches (remaining 64 unseeded players paired randomly)
+ *   Total: 64 R1 matches ✓ (128 players)
+ *
+ * Note: in the hot simulation loop, seeded positions are pre-computed via getSeededMatchOrder
+ * and inlined directly — this function is used for testing and bracket-draw path only.
+ *
+ * Exported for unit testing.
+ */
+export function buildR1Bracket(
+  seededIds: string[],   // exactly 32, index 0 = seed 1
+  unseededIds: string[]  // exactly 96, shuffled
+): Array<[string, string]> {
+  // The 32 seeded players each face one of the first 32 unseeded opponents.
+  // Seeds are arranged in bracket order using the standard balanced structure
+  // for 32 seeds (same algorithm as snooker's R32_BRACKET but generalised).
+  const seededMatchOrder = getSeededMatchOrder(32); // returns 32 seed positions in bracket order
+
+  const pairs: Array<[string, string]> = [];
+
+  // 32 seeded-vs-unseeded R1 matches
+  for (let i = 0; i < 32; i++) {
+    const seedPos = seededMatchOrder[i] - 1; // 0-indexed
+    pairs.push([seededIds[seedPos], unseededIds[i]]);
+  }
+
+  // 32 unseeded-vs-unseeded R1 matches (players 32–95)
+  for (let i = 32; i < 96; i += 2) {
+    pairs.push([unseededIds[i], unseededIds[i + 1]]);
+  }
+
+  return pairs;
+}
+
+/**
+ * Returns seed positions in standard balanced bracket order for N seeds.
+ * Guarantees seed 1 and seed 2 can only meet in the Final.
+ * E.g. for N=4: [1, 4, 3, 2] → match order 1v4, 3v2 in the top/bottom halves.
+ *
+ * Algorithm: start with [1, 2], repeatedly interleave (n+1 - seed) complements.
+ * Exported for unit testing.
+ */
+export function getSeededMatchOrder(n: number): number[] {
+  let order = [1, 2];
+  while (order.length < n) {
+    const size = order.length;
+    const newOrder: number[] = [];
+    for (const seed of order) {
+      newOrder.push(seed);
+      newOrder.push(2 * size + 1 - seed);
+    }
+    order = newOrder;
+  }
+  return order;
+}
+
+/** Fisher-Yates shuffle (in-place, returns array). */
+function shuffle<T>(arr: T[]): T[] {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+// ─── Simulator ────────────────────────────────────────────────────────────────
+
+export class DartsSimulator implements Simulator {
+  async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
+    const db = database();
+
+    // 1. Find the bracket scoring event (if it exists).
+    const bracketEvent = await db.query.scoringEvents.findFirst({
+      where: and(
+        eq(schema.scoringEvents.sportsSeasonId, sportsSeasonId),
+        eq(schema.scoringEvents.eventType, "playoff_game")
+      ),
+    });
+
+    // 2. Load playoff matches (empty if bracket hasn't been drawn yet).
+    const allMatches = bracketEvent
+      ? await db.query.playoffMatches.findMany({
+          where: eq(schema.playoffMatches.scoringEventId, bracketEvent.id),
+          orderBy: (m, { asc }) => [asc(m.matchNumber)],
+        })
+      : [];
+
+    // 3. Load Elo ratings and world rankings.
+    const evRows = await db
+      .select({
+        participantId: schema.participantExpectedValues.participantId,
+        sourceElo: schema.participantExpectedValues.sourceElo,
+        worldRanking: schema.participantExpectedValues.worldRanking,
+      })
+      .from(schema.participantExpectedValues)
+      .where(eq(schema.participantExpectedValues.sportsSeasonId, sportsSeasonId));
+
+    const eloMap = new Map<string, number>();
+    const rankingMap = new Map<string, number>();
+    for (const r of evRows) {
+      if (r.sourceElo !== null && r.sourceElo !== undefined) {
+        eloMap.set(r.participantId, r.sourceElo);
+      }
+      if (r.worldRanking !== null && r.worldRanking !== undefined) {
+        rankingMap.set(r.participantId, r.worldRanking);
+      }
+    }
+
+    // Determine simulation path.
+    const bracketPopulated = allMatches.some((m) => m.participant1Id && m.participant2Id);
+
+    if (bracketPopulated) {
+      return this.simulateBracket(allMatches, eloMap);
+    } else {
+      return this.simulatePreBracket(sportsSeasonId, eloMap, rankingMap, db);
+    }
+  }
+
+  // ─── Path A: Bracket drawn ────────────────────────────────────────────────
+
+  private async simulateBracket(
+    allMatches: Awaited<ReturnType<ReturnType<typeof database>["query"]["playoffMatches"]["findMany"]>>,
+    eloMap: Map<string, number>
+  ): Promise<SimulationResult[]> {
+    // Group matches by round, sorted by match count descending (R1 first = most matches).
+    const byRound = new Map<string, typeof allMatches>();
+    for (const m of allMatches) {
+      if (!byRound.has(m.round)) byRound.set(m.round, []);
+      byRound.get(m.round)?.push(m);
+    }
+
+    const sortedRounds = [...byRound.values()]
+      .toSorted((a, b) => b.length - a.length)
+      .map((matches) => matches.sort((a, b) => a.matchNumber - b.matchNumber));
+
+    if (sortedRounds.length !== 7) {
+      throw new Error(
+        `Expected 7 rounds for PDC World Darts Championship, found ${sortedRounds.length}. ` +
+          `Rounds: ${[...byRound.keys()].join(", ")}`
+      );
+    }
+
+    const [r1Matches, r2Matches, r3Matches, r4Matches, qfMatches, sfMatches, finalMatches] = sortedRounds;
+
+    if (r1Matches.length !== 64) {
+      throw new Error(
+        `Expected 64 R1 matches (128-player bracket), found ${r1Matches.length}.`
+      );
+    }
+
+    // Collect all 128 participant IDs from R1.
+    const participantIds: string[] = [];
+    for (const m of r1Matches) {
+      if (!m.participant1Id || !m.participant2Id) {
+        throw new Error(
+          `R1 match ${m.matchNumber} is missing participants. ` +
+            `Assign all 128 players to the bracket before running simulation.`
+        );
+      }
+      participantIds.push(m.participant1Id, m.participant2Id);
+    }
+
+    const fallbackElo = 1600;
+
+    // Cache matchWinProb — Elo values are fixed across simulations.
+    const matchProbCache = new Map<string, number>();
+    const simMatch = (p1: string, p2: string, setsToWin: number): { winner: string; loser: string } => {
+      const elo1 = eloMap.get(p1) ?? fallbackElo;
+      const elo2 = eloMap.get(p2) ?? fallbackElo;
+      const cacheKey = `${elo1},${elo2},${setsToWin}`;
+      let winProb = matchProbCache.get(cacheKey);
+      if (winProb === undefined) {
+        winProb = matchWinProb(setWinProb(elo1, elo2), setsToWin);
+        matchProbCache.set(cacheKey, winProb);
+      }
+      const winner = Math.random() < winProb ? p1 : p2;
+      return { winner, loser: winner === p1 ? p2 : p1 };
+    };
+
+    const r1ByNum  = new Map(r1Matches.map((m) => [m.matchNumber, m]));
+    const r2ByNum  = new Map(r2Matches.map((m) => [m.matchNumber, m]));
+    const r3ByNum  = new Map(r3Matches.map((m) => [m.matchNumber, m]));
+    const r4ByNum  = new Map(r4Matches.map((m) => [m.matchNumber, m]));
+    const qfByNum  = new Map(qfMatches.map((m) => [m.matchNumber, m]));
+    const sfByNum  = new Map(sfMatches.map((m) => [m.matchNumber, m]));
+    const finalMatch = finalMatches[0];
+
+    const championCounts  = new Map<string, number>(participantIds.map((id) => [id, 0]));
+    const finalistCounts  = new Map<string, number>(participantIds.map((id) => [id, 0]));
+    const sfLoserCounts   = new Map<string, number>(participantIds.map((id) => [id, 0]));
+    const qfLoserCounts   = new Map<string, number>(participantIds.map((id) => [id, 0]));
+
+    for (let s = 0; s < NUM_SIMULATIONS; s++) {
+      // R1 (64 matches)
+      const r1Winners: string[] = [];
+      for (let i = 1; i <= 64; i++) {
+        const m = r1ByNum.get(i);
+        if (!m) continue;
+        if (m.isComplete && m.winnerId) {
+          r1Winners.push(m.winnerId);
+        } else {
+          const { winner } = simMatch(m.participant1Id ?? "", m.participant2Id ?? "", SETS_TO_WIN[0]);
+          r1Winners.push(winner);
+        }
+      }
+
+      // R2 (32 matches)
+      const r2Winners: string[] = [];
+      for (let i = 1; i <= 32; i++) {
+        const dbMatch = r2ByNum.get(i);
+        let winner: string;
+        if (dbMatch?.isComplete && dbMatch.winnerId) {
+          winner = dbMatch.winnerId;
+        } else {
+          const p1 = r1Winners[(i - 1) * 2];
+          const p2 = r1Winners[(i - 1) * 2 + 1];
+          ({ winner } = simMatch(p1, p2, SETS_TO_WIN[1]));
+        }
+        r2Winners.push(winner);
+      }
+
+      // R3 (16 matches)
+      const r3Winners: string[] = [];
+      for (let i = 1; i <= 16; i++) {
+        const dbMatch = r3ByNum.get(i);
+        let winner: string;
+        if (dbMatch?.isComplete && dbMatch.winnerId) {
+          winner = dbMatch.winnerId;
+        } else {
+          const p1 = r2Winners[(i - 1) * 2];
+          const p2 = r2Winners[(i - 1) * 2 + 1];
+          ({ winner } = simMatch(p1, p2, SETS_TO_WIN[2]));
+        }
+        r3Winners.push(winner);
+      }
+
+      // R4 (8 matches)
+      const r4Winners: string[] = [];
+      for (let i = 1; i <= 8; i++) {
+        const dbMatch = r4ByNum.get(i);
+        let winner: string;
+        if (dbMatch?.isComplete && dbMatch.winnerId) {
+          winner = dbMatch.winnerId;
+        } else {
+          const p1 = r3Winners[(i - 1) * 2];
+          const p2 = r3Winners[(i - 1) * 2 + 1];
+          ({ winner } = simMatch(p1, p2, SETS_TO_WIN[3]));
+        }
+        r4Winners.push(winner);
+      }
+
+      // QF (4 matches)
+      const qfWinners: string[] = [];
+      for (let i = 1; i <= 4; i++) {
+        const dbMatch = qfByNum.get(i);
+        let winner: string;
+        let loser: string;
+        if (dbMatch?.isComplete && dbMatch.winnerId && dbMatch.loserId) {
+          winner = dbMatch.winnerId;
+          loser = dbMatch.loserId;
+        } else {
+          const p1 = r4Winners[(i - 1) * 2];
+          const p2 = r4Winners[(i - 1) * 2 + 1];
+          ({ winner, loser } = simMatch(p1, p2, SETS_TO_WIN[4]));
+        }
+        qfWinners.push(winner);
+        qfLoserCounts.set(loser, (qfLoserCounts.get(loser) ?? 0) + 1);
+      }
+
+      // SF (2 matches)
+      const sfWinners: string[] = [];
+      for (let i = 1; i <= 2; i++) {
+        const dbMatch = sfByNum.get(i);
+        let winner: string;
+        let loser: string;
+        if (dbMatch?.isComplete && dbMatch.winnerId && dbMatch.loserId) {
+          winner = dbMatch.winnerId;
+          loser = dbMatch.loserId;
+        } else {
+          const p1 = qfWinners[(i - 1) * 2];
+          const p2 = qfWinners[(i - 1) * 2 + 1];
+          ({ winner, loser } = simMatch(p1, p2, SETS_TO_WIN[5]));
+        }
+        sfWinners.push(winner);
+        sfLoserCounts.set(loser, (sfLoserCounts.get(loser) ?? 0) + 1);
+      }
+
+      // Final
+      let champion: string;
+      let finalist: string;
+      if (finalMatch?.isComplete && finalMatch.winnerId && finalMatch.loserId) {
+        champion = finalMatch.winnerId;
+        finalist = finalMatch.loserId;
+      } else {
+        ({ winner: champion, loser: finalist } = simMatch(sfWinners[0], sfWinners[1], SETS_TO_WIN[6]));
+      }
+      championCounts.set(champion, (championCounts.get(champion) ?? 0) + 1);
+      finalistCounts.set(finalist, (finalistCounts.get(finalist) ?? 0) + 1);
+    }
+
+    return buildResults(participantIds, NUM_SIMULATIONS, {
+      championCounts,
+      finalistCounts,
+      sfLoserCounts,
+      qfLoserCounts,
+    });
+  }
+
+  // ─── Path B: Pre-bracket simulation ──────────────────────────────────────────
+  // Top 32 seeds are placed into fixed bracket positions.
+  // Remaining 96 players are randomly drawn into unseeded slots each simulation.
+
+  private async simulatePreBracket(
+    sportsSeasonId: string,
+    eloMap: Map<string, number>,
+    rankingMap: Map<string, number>,
+    db: ReturnType<typeof database>
+  ): Promise<SimulationResult[]> {
+    const allParticipants = await db
+      .select({ id: schema.participants.id, name: schema.participants.name })
+      .from(schema.participants)
+      .where(eq(schema.participants.sportsSeasonId, sportsSeasonId));
+
+    if (allParticipants.length < 2) {
+      throw new Error(
+        `Pre-bracket simulation requires at least 2 participants (got ${allParticipants.length}). ` +
+          `Add players to this sports season first.`
+      );
+    }
+
+    const fallbackElo = 1600;
+
+    // Sort participants by world ranking (ascending). Fall back to Elo order (descending) for
+    // any without a ranking, then alphabetical as a final tiebreak.
+    const sorted = [...allParticipants].toSorted((a, b) => {
+      const rankA = rankingMap.get(a.id);
+      const rankB = rankingMap.get(b.id);
+      if (rankA !== undefined && rankB !== undefined) return rankA - rankB;
+      if (rankA !== undefined) return -1; // ranked before unranked
+      if (rankB !== undefined) return 1;
+      // Both unranked — sort by Elo descending
+      return (eloMap.get(b.id) ?? fallbackElo) - (eloMap.get(a.id) ?? fallbackElo);
+    });
+
+    const topSeeds = sorted.slice(0, TOP_SEEDS).map((p) => p.id);   // seeds 1–32
+    const unseeded = sorted.slice(TOP_SEEDS).map((p) => p.id);       // remaining players
+
+    const allParticipantIds = allParticipants.map((p) => p.id);
+    const championCounts  = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
+    const finalistCounts  = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
+    const sfLoserCounts   = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
+    const qfLoserCounts   = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
+
+    // Cache set-level probabilities — fixed across all simulations.
+    const matchProbCache = new Map<string, number>();
+    const simMatch = (p1Id: string, p2Id: string, setsToWin: number): string => {
+      const elo1 = eloMap.get(p1Id) ?? fallbackElo;
+      const elo2 = eloMap.get(p2Id) ?? fallbackElo;
+      const cacheKey = `${elo1},${elo2},${setsToWin}`;
+      let winProb = matchProbCache.get(cacheKey);
+      if (winProb === undefined) {
+        winProb = matchWinProb(setWinProb(elo1, elo2), setsToWin);
+        matchProbCache.set(cacheKey, winProb);
+      }
+      return Math.random() < winProb ? p1Id : p2Id;
+    };
+
+    // Pre-compute fixed seeded bracket positions once — only the unseeded draw changes per sim.
+    const seededMatchOrder = getSeededMatchOrder(TOP_SEEDS);
+    const seededSlots = seededMatchOrder.map(seed => topSeeds[seed - 1]);
+
+    // Pad unseeded pool to 96 once before the loop.
+    // In practice the admin should always load 128 players; this guards against edge cases.
+    const unseededPool = [...unseeded];
+    while (unseededPool.length + topSeeds.length < 128) {
+      unseededPool.push(`__bye_${unseededPool.length}`);
+    }
+
+    for (let s = 0; s < NUM_SIMULATIONS; s++) {
+      // Draw: shuffle the unseeded pool — seeded positions are pre-computed.
+      const drawnUnseeded = shuffle([...unseededPool]);
+
+      // Build R1 pairs inline using pre-computed seeded slots.
+      const r1Pairs: Array<[string, string]> = [];
+      for (let i = 0; i < TOP_SEEDS; i++) {
+        r1Pairs.push([seededSlots[i], drawnUnseeded[i]]);
+      }
+      for (let i = TOP_SEEDS; i < drawnUnseeded.length; i += 2) {
+        r1Pairs.push([drawnUnseeded[i], drawnUnseeded[i + 1]]);
+      }
+
+      // R1 (64 matches)
+      const r1Winners: string[] = [];
+      for (const [p1, p2] of r1Pairs) {
+        r1Winners.push(simMatch(p1, p2, SETS_TO_WIN[0]));
+      }
+
+      // R2–R4 (32 / 16 / 8 matches)
+      const r2Winners: string[] = [];
+      for (let i = 0; i < r1Winners.length; i += 2) {
+        r2Winners.push(simMatch(r1Winners[i], r1Winners[i + 1], SETS_TO_WIN[1]));
+      }
+      const r3Winners: string[] = [];
+      for (let i = 0; i < r2Winners.length; i += 2) {
+        r3Winners.push(simMatch(r2Winners[i], r2Winners[i + 1], SETS_TO_WIN[2]));
+      }
+      const r4Winners: string[] = [];
+      for (let i = 0; i < r3Winners.length; i += 2) {
+        r4Winners.push(simMatch(r3Winners[i], r3Winners[i + 1], SETS_TO_WIN[3]));
+      }
+
+      // QF (4 matches)
+      const qfWinners: string[] = [];
+      for (let i = 0; i < r4Winners.length; i += 2) {
+        const p1 = r4Winners[i], p2 = r4Winners[i + 1];
+        const winner = simMatch(p1, p2, SETS_TO_WIN[4]);
+        const loser = winner === p1 ? p2 : p1;
+        qfWinners.push(winner);
+        qfLoserCounts.set(loser, (qfLoserCounts.get(loser) ?? 0) + 1);
+      }
+
+      // SF (2 matches)
+      const sfWinners: string[] = [];
+      for (let i = 0; i < qfWinners.length; i += 2) {
+        const p1 = qfWinners[i], p2 = qfWinners[i + 1];
+        const winner = simMatch(p1, p2, SETS_TO_WIN[5]);
+        const loser = winner === p1 ? p2 : p1;
+        sfWinners.push(winner);
+        sfLoserCounts.set(loser, (sfLoserCounts.get(loser) ?? 0) + 1);
+      }
+
+      // Final
+      const champion = simMatch(sfWinners[0], sfWinners[1], SETS_TO_WIN[6]);
+      const finalist = champion === sfWinners[0] ? sfWinners[1] : sfWinners[0];
+      championCounts.set(champion, (championCounts.get(champion) ?? 0) + 1);
+      finalistCounts.set(finalist, (finalistCounts.get(finalist) ?? 0) + 1);
+    }
+
+    return buildResults(allParticipantIds, NUM_SIMULATIONS, {
+      championCounts,
+      finalistCounts,
+      sfLoserCounts,
+      qfLoserCounts,
+    });
+  }
+}
+
+// ─── Shared result builder ─────────────────────────────────────────────────────
+
+function buildResults(
+  participantIds: string[],
+  N: number,
+  counts: {
+    championCounts: Map<string, number>;
+    finalistCounts: Map<string, number>;
+    sfLoserCounts: Map<string, number>;
+    qfLoserCounts: Map<string, number>;
+  }
+): SimulationResult[] {
+  const { championCounts, finalistCounts, sfLoserCounts, qfLoserCounts } = counts;
+
+  const results: SimulationResult[] = participantIds.map((participantId) => {
+    const c  = championCounts.get(participantId)  ?? 0;
+    const f  = finalistCounts.get(participantId)  ?? 0;
+    const sf = sfLoserCounts.get(participantId)   ?? 0;
+    const qf = qfLoserCounts.get(participantId)   ?? 0;
+    return {
+      participantId,
+      probabilities: {
+        probFirst:   c  / N,
+        probSecond:  f  / N,
+        probThird:   sf / (2 * N),
+        probFourth:  sf / (2 * N),
+        probFifth:   qf / (4 * N),
+        probSixth:   qf / (4 * N),
+        probSeventh: qf / (4 * N),
+        probEighth:  qf / (4 * N),
+      },
+      source: "darts_world_championship_monte_carlo",
+    };
+  });
+
+  // Per-position column normalisation — ensures sums are exactly 1.0.
+  const positionKeys: Array<keyof typeof results[0]["probabilities"]> = [
+    "probFirst", "probSecond", "probThird", "probFourth",
+    "probFifth", "probSixth", "probSeventh", "probEighth",
+  ];
+  for (const key of positionKeys) {
+    const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
+    const residual = 1.0 - colSum;
+    if (residual !== 0) {
+      const maxResult = results.reduce((best, r) =>
+        r.probabilities[key] > best.probabilities[key] ? r : best
+      );
+      maxResult.probabilities[key] += residual;
+    }
+  }
+
+  return results;
+}
diff --git a/app/services/simulations/registry.ts b/app/services/simulations/registry.ts
index f369f73..088d47b 100644
--- a/app/services/simulations/registry.ts
+++ b/app/services/simulations/registry.ts
@@ -18,6 +18,7 @@ import { NHLSimulator } from "./nhl-simulator";
 import { AFLSimulator } from "./afl-simulator";
 import { SnookerSimulator } from "./snooker-simulator";
 import { TennisSimulator } from "./tennis-simulator";
+import { DartsSimulator } from "./darts-simulator";
 import { MLBSimulator } from "./mlb-simulator";
 import { WNBASimulator } from "./wnba-simulator";
 import { WorldCupSimulator } from "./world-cup-simulator";
@@ -38,6 +39,7 @@ export const SIMULATOR_TYPES = [
   "mlb_bracket",
   "wnba_bracket",
   "world_cup",
+  "darts_bracket",
 ] as const;
 
 export type SimulatorType = typeof SIMULATOR_TYPES[number];
@@ -122,6 +124,10 @@ const REGISTRY: Record<SimulatorType, { info: SimulatorInfo; create: () => Simul
     info: { name: "FIFA World Cup 2026 Monte Carlo", description: "Simulates the full 48-team World Cup: round-robin group stage (12 groups), best-8 third-place selection, R32→R16→QF→SF→3rd place game→Final. Uses blended Elo + futures odds." },
     create: () => new WorldCupSimulator(),
   },
+  darts_bracket: {
+    info: { name: "PDC World Darts Championship Monte Carlo", description: "Simulates the 128-player World Darts Championship bracket using set-level Bernoulli win probability and Elo ratings. Top 32 seeds placed in fixed positions; remaining 96 players randomly drawn per simulation." },
+    create: () => new DartsSimulator(),
+  },
 };
 
 export function getSimulator(simulatorType: SimulatorType): Simulator {
diff --git a/database/schema.ts b/database/schema.ts
index d03c29e..f522f26 100644
--- a/database/schema.ts
+++ b/database/schema.ts
@@ -98,6 +98,7 @@ export const simulatorTypeEnum = pgEnum("simulator_type", [
   "mlb_bracket",
   "wnba_bracket",
   "world_cup",
+  "darts_bracket",
 ]);
 
 export const playoffMatchGameStatusEnum = pgEnum("playoff_match_game_status", [
@@ -588,7 +589,8 @@ export const participantExpectedValues = pgTable("participant_expected_values",
   // Metadata
   source: probabilitySourceEnum("source").default("manual"), // How probabilities were generated
   sourceOdds: integer("source_odds"), // Original odds if source is futures_odds (American odds format)
-  sourceElo: integer("source_elo"), // Raw Elo rating if source is elo-based simulator (e.g. snooker_bracket)
+  sourceElo: integer("source_elo"), // Raw Elo rating if source is elo-based simulator (e.g. snooker_bracket, darts_bracket)
+  worldRanking: integer("world_ranking"), // World ranking for sports that use it for bracket seeding (e.g. darts_bracket)
   calculatedAt: timestamp("calculated_at").defaultNow().notNull(),
   updatedAt: timestamp("updated_at").defaultNow().notNull(),
 }, (t) => ({
diff --git a/drizzle/0067_darts_bracket.sql b/drizzle/0067_darts_bracket.sql
new file mode 100644
index 0000000..1d2c08f
--- /dev/null
+++ b/drizzle/0067_darts_bracket.sql
@@ -0,0 +1,2 @@
+ALTER TYPE "public"."simulator_type" ADD VALUE 'darts_bracket';--> statement-breakpoint
+ALTER TABLE "participant_expected_values" ADD COLUMN "world_ranking" integer;
diff --git a/drizzle/meta/0067_snapshot.json b/drizzle/meta/0067_snapshot.json
new file mode 100644
index 0000000..94d50d4
--- /dev/null
+++ b/drizzle/meta/0067_snapshot.json
@@ -0,0 +1,4346 @@
+{
+  "id": "0067_darts_bracket",
+  "prevId": "0066_stiff_siren",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "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.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.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_participants_id_fk": {
+          "name": "draft_picks_participant_id_participants_id_fk",
+          "tableFrom": "draft_picks",
+          "tableTo": "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_participants_id_fk": {
+          "name": "draft_queue_participant_id_participants_id_fk",
+          "tableFrom": "draft_queue",
+          "tableTo": "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
+        },
+        "participant_id": {
+          "name": "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": {},
+      "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_participant_id_participants_id_fk": {
+          "name": "event_results_participant_id_participants_id_fk",
+          "tableFrom": "event_results",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "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_participants_id_fk": {
+          "name": "group_stage_matches_participant1_id_participants_id_fk",
+          "tableFrom": "group_stage_matches",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant1_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "group_stage_matches_participant2_id_participants_id_fk": {
+          "name": "group_stage_matches_participant2_id_participants_id_fk",
+          "tableFrom": "group_stage_matches",
+          "tableTo": "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_participants_id_fk": {
+          "name": "participant_ev_snapshots_participant_id_participants_id_fk",
+          "tableFrom": "participant_ev_snapshots",
+          "tableTo": "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_expected_values": {
+      "name": "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
+        },
+        "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()"
+        },
+        "world_ranking": {
+          "name": "world_ranking",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "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": {
+        "participant_expected_values_participant_id_participants_id_fk": {
+          "name": "participant_expected_values_participant_id_participants_id_fk",
+          "tableFrom": "participant_expected_values",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "participant_expected_values_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_expected_values_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_expected_values",
+          "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
+        },
+        "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": {
+        "participant_golf_skills_unique": {
+          "name": "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": {
+        "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"
+        },
+        "participant_golf_skills_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_golf_skills_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_golf_skills",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_qualifying_totals": {
+      "name": "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": {
+        "participant_qualifying_totals_participant_id_participants_id_fk": {
+          "name": "participant_qualifying_totals_participant_id_participants_id_fk",
+          "tableFrom": "participant_qualifying_totals",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "participant_qualifying_totals_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_qualifying_totals_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_qualifying_totals",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.participant_results": {
+      "name": "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": {
+        "participant_results_participant_id_participants_id_fk": {
+          "name": "participant_results_participant_id_participants_id_fk",
+          "tableFrom": "participant_results",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "participant_results_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_results_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_results",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_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_participants_id_fk": {
+          "name": "participant_season_results_participant_id_participants_id_fk",
+          "tableFrom": "participant_season_results",
+          "tableTo": "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
+        },
+        "sports_season_id": {
+          "name": "sports_season_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_unique": {
+          "name": "participant_surface_elos_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": {
+        "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"
+        },
+        "participant_surface_elos_sports_season_id_sports_seasons_id_fk": {
+          "name": "participant_surface_elos_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participant_surface_elos",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_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()"
+        },
+        "sports_season_id": {
+          "name": "sports_season_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "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'"
+        },
+        "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": {
+        "participants_sports_season_id_sports_seasons_id_fk": {
+          "name": "participants_sports_season_id_sports_seasons_id_fk",
+          "tableFrom": "participants",
+          "tableTo": "sports_seasons",
+          "columnsFrom": [
+            "sports_season_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_participants_id_fk": {
+          "name": "playoff_match_games_winner_id_participants_id_fk",
+          "tableFrom": "playoff_match_games",
+          "tableTo": "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_participants_id_fk": {
+          "name": "playoff_match_odds_participant_id_participants_id_fk",
+          "tableFrom": "playoff_match_odds",
+          "tableTo": "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_participants_id_fk": {
+          "name": "playoff_matches_participant1_id_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant1_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_participant2_id_participants_id_fk": {
+          "name": "playoff_matches_participant2_id_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "participant2_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_winner_id_participants_id_fk": {
+          "name": "playoff_matches_winner_id_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "participants",
+          "columnsFrom": [
+            "winner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "playoff_matches_loser_id_participants_id_fk": {
+          "name": "playoff_matches_loser_id_participants_id_fk",
+          "tableFrom": "playoff_matches",
+          "tableTo": "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
+        },
+        "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_participants_id_fk": {
+          "name": "regular_season_standings_participant_id_participants_id_fk",
+          "tableFrom": "regular_season_standings",
+          "tableTo": "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
+        },
+        "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"
+        }
+      },
+      "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_paused": {
+          "name": "draft_paused",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 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.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
+        },
+        "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'"
+        },
+        "is_draftable": {
+          "name": "is_draftable",
+          "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": {
+        "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"
+        }
+      },
+      "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_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
+        },
+        "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_participants_id_fk": {
+          "name": "tournament_group_members_participant_id_participants_id_fk",
+          "tableFrom": "tournament_group_members",
+          "tableTo": "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.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": true
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "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
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "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": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_clerk_id_unique": {
+          "name": "users_clerk_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "clerk_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "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.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",
+        "afl_bracket",
+        "snooker_bracket",
+        "tennis_qualifying_points",
+        "mlb_bracket",
+        "wnba_bracket",
+        "world_cup",
+        "darts_bracket"
+      ]
+    },
+    "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"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index 84eabc3..b9ae77a 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -470,6 +470,13 @@
       "when": 1774802533652,
       "tag": "0066_stiff_siren",
       "breakpoints": true
+    },
+    {
+      "idx": 67,
+      "version": "7",
+      "when": 1774900000000,
+      "tag": "0067_darts_bracket",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file