From a71e256bfdffc36abec1186dc77dbe5aca4a96f4 Mon Sep 17 00:00:00 2001
From: Chris Parsons <438676+chrisparsons83@users.noreply.github.com>
Date: Sun, 5 Apr 2026 13:40:05 -0700
Subject: [PATCH] Add CS2 Major Qualifying Points simulator and stage
 management (#260)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add CS2 Major qualifying points simulator

Implements a full CS2 Major tournament simulator with:
- 3-stage Swiss format (Opening Bo1, Elimination Bo1/Bo3, Decider all Bo3)
  + Champions Stage 8-team single-elimination (QF Bo3, SF Bo3, GF Bo5)
- Monte Carlo simulation (10,000 iterations) accumulating QP across 2 majors/season
- Sampled 24-team field per iteration: top 12 guaranteed, remaining weighted by 1/rank
- Stage 3 exits (placements 9-16) sub-ranked by W-L record (2-3 > 1-3 > 0-3)
- Stage assignments stored per-event so actual field composition drives simulation
- Admin CS Elo form for entering team Elo + HLTV world rankings
- Admin CS2 stage setup page for assigning teams to stages and tracking advancement
- Database migration: cs2_major_qualifying_points enum value + cs2_major_stage_results table
- 24 unit tests covering all exported pure functions

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Consolidate Elo + ranking input into generic elo-ratings page

The darts-elo and cs-elo pages were unreachable from the admin nav,
which always links to the generic elo-ratings page. Extended elo-ratings
to conditionally show world ranking fields for simulator types that need
it (darts_bracket, cs2_major_qualifying_points), then deleted the
redundant sport-specific pages.

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Consolidate server postgres connections into one shared pool

Four separate postgres() clients were open simultaneously (app, timer,
snapshots, socket), each defaulting to 10 connections, exhausting the
database's max_connections limit. Replaced with a single shared lazy-
initialized client in server/db.ts using a Proxy to defer the
DATABASE_URL check until first use (preserving test compatibility).

Also bumps the CS2 Champions Stage stochastic test from 200 → 1000
iterations to eliminate flakiness.

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Fix and() bug and add Swiss loop safety guard

- cs2-major-stage.ts: markCs2StageEliminations and setCs2FinalPlacements
  were using JS && instead of Drizzle and(), causing WHERE to filter only
  by participantId (not scoringEventId), which would update rows across
  all events instead of just the target event
- cs-major-simulator.ts: add break guard in simulateSwiss while loop to
  prevent infinite loop if pairGroups returns no pairs

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Fix all remaining code review issues

- cs2-major-stage.ts: use schema column reference for stageEliminated
  in markCs2StageEliminations instead of raw SQL string
- cs-major-simulator.ts: simulateOneMajor now locks in known stage
  results when a stage is complete (8 recorded eliminations), only
  simulating the remaining stages during live events
- admin event page: add CS2 Stage Setup button for cs2_major_qualifying_points
  simulator types; expose simulatorType in server loader type cast
- cs2-setup.tsx: replace document.getElementById DOM manipulation with
  React state (eliminatedChecked map) for checkbox show/hide logic;
  remove unused stageMap and unassignedParticipants variables

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Fix oxlint errors: non-null assertions, sort→toSorted, unused vars

- cs-major-simulator.ts: replace 5 non-null assertions (!) with safe
  optional chaining / if-guards; replace 6 .sort() with .toSorted()
- cs2-major-stage.ts: remove unused `inArray` import
- cs2-setup.tsx: remove unused `assignedIds` variable

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

* Fix flaky Champions Stage stochastic test

The makeTeams(8) helper creates only a 70-pt Elo spread (1800→1730).
With the Champions Stage bracket math this gives team-0 a ~19.6% win
rate — right at the 0.2 threshold, causing the test to fail ~63% of
the time in CI despite 1000 iterations.

Use 100-pt steps (1800→1100) instead, giving team-0 a ~40% win rate
and raising the assertion threshold to 0.25 for a clear safety margin.

https://claude.ai/code/session_019w21Nkf5TvTZHH6oVHaQXR

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 app/models/cs2-major-stage.ts                 | 193 +++++
 app/routes.ts                                 |   8 +-
 .../admin.sports-seasons.$id.darts-elo.tsx    | 470 -------------
 .../admin.sports-seasons.$id.elo-ratings.tsx  | 217 ++++--
 ...-seasons.$id.events.$eventId.cs2-setup.tsx | 337 +++++++++
 ...orts-seasons.$id.events.$eventId.server.ts |   2 +-
 ...min.sports-seasons.$id.events.$eventId.tsx |   8 +
 .../__tests__/cs-major-simulator.test.ts      | 237 +++++++
 .../simulations/cs-major-simulator.ts         | 658 ++++++++++++++++++
 app/services/simulations/registry.ts          |   6 +
 database/schema.ts                            |  42 ++
 drizzle/0068_cs2_major_simulator.sql          |  26 +
 drizzle/meta/_journal.json                    |   7 +
 server/app.ts                                 |  15 +-
 server/db.ts                                  |  29 +
 server/snapshots.ts                           |  11 +-
 server/socket.ts                              |  17 +-
 server/timer.ts                               |  11 +-
 18 files changed, 1706 insertions(+), 588 deletions(-)
 create mode 100644 app/models/cs2-major-stage.ts
 delete mode 100644 app/routes/admin.sports-seasons.$id.darts-elo.tsx
 create mode 100644 app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx
 create mode 100644 app/services/simulations/__tests__/cs-major-simulator.test.ts
 create mode 100644 app/services/simulations/cs-major-simulator.ts
 create mode 100644 drizzle/0068_cs2_major_simulator.sql
 create mode 100644 server/db.ts

diff --git a/app/models/cs2-major-stage.ts b/app/models/cs2-major-stage.ts
new file mode 100644
index 0000000..6a30bc5
--- /dev/null
+++ b/app/models/cs2-major-stage.ts
@@ -0,0 +1,193 @@
+/**
+ * Model for CS2 Major Stage Results
+ *
+ * Tracks the 3-stage Swiss format of CS2 Majors:
+ *   Stage 1 (Opening Stage):   16 teams, lowest-seeded, Swiss Bo1/Bo3
+ *   Stage 2 (Elimination Stage): 16 teams (8 direct Challengers + 8 from Stage 1), Swiss Bo1/Bo3
+ *   Stage 3 (Decider Stage):   16 teams (8 direct Legends + 8 from Stage 2), Swiss all Bo3
+ *   Champions Stage:           8 teams, single-elimination (uses simple_8 bracket template)
+ *
+ * One row per (scoringEventId, participantId) — tracks which stage they enter,
+ * where they were eliminated, their W-L record at elimination (for QP sub-ranking
+ * within placements 9–16), and final placement after the event completes.
+ */
+
+import { database } from "~/database/context";
+import { cs2MajorStageResults, participants } from "~/database/schema";
+import { eq, and, sql } from "drizzle-orm";
+
+export interface Cs2StageResult {
+  id: string;
+  scoringEventId: string;
+  participantId: string;
+  stageEntry: number;              // 1, 2, or 3
+  stageEliminated: number | null;  // null = made Champions Stage
+  stageEliminatedWins: number | null; // 0, 1, or 2 wins at time of elimination
+  finalPlacement: number | null;   // 1–32, set after event completes
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Cs2StageResultWithName extends Cs2StageResult {
+  participantName: string;
+}
+
+export interface Cs2StageAssignmentInput {
+  scoringEventId: string;
+  participantId: string;
+  stageEntry: number;
+}
+
+/**
+ * Get all stage results for a CS2 Major event, joined with participant names.
+ */
+export async function getCs2StageResultsForEvent(
+  scoringEventId: string
+): Promise<Cs2StageResultWithName[]> {
+  const db = database();
+  const rows = await db
+    .select({
+      id: cs2MajorStageResults.id,
+      scoringEventId: cs2MajorStageResults.scoringEventId,
+      participantId: cs2MajorStageResults.participantId,
+      stageEntry: cs2MajorStageResults.stageEntry,
+      stageEliminated: cs2MajorStageResults.stageEliminated,
+      stageEliminatedWins: cs2MajorStageResults.stageEliminatedWins,
+      finalPlacement: cs2MajorStageResults.finalPlacement,
+      createdAt: cs2MajorStageResults.createdAt,
+      updatedAt: cs2MajorStageResults.updatedAt,
+      participantName: participants.name,
+    })
+    .from(cs2MajorStageResults)
+    .innerJoin(participants, eq(cs2MajorStageResults.participantId, participants.id))
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId))
+    .orderBy(cs2MajorStageResults.stageEntry, participants.name);
+
+  return rows;
+}
+
+/**
+ * Get raw stage results for a CS2 Major event (without participant names).
+ * Used by the simulator.
+ */
+export async function getCs2StageResultsMapForEvent(
+  scoringEventId: string
+): Promise<Map<string, Cs2StageResult>> {
+  const db = database();
+  const rows = await db
+    .select()
+    .from(cs2MajorStageResults)
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId));
+
+  return new Map(rows.map((r) => [r.participantId, r]));
+}
+
+/**
+ * Upsert stage assignments for a CS2 Major event.
+ * Sets stageEntry for each participant; resets stageEliminated/stageEliminatedWins
+ * so that re-assigning a team's stage also clears any previously recorded results.
+ */
+export async function upsertCs2StageAssignments(
+  inputs: Cs2StageAssignmentInput[]
+): Promise<void> {
+  if (inputs.length === 0) return;
+  const db = database();
+  const now = new Date();
+
+  await db
+    .insert(cs2MajorStageResults)
+    .values(
+      inputs.map(({ scoringEventId, participantId, stageEntry }) => ({
+        scoringEventId,
+        participantId,
+        stageEntry,
+        stageEliminated: null,
+        stageEliminatedWins: null,
+        finalPlacement: null,
+        createdAt: now,
+        updatedAt: now,
+      }))
+    )
+    .onConflictDoUpdate({
+      target: [cs2MajorStageResults.scoringEventId, cs2MajorStageResults.participantId],
+      set: {
+        stageEntry: sql`excluded.stage_entry`,
+        stageEliminated: null,
+        stageEliminatedWins: null,
+        finalPlacement: null,
+        updatedAt: sql`excluded.updated_at`,
+      },
+    });
+}
+
+/**
+ * Remove all stage assignments for a CS2 Major event.
+ * Called when the admin resets the event setup.
+ */
+export async function clearCs2StageAssignments(
+  scoringEventId: string
+): Promise<void> {
+  const db = database();
+  await db
+    .delete(cs2MajorStageResults)
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId));
+}
+
+/**
+ * Mark teams as eliminated from a specific stage.
+ * Records stageEliminated and stageEliminatedWins for the specified participants.
+ * Teams NOT in eliminatedEntries that are in this stage are implicitly considered
+ * to have advanced (stageEliminated remains null).
+ */
+export async function markCs2StageEliminations(
+  scoringEventId: string,
+  eliminations: Array<{ participantId: string; winsAtElimination: number }>
+): Promise<void> {
+  if (eliminations.length === 0) return;
+  const db = database();
+  const now = new Date();
+
+  // Use individual upserts for each eliminated team to set their specific win count
+  await Promise.all(
+    eliminations.map(({ participantId, winsAtElimination }) =>
+      db
+        .update(cs2MajorStageResults)
+        .set({
+          stageEliminated: sql`${cs2MajorStageResults.stageEntry}`,  // eliminated at their current stage
+          stageEliminatedWins: winsAtElimination,
+          updatedAt: now,
+        })
+        .where(and(
+          eq(cs2MajorStageResults.scoringEventId, scoringEventId),
+          eq(cs2MajorStageResults.participantId, participantId)
+        ))
+    )
+  );
+}
+
+/**
+ * Set final placements for all participants in a CS2 Major event.
+ * Called after the Champions Stage is complete.
+ * placements: Map from participantId to final placement (1–32)
+ */
+export async function setCs2FinalPlacements(
+  scoringEventId: string,
+  placements: Record<string, number>
+): Promise<void> {
+  const db = database();
+  const now = new Date();
+  const participantIds = Object.keys(placements);
+  if (participantIds.length === 0) return;
+
+  await Promise.all(
+    participantIds.map((participantId) =>
+      db
+        .update(cs2MajorStageResults)
+        .set({ finalPlacement: placements[participantId], updatedAt: now })
+        .where(and(
+          eq(cs2MajorStageResults.scoringEventId, scoringEventId),
+          eq(cs2MajorStageResults.participantId, participantId)
+        ))
+    )
+  );
+}
diff --git a/app/routes.ts b/app/routes.ts
index cf108fa..5d586d0 100644
--- a/app/routes.ts
+++ b/app/routes.ts
@@ -79,6 +79,10 @@ export default [
       "sports-seasons/:id/events/:eventId/bracket",
       "routes/admin.sports-seasons.$id.events.$eventId.bracket.tsx"
     ),
+    route(
+      "sports-seasons/:id/events/:eventId/cs2-setup",
+      "routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx"
+    ),
     route(
       "sports-seasons/:id/expected-values",
       "routes/admin.sports-seasons.$id.expected-values.tsx"
@@ -95,10 +99,6 @@ 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
deleted file mode 100644
index 52cd5f4..0000000
--- a/app/routes/admin.sports-seasons.$id.darts-elo.tsx
+++ /dev/null
@@ -1,470 +0,0 @@
-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/routes/admin.sports-seasons.$id.elo-ratings.tsx b/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
index 0f07c11..7c0416d 100644
--- a/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
+++ b/app/routes/admin.sports-seasons.$id.elo-ratings.tsx
@@ -30,7 +30,15 @@ import {
 } from '~/components/ui/card';
 import { useState } from 'react';
 import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
+import { normalizeName } from '~/lib/fuzzy-match';
 
+// Simulator types that use worldRanking in addition to sourceElo
+const RANKING_SIMULATOR_TYPES = new Set(['darts_bracket', 'cs2_major_qualifying_points']);
+
+function rankingLabel(simulatorType: string | null | undefined): string {
+  if (simulatorType === 'cs2_major_qualifying_points') return 'HLTV Rank';
+  return 'World Rank';
+}
 
 export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
   return [{ title: `Elo Ratings — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
@@ -48,14 +56,17 @@ export async function loader({ params }: Route.LoaderArgs) {
   const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
   const existingEVs = await getAllParticipantEVsForSeason(sportsSeasonId);
 
-  const existingElos: Record<string, number> = {};
+  const existingData: Record<string, { elo: number | null; ranking: number | null }> = {};
   for (const ev of existingEVs) {
-    if (ev.sourceElo !== null && ev.sourceElo !== undefined) {
-      existingElos[ev.participantId] = ev.sourceElo;
-    }
+    existingData[ev.participantId] = {
+      elo: ev.sourceElo ?? null,
+      ranking: ev.worldRanking ?? null,
+    };
   }
 
-  return { sportsSeason, participants, existingElos };
+  const usesRanking = RANKING_SIMULATOR_TYPES.has(sportsSeason.sport?.simulatorType ?? '');
+
+  return { sportsSeason, participants, existingData, usesRanking };
 }
 
 interface ActionData {
@@ -73,15 +84,27 @@ export async function action({ request, params }: Route.ActionArgs) {
   }
 
   const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
+  const usesRanking = RANKING_SIMULATOR_TYPES.has(sportsSeason.sport?.simulatorType ?? '');
 
-  // Parse Elo ratings from form
-  const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number }> = [];
+  const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }> = [];
   for (const participant of participants) {
-    const val = formData.get(`elo_${participant.id}`) as string;
-    if (val && val.trim() !== '') {
-      const elo = Number(val);
+    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) {
-        eloInputs.push({ participantId: participant.id, sportsSeasonId, sourceElo: elo });
+        if (usesRanking) {
+          const ranking = rankVal && rankVal.trim() !== '' ? Number(rankVal) : null;
+          eloInputs.push({
+            participantId: participant.id,
+            sportsSeasonId,
+            sourceElo: elo,
+            worldRanking: ranking && !isNaN(ranking) && ranking > 0 ? ranking : null,
+          });
+        } else {
+          eloInputs.push({ participantId: participant.id, sportsSeasonId, sourceElo: elo });
+        }
       }
     }
   }
@@ -98,10 +121,8 @@ export async function action({ request, params }: Route.ActionArgs) {
     return { success: false, message: 'A simulation is already running. Please wait.' };
   }
 
-  // Persist Elo ratings
   await batchSaveSourceElos(eloInputs);
 
-  // Auto-run simulation
   await updateSportsSeason(sportsSeasonId, { simulationStatus: 'running' });
 
   try {
@@ -112,8 +133,6 @@ export async function action({ request, params }: Route.ActionArgs) {
       throw new Error('Simulation returned no results.');
     }
 
-    // Zero out any participants not in simulation results
-    const allParticipants = participants;
     const simulatedIds = new Set(results.map(r => r.participantId));
     const ZERO_PROBS = {
       probFirst: 0, probSecond: 0, probThird: 0, probFourth: 0,
@@ -127,7 +146,7 @@ export async function action({ request, params }: Route.ActionArgs) {
         scoringRules: DEFAULT_SCORING_RULES,
         source: 'elo_simulation' as const,
       })),
-      ...allParticipants
+      ...participants
         .filter(p => !simulatedIds.has(p.id))
         .map(p => ({
           participantId: p.id,
@@ -140,13 +159,11 @@ export async function action({ request, params }: Route.ActionArgs) {
 
     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 => ({
@@ -169,7 +186,7 @@ export async function action({ request, params }: Route.ActionArgs) {
     await updateSportsSeason(sportsSeasonId, { simulationStatus: 'idle' });
   } catch (error) {
     await updateSportsSeason(sportsSeasonId, { simulationStatus: 'failed' });
-    logger.error('Error running snooker simulation:', error);
+    logger.error('Error running simulation:', error);
     return {
       success: false,
       message: error instanceof Error ? error.message : 'Simulation failed',
@@ -179,31 +196,33 @@ export async function action({ request, params }: Route.ActionArgs) {
   return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
 }
 
-function normalizeName(name: string): string {
-  return name.toLowerCase().replace(/[^a-z0-9\s]/g, '').replace(/\s+/g, ' ').trim();
-}
-
 export default function AdminSportsSeasonEloRatings() {
-  const { sportsSeason, participants, existingElos } = useLoaderData<typeof loader>();
+  const { sportsSeason, participants, existingData, usesRanking } = 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 existing = existingElos[p.id];
-      if (existing !== undefined && existing !== null) {
-        initial[p.id] = existing.toString();
-      }
+      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, 2450" format one per line
   const [bulkText, setBulkText] = useState('');
   const [parseResults, setParseResults] = useState<{
-    matched: Array<{ participantId: string; name: string; elo: number; inputName: string }>;
-    unmatched: Array<{ inputName: string; elo: number }>;
+    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) {
@@ -227,30 +246,33 @@ export default function AdminSportsSeasonEloRatings() {
   }
 
   function parseBulkText() {
-    // Format: "Player Name, 2450" or "Player Name: 2450" or "Player Name 2450"
     const lines = bulkText.split('\n');
-    const matched: Array<{ participantId: string; name: string; elo: number; inputName: string }> = [];
-    const unmatched: Array<{ inputName: string; elo: number }> = [];
+    const matched: Array<{ participantId: string; name: string; elo: number; ranking: number | null; inputName: string }> = [];
+    const unmatched: Array<{ inputName: string; elo: number; ranking: number | null }> = [];
     const seen = new Set<string>();
 
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed) continue;
 
-      // Match "Name, 2450" or "Name: 2450" or "Name 2450" (Elo is a 4-digit integer)
-      const match = /^(.+?)[\s,:\t]+(\d{3,5})\s*$/.exec(trimmed);
+      // Match "Name, Elo" or "Name, Elo, Ranking" (comma/colon/tab separated)
+      const match = usesRanking
+        ? /^(.+?)[\s,:\t]+(\d{3,5})(?:[\s,:\t]+(\d{1,3}))?\s*$/.exec(trimmed)
+        : /^(.+?)[\s,:\t]+(\d{3,5})\s*$/.exec(trimmed);
       if (!match) continue;
 
       const inputName = match[1].trim();
       const elo = parseInt(match[2], 10);
+      const ranking = usesRanking && match[3] ? parseInt(match[3], 10) : null;
+
       if (isNaN(elo) || elo < 500 || elo > 5000) continue;
 
       const participant = findParticipantMatch(inputName);
       if (participant && !seen.has(participant.id)) {
         seen.add(participant.id);
-        matched.push({ participantId: participant.id, name: participant.name, elo, inputName });
+        matched.push({ participantId: participant.id, name: participant.name, elo, ranking, inputName });
       } else if (!participant) {
-        unmatched.push({ inputName, elo });
+        unmatched.push({ inputName, elo, ranking });
       }
     }
 
@@ -259,16 +281,33 @@ export default function AdminSportsSeasonEloRatings() {
 
   function applyMatches() {
     if (!parseResults) return;
-    const newValues = { ...eloValues };
+    const newElos = { ...eloValues };
+    const newRanks = { ...rankValues };
     for (const m of parseResults.matched) {
-      newValues[m.participantId] = m.elo.toString();
+      newElos[m.participantId] = m.elo.toString();
+      if (m.ranking !== null) newRanks[m.participantId] = m.ranking.toString();
     }
-    setEloValues(newValues);
+    setEloValues(newElos);
+    setRankValues(newRanks);
     setParseResults(null);
     setBulkText('');
   }
 
   const isSubmitting = navigation.state === 'submitting';
+  const simulatorType = sportsSeason.sport?.simulatorType ?? null;
+  const rankLabel = rankingLabel(simulatorType);
+
+  // When ranking is available, sort by rank ascending, then unranked alphabetically
+  const sortedParticipants = usesRanking
+    ? [...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);
+      })
+    : participants;
 
   return (
     <div className="container mx-auto py-8">
@@ -284,13 +323,29 @@ export default function AdminSportsSeasonEloRatings() {
         <CardHeader>
           <CardTitle>Bulk Import</CardTitle>
           <CardDescription>
-            Paste Elo ratings one per line. Format: <code>Player Name, 2450</code>. Player names
-            are fuzzy-matched to participants. Elo values should be in the 2000–2900 range for snooker.
+            {usesRanking ? (
+              <>
+                Paste one entry per line. Format:{' '}
+                <code>Name, Elo, {rankLabel}</code> (ranking is optional — omit it and the simulator
+                will use Elo order for seeding). Names are fuzzy-matched to participants.
+              </>
+            ) : (
+              <>
+                Paste Elo ratings one per line. Format: <code>Player Name, 2450</code>. Player names
+                are fuzzy-matched to participants.
+              </>
+            )}
           </CardDescription>
         </CardHeader>
         <CardContent className="space-y-4">
           <Textarea
-            placeholder={`Judd Trump, 2594\nRonnie O'Sullivan, 2441\nMark Selby, 2432`}
+            placeholder={
+              usesRanking
+                ? simulatorType === 'cs2_major_qualifying_points'
+                  ? `Natus Vincere, 1850, 1\nFaZe Clan, 1820, 2\nVitality, 1810, 3`
+                  : `Luke Littler, 2099, 1\nMichael van Gerwen, 1950, 2\nLuke Humphries, 1947, 3`
+                : `Judd Trump, 2594\nRonnie O'Sullivan, 2441\nMark Selby, 2432`
+            }
             value={bulkText}
             onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
             rows={8}
@@ -312,7 +367,10 @@ export default function AdminSportsSeasonEloRatings() {
                     {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; {m.elo}</span>
+                        <span className="font-medium">
+                          {m.name} &rarr; Elo {m.elo}
+                          {usesRanking && m.ranking !== null ? `, ${rankLabel} #${m.ranking}` : ''}
+                        </span>
                       </div>
                     ))}
                   </div>
@@ -329,7 +387,10 @@ export default function AdminSportsSeasonEloRatings() {
                     {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">{u.elo}</span>
+                        <span className="font-medium">
+                          Elo {u.elo}
+                          {usesRanking && u.ranking !== null ? `, ${rankLabel} #${u.ranking}` : ''}
+                        </span>
                       </div>
                     ))}
                   </div>
@@ -349,29 +410,58 @@ export default function AdminSportsSeasonEloRatings() {
       <div className="grid gap-6 lg:grid-cols-2">
         <Card>
           <CardHeader>
-            <CardTitle>Player Elo Ratings</CardTitle>
+            <CardTitle>
+              {usesRanking ? `Player Elo & ${rankLabel}s` : 'Player Elo Ratings'}
+            </CardTitle>
             <CardDescription>
-              Enter each player's current Elo rating. Saving will automatically run the simulation
-              and update expected values. Snooker Elo typically ranges from ~2000 (qualifier level)
-              to ~2600 (world-class).
+              {usesRanking
+                ? `Enter each player's Elo and ${rankLabel}. Saving will automatically run the simulation and update expected values.`
+                : 'Enter each player\'s current Elo rating. Saving will automatically run the simulation and update expected values.'}
             </CardDescription>
           </CardHeader>
           <CardContent>
             <Form method="post" className="space-y-4">
-              <div className="space-y-3">
-                {participants.map(participant => (
-                  <div key={participant.id} className="grid grid-cols-2 gap-4 items-center">
-                    <Label htmlFor={`elo_${participant.id}`}>{participant.name}</Label>
+              {usesRanking && (
+                <div className="grid grid-cols-[1fr_100px_90px] gap-x-3 gap-y-1 items-center text-xs font-medium text-muted-foreground">
+                  <span>Player</span>
+                  <span>Elo</span>
+                  <span>{rankLabel} #</span>
+                </div>
+              )}
+              <div className="space-y-2">
+                {sortedParticipants.map(participant => (
+                  <div
+                    key={participant.id}
+                    className={usesRanking
+                      ? 'grid grid-cols-[1fr_100px_90px] gap-x-3 items-center'
+                      : 'grid grid-cols-2 gap-4 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="2450"
+                      placeholder={usesRanking ? '1800' : '2450'}
                       value={eloValues[participant.id] ?? ''}
                       onChange={e =>
                         setEloValues(prev => ({ ...prev, [participant.id]: e.target.value }))
                       }
+                      className={usesRanking ? 'h-8 text-sm' : undefined}
                     />
+                    {usesRanking && (
+                      <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>
@@ -394,17 +484,18 @@ export default function AdminSportsSeasonEloRatings() {
           </CardHeader>
           <CardContent className="text-sm space-y-2">
             <ol className="list-decimal list-inside space-y-2">
-              <li>Save Elo ratings for all participants</li>
-              <li>Compute per-frame win probability: p = 1 / (1 + e^(−ΔElo/700))</li>
-              <li>Compute match win probability using the Bernoulli frame model for each round's best-of length</li>
-              <li>Run 50,000 Monte Carlo simulations of the full bracket</li>
+              <li>Save Elo ratings{usesRanking ? ` and ${rankLabel}s` : ''} for all participants</li>
+              <li>Compute per-game win probability from Elo difference</li>
+              <li>Compute match win probability using the Bernoulli model for each round's format</li>
+              <li>Run Monte Carlo simulations of the full event</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 frames: R32 best-of-19, R16/QF best-of-25, SF best-of-33, Final best-of-35</div>
-              <div>World rankings (for pre-bracket draws) are hardcoded in the simulator.</div>
-            </div>
+            {usesRanking && (
+              <div className="mt-4 text-muted-foreground text-xs">
+                {rankLabel} is optional — if omitted, the simulator uses Elo order for seeding.
+              </div>
+            )}
           </CardContent>
         </Card>
       </div>
diff --git a/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx b/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx
new file mode 100644
index 0000000..4051206
--- /dev/null
+++ b/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx
@@ -0,0 +1,337 @@
+import { Form, useLoaderData, useActionData, useNavigation, Link } from 'react-router';
+import type { Route } from './+types/admin.sports-seasons.$id.events.$eventId.cs2-setup';
+
+import { findSportsSeasonById } from '~/models/sports-season';
+import { getScoringEventById } from '~/models/scoring-event';
+import { findParticipantsBySportsSeasonId } from '~/models/participant';
+import {
+  getCs2StageResultsForEvent,
+  upsertCs2StageAssignments,
+  markCs2StageEliminations,
+  clearCs2StageAssignments,
+} from '~/models/cs2-major-stage';
+import { Button } from '~/components/ui/button';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '~/components/ui/card';
+import { Badge } from '~/components/ui/badge';
+import { ArrowLeft, Save, Trash2, CheckCircle2 } from 'lucide-react';
+import { useState } from 'react';
+
+export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
+  return [{ title: `CS2 Stage Setup — ${data?.event?.name ?? "Event"} - Brackt Admin` }];
+}
+
+export async function loader({ params }: Route.LoaderArgs) {
+  const sportsSeasonId = params.id;
+  const eventId = params.eventId;
+
+  const [sportsSeason, event] = await Promise.all([
+    findSportsSeasonById(sportsSeasonId),
+    getScoringEventById(eventId),
+  ]);
+
+  if (!sportsSeason) throw new Response('Sports season not found', { status: 404 });
+  if (!event) throw new Response('Event not found', { status: 404 });
+
+  const [participants, stageResults] = await Promise.all([
+    findParticipantsBySportsSeasonId(sportsSeasonId),
+    getCs2StageResultsForEvent(eventId),
+  ]);
+
+  return { sportsSeason, event, participants, stageResults };
+}
+
+interface ActionData {
+  success?: boolean;
+  message?: string;
+}
+
+export async function action({ request, params }: Route.ActionArgs) {
+  const eventId = params.eventId;
+  const formData = await request.formData();
+  const intent = formData.get('intent') as string;
+
+  if (intent === 'reset') {
+    await clearCs2StageAssignments(eventId);
+    return { success: true, message: 'Stage assignments cleared.' };
+  }
+
+  if (intent === 'assign') {
+    const assignments: Array<{ scoringEventId: string; participantId: string; stageEntry: number }> = [];
+    for (const [key, value] of formData.entries()) {
+      if (key.startsWith('stage_')) {
+        const participantId = key.slice('stage_'.length);
+        const stageEntry = parseInt(value as string, 10);
+        if (!isNaN(stageEntry) && stageEntry >= 1 && stageEntry <= 3) {
+          assignments.push({ scoringEventId: eventId, participantId, stageEntry });
+        }
+      }
+    }
+
+    if (assignments.length === 0) {
+      return { success: false, message: 'No stage assignments submitted.' };
+    }
+
+    await upsertCs2StageAssignments(assignments);
+    return { success: true, message: `Saved ${assignments.length} stage assignments.` };
+  }
+
+  if (intent === 'mark-eliminations') {
+    // Parse elimination data: elim_{participantId} = winsAtElimination (0, 1, or 2)
+    const eliminations: Array<{ participantId: string; winsAtElimination: number }> = [];
+    for (const [key, value] of formData.entries()) {
+      if (key.startsWith('elim_')) {
+        const participantId = key.slice('elim_'.length);
+        const wins = parseInt(value as string, 10);
+        if (!isNaN(wins) && wins >= 0 && wins <= 2) {
+          eliminations.push({ participantId, winsAtElimination: wins });
+        }
+      }
+    }
+
+    await markCs2StageEliminations(eventId, eliminations);
+    return { success: true, message: `Marked ${eliminations.length} eliminations.` };
+  }
+
+  return { success: false, message: 'Unknown action.' };
+}
+
+const STAGE_LABELS: Record<number, { label: string; description: string; maxTeams: number; badgeVariant: 'default' | 'secondary' | 'outline' }> = {
+  1: { label: 'Stage 1', description: 'Opening Stage (16 teams, Bo1 Swiss)', maxTeams: 16, badgeVariant: 'outline' },
+  2: { label: 'Stage 2', description: 'Elimination Stage (8 Challengers, Bo1/Bo3 Swiss)', maxTeams: 8, badgeVariant: 'secondary' },
+  3: { label: 'Stage 3', description: 'Decider Stage (8 Legends, all Bo3 Swiss)', maxTeams: 8, badgeVariant: 'default' },
+};
+
+const RECORD_OPTIONS = [
+  { value: '2', label: '2-3 (advanced furthest)' },
+  { value: '1', label: '1-3' },
+  { value: '0', label: '0-3 (earliest exit)' },
+];
+
+export default function AdminCs2Setup() {
+  const { sportsSeason, event, participants, stageResults } = useLoaderData<typeof loader>();
+  const actionData = useActionData<ActionData>();
+  const navigation = useNavigation();
+  const isSubmitting = navigation.state === 'submitting';
+
+  // Stage assignment state (local, submitted via form)
+  const [stageSelections, setStageSelections] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    stageResults.forEach(r => { initial[r.participantId] = r.stageEntry.toString(); });
+    return initial;
+  });
+
+  // Elimination checkbox state — tracks which teams are checked as eliminated
+  const [eliminatedChecked, setEliminatedChecked] = useState<Record<string, boolean>>(() => {
+    const initial: Record<string, boolean> = {};
+    stageResults.forEach(r => { initial[r.participantId] = r.stageEliminated !== null; });
+    return initial;
+  });
+
+  // Group participants by stage for display
+  const byStage: Record<number, typeof stageResults> = { 1: [], 2: [], 3: [] };
+  for (const r of stageResults) {
+    byStage[r.stageEntry]?.push(r);
+  }
+
+  const stageCounts = Object.fromEntries(
+    Object.entries(byStage).map(([k, v]) => [k, v.length])
+  );
+
+  return (
+    <div className="container mx-auto py-8">
+      <div className="mb-6">
+        <Link
+          to={`/admin/sports-seasons/${sportsSeason.id}/events/${event.id}`}
+          className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-4"
+        >
+          <ArrowLeft className="h-4 w-4" />
+          Back to event
+        </Link>
+        <h1 className="text-3xl font-bold mb-1">CS2 Stage Setup</h1>
+        <p className="text-muted-foreground">{event.name} — {sportsSeason.name}</p>
+      </div>
+
+      {actionData?.message && (
+        <div className={`mb-4 p-3 rounded-md text-sm ${actionData.success ? 'bg-emerald-500/10 text-emerald-400 border border-emerald-500/30' : 'bg-destructive/10 text-destructive border border-destructive/30'}`}>
+          {actionData.message}
+        </div>
+      )}
+
+      {/* Stage Assignment */}
+      <Card className="mb-6">
+        <CardHeader>
+          <CardTitle className="flex items-center justify-between">
+            Stage Assignments
+            {stageResults.length > 0 && (
+              <Form method="post">
+                <input type="hidden" name="intent" value="reset" />
+                <Button type="submit" variant="ghost" size="sm" className="text-destructive">
+                  <Trash2 className="h-4 w-4 mr-1" />
+                  Reset all
+                </Button>
+              </Form>
+            )}
+          </CardTitle>
+          <CardDescription>
+            Assign each team to their starting stage. Stage 1 = 16 Opening Stage teams,
+            Stage 2 = 8 Challengers (skip Stage 1), Stage 3 = 8 Legends (skip Stages 1 and 2).
+            Total: 32 teams across all three stages.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <Form method="post" className="space-y-6">
+            <input type="hidden" name="intent" value="assign" />
+
+            {/* Stage summary badges */}
+            <div className="flex gap-3 flex-wrap">
+              {[1, 2, 3].map(stage => (
+                <div key={stage} className="flex items-center gap-2 text-sm">
+                  <Badge variant={STAGE_LABELS[stage].badgeVariant}>{STAGE_LABELS[stage].label}</Badge>
+                  <span className="text-muted-foreground">
+                    {stageCounts[stage] ?? 0}/{STAGE_LABELS[stage].maxTeams} teams
+                  </span>
+                </div>
+              ))}
+            </div>
+
+            {/* Teams listed with stage selectors */}
+            <div className="space-y-1">
+              <div className="grid grid-cols-[1fr_160px] gap-x-3 text-xs font-medium text-muted-foreground px-1 mb-2">
+                <span>Team</span>
+                <span>Starting Stage</span>
+              </div>
+              {participants.map(participant => (
+                <div key={participant.id} className="grid grid-cols-[1fr_160px] gap-x-3 items-center py-1 border-b border-border/40 last:border-0">
+                  <span className="text-sm">{participant.name}</span>
+                  <select
+                    name={`stage_${participant.id}`}
+                    value={stageSelections[participant.id] ?? ''}
+                    onChange={e => setStageSelections(prev => ({ ...prev, [participant.id]: e.target.value }))}
+                    className="h-8 text-sm rounded-md border border-input bg-background px-2"
+                  >
+                    <option value="">— not assigned —</option>
+                    <option value="1">Stage 1 (Opening)</option>
+                    <option value="2">Stage 2 (Elimination)</option>
+                    <option value="3">Stage 3 (Decider)</option>
+                  </select>
+                </div>
+              ))}
+            </div>
+
+            <Button type="submit" disabled={isSubmitting}>
+              <Save className="h-4 w-4 mr-2" />
+              {isSubmitting ? 'Saving...' : 'Save Stage Assignments'}
+            </Button>
+          </Form>
+        </CardContent>
+      </Card>
+
+      {/* Advancement Tracking (only shown when stage assignments exist) */}
+      {stageResults.length > 0 && (
+        <Card className="mb-6">
+          <CardHeader>
+            <CardTitle>Stage Advancement Tracking</CardTitle>
+            <CardDescription>
+              Record which teams were eliminated and their W-L record at elimination.
+              Teams not listed as eliminated are assumed to have advanced (or are still playing).
+              Stage 3 W-L records determine QP sub-placements (9–16).
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Form method="post" className="space-y-6">
+              <input type="hidden" name="intent" value="mark-eliminations" />
+
+              {[1, 2, 3].map(stage => {
+                const teamsInStage = byStage[stage];
+                if (teamsInStage.length === 0) return null;
+
+                return (
+                  <div key={stage}>
+                    <h3 className="text-sm font-semibold mb-3 flex items-center gap-2">
+                      <Badge variant={STAGE_LABELS[stage].badgeVariant}>{STAGE_LABELS[stage].label}</Badge>
+                      {STAGE_LABELS[stage].description}
+                    </h3>
+                    <div className="space-y-1">
+                      {teamsInStage.map(r => {
+                        const isEliminated = eliminatedChecked[r.participantId] ?? false;
+                        return (
+                          <div key={r.participantId} className="grid grid-cols-[1fr_auto_200px] gap-x-3 items-center py-1 border-b border-border/40 last:border-0">
+                            <span className="text-sm flex items-center gap-2">
+                              {r.participantName}
+                              {r.stageEliminated !== null && (
+                                <Badge variant="outline" className="text-xs">
+                                  eliminated {r.stageEliminatedWins}-3
+                                </Badge>
+                              )}
+                            </span>
+                            <label className="flex items-center gap-2 text-sm cursor-pointer">
+                              <input
+                                type="checkbox"
+                                checked={isEliminated}
+                                onChange={e =>
+                                  setEliminatedChecked(prev => ({
+                                    ...prev,
+                                    [r.participantId]: e.target.checked,
+                                  }))
+                                }
+                                className="rounded"
+                              />
+                              Eliminated
+                            </label>
+                            {isEliminated && (
+                              <select
+                                name={`elim_${r.participantId}`}
+                                defaultValue={r.stageEliminatedWins?.toString() ?? '0'}
+                                className="h-8 w-full text-sm rounded-md border border-input bg-background px-2"
+                              >
+                                {RECORD_OPTIONS.map(opt => (
+                                  <option key={opt.value} value={opt.value}>{opt.label}</option>
+                                ))}
+                              </select>
+                            )}
+                            {!isEliminated && <div />}
+                          </div>
+                        );
+                      })}
+                    </div>
+                  </div>
+                );
+              })}
+
+              <Button type="submit" disabled={isSubmitting}>
+                <CheckCircle2 className="h-4 w-4 mr-2" />
+                {isSubmitting ? 'Saving...' : 'Save Eliminations'}
+              </Button>
+            </Form>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Champions Stage link */}
+      {stageResults.length > 0 && (
+        <Card>
+          <CardHeader>
+            <CardTitle>Champions Stage (Playoffs)</CardTitle>
+            <CardDescription>
+              The 8-team single-elimination bracket. Use the bracket admin to track
+              Quarterfinals, Semifinals, and Grand Final results.
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Link to={`/admin/sports-seasons/${sportsSeason.id}/events/${event.id}/bracket`}>
+              <Button variant="outline">
+                Open Bracket Admin →
+              </Button>
+            </Link>
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/app/routes/admin.sports-seasons.$id.events.$eventId.server.ts b/app/routes/admin.sports-seasons.$id.events.$eventId.server.ts
index 9bc792a..8dfc594 100644
--- a/app/routes/admin.sports-seasons.$id.events.$eventId.server.ts
+++ b/app/routes/admin.sports-seasons.$id.events.$eventId.server.ts
@@ -63,7 +63,7 @@ export async function loader({ params }: Route.LoaderArgs) {
 
   return {
     sportsSeason: sportsSeason as typeof sportsSeason & {
-      sport: { id: string; name: string; type: string; slug: string };
+      sport: { id: string; name: string; type: string; slug: string; simulatorType: string | null };
     },
     event,
     participants,
diff --git a/app/routes/admin.sports-seasons.$id.events.$eventId.tsx b/app/routes/admin.sports-seasons.$id.events.$eventId.tsx
index ac4bda0..8e8513a 100644
--- a/app/routes/admin.sports-seasons.$id.events.$eventId.tsx
+++ b/app/routes/admin.sports-seasons.$id.events.$eventId.tsx
@@ -230,6 +230,14 @@ export default function EventResults({
                   </Link>
                 </Button>
               )}
+              {sportsSeason.sport?.simulatorType === "cs2_major_qualifying_points" && (
+                <Button variant="outline" asChild>
+                  <Link to={`/admin/sports-seasons/${sportsSeason.id}/events/${event.id}/cs2-setup`}>
+                    <Brackets className="mr-2 h-4 w-4" />
+                    CS2 Stage Setup
+                  </Link>
+                </Button>
+              )}
               {event.isComplete ? (
                 <Badge variant="default" className="bg-emerald-500">
                   <CheckCircle2 className="mr-1 h-3 w-3" />
diff --git a/app/services/simulations/__tests__/cs-major-simulator.test.ts b/app/services/simulations/__tests__/cs-major-simulator.test.ts
new file mode 100644
index 0000000..f57efad
--- /dev/null
+++ b/app/services/simulations/__tests__/cs-major-simulator.test.ts
@@ -0,0 +1,237 @@
+import { describe, it, expect } from "vitest";
+import {
+  gameWinProb,
+  seriesWinProb,
+  sampleField,
+  simulateSwiss,
+  simulateChampionsStage,
+} from "../cs-major-simulator";
+
+// Helper to build a pool of teams
+function makeTeams(n: number, baseElo = 1800, baseRank = 1) {
+  return Array.from({ length: n }, (_, i) => ({
+    id: `team-${i}`,
+    elo: baseElo - i * 10,
+    rank: baseRank + i,
+  }));
+}
+
+// ─── gameWinProb ──────────────────────────────────────────────────────────────
+
+describe("gameWinProb", () => {
+  it("returns 0.5 for equal Elo", () => {
+    expect(gameWinProb(1800, 1800)).toBeCloseTo(0.5, 5);
+    expect(gameWinProb(2000, 2000)).toBeCloseTo(0.5, 5);
+  });
+
+  it("returns > 0.5 for positive advantage, < 0.5 for negative", () => {
+    expect(gameWinProb(2000, 1700)).toBeGreaterThan(0.5);
+    expect(gameWinProb(1700, 2000)).toBeLessThan(0.5);
+  });
+
+  it("is symmetric: p(a,b) + p(b,a) = 1", () => {
+    expect(gameWinProb(2000, 1700) + gameWinProb(1700, 2000)).toBeCloseTo(1.0, 5);
+  });
+
+  it("stays strictly in (0, 1)", () => {
+    const p = gameWinProb(3000, 1000);
+    expect(p).toBeLessThan(1);
+    expect(p).toBeGreaterThan(0);
+  });
+});
+
+// ─── seriesWinProb ────────────────────────────────────────────────────────────
+
+describe("seriesWinProb", () => {
+  it("returns 0.5 for equal players (p=0.5) in any format", () => {
+    expect(seriesWinProb(0.5, 2)).toBeCloseTo(0.5, 5);  // Bo3
+    expect(seriesWinProb(0.5, 3)).toBeCloseTo(0.5, 5);  // Bo5
+    expect(seriesWinProb(0.5, 4)).toBeCloseTo(0.5, 5);  // Bo7
+  });
+
+  it("amplifies better team advantage in longer formats", () => {
+    const bo3 = seriesWinProb(0.6, 2);
+    const bo5 = seriesWinProb(0.6, 3);
+    expect(bo5).toBeGreaterThan(bo3);
+  });
+
+  it("approaches 1.0 as p → 1.0", () => {
+    expect(seriesWinProb(0.9999, 2)).toBeCloseTo(1.0, 3);
+    expect(seriesWinProb(0.9999, 3)).toBeCloseTo(1.0, 3);
+  });
+
+  it("sums to 1 with complement", () => {
+    const p = 0.63;
+    expect(seriesWinProb(p, 2) + seriesWinProb(1 - p, 2)).toBeCloseTo(1.0, 5);
+    expect(seriesWinProb(p, 3) + seriesWinProb(1 - p, 3)).toBeCloseTo(1.0, 5);
+  });
+
+  it("Bo3 win prob with p=0.6 is in expected range", () => {
+    // P(2-0) + P(2-1) = 0.36 + 2*0.36*0.4 = 0.36 + 0.288 = 0.648
+    expect(seriesWinProb(0.6, 2)).toBeCloseTo(0.648, 3);
+  });
+});
+
+// ─── sampleField ──────────────────────────────────────────────────────────────
+
+describe("sampleField", () => {
+  it("returns all teams when pool <= fieldSize", () => {
+    const pool = makeTeams(20);
+    const field = sampleField(pool, 32);
+    expect(field).toHaveLength(20);
+  });
+
+  it("returns fieldSize teams when pool > fieldSize", () => {
+    const pool = makeTeams(50);
+    const field = sampleField(pool, 32);
+    expect(field).toHaveLength(32);
+  });
+
+  it("always includes the top 12 ranked teams", () => {
+    const pool = makeTeams(50);
+    const top12Ids = new Set(pool.slice(0, 12).map((t) => t.id));
+
+    for (let i = 0; i < 20; i++) {
+      const field = sampleField(pool, 32);
+      const fieldIds = new Set(field.map((t) => t.id));
+      for (const id of top12Ids) {
+        expect(fieldIds.has(id)).toBe(true);
+      }
+    }
+  });
+
+  it("never includes more teams than fieldSize", () => {
+    const pool = makeTeams(100);
+    for (let i = 0; i < 10; i++) {
+      expect(sampleField(pool, 32)).toHaveLength(32);
+    }
+  });
+
+  it("returns unique teams", () => {
+    const pool = makeTeams(50);
+    const field = sampleField(pool, 32);
+    const ids = field.map((t) => t.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});
+
+// ─── simulateSwiss ────────────────────────────────────────────────────────────
+
+describe("simulateSwiss", () => {
+  it("returns exactly 8 advanced and 8 eliminated from 16 teams", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    expect(result.advanced).toHaveLength(8);
+    expect(result.eliminated).toHaveLength(8);
+  });
+
+  it("all advanced teams have 3 wins (implicit by advancement threshold)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    // Advanced teams reached 3 wins — we can't directly check wins here,
+    // but we verify each participant appears in exactly one group
+    const allIds = new Set([
+      ...result.advanced.map((t) => t.id),
+      ...result.eliminated.map((t) => t.id),
+    ]);
+    expect(allIds.size).toBe(16);
+    for (const team of teams) {
+      expect(allIds.has(team.id)).toBe(true);
+    }
+  });
+
+  it("eliminated teams have wins 0, 1, or 2", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    for (const t of result.eliminated) {
+      expect(t.wins).toBeGreaterThanOrEqual(0);
+      expect(t.wins).toBeLessThanOrEqual(2);
+    }
+  });
+
+  it("total wins + losses = total matches played (conservation check)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    // Eliminated teams have exactly 3 losses
+    // Total losses = 8 * 3 = 24
+    // Total wins = sum of wins for all eliminated + 8 * 3 for advanced = ?
+    // Each win by advanced team = 1 loss for an eliminated team
+    const totalLossesEliminated = result.eliminated.length * 3; // 24
+    expect(totalLossesEliminated).toBe(24);
+  });
+
+  it("works with Bo3 format (Swiss all Bo3)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, true);
+    expect(result.advanced).toHaveLength(8);
+    expect(result.eliminated).toHaveLength(8);
+  });
+
+  it("teams with much higher Elo advance more often (stochastic check)", () => {
+    // Top 8 teams have Elo 2000+, bottom 8 have Elo 1000
+    const teams = [
+      ...Array.from({ length: 8 }, (_, i) => ({ id: `top-${i}`, elo: 2000, rank: i + 1 })),
+      ...Array.from({ length: 8 }, (_, i) => ({ id: `bot-${i}`, elo: 1000, rank: i + 9 })),
+    ];
+
+    let topAdvances = 0;
+    const runs = 100;
+    for (let i = 0; i < runs; i++) {
+      const result = simulateSwiss(teams, false);
+      for (const t of result.advanced) {
+        if (t.id.startsWith("top-")) topAdvances++;
+      }
+    }
+
+    // Top teams should advance much more than half the time across runs
+    // Expected: ~7-8 top teams advance per run → topAdvances should be >> 400 (50%)
+    expect(topAdvances / runs).toBeGreaterThan(6);
+  });
+});
+
+// ─── simulateChampionsStage ───────────────────────────────────────────────────
+
+describe("simulateChampionsStage", () => {
+  it("throws if not exactly 8 teams", () => {
+    expect(() => simulateChampionsStage(makeTeams(7))).toThrow();
+    expect(() => simulateChampionsStage(makeTeams(9))).toThrow();
+  });
+
+  it("assigns placements to all 8 teams", () => {
+    const teams = makeTeams(8);
+    const result = simulateChampionsStage(teams);
+    expect(result.placements.size).toBe(8);
+    for (const team of teams) {
+      expect(result.placements.has(team.id)).toBe(true);
+    }
+  });
+
+  it("has exactly one 1st, one 2nd, two 3rd/4th, four 5th-8th", () => {
+    const teams = makeTeams(8);
+    const result = simulateChampionsStage(teams);
+    const placements = [...result.placements.values()];
+    expect(placements.filter(p => p === 1)).toHaveLength(1);
+    expect(placements.filter(p => p === 2)).toHaveLength(1);
+    expect(placements.filter(p => p >= 3 && p <= 4)).toHaveLength(2);
+    expect(placements.filter(p => p >= 5 && p <= 8)).toHaveLength(4);
+  });
+
+  it("top Elo team wins more often than last (stochastic)", () => {
+    // Use a clear Elo spread so team-0 has a decisive advantage.
+    // makeTeams(8) only gives a 70-pt gap (1800→1730) which puts the
+    // true win rate right at the 0.2 threshold — extremely flaky.
+    // 100-pt steps (1800→1100) give team-0 a ~40% win rate, well clear of 0.25.
+    const teams = Array.from({ length: 8 }, (_, i) => ({
+      id: `team-${i}`,
+      elo: 1800 - i * 100,
+      rank: i + 1,
+    }));
+    let wins = 0;
+    for (let i = 0; i < 1000; i++) {
+      const result = simulateChampionsStage(teams);
+      if (result.placements.get("team-0") === 1) wins++;
+    }
+    // Should win well above 12.5% (1/8 random baseline)
+    expect(wins / 1000).toBeGreaterThan(0.25);
+  });
+});
diff --git a/app/services/simulations/cs-major-simulator.ts b/app/services/simulations/cs-major-simulator.ts
new file mode 100644
index 0000000..425606a
--- /dev/null
+++ b/app/services/simulations/cs-major-simulator.ts
@@ -0,0 +1,658 @@
+/**
+ * CS2 Major Qualifying Points Simulator
+ *
+ * Monte Carlo simulation of the 2 CS2 Majors per year. Qualifying points (QP)
+ * accumulate across both majors; final QP totals determine fantasy placements (1st–8th).
+ *
+ * CS2 Major format (32 teams, 3 Swiss stages + playoffs):
+ *   Stage 1 (Opening Stage):     16 teams, Swiss, Bo1 matches
+ *   Stage 2 (Elimination Stage): 16 teams (8 Challengers + 8 from Stage 1), Swiss, Bo1/Bo3
+ *   Stage 3 (Decider Stage):     16 teams (8 Legends + 8 from Stage 2), Swiss, all Bo3
+ *   Champions Stage:              8 teams, single-elimination (QF Bo3, SF Bo3, GF Bo5)
+ *
+ * Field selection (per iteration):
+ *   - Top 12 participants by world ranking are always in the simulated field.
+ *   - Remaining spots (up to 32 total) are sampled from the rest of the pool,
+ *     weighted by 1/rank (lower rank = higher inclusion probability).
+ *   - If cs2MajorStageResults records exist for an event, those explicit
+ *     stage assignments are used instead of sampling/rank inference.
+ *
+ * Stage assignment within the 32-team field:
+ *   - With explicit stage data: use stageEntry from cs2MajorStageResults
+ *   - Without: top 8 by world ranking → Stage 3, next 8 → Stage 2, bottom 16 → Stage 1
+ *
+ * QP for Stage 3 exits (placements 9–16) is sub-ranked by W-L record:
+ *   - 2-3 teams → higher placements within 9–16
+ *   - 1-3 teams → middle placements
+ *   - 0-3 teams → lowest placements within 9–16
+ *   QP is tie-split (averaged) within each W-L group.
+ *
+ * Stages 1 and 2 exits (placements 17–32) earn 0 QP.
+ */
+
+import { database } from "~/database/context";
+import { eq, and, inArray } from "drizzle-orm";
+import * as schema from "~/database/schema";
+import { getQPConfig } from "~/models/qualifying-points";
+import { getCs2StageResultsMapForEvent } from "~/models/cs2-major-stage";
+import type { Simulator, SimulationResult } from "./types";
+
+// ─── Simulation parameters ────────────────────────────────────────────────────
+
+const NUM_SIMULATIONS = 10_000;
+
+/** Total field size per CS2 Major. */
+const FIELD_SIZE = 32;
+
+/** Number of teams guaranteed in the simulated field (always included). */
+const GUARANTEED_COUNT = 12;
+
+/**
+ * Elo divisor for per-game win probability.
+ * Standard chess Elo uses 400. CS2 maps well to single-game level.
+ * 200-pt gap ≈ 76% win probability; 400-pt gap ≈ 91%.
+ */
+const ELO_DIVISOR = 400;
+
+/** Fallback Elo for teams with no stored rating. */
+const FALLBACK_ELO = 1500;
+
+// ─── Math helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Per-game win probability for team 1 vs team 2.
+ * Exported for unit testing.
+ */
+export function gameWinProb(elo1: number, elo2: number): number {
+  return 1 / (1 + Math.pow(10, (elo2 - elo1) / ELO_DIVISOR));
+}
+
+/**
+ * Match win probability using the Bernoulli series model.
+ * For a best-of-(2S-1) match (first to S wins):
+ *   P(win) = Σ_{k=0}^{S-1} C(S-1+k, k) × p^S × (1-p)^k
+ * Exported for unit testing.
+ */
+export function seriesWinProb(p: number, winsNeeded: number): number {
+  let prob = 0;
+  for (let k = 0; k < winsNeeded; k++) {
+    prob += binomialCoeff(winsNeeded - 1 + k, k) * Math.pow(p, winsNeeded) * Math.pow(1 - p, k);
+  }
+  return prob;
+}
+
+/** Binomial coefficient C(n, k). */
+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;
+}
+
+/** Fisher-Yates in-place shuffle. Returns the array for chaining. */
+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;
+}
+
+// ─── Field selection ──────────────────────────────────────────────────────────
+
+interface TeamWithElo {
+  id: string;
+  elo: number;
+  rank: number;  // HLTV world ranking (lower = better)
+}
+
+/**
+ * Sample a 32-team field from the pool.
+ * - Top GUARANTEED_COUNT (12) by rank are always included.
+ * - Remaining spots are weighted-randomly sampled from the rest, weight = 1/rank.
+ * - If pool.length <= FIELD_SIZE, returns all teams.
+ * Exported for unit testing.
+ */
+export function sampleField(
+  pool: TeamWithElo[],
+  fieldSize: number = FIELD_SIZE
+): TeamWithElo[] {
+  const sorted = [...pool].toSorted((a, b) => a.rank - b.rank);
+
+  if (sorted.length <= fieldSize) return sorted;
+
+  const guaranteed = sorted.slice(0, GUARANTEED_COUNT);
+  const rest = sorted.slice(GUARANTEED_COUNT);
+  const needed = fieldSize - guaranteed.length;
+
+  if (needed <= 0) return guaranteed;
+  if (rest.length <= needed) return [...guaranteed, ...rest];
+
+  // Weighted sample without replacement, weight = 1/rank
+  const weights = rest.map((t) => 1 / t.rank);
+  const sampled = weightedSampleWithoutReplacement(rest, weights, needed);
+
+  return [...guaranteed, ...sampled];
+}
+
+/** Weighted sampling without replacement using the Gumbel-max trick. */
+function weightedSampleWithoutReplacement<T>(
+  items: T[],
+  weights: number[],
+  count: number
+): T[] {
+  const keys = weights.map((w) => -Math.log(Math.random()) / w);
+  const indexed = items.map((item, i) => ({ item, key: keys[i] }));
+  const sortedIndexed = indexed.toSorted((a, b) => a.key - b.key);
+  return sortedIndexed.slice(0, count).map((x) => x.item);
+}
+
+// ─── Swiss stage simulation ───────────────────────────────────────────────────
+
+interface SwissResult {
+  /** Teams that advanced (3 wins). */
+  advanced: Array<{ id: string; elo: number; rank: number }>;
+  /** Teams eliminated, with their win count at time of elimination. */
+  eliminated: Array<{ id: string; elo: number; rank: number; wins: number }>;
+}
+
+/**
+ * Simulate one Swiss-format stage.
+ * Teams are grouped by their (wins, losses) record each round. Teams are paired
+ * randomly within each record group. First to 3 wins advances; first to 3 losses
+ * is eliminated.
+ *
+ * @param teams - Teams entering this stage.
+ * @param bo3   - If true, use Bo3 series win probability; otherwise Bo1 (single game).
+ * @returns advanced and eliminated arrays.
+ *
+ * Exported for unit testing.
+ */
+export function simulateSwiss(teams: TeamWithElo[], bo3: boolean): SwissResult {
+  const wins = new Map<string, number>(teams.map((t) => [t.id, 0]));
+  const losses = new Map<string, number>(teams.map((t) => [t.id, 0]));
+  const eloMap = new Map<string, number>(teams.map((t) => [t.id, t.elo]));
+
+  const advanced: SwissResult["advanced"] = [];
+  const eliminated: SwissResult["eliminated"] = [];
+  const advancedIds = new Set<string>();
+  const eliminatedIds = new Set<string>();
+
+  const teamById = new Map<string, TeamWithElo>(teams.map((t) => [t.id, t]));
+
+  // Run rounds until every team has reached 3W or 3L
+  while (advancedIds.size + eliminatedIds.size < teams.length) {
+    // Collect active teams grouped by (W, L) record
+    const active = teams.filter((t) => !advancedIds.has(t.id) && !eliminatedIds.has(t.id));
+    const groups = groupByRecord(active, wins, losses);
+
+    // If a group has an odd number, move one team to the nearest adjacent group
+    // (simplified: skip teams that can't be paired — they sit out this round)
+    const pairs = pairGroups(groups);
+
+    // Safety: if no pairs can be formed (shouldn't happen with even team counts
+    // but guards against an infinite loop if an odd active count somehow occurs)
+    if (pairs.length === 0) break;
+
+    for (const [t1, t2] of pairs) {
+      const e1 = eloMap.get(t1.id) ?? FALLBACK_ELO;
+      const e2 = eloMap.get(t2.id) ?? FALLBACK_ELO;
+      const p = bo3
+        ? seriesWinProb(gameWinProb(e1, e2), 2)  // Bo3: first to 2
+        : gameWinProb(e1, e2);                     // Bo1: single game
+
+      const t1Wins = Math.random() < p;
+      const winnerId = t1Wins ? t1.id : t2.id;
+      const loserId = t1Wins ? t2.id : t1.id;
+
+      wins.set(winnerId, (wins.get(winnerId) ?? 0) + 1);
+      losses.set(loserId, (losses.get(loserId) ?? 0) + 1);
+
+      if ((wins.get(winnerId) ?? 0) >= 3) {
+        advancedIds.add(winnerId);
+        const t = teamById.get(winnerId);
+        if (t) advanced.push({ id: t.id, elo: t.elo, rank: t.rank });
+      }
+      if ((losses.get(loserId) ?? 0) >= 3) {
+        eliminatedIds.add(loserId);
+        const t = teamById.get(loserId);
+        if (t) eliminated.push({ id: t.id, elo: t.elo, rank: t.rank, wins: wins.get(loserId) ?? 0 });
+      }
+    }
+  }
+
+  return { advanced, eliminated };
+}
+
+/** Group active teams by (wins, losses) record key. */
+function groupByRecord(
+  active: TeamWithElo[],
+  wins: Map<string, number>,
+  losses: Map<string, number>
+): Map<string, TeamWithElo[]> {
+  const groups = new Map<string, TeamWithElo[]>();
+  for (const t of active) {
+    const key = `${wins.get(t.id) ?? 0}-${losses.get(t.id) ?? 0}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)?.push(t);
+  }
+  return groups;
+}
+
+/**
+ * Pair teams within each record group. Teams in groups with an odd count
+ * are handled by merging the leftover into an adjacent group (simpler: skip
+ * them for this round — they sit out and play next round).
+ */
+function pairGroups(groups: Map<string, TeamWithElo[]>): Array<[TeamWithElo, TeamWithElo]> {
+  const pairs: Array<[TeamWithElo, TeamWithElo]> = [];
+  const leftover: TeamWithElo[] = [];
+
+  for (const group of groups.values()) {
+    const shuffled = shuffle([...group]);
+    for (let i = 0; i + 1 < shuffled.length; i += 2) {
+      pairs.push([shuffled[i], shuffled[i + 1]]);
+    }
+    if (shuffled.length % 2 !== 0) {
+      leftover.push(shuffled[shuffled.length - 1]);
+    }
+  }
+
+  // Pair leftover teams with each other (different records, cross-group match)
+  for (let i = 0; i + 1 < leftover.length; i += 2) {
+    pairs.push([leftover[i], leftover[i + 1]]);
+  }
+
+  return pairs;
+}
+
+// ─── Champions Stage (8-team single-elimination bracket) ─────────────────────
+
+interface ChampionsResult {
+  placements: Map<string, number>;  // participantId → placement (1–8)
+}
+
+/**
+ * Simulate the Champions Stage 8-team single-elimination bracket.
+ * Seeds are assigned by rank within the 8 advancing teams.
+ * Rounds: QF (Bo3), SF (Bo3), GF (Bo5).
+ * Exported for unit testing.
+ */
+export function simulateChampionsStage(teams: TeamWithElo[]): ChampionsResult {
+  if (teams.length !== 8) {
+    throw new Error(`simulateChampionsStage expects exactly 8 teams, got ${teams.length}`);
+  }
+
+  // Seed by rank ascending
+  const seeded = [...teams].toSorted((a, b) => a.rank - b.rank);
+  // Standard 8-team seeding: 1v8, 4v5, 3v6, 2v7
+  const bracket: [TeamWithElo, TeamWithElo][] = [
+    [seeded[0], seeded[7]],
+    [seeded[3], seeded[4]],
+    [seeded[2], seeded[5]],
+    [seeded[1], seeded[6]],
+  ];
+
+  const placements = new Map<string, number>();
+
+  const simMatch = (t1: TeamWithElo, t2: TeamWithElo, winsNeeded: number): TeamWithElo => {
+    const p = seriesWinProb(gameWinProb(t1.elo, t2.elo), winsNeeded);
+    return Math.random() < p ? t1 : t2;
+  };
+
+  // Quarterfinals (Bo3 = first to 2)
+  const sfTeams: TeamWithElo[] = [];
+  for (const [t1, t2] of bracket) {
+    const winner = simMatch(t1, t2, 2);
+    const loser = winner.id === t1.id ? t2 : t1;
+    sfTeams.push(winner);
+    placements.set(loser.id, 7);  // QF losers: 5th–8th (averaged to 6.5, use 7 for counting)
+  }
+  // Assign QF losers to placements 5–8
+  const qfLosers = [...placements.keys()];
+  qfLosers.forEach((id, i) => placements.set(id, 5 + i));
+
+  // Semifinals (Bo3 = first to 2)
+  const finalTeams: TeamWithElo[] = [];
+  const sfLosers: TeamWithElo[] = [];
+  for (let i = 0; i < sfTeams.length; i += 2) {
+    const winner = simMatch(sfTeams[i], sfTeams[i + 1], 2);
+    const loser = winner.id === sfTeams[i].id ? sfTeams[i + 1] : sfTeams[i];
+    finalTeams.push(winner);
+    sfLosers.push(loser);
+  }
+  sfLosers.forEach((t, i) => placements.set(t.id, 3 + i));
+
+  // Grand Final (Bo5 = first to 3)
+  const champion = simMatch(finalTeams[0], finalTeams[1], 3);
+  const finalist = champion.id === finalTeams[0].id ? finalTeams[1] : finalTeams[0];
+  placements.set(champion.id, 1);
+  placements.set(finalist.id, 2);
+
+  return { placements };
+}
+
+// ─── QP helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Calculate QP for Stage 3 exits based on their W-L record.
+ * Teams are ranked within 9–16 by wins (2-3 > 1-3 > 0-3).
+ * Within the same wins count, QP is tie-split (averaged) across placement slots.
+ *
+ * qpConfig: array indexed by placement (1-indexed), qpConfig[placement] = QP value.
+ *           Placements 9–16 correspond to indices 9–16.
+ */
+function calcStage3ExitQP(
+  elimTeams: Array<{ id: string; wins: number }>,
+  qpConfig: Map<number, number>
+): Map<string, number> {
+  // Group teams by wins count (0, 1, 2)
+  const byWins = new Map<number, string[]>();
+  for (const t of elimTeams) {
+    if (!byWins.has(t.wins)) byWins.set(t.wins, []);
+    byWins.get(t.wins)?.push(t.id);
+  }
+
+  // Assign placement slots 9–16 from highest wins first
+  const result = new Map<string, number>();
+  const winsGroups = [...byWins.entries()].toSorted((a, b) => b[0] - a[0]);  // descending wins
+
+  let slotStart = 9;
+  for (const [, ids] of winsGroups) {
+    const slots = Array.from({ length: ids.length }, (_, i) => slotStart + i);
+    const avgQP = slots.reduce((sum, s) => sum + (qpConfig.get(s) ?? 0), 0) / slots.length;
+    for (const id of ids) {
+      result.set(id, avgQP);
+    }
+    slotStart += ids.length;
+  }
+
+  return result;
+}
+
+// ─── Simulator ────────────────────────────────────────────────────────────────
+
+export class CSMajorSimulator implements Simulator {
+  async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
+    const db = database();
+
+    // 1. Load all participants for this sports season.
+    const allParticipants = await db
+      .select({ id: schema.participants.id })
+      .from(schema.participants)
+      .where(eq(schema.participants.sportsSeasonId, sportsSeasonId));
+
+    const participantIds = allParticipants.map((p) => p.id);
+
+    if (participantIds.length === 0) {
+      throw new Error(`No participants found for sports season ${sportsSeasonId}.`);
+    }
+
+    // 2. 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));
+
+    const eloMap = new Map<string, { elo: number; rank: number }>();
+    for (const row of evRows) {
+      if (row.sourceElo !== null) {
+        eloMap.set(row.participantId, {
+          elo: row.sourceElo,
+          rank: row.worldRanking ?? 9999,
+        });
+      }
+    }
+
+    // Build pool: all participants with Elo ratings, sorted by rank
+    const pool: TeamWithElo[] = participantIds
+      .filter((id) => eloMap.has(id))
+      .map((id) => {
+        const e = eloMap.get(id);
+        return { id, elo: e?.elo ?? FALLBACK_ELO, rank: e?.rank ?? 9999 };
+      })
+      .toSorted((a, b) => a.rank - b.rank);
+
+    if (pool.length === 0) {
+      throw new Error(
+        `No participants with Elo ratings found for sports season ${sportsSeasonId}. ` +
+        `Enter Elo ratings via the CS Elo admin page before simulating.`
+      );
+    }
+
+    // 3. Load QP config (placements 1–16 earn QP; 17+ earn 0).
+    const qpConfigArray = await getQPConfig(sportsSeasonId);
+    const qpConfig = new Map<number, number>(
+      qpConfigArray.map((c) => [c.placement, parseFloat(c.points)])
+    );
+
+    // 4. Load all CS major scoring events for this sports season.
+    const events = await db.query.scoringEvents.findMany({
+      where: and(
+        eq(schema.scoringEvents.sportsSeasonId, sportsSeasonId),
+        eq(schema.scoringEvents.eventType, "major_tournament")
+      ),
+      orderBy: (e, { asc }) => [asc(e.eventDate)],
+    });
+
+    if (events.length === 0) {
+      throw new Error(
+        `No major_tournament scoring events found for sports season ${sportsSeasonId}. ` +
+        `Create the CS Major scoring events first.`
+      );
+    }
+
+    // 5. For completed events, read actual QP from eventResults.
+    const completedEventIds = events.filter((e) => e.isComplete).map((e) => e.id);
+    const actualQPMap = new Map<string, number>(participantIds.map((id) => [id, 0]));
+
+    if (completedEventIds.length > 0) {
+      const actualResults = await db
+        .select({
+          participantId: schema.eventResults.participantId,
+          qualifyingPointsAwarded: schema.eventResults.qualifyingPointsAwarded,
+        })
+        .from(schema.eventResults)
+        .where(inArray(schema.eventResults.scoringEventId, completedEventIds));
+
+      for (const r of actualResults) {
+        if (r.qualifyingPointsAwarded !== null) {
+          const prev = actualQPMap.get(r.participantId) ?? 0;
+          actualQPMap.set(r.participantId, prev + parseFloat(r.qualifyingPointsAwarded));
+        }
+      }
+    }
+
+    // 6. Load stage results for each event (for explicit field composition).
+    const eventStageResults = new Map<string, Awaited<ReturnType<typeof getCs2StageResultsMapForEvent>>>();
+    for (const event of events) {
+      const stageResults = await getCs2StageResultsMapForEvent(event.id);
+      if (stageResults.size > 0) {
+        eventStageResults.set(event.id, stageResults);
+      }
+    }
+
+    const incompleteEvents = events.filter((e) => !e.isComplete);
+
+    // 7. Monte Carlo loop.
+    const counts: number[][] = Array.from({ length: participantIds.length }, () => Array(8).fill(0));
+    const idToIndex = new Map<string, number>(participantIds.map((id, i) => [id, i]));
+
+    for (let sim = 0; sim < NUM_SIMULATIONS; sim++) {
+      const simQP = new Map<string, number>(actualQPMap);
+
+      for (const event of incompleteEvents) {
+        const stageResultsForEvent = eventStageResults.get(event.id);
+        const eventQP = simulateOneMajor(pool, stageResultsForEvent, qpConfig);
+        for (const [pid, qp] of eventQP) {
+          simQP.set(pid, (simQP.get(pid) ?? 0) + qp);
+        }
+      }
+
+      // Rank all participants by total QP descending.
+      const ranked = [...simQP.entries()].toSorted((a, b) => b[1] - a[1]);
+      for (let rank = 0; rank < Math.min(8, ranked.length); rank++) {
+        const [pid] = ranked[rank];
+        const idx = idToIndex.get(pid);
+        if (idx !== undefined) counts[idx][rank]++;
+      }
+    }
+
+    // 8. Convert counts to probabilities.
+    return participantIds.map((participantId, i) => ({
+      participantId,
+      probabilities: {
+        probFirst:   counts[i][0] / NUM_SIMULATIONS,
+        probSecond:  counts[i][1] / NUM_SIMULATIONS,
+        probThird:   counts[i][2] / NUM_SIMULATIONS,
+        probFourth:  counts[i][3] / NUM_SIMULATIONS,
+        probFifth:   counts[i][4] / NUM_SIMULATIONS,
+        probSixth:   counts[i][5] / NUM_SIMULATIONS,
+        probSeventh: counts[i][6] / NUM_SIMULATIONS,
+        probEighth:  counts[i][7] / NUM_SIMULATIONS,
+      },
+      source: "cs2_major_qualifying_points_monte_carlo",
+    }));
+  }
+}
+
+// ─── Single major simulation ───────────────────────────────────────────────────
+
+/**
+ * Simulate one CS2 Major and return QP earned per participant.
+ *
+ * If stage results are provided, uses them to determine field composition
+ * and to lock in results for any completed stages, only simulating the
+ * remaining stages. A stage is considered complete when the expected 8
+ * eliminations for that stage have been recorded.
+ *
+ * Returns a Map from participantId → QP earned in this major.
+ */
+function simulateOneMajor(
+  pool: TeamWithElo[],
+  stageResults: Map<string, { stageEntry: number; stageEliminated: number | null; stageEliminatedWins: number | null }> | undefined,
+  qpConfig: Map<number, number>
+): Map<string, number> {
+  const qpMap = new Map<string, number>();
+  const poolById = new Map<string, TeamWithElo>(pool.map((t) => [t.id, t]));
+
+  // ── Determine field and stage assignments ─────────────────────────────────
+  let stage1Teams: TeamWithElo[];
+  let stage2Direct: TeamWithElo[];
+  let stage3Direct: TeamWithElo[];
+
+  if (stageResults && stageResults.size > 0) {
+    const s1: TeamWithElo[] = [];
+    const s2: TeamWithElo[] = [];
+    const s3: TeamWithElo[] = [];
+    for (const [participantId, result] of stageResults) {
+      const team = poolById.get(participantId);
+      if (!team) continue;
+      if (result.stageEntry === 1) s1.push(team);
+      else if (result.stageEntry === 2) s2.push(team);
+      else if (result.stageEntry === 3) s3.push(team);
+    }
+    stage1Teams = s1;
+    stage2Direct = s2;
+    stage3Direct = s3;
+  } else {
+    const field = sampleField(pool, FIELD_SIZE);
+    const sorted = field.toSorted((a, b) => a.rank - b.rank);
+    stage3Direct = sorted.slice(0, 8);
+    stage2Direct = sorted.slice(8, 16);
+    stage1Teams  = sorted.slice(16, 32);
+  }
+
+  // ── Lock in known stage results ───────────────────────────────────────────
+  // A stage is "complete" when exactly 8 teams have been recorded as
+  // eliminated at that stage (the expected output of each Swiss stage).
+  const eliminatedAtStage = (stageNum: number) =>
+    stageResults
+      ? [...stageResults.entries()]
+          .filter(([, r]) => r.stageEliminated === stageNum)
+          .map(([id, r]) => ({
+            id,
+            elo: poolById.get(id)?.elo ?? FALLBACK_ELO,
+            rank: poolById.get(id)?.rank ?? 9999,
+            wins: r.stageEliminatedWins ?? 0,
+          }))
+      : [];
+
+  const stage1Elim = eliminatedAtStage(1);
+  const stage2Elim = eliminatedAtStage(2);
+  const stage3Elim = eliminatedAtStage(3);
+
+  const stage1Complete = stage1Elim.length === 8;
+  const stage2Complete = stage2Elim.length === 8;
+  const stage3Complete = stage3Elim.length === 8;
+
+  // ── Stage 1 ───────────────────────────────────────────────────────────────
+  let stage1Advanced: TeamWithElo[];
+  let stage1EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
+
+  if (stage1Complete) {
+    // Use known results: teams that entered Stage 1 but weren't eliminated there advanced
+    const stage1EliminatedIds = new Set(stage1Elim.map((t) => t.id));
+    stage1Advanced = stage1Teams.filter((t) => !stage1EliminatedIds.has(t.id));
+    stage1EliminatedFinal = stage1Elim;
+  } else {
+    const result = simulateSwiss(stage1Teams, false);
+    stage1Advanced = result.advanced;
+    stage1EliminatedFinal = result.eliminated;
+  }
+
+  // ── Stage 2 ───────────────────────────────────────────────────────────────
+  const stage2Teams = [...stage2Direct, ...stage1Advanced];
+  let stage2Advanced: TeamWithElo[];
+  let stage2EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
+
+  if (stage2Complete) {
+    const stage2EliminatedIds = new Set(stage2Elim.map((t) => t.id));
+    stage2Advanced = stage2Teams.filter((t) => !stage2EliminatedIds.has(t.id));
+    stage2EliminatedFinal = stage2Elim;
+  } else {
+    const result = simulateSwiss(stage2Teams, false);
+    stage2Advanced = result.advanced;
+    stage2EliminatedFinal = result.eliminated;
+  }
+
+  // ── Stage 3 ───────────────────────────────────────────────────────────────
+  const stage3Teams = [...stage3Direct, ...stage2Advanced];
+  let champTeams: TeamWithElo[];
+  let stage3EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
+
+  if (stage3Complete) {
+    const stage3EliminatedIds = new Set(stage3Elim.map((t) => t.id));
+    champTeams = stage3Teams.filter((t) => !stage3EliminatedIds.has(t.id));
+    stage3EliminatedFinal = stage3Elim;
+  } else {
+    const result = simulateSwiss(stage3Teams, true);
+    champTeams = result.advanced;
+    stage3EliminatedFinal = result.eliminated;
+  }
+
+  // ── Champions Stage ───────────────────────────────────────────────────────
+  const champResult = simulateChampionsStage(champTeams);
+
+  // ── Assign QP ─────────────────────────────────────────────────────────────
+  for (const [pid, placement] of champResult.placements) {
+    qpMap.set(pid, qpConfig.get(placement) ?? 0);
+  }
+
+  const stage3ExitQP = calcStage3ExitQP(stage3EliminatedFinal, qpConfig);
+  for (const [pid, qp] of stage3ExitQP) {
+    qpMap.set(pid, qp);
+  }
+
+  for (const t of stage1EliminatedFinal) qpMap.set(t.id, 0);
+  for (const t of stage2EliminatedFinal) qpMap.set(t.id, 0);
+
+  return qpMap;
+}
diff --git a/app/services/simulations/registry.ts b/app/services/simulations/registry.ts
index 088d47b..eca9a44 100644
--- a/app/services/simulations/registry.ts
+++ b/app/services/simulations/registry.ts
@@ -19,6 +19,7 @@ import { AFLSimulator } from "./afl-simulator";
 import { SnookerSimulator } from "./snooker-simulator";
 import { TennisSimulator } from "./tennis-simulator";
 import { DartsSimulator } from "./darts-simulator";
+import { CSMajorSimulator } from "./cs-major-simulator";
 import { MLBSimulator } from "./mlb-simulator";
 import { WNBASimulator } from "./wnba-simulator";
 import { WorldCupSimulator } from "./world-cup-simulator";
@@ -40,6 +41,7 @@ export const SIMULATOR_TYPES = [
   "wnba_bracket",
   "world_cup",
   "darts_bracket",
+  "cs2_major_qualifying_points",
 ] as const;
 
 export type SimulatorType = typeof SIMULATOR_TYPES[number];
@@ -128,6 +130,10 @@ const REGISTRY: Record<SimulatorType, { info: SimulatorInfo; create: () => Simul
     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(),
   },
+  cs2_major_qualifying_points: {
+    info: { name: "CS2 Major Qualifying Points Monte Carlo", description: "Simulates 2 CS2 Majors per season (3 Swiss stages: Opening Bo1, Elimination Bo1, Decider Bo3, then Champions Stage single-elimination). Awards QP by final placement; ranks teams by total QP across both majors. Stage 3 exits (placements 9–16) are sub-ranked by W-L record." },
+    create: () => new CSMajorSimulator(),
+  },
 };
 
 export function getSimulator(simulatorType: SimulatorType): Simulator {
diff --git a/database/schema.ts b/database/schema.ts
index f522f26..c9bec68 100644
--- a/database/schema.ts
+++ b/database/schema.ts
@@ -99,6 +99,7 @@ export const simulatorTypeEnum = pgEnum("simulator_type", [
   "wnba_bracket",
   "world_cup",
   "darts_bracket",
+  "cs2_major_qualifying_points",
 ]);
 
 export const playoffMatchGameStatusEnum = pgEnum("playoff_match_game_status", [
@@ -859,6 +860,7 @@ export const scoringEventsRelations = relations(scoringEvents, ({ one, many }) =
   eventResults: many(eventResults),
   playoffMatches: many(playoffMatches),
   tournamentGroups: many(tournamentGroups),
+  cs2MajorStageResults: many(cs2MajorStageResults),
 }));
 
 export const eventResultsRelations = relations(eventResults, ({ one }) => ({
@@ -1196,3 +1198,43 @@ export const participantGolfSkillsRelations = relations(participantGolfSkills, (
     references: [sportsSeasons.id],
   }),
 }));
+
+// ─── CS2 Major Stage Results ───────────────────────────────────────────────────
+// Tracks which teams are assigned to each Swiss stage of a CS2 Major, and their
+// advancement/elimination results. One row per (scoringEventId, participantId).
+//
+// stageEntry:          1=Opening Stage, 2=Elimination Stage, 3=Decider Stage
+// stageEliminated:     which stage they were eliminated at (null = made Champions Stage)
+// stageEliminatedWins: wins at time of elimination (0, 1, or 2); used to rank teams
+//                      within placements 9–16 for Stage 3 QP (2-3 > 1-3 > 0-3)
+// finalPlacement:      overall placement 1–32 (set after event completes)
+
+export const cs2MajorStageResults = pgTable("cs2_major_stage_results", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  scoringEventId: uuid("scoring_event_id")
+    .notNull()
+    .references(() => scoringEvents.id, { onDelete: "cascade" }),
+  participantId: uuid("participant_id")
+    .notNull()
+    .references(() => participants.id, { onDelete: "cascade" }),
+  stageEntry: integer("stage_entry").notNull(),
+  stageEliminated: integer("stage_eliminated"),
+  stageEliminatedWins: integer("stage_eliminated_wins"),
+  finalPlacement: integer("final_placement"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (t) => ({
+  uniqueEventParticipant: uniqueIndex("cs2_major_stage_results_unique")
+    .on(t.scoringEventId, t.participantId),
+}));
+
+export const cs2MajorStageResultsRelations = relations(cs2MajorStageResults, ({ one }) => ({
+  scoringEvent: one(scoringEvents, {
+    fields: [cs2MajorStageResults.scoringEventId],
+    references: [scoringEvents.id],
+  }),
+  participant: one(participants, {
+    fields: [cs2MajorStageResults.participantId],
+    references: [participants.id],
+  }),
+}));
diff --git a/drizzle/0068_cs2_major_simulator.sql b/drizzle/0068_cs2_major_simulator.sql
new file mode 100644
index 0000000..3d1e8b9
--- /dev/null
+++ b/drizzle/0068_cs2_major_simulator.sql
@@ -0,0 +1,26 @@
+ALTER TYPE "public"."simulator_type" ADD VALUE 'cs2_major_qualifying_points';--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "cs2_major_stage_results" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"scoring_event_id" uuid NOT NULL,
+	"participant_id" uuid NOT NULL,
+	"stage_entry" integer NOT NULL,
+	"stage_eliminated" integer,
+	"stage_eliminated_wins" integer,
+	"final_placement" integer,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "cs2_major_stage_results" ADD CONSTRAINT "cs2_major_stage_results_scoring_event_id_scoring_events_id_fk" FOREIGN KEY ("scoring_event_id") REFERENCES "public"."scoring_events"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "cs2_major_stage_results" ADD CONSTRAINT "cs2_major_stage_results_participant_id_participants_id_fk" FOREIGN KEY ("participant_id") REFERENCES "public"."participants"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "cs2_major_stage_results_unique" ON "cs2_major_stage_results" USING btree ("scoring_event_id","participant_id");
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index b9ae77a..36b96fd 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -477,6 +477,13 @@
       "when": 1774900000000,
       "tag": "0067_darts_bracket",
       "breakpoints": true
+    },
+    {
+      "idx": 68,
+      "version": "7",
+      "when": 1775000000000,
+      "tag": "0068_cs2_major_simulator",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/server/app.ts b/server/app.ts
index c175623..48a9e00 100644
--- a/server/app.ts
+++ b/server/app.ts
@@ -1,27 +1,14 @@
 import { createRequestHandler } from "@react-router/express";
-import { drizzle } from "drizzle-orm/postgres-js";
 import express from "express";
-import postgres from "postgres";
 import type { ServerBuild } from "react-router";
 import { RouterContextProvider } from "react-router";
 
 import { DatabaseContext } from "~/database/context";
-import * as schema from "~/database/schema";
+import { db } from "./db";
 import { expressValueContext } from "~/contexts/express";
 
 export const app = express();
 
-if (!process.env.DATABASE_URL) throw new Error("DATABASE_URL is required");
-
-// In dev, ssrLoadModule re-evaluates this file on every request. Cache the
-// client on globalThis so HMR re-loads reuse the same connection pool instead
-// of leaking a new one each time.
-declare global {
-  // TypeScript requires `var` in `declare global` blocks — `let`/`const` are not allowed here.
-  var __pgClient: ReturnType<typeof postgres> | undefined; // eslint-disable-line no-var
-}
-const client = (globalThis.__pgClient ??= postgres(process.env.DATABASE_URL));
-const db = drizzle(client, { schema });
 app.use((_, __, next) => DatabaseContext.run(db, next));
 
 app.use(
diff --git a/server/db.ts b/server/db.ts
new file mode 100644
index 0000000..911f809
--- /dev/null
+++ b/server/db.ts
@@ -0,0 +1,29 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "~/database/schema";
+
+// Cache the client on globalThis so HMR re-evaluations and multiple server
+// modules share a single connection pool instead of each opening their own.
+declare global {
+  // eslint-disable-next-line no-var
+  var __pgClient: ReturnType<typeof postgres> | undefined;
+  // eslint-disable-next-line no-var
+  var __pgDb: ReturnType<typeof drizzle<typeof schema>> | undefined;
+}
+
+function getDb() {
+  if (!globalThis.__pgDb) {
+    if (!process.env.DATABASE_URL) throw new Error("DATABASE_URL is required");
+    globalThis.__pgClient ??= postgres(process.env.DATABASE_URL);
+    globalThis.__pgDb = drizzle(globalThis.__pgClient, { schema });
+  }
+  return globalThis.__pgDb;
+}
+
+// Export a Proxy so callers can use `db.query.foo` etc. without calling getDb() themselves.
+// The proxy defers the DATABASE_URL check until the first actual property access.
+export const db = new Proxy({} as ReturnType<typeof drizzle<typeof schema>>, {
+  get(_target, prop) {
+    return getDb()[prop as keyof ReturnType<typeof drizzle<typeof schema>>];
+  },
+});
diff --git a/server/snapshots.ts b/server/snapshots.ts
index 360d9a9..848206a 100644
--- a/server/snapshots.ts
+++ b/server/snapshots.ts
@@ -1,17 +1,8 @@
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
 import * as schema from "~/database/schema";
 import { eq, or } from "drizzle-orm";
 import { createDailySnapshot } from "~/models/standings";
 import { logger } from "./logger";
-
-// Create a dedicated database connection for the snapshot system
-const connectionString = process.env.DATABASE_URL;
-if (!connectionString) {
-  throw new Error("DATABASE_URL is required for snapshot system");
-}
-const client = postgres(connectionString);
-const db = drizzle(client, { schema });
+import { db } from "./db";
 
 let snapshotInterval: NodeJS.Timeout | null = null;
 const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // Check once per day (in milliseconds)
diff --git a/server/socket.ts b/server/socket.ts
index 29c31ad..8bdea68 100644
--- a/server/socket.ts
+++ b/server/socket.ts
@@ -1,23 +1,10 @@
 import type { Socket } from "socket.io";
 import { Server as SocketIOServer } from "socket.io";
 import type { Server as HTTPServer } from "http";
-import { drizzle } from "drizzle-orm/postgres-js";
-import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
 import * as schema from "~/database/schema";
 import { eq, and, asc } from "drizzle-orm";
 import { logger } from "./logger";
-
-// Lazy-initialized DB for socket-level validation queries (team ownership checks)
-let _socketDb: PostgresJsDatabase<typeof schema> | null = null;
-function getSocketDb(): PostgresJsDatabase<typeof schema> {
-  if (!_socketDb) {
-    const url = process.env.DATABASE_URL;
-    if (!url) throw new Error("DATABASE_URL is required");
-    _socketDb = drizzle(postgres(url), { schema });
-  }
-  return _socketDb;
-}
+import { db } from "./db";
 
 // Socket event types
 interface ServerToClientEvents {
@@ -142,7 +129,6 @@ export function initializeSocketIO(httpServer: HTTPServer): SocketIOServer {
       // If teamId provided, validate it belongs to this season before tracking
       if (teamId) {
         try {
-          const db = getSocketDb();
           const team = await db.query.teams.findFirst({
             where: and(eq(schema.teams.id, teamId), eq(schema.teams.seasonId, seasonId)),
           });
@@ -185,7 +171,6 @@ export function initializeSocketIO(httpServer: HTTPServer): SocketIOServer {
       // tokens or flaky mobile networks. This socket-based sync provides an
       // additional, more reliable path since the socket is already connected.
       try {
-        const db = getSocketDb();
         const [seasonData, picks, timerRows, queueItems] = await Promise.all([
           db.query.seasons.findFirst({
             where: eq(schema.seasons.id, seasonId),
diff --git a/server/timer.ts b/server/timer.ts
index 753a407..7f19994 100644
--- a/server/timer.ts
+++ b/server/timer.ts
@@ -1,19 +1,10 @@
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
 import * as schema from "~/database/schema";
 import { eq, and, asc, sql } from "drizzle-orm";
 import type { InferSelectModel } from "drizzle-orm";
 import { getSocketIO } from "./socket";
 import { executeAutoPick, calculatePickInfo } from "~/models/draft-utils";
 import { logger } from "./logger";
-
-// Create a dedicated database connection for the timer
-const connectionString = process.env.DATABASE_URL;
-if (!connectionString) {
-  throw new Error("DATABASE_URL is required for timer system");
-}
-const client = postgres(connectionString);
-const db = drizzle(client, { schema });
+import { db } from "./db";
 
 let timerInterval: NodeJS.Timeout | null = null;
 let timerTickRunning = false;