Refactor snooker simulator to use DB world rankings, add snooker-elo admin page

- Remove hardcoded SEEDINGS_2026 name→seed map from snooker-simulator.ts
- Load worldRanking from participantExpectedValues (same column darts uses)
- Top 16 by worldRanking get seeded; fallback to Elo order if none stored
- Add /admin/sports-seasons/:id/snooker-elo route with bulk import (name, Elo,
  world ranking format) and per-player Elo + Rank # form, matching darts-elo UX
- Update snooker simulator tests: remove name-based ranking fixtures, add tests
  for DB-driven rankings and Elo fallback

https://claude.ai/code/session_01Fz54vdsLjDVintFguH32To

app/routes.ts

@@ -99,6 +99,10 @@ export default [
       "sports-seasons/:id/darts-elo",
       "routes/admin.sports-seasons.$id.darts-elo.tsx"
     ),
+    route(
+      "sports-seasons/:id/snooker-elo",
+      "routes/admin.sports-seasons.$id.snooker-elo.tsx"
+    ),
     route(
       "sports-seasons/:id/golf-skills",
       "routes/admin.sports-seasons.$id.golf-skills.tsx"

app/routes/admin.sports-seasons.$id.snooker-elo.tsx

@@ -0,0 +1,472 @@
+import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
+import type { Route } from './+types/admin.sports-seasons.$id.snooker-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: `Snooker 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 snooker simulation:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Simulation failed',
+    };
+  }
+
+  return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
+}
+
+export default function AdminSportsSeasonSnookerElo() {
+  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, 1800, 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, 1800, 1"   (name, elo, world ranking)
+    //   "Player Name, 1800"      (name, elo — ranking omitted)
+    //   "Player Name: 1800: 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">Snooker 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, 1800, 1</code> (name, Elo, world ranking).
+            The world ranking is required for bracket seeding — the top 16 ranked players
+            are seeded, the rest are drawn as qualifiers. Omit the ranking and the simulator
+            will seed by Elo order instead.
+            Player names are fuzzy-matched to participants.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <Textarea
+            placeholder={`Judd Trump, 2050, 1\nKyren Wilson, 1980, 2\nNeil Robertson, 1960, 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 Snooker Elo and world ranking. World ranking determines bracket
+              seeding (top 16 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="1600"
+                      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 players</li>
+              <li>Top 16 seeds placed in fixed bracket positions; remaining players randomly drawn as qualifiers per simulation</li>
+              <li>Qualifiers (seeds 17+) play best-of-19 qualifying rounds to fill the 32-player bracket if more than 16 are present</li>
+              <li>Per-frame win probability: p = 1 / (1 + e^(−ΔElo/700))</li>
+              <li>Match win probability via Bernoulli frames 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>
+            </ol>
+            <div className="mt-4 text-muted-foreground text-xs space-y-1">
+              <div>Round formats: R32 best-of-19, R16/QF best-of-25, SF best-of-33, Final best-of-35</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>
+  );
+}

app/services/simulations/__tests__/snooker-simulator.test.ts

@@ -144,6 +144,7 @@ function makeEVRows(eloOverride?: Map<string, number>) {
   return PARTICIPANT_IDS.map((participantId) => ({
     participantId,
     sourceElo: eloOverride?.get(participantId) ?? ELO_BASE,
+    worldRanking: null,
   }));
 }
 
@@ -371,56 +372,49 @@ describe("SnookerSimulator.simulate() — Path B (pre-bracket)", () => {
     select: MockInstance;
   };
 
-  // 32 participants: use names that match the hardcoded rankings
+  // 32 participants — names don't drive seeding anymore; worldRanking in EV rows does.
-  const RANKED_NAMES = [
+  const SEASON_PARTICIPANTS = Array.from({ length: 32 }, (_, i) => ({
-    "Judd Trump", "Kyren Wilson", "Mark Selby", "Ronnie O'Sullivan",
-    "Mark Allen", "Luca Brecel", "Neil Robertson", "John Higgins",
-    "Ryan Day", "Zhao Xintong", "Jak Jones", "Si Jiahui",
-    "Barry Hawkins", "Ding Junhui", "Pang Junxu", "Zhang Anda",
-    "Xiao Guodong", "Jack Lisowski", "Shaun Murphy", "David Gilbert",
-    "Anthony McGill", "Tom Ford", "Stuart Bingham", "Andrew Higginson",
-    "Chris Wakelin", "Gary Wilson", "Matthew Selt", "Gerard Greene",
-    "Ben Woollaston", "Jamie Jones", "Robbie Williams", "Mark Williams",
-  ];
-
-  const SEASON_PARTICIPANTS = RANKED_NAMES.map((name, i) => ({
     id: `player-${i + 1}`,
-    name,
+    name: `Player ${i + 1}`,
   }));
 
-  beforeEach(async () => {
+  // Build EV rows including worldRanking (rank 1 = player-1, rank 2 = player-2, etc.)
-    const { database } = await import("~/database/context");
+  function makeEvRows(rankOverride?: Map<string, number | null>) {
-
+    return SEASON_PARTICIPANTS.map((p, i) => ({
-    // select() is called twice in Path B:
+      participantId: p.id,
-    // 1. for participantExpectedValues (EV/Elo rows)
+      sourceElo: ELO_BASE,
-    // 2. for participants (all players in the season)
+      worldRanking: rankOverride?.has(p.id) ? rankOverride.get(p.id) : i + 1,
-    const eloRows = SEASON_PARTICIPANTS.map(p => ({ participantId: p.id, sourceElo: ELO_BASE }));
+    }));
-    const participantRows = SEASON_PARTICIPANTS;
+  }
 
+  function setupMockDb(evRows: ReturnType<typeof makeEvRows>, participantRows = SEASON_PARTICIPANTS) {
     mockDb = {
       query: {
         scoringEvents: { findFirst: vi.fn() },
         playoffMatches: { findMany: vi.fn() },
       },
       select: vi.fn()
+        // First select(): participantExpectedValues (Elo + worldRanking)
         .mockReturnValueOnce({
-          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(eloRows) }),
+          from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(evRows) }),
         })
+        // Second select(): participants (id + name)
         .mockReturnValueOnce({
           from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(participantRows) }),
         }),
     };
-
-    (database as unknown as MockInstance).mockReturnValue(mockDb);
-
     mockDb.query.scoringEvents.findFirst.mockResolvedValue({
       id: "event-1",
       sportsSeasonId: "season-1",
       eventType: "playoff_game",
     });
-
-    // No matches → triggers Path B
     mockDb.query.playoffMatches.findMany.mockResolvedValue([]);
+  }
+
+  beforeEach(async () => {
+    const { database } = await import("~/database/context");
+    setupMockDb(makeEvRows());
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
   });
 
   it("returns 32 results when bracket is not yet populated", async () => {
@@ -444,10 +438,59 @@ describe("SnookerSimulator.simulate() — Path B (pre-bracket)", () => {
     }
   });
 
+  it("top-seeded player (rank 1, highest Elo) has highest win probability", async () => {
+    const { database } = await import("~/database/context");
+
+    // Give the seed-1 player a big Elo advantage; everyone else gets low Elo
+    const eloRows = SEASON_PARTICIPANTS.map((p, i) => ({
+      participantId: p.id,
+      sourceElo: i === 0 ? 3000 : 1500,
+      worldRanking: i + 1,
+    }));
+    setupMockDb(eloRows);
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
+
+    const sim = new SnookerSimulator();
+    const results = await sim.simulate("season-1");
+
+    const topSeedResult = results.find(r => r.participantId === "player-1");
+    const otherProbFirsts = results
+      .filter(r => r.participantId !== "player-1")
+      .map(r => r.probabilities.probFirst);
+
+    expect(topSeedResult).toBeDefined();
+    expect(topSeedResult!.probabilities.probFirst).toBeGreaterThan(Math.max(...otherProbFirsts));
+  });
+
+  it("falls back to Elo order when no world rankings are stored", async () => {
+    const { database } = await import("~/database/context");
+
+    // No worldRanking on any row — simulator should use Elo order
+    const eloRows = SEASON_PARTICIPANTS.map((p, i) => ({
+      participantId: p.id,
+      sourceElo: i === 0 ? 3000 : 1500, // player-1 has highest Elo
+      worldRanking: null,
+    }));
+    setupMockDb(eloRows);
+    (database as unknown as MockInstance).mockReturnValue(mockDb);
+
+    const sim = new SnookerSimulator();
+    const results = await sim.simulate("season-1");
+
+    // player-1 with the highest Elo should be treated as seed 1
+    const topEloResult = results.find(r => r.participantId === "player-1");
+    const otherProbFirsts = results
+      .filter(r => r.participantId !== "player-1")
+      .map(r => r.probabilities.probFirst);
+
+    expect(topEloResult).toBeDefined();
+    expect(topEloResult!.probabilities.probFirst).toBeGreaterThan(Math.max(...otherProbFirsts));
+  });
+
   it("throws if fewer than 17 participants exist", async () => {
     const { database } = await import("~/database/context");
     const tooFew = SEASON_PARTICIPANTS.slice(0, 10);
-    const eloRows = tooFew.map(p => ({ participantId: p.id, sourceElo: ELO_BASE }));
+    const eloRows = tooFew.map((p, i) => ({ participantId: p.id, sourceElo: ELO_BASE, worldRanking: i + 1 }));
 
     (database as unknown as MockInstance).mockReturnValue({
       ...mockDb,

app/services/simulations/snooker-simulator.ts

@@ -7,15 +7,15 @@
  *
  * Algorithm:
  *   1. Load the bracket scoring event and all playoff matches from DB.
- *   2. Load Elo ratings from participantExpectedValues.sourceElo.
+ *   2. Load Elo ratings and world rankings from participantExpectedValues.
  *   3. Compute per-match win probability using the Bernoulli frame model:
  *        p_frame = 1 / (1 + e^(-(Elo1 - Elo2) / ELO_DIVISOR))
  *        P(win match) = sum_{w2=0}^{F-1} C(F-1+w2, w2) * p^F * (1-p)^w2
  *      where F = frames to win, which varies by round.
  *   4. Two simulation paths:
  *      a. Bracket populated: simulate from actual draw, respecting completed matches.
- *      b. No bracket: simulate qualifying (ranks 17-48 play one round best-of-19),
+ *      b. No bracket: sort players by worldRanking (fallback: Elo order), place top 16
- *         randomly pair 16 winners vs top 16 seeds, then simulate 5-round bracket.
+ *         as seeds, randomly draw the rest into seed slots 17-32 each simulation.
  *   5. Track integer placement counts per tier across 50,000 simulations.
  *   6. Convert to probability distributions using exact denominators (column sums = 1.0).
  *
@@ -34,7 +34,8 @@
  *   R16 losers         → all 0
  *   R32 losers         → all 0
  *
- * World rankings (for pre-bracket path): hardcoded below. Update annually.
+ * World rankings (for pre-bracket path): loaded from participantExpectedValues.worldRanking.
+ * Set via the snooker-elo admin page. Falls back to Elo order if no rankings are stored.
  */
 
 import { database } from "~/database/context";
@@ -75,62 +76,6 @@ const ELO_DIVISOR = 700;
  */
 const FRAMES_TO_WIN = [10, 13, 13, 17, 18] as const;
 
-// ─── Tournament seedings (2025 World Snooker Championship) ────────────────────
-// Seed 1 = defending champion; seeds 2-16 = world ranking order (skipping champion).
-// Seeds 17+ = qualifiers — only their relative order here matters (all > 16).
-// Update this map each year when a new snooker season is added.
-// Players not in this map default to seed 999 (treated as qualifiers).
-
-const SEEDINGS_2026: Record<string, number> = {
-  "Judd Trump": 1,
-  "Kyren Wilson": 2,
-  "Neil Robertson": 3,
-  "Mark Williams": 4,
-  "Zhao Xintong": 5,
-  "John Higgins": 6,
-  "Mark Selby": 7,
-  "Shaun Murphy": 8,
-  "Xiao Guodong": 9,
-  "Ronnie O'Sullivan": 10,
-  "Barry Hawkins": 11,
-  "Wu Yize": 12,
-  "Chris Wakelin": 13,
-  "Mark Allen": 14,
-  "Si Jiahui": 15,
-  "Ding Junhui": 16,
-  "Stuart Bingham": 17,
-  "Jack Lisowski": 18,
-  "Jak Jones": 19,
-  "Zhang Anda": 20,
-  "Elliot Slessor": 21,
-  "Thepchaiya Un-Nooh": 22,
-  "Ali Carter": 23,
-  "Gary Wilson": 24,
-  "Zhou Yuelong": 25,
-  "David Gilbert": 26,
-  "Stephen Maguire": 27,
-  "Joe O'Connor": 28,
-  "Pang Junxu": 29,
-  "Lei Peifan": 30,
-  "Yuan Sijun": 31,
-  "Tom Ford": 32,
-  "Hossein Vafaei": 33,
-  "Jimmy Robertson": 34,
-  "Ryan Day": 35,
-  "Jackson Page": 36,
-  "Matthew Selt": 37,
-  "Xu Si": 38,
-  "Ben Woollaston": 39,
-  "Aaron Hill": 40,
-  "Daniel Wells": 41,
-  "Anthony McGill": 42,
-  "Zak Surety": 43,
-  "Stan Moody": 44,
-  "Noppon Saengkham": 45,
-  "Luca Brecel": 46,
-  "He Guoqiang": 47,
-  "Matthew Stevens": 48,
-};
 
 /**
  * Standard seeded R32 bracket for 32-player single-elimination.
@@ -153,22 +98,6 @@ const R32_BRACKET: Array<[number, number]> = [
   [15, 18], [2, 31],
 ];
 
-// ─── Name normalization ──────────────────────────────────────────────────────
-// Normalize unicode apostrophes/quotes so DB names (which may use curly quotes
-// like U+2019 ') match the ASCII apostrophes (U+0027 ') in SEEDINGS keys.
-
-function normalizeApostrophes(name: string): string {
-  return name.replace(/[\u2018\u2019\u2032\u0060]/g, "'");
-}
-
-const SEEDINGS_NORMALIZED = new Map(
-  Object.entries(SEEDINGS_2026).map(([name, seed]) => [normalizeApostrophes(name), seed])
-);
-
-function getSeedingForName(name: string): number {
-  return SEEDINGS_NORMALIZED.get(normalizeApostrophes(name)) ?? 999;
-}
-
 // ─── Math helpers ──────────────────────────────────────────────────────────────
 
 /**
@@ -248,23 +177,28 @@ export class SnookerSimulator implements Simulator {
         })
       : [];
 
-    // 3. Load Elo ratings from participantExpectedValues.
+    // 3. Load Elo ratings and world rankings from participantExpectedValues.
     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));
 
-    // Build Elo map; fall back to 1500 for any participant with no stored rating.
+    // Build Elo and ranking maps; fall back to 1500 for any participant with no stored rating.
     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);
       } else if (!eloMap.has(r.participantId)) {
         eloMap.set(r.participantId, 1500);
       }
+      if (r.worldRanking !== null && r.worldRanking !== undefined) {
+        rankingMap.set(r.participantId, r.worldRanking);
+      }
     }
 
     // Determine which simulation path to take.
@@ -274,7 +208,7 @@ export class SnookerSimulator implements Simulator {
     if (bracketPopulated) {
       return this.simulateBracket(allMatches, eloMap);
     } else {
-      return this.simulatePreBracket(sportsSeasonId, eloMap, db);
+      return this.simulatePreBracket(sportsSeasonId, eloMap, rankingMap, db);
     }
   }
 
@@ -442,14 +376,18 @@ export class SnookerSimulator implements Simulator {
   }
 
   // ─── Path B: Pre-bracket simulation ─────────────────────────────────────────
-  // Players 17-48 haven't qualified yet. Each simulation:
+  // Players beyond the top 16 seeds haven't been drawn yet. Each simulation:
-  //   1. Randomly pairs the qualifiers (17-48) and simulates 16 best-of-19 matches.
+  //   1. Randomly pairs qualifiers (seeds 17+) and simulates best-of-19 matches if >16.
-  //   2. The 16 winners are shuffled and randomly drawn into seed slots 17-32.
+  //   2. The 16 remaining qualifiers are shuffled and drawn into seed slots 17-32.
   //   3. The full 32-player bracket is then simulated using the proper seeded structure.
+  //
+  // Seeding is determined by worldRanking from participantExpectedValues (ascending).
+  // Falls back to Elo order (descending) for players with no ranking stored.
 
   private async simulatePreBracket(
     sportsSeasonId: string,
     eloMap: Map<string, number>,
+    rankingMap: Map<string, number>,
     db: ReturnType<typeof database>
   ): Promise<SimulationResult[]> {
     const allParticipants = await db
@@ -464,15 +402,20 @@ export class SnookerSimulator implements Simulator {
       );
     }
 
-    // Sort by seeding. Unranked players default to 999 (treated as qualifiers).
+    // Sort by world ranking (ascending). Unranked players fall back to Elo order (descending).
+    const fallbackElo = 1500;
     const ranked = allParticipants.toSorted((a, b) => {
-      return getSeedingForName(a.name) - getSeedingForName(b.name);
+      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;
+      if (rankB !== undefined) return 1;
+      return (eloMap.get(b.id) ?? fallbackElo) - (eloMap.get(a.id) ?? fallbackElo);
     });
 
     const topSeeds = ranked.slice(0, 16);   // Fixed seed positions 1-16
     const qualifiers = ranked.slice(16);    // Randomly drawn into positions 17-32
 
-    const fallbackElo = 1500;
     const matchProbCache = new Map<string, number>();
     const simMatch = (p1Id: string, p2Id: string, framesToWin: number): string => {
       const elo1 = eloMap.get(p1Id) ?? fallbackElo;