@vatvaghool/create-ipl-dashboard 0.1.0

package/template/README.md

@@ -0,0 +1,160 @@
+# IPL Fantasy Cricket Dashboard
+
+Private Next.js dashboard for an IPL fantasy league. Combines seeded match history with live leaderboard snapshots to show standings, match-by-match movement, captain picks, cumulative trends, and league insights in one place.
+
+## Screenshots
+
+<!-- TODO: Add screenshots -->
+| Dashboard Overview | Performance Tracker |
+|:---:|:---:|
+| ![](./screenshots/dashboard-overview.png) | ![](./screenshots/performance-tracker.png) |
+
+| Captain Board | Ledger Table |
+|:---:|:---:|
+| ![](./screenshots/captain-board.png) | ![](./screenshots/ledger-table.png) |
+
+| Match Scrubber | AI Roasting |
+|:---:|:---:|
+| ![](./screenshots/match-scrubber.png) | ![](./screenshots/ai-roasting.png) |
+
+---
+
+## Quick Start
+
+```bash
+npm install
+```
+
+Create a `.env` file:
+
+```env
+MONGODB_URI=your_mongodb_connection_string
+IPL_LEAGUE_URL=https://fantasy.iplt20.com/classic/league/view/your_league_id
+IPL_POST_SECRET=your_secret_here
+```
+
+Start the app:
+
+```bash
+npm run dev:simple
+```
+
+Open http://localhost:3000
+
+---
+
+## Components
+
+### Dashboard Sections
+
+| Component | File | Description |
+|-----------|------|-------------|
+| **StickyMini** | `components/dashboard/StickyMini.tsx` | Compact stat card with title, value, note, and color-coded icon |
+| **SectionCard** | `components/dashboard/SectionCard.tsx` | Animated motion-section wrapper with title, note, accent color, and staggered entrance |
+| **ChartBoard** | `components/dashboard/ChartBoard.tsx` | Recharts bar chart for team data with pill tags and tooltips |
+| **CaptainBoard** | `components/dashboard/CaptainBoard.tsx` | Displays captain/vice-captain picks per team with shield icons |
+| **LedgerTable** | `components/dashboard/LedgerTable.tsx` | Full standings table with colors, boosters, rank arrows, and formatted points |
+| **LatestBadge** | `components/dashboard/LatestBadge.tsx` | Color-coded pill badge for points (pink <200, orange 200-400, green >400) |
+
+### Widgets
+
+| Component | File | Description |
+|-----------|------|-------------|
+| **PerformanceTracker** | `components/PerformanceTracker.tsx` | Recharts line chart tracking each team's point trajectory across match days |
+| **CrownBattle** | `components/CrownBattle.tsx` | Head-to-head showdown between #1 and #2 ranked teams |
+| **AIRoasting** | `components/AIRoasting.tsx` | AI-generated roast commentary cards cycling through hot/cold/lightning/trend types |
+| **FantasyStockTicker** | `components/FantasyStockTicker.tsx` | Team stocks with trend arrows, sparklines, and fluctuating values |
+| **TeamDNAScanner** | `components/TeamDNAScanner.tsx` | Sci-fi DNA scan visualization with moving scan-line and std deviation metrics |
+| **MatchRecapScroll** | `components/MatchRecapScroll.tsx` | Scroll-styled recap panel for the latest match day results |
+| **MatchStoryScrubber** | `components/MatchStoryScrubber.tsx` | Interactive timeline scrubber to step through match history with bar charts |
+| **LiveMatchTicker** | `components/LiveMatchTicker.tsx` | Live-scrolling ticker of upcoming matches with countdowns |
+| **ProgressGlowRings** | `components/ProgressGlowRings.tsx` | Animated SVG glowing ring progress indicators per team |
+| **ColorWave** | `components/ColorWave.tsx` | Animated SVG wave/chart visualizing team scores over time |
+| **FireworksBurst** | `components/FireworksBurst.tsx` | Particle-based fireworks celebration on milestones |
+| **ThemeToggle** | `components/ThemeToggle.tsx` | Dark/light mode toggle persisted to localStorage |
+
+### UI Primitives
+
+| Component | File | Description |
+|-----------|------|-------------|
+| **TeamPills** | `components/ui/TeamPills.tsx` | Flex-wrap row of bordered pill/chip team labels |
+| **DashboardChartFrame** | `components/ui/DashboardChartFrame.tsx` | Responsive chart wrapper with hover-jitter effects |
+| **DoodleSpinner** | `components/ui/DoodleSpinner.tsx` | Hand-drawn SVG loading spinner with dotted circles |
+
+---
+
+## API Endpoints
+
+| Route | Method | Description |
+|-------|--------|-------------|
+| `/api/ipl` | GET | Full dashboard payload used by the UI |
+| `/api/ipl?format=snapshot` | GET | Raw normalized snapshot only |
+| `/api/ipl` | POST | Ingest a leaderboard snapshot |
+| `/api/ipl/transfers` | GET | Transfer/booster snapshot for all teams |
+| `/api/ipl/transfers` | POST | Ingest a single team transfer record |
+| `/api/ipl/upcoming-matches` | GET | Upcoming match schedule |
+| `/api/ops/status` | GET | Health/monitoring endpoint |
+
+---
+
+## Data Flow
+
+```
+GET /api/ipl resolution order:
+  1. MongoDB raw users (if MONGODB_URI configured)
+  2. Fallback: local seed data (app/api/ipl/data.ts)
+  3. MongoDB live snapshot (if MONGODB_URI configured)
+  4. Fallback: local snapshot file (app/api/ipl/live-snapshot.json)
+```
+
+---
+
+## Configuration
+
+All hardcoded values are centralized in `app/lib/config.ts` and overridable via environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MONGODB_URI` | - | MongoDB connection string |
+| `IPL_LEAGUE_URL` | fantasy.iplt20.com/... | Fantasy league page URL |
+| `IPL_POST_SECRET` | - | Bearer token for POST endpoints |
+| `IPL_DB_NAME` | `ipl` | MongoDB database name |
+| `IPL_COLLECTION_NAME` | `ipl` | MongoDB collection name |
+| `IPL_TOTAL_TRANSFERS` | `160` | Total transfers per season |
+| `IPL_SYNC_INTERVAL_MS` | `120000` | Dashboard polling interval |
+| `IPL_DASHBOARD_STALE_MINUTES` | `20` (prod) / `180` (dev) | Staleness threshold |
+| `IPL_TRANSFERS_STALE_MINUTES` | `720` (prod) / `1440` (dev) | Transfer staleness threshold |
+
+---
+
+## Automation
+
+```bash
+# Capture login state for Playwright scrapers
+npm run capture:ipl-auth
+
+# Scrape live leaderboard snapshot
+npm run sync:ipl
+
+# Scrape transfer/booster data
+npm run sync:ipl:transfers
+
+# Run both in sequence (for cloud jobs)
+npm run sync:cloud
+```
+
+Also supports a browser bookmarklet — visit `/api/ipl/bookmarklet` while the app is running, copy the returned `javascript:` code, and save it as a bookmark. Click it on the fantasy leaderboard page to sync data.
+
+---
+
+## Stack
+
+- **Next.js** 16 App Router
+- **React** 19
+- **TypeScript**
+- **Tailwind CSS** 4
+- **Recharts** — charts
+- **Framer Motion** — animations
+- **MongoDB** — data persistence
+- **Zustand** — client state
+- **Playwright** — scraper automation

package/template/app/api/ipl/data.ts

@@ -0,0 +1,24 @@
+import type { RawApiUser } from "../../types";
+import { TEAMS } from "../../data/teams.ts";
+import { MATCH_POINTS } from "../../data/match-points.ts";
+
+const calcPoints = (matches: Array<{ matchId: number; points: number }>) =>
+  matches.reduce((sum, m) => sum + m.points, 0);
+
+export const rawApiUsers: RawApiUser[] = TEAMS.filter((t) => t.id <= 8)
+  .map((team) => {
+    const matches = MATCH_POINTS
+      .filter((row) => row.teamId === team.id)
+      .map((row) => ({ matchId: row.matchId, points: row.points }))
+      .sort((a, b) => a.matchId - b.matchId);
+    return {
+      rno: team.id,
+      temname: team.name,
+      points: 0,
+      matches,
+    };
+  })
+  .map((user) => ({
+    ...user,
+    points: calcPoints(user.matches),
+  }));

package/template/app/api/ipl/route.ts

@@ -0,0 +1,505 @@
+import { NextResponse } from "next/server";
+import { readFile, writeFile } from "node:fs/promises";
+import type { RawApiUser, ScrapedDashboardPayload } from "../../types";
+import {
+  buildDashboardFromSnapshot,
+  buildManualDashboard,
+  normalizeRawApiUsers,
+  normalizePayload,
+  serializeRawApiUsersModule,
+  syncRawUsersWithSnapshot,
+  resolveTeamId,
+  getTransformOptions,
+} from "./transform";
+import { rawApiUsers } from "./data";
+import getMongoDb from "../../lib/useDb";
+import { config } from "../../lib/config.ts";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+export const runtime = "nodejs";
+
+const DASHBOARD_COLLECTION = config.mongodb.collectionName;
+const DASHBOARD_DOCUMENT_TYPE = config.docTypes.dashboard;
+const RAW_USERS_DOCUMENT_TYPE = config.docTypes.rawUsers;
+const isProduction = process.env.NODE_ENV === "production";
+const allowLocalSnapshotFallback = !isProduction;
+const allowLocalSeedDataWrites =
+  !isProduction && process.env.IPL_WRITE_SEED_DATA_FILE === "1";
+const SNAPSHOT_FILE_PATH = config.paths.snapshotFile;
+const SEED_DATA_FILE_PATH = config.paths.seedDataFile;
+
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Cache-Control": "no-store, no-cache, must-revalidate",
+  Pragma: "no-cache",
+  Expires: "0",
+};
+
+const LOG_TAG = "[ipl-api]";
+const shouldLog =
+  process.env.IPL_API_LOG === "1" || process.env.NODE_ENV !== "production";
+const shouldLogPayload = process.env.IPL_API_LOG_PAYLOAD === "1";
+
+const log = (message: string, details?: unknown) => {
+  if (!shouldLog) return;
+  if (details === undefined) {
+    console.log(LOG_TAG, message);
+    return;
+  }
+  console.log(LOG_TAG, message, details);
+};
+
+const opts = getTransformOptions();
+
+const getDb = async () => {
+  try {
+    return await getMongoDb();
+  } catch (error) {
+    console.error("MongoDB connection failed:", error);
+    return null;
+  }
+};
+
+const readMongoSnapshot = async () => {
+  const db = await getDb();
+  if (!db) return null;
+  try {
+    const document = await db
+      .collection(DASHBOARD_COLLECTION)
+      .findOne({ type: DASHBOARD_DOCUMENT_TYPE });
+    return normalizePayload(document);
+  } catch (error) {
+    console.error("Failed to read IPL snapshot from MongoDB:", error);
+    return null;
+  }
+};
+
+const readMongoRawUsers = async () => {
+  const db = await getDb();
+  if (!db) return null;
+  try {
+    const document = await db
+      .collection(DASHBOARD_COLLECTION)
+      .findOne({ type: RAW_USERS_DOCUMENT_TYPE });
+    return normalizeRawApiUsers(document?.users);
+  } catch (error) {
+    console.error("Failed to read IPL raw users from MongoDB:", error);
+    return null;
+  }
+};
+
+const readSnapshotFile = async () => {
+  if (!allowLocalSnapshotFallback) {
+    return null;
+  }
+
+  try {
+    const content = await readFile(SNAPSHOT_FILE_PATH, "utf8");
+    return normalizePayload(JSON.parse(content));
+  } catch {
+    return null;
+  }
+};
+
+const readLocalRawUsers = () => normalizeRawApiUsers(rawApiUsers);
+const createEmptyDashboard = () => buildManualDashboard([]);
+
+const withPreviousSnapshotMovement = (
+  payload: ScrapedDashboardPayload,
+  previous: ScrapedDashboardPayload | null,
+): ScrapedDashboardPayload => {
+  if (!previous?.leaders.length) {
+    return payload;
+  }
+
+  const previousByName = new Map(
+    previous.leaders.map((leader) => [leader.name, leader] as const),
+  );
+
+  return {
+    ...payload,
+    leaders: payload.leaders.map((leader) => {
+      const previousLeader = previousByName.get(leader.name);
+
+      if (!previousLeader) {
+        return leader;
+      }
+
+      return {
+        ...leader,
+        netRank: previousLeader.rank,
+        netPoints: previousLeader.points,
+      };
+    }),
+  };
+};
+
+const snapshotFingerprint = (payload: ScrapedDashboardPayload | null) => {
+  if (!payload) return "";
+  const normalizedLeaders = [...payload.leaders]
+    .map((leader) => ({
+      rank: leader.rank,
+      name: leader.name,
+      points: leader.points,
+      lastMatchPoints: leader.lastMatchPoints,
+      transfersLeft: leader.transfersLeft,
+      transfersUsed: leader.transfersUsed,
+      totalTransfers: leader.totalTransfers,
+      boostersUsed: leader.boostersUsed,
+      captain: leader.captain,
+      viceCaptain: leader.viceCaptain,
+      players: leader.players,
+    }))
+    .sort((a, b) => a.rank - b.rank);
+  return JSON.stringify({
+    completedMatches: payload.completedMatches,
+    dailyTransferUpdatedAt: payload.dailyTransferUpdatedAt,
+    leaders: normalizedLeaders,
+  });
+};
+
+const snapshotsAreEqual = (
+  current: ScrapedDashboardPayload | null,
+  next: ScrapedDashboardPayload,
+) => Boolean(current) && snapshotFingerprint(current) === snapshotFingerprint(next);
+
+const snapshotSummary = (payload: ScrapedDashboardPayload | null) => {
+  if (!payload) return null;
+  const topLeaders = [...payload.leaders]
+    .sort((a, b) => a.rank - b.rank)
+    .slice(0, 5)
+    .map((leader) => ({
+      rank: leader.rank,
+      name: leader.name,
+      teamId: resolveTeamId(leader.name),
+      points: leader.points,
+      lastMatchPoints: leader.lastMatchPoints,
+      transfersLeft: leader.transfersLeft,
+      transfersUsed: leader.transfersUsed,
+      totalTransfers: leader.totalTransfers,
+      boostersUsed: leader.boostersUsed,
+    }));
+  return {
+    updatedAt: payload.updatedAt,
+    dailyTransferUpdatedAt: payload.dailyTransferUpdatedAt,
+    completedMatches: payload.completedMatches,
+    leadersCount: payload.leaders.length,
+    topLeaders,
+  };
+};
+
+const writeMongoSnapshot = async (payload: ScrapedDashboardPayload) => {
+  const db = await getDb();
+  if (!db) return { configured: false, stored: false };
+  try {
+    const current = await readMongoSnapshot();
+    if (snapshotsAreEqual(current, payload)) {
+      return { configured: true, stored: true, status: "unchanged" as const };
+    }
+    await db.collection(DASHBOARD_COLLECTION).updateOne(
+      { type: DASHBOARD_DOCUMENT_TYPE },
+      {
+        $set: {
+          type: DASHBOARD_DOCUMENT_TYPE,
+          updatedAt: payload.updatedAt,
+          dailyTransferUpdatedAt: payload.dailyTransferUpdatedAt,
+          completedMatches: payload.completedMatches,
+          leaders: payload.leaders.map((l) => ({
+            ...l,
+            teamId: resolveTeamId(l.name),
+          })),
+        },
+      },
+      { upsert: true },
+    );
+    return { configured: true, stored: true, status: "updated" as const };
+  } catch (error) {
+    console.error("Failed to write IPL snapshot to MongoDB:", error);
+    return { configured: true, stored: false, status: "failed" as const };
+  }
+};
+
+const writeMongoRawUsers = async (users: RawApiUser[]) => {
+  const db = await getDb();
+  if (!db) return { configured: false, stored: false };
+  try {
+    await db.collection(DASHBOARD_COLLECTION).updateOne(
+      { type: RAW_USERS_DOCUMENT_TYPE },
+      {
+        $set: {
+          type: RAW_USERS_DOCUMENT_TYPE,
+          updatedAt: new Date().toISOString(),
+          users: users.map((user) => ({
+            rno: user.rno,
+            temname: user.temname,
+            points: user.points,
+            teamId: resolveTeamId(user.temname),
+            matches: [...user.matches].sort((a, b) => a.matchId - b.matchId),
+          })),
+        },
+      },
+      { upsert: true },
+    );
+    return { configured: true, stored: true };
+  } catch (error) {
+    console.error("Failed to write IPL raw users to MongoDB:", error);
+    return { configured: true, stored: false };
+  }
+};
+
+const writeSnapshotFile = async (payload: ScrapedDashboardPayload) => {
+  if (!allowLocalSnapshotFallback) {
+    return false;
+  }
+
+  try {
+    await writeFile(
+      SNAPSHOT_FILE_PATH,
+      `${JSON.stringify(payload, null, 2)}\n`,
+      "utf8",
+    );
+    return true;
+  } catch (error) {
+    console.error("Failed to write IPL live-snapshot.json:", error);
+    return false;
+  }
+};
+
+const writeSeedDataFile = async (users: RawApiUser[]) => {
+  if (!allowLocalSeedDataWrites) {
+    return { configured: false, stored: false };
+  }
+
+  try {
+    await writeFile(
+      SEED_DATA_FILE_PATH,
+      `${serializeRawApiUsersModule(users)}\n`,
+      "utf8",
+    );
+    return { configured: true, stored: true };
+  } catch (error) {
+    console.error("Failed to update IPL seed data file:", error);
+    return { configured: true, stored: false };
+  }
+};
+
+export async function OPTIONS() {
+  return new Response(null, { status: 204, headers: corsHeaders });
+}
+
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+  const format = url.searchParams.get("format");
+  const mongoConfigured = Boolean(process.env.MONGODB_URI);
+
+  log("GET /api/ipl", {
+    format,
+    mongoConfigured,
+    allowLocalSnapshotFallback,
+    url: url.toString(),
+  });
+
+  const [mongoUsers, fileSnapshot, mongoSnapshot] = await Promise.all([
+    readMongoRawUsers(),
+    readSnapshotFile(),
+    readMongoSnapshot(),
+  ]);
+  const manualUsers = mongoUsers ?? readLocalRawUsers();
+  const snapshot = mongoSnapshot ?? fileSnapshot;
+  const manualDashboard = manualUsers
+    ? buildManualDashboard(manualUsers, opts)
+    : createEmptyDashboard();
+  const snapshotSource = mongoSnapshot ? "mongo" : fileSnapshot ? "file" : null;
+
+  log("GET /api/ipl resolved sources", {
+    snapshotSource,
+    hasMongoRawUsers: Boolean(mongoUsers),
+    hasFallbackRawUsers: !mongoUsers && Boolean(rawApiUsers?.length),
+    allowLocalSnapshotFallback,
+    snapshot: snapshotSummary(snapshot),
+  });
+
+  if (format === "snapshot") {
+    if (snapshot) {
+      log("GET /api/ipl?format=snapshot -> 200", { snapshotSource, snapshot: snapshotSummary(snapshot) });
+      return NextResponse.json(snapshot, { headers: corsHeaders });
+    }
+    log("GET /api/ipl?format=snapshot -> 503 (no snapshot)", { snapshotSource });
+    return NextResponse.json(
+      { error: "No IPL snapshot found yet. POST a live snapshot first." },
+      { status: 503, headers: corsHeaders },
+    );
+  }
+
+  if (snapshot) {
+    log("GET /api/ipl -> 200 (dashboard merged)", { snapshotSource, snapshot: snapshotSummary(snapshot) });
+    return NextResponse.json(
+      buildDashboardFromSnapshot(snapshot, manualDashboard, opts),
+      { headers: corsHeaders },
+    );
+  }
+
+  if (manualUsers) {
+    log("GET /api/ipl -> 200 (manual only)", { users: manualUsers.length });
+    return NextResponse.json(manualDashboard, { headers: corsHeaders });
+  }
+
+  log("GET /api/ipl -> 503 (no data)");
+  return NextResponse.json(
+    { error: "No IPL dashboard data found yet. POST a live snapshot first." },
+    { status: 503, headers: corsHeaders },
+  );
+}
+
+export async function POST(request: Request) {
+  const secret = process.env.IPL_POST_SECRET;
+  const auth = request.headers.get("authorization");
+  const mongoConfigured = Boolean(process.env.MONGODB_URI);
+
+  if (secret && auth !== `Bearer ${secret}`) {
+    log("POST /api/ipl -> 401 (missing or invalid bearer token)");
+    return NextResponse.json(
+      { error: "Unauthorized" },
+      { status: 401, headers: corsHeaders },
+    );
+  }
+
+  const payload = normalizePayload(await request.json().catch(() => null));
+
+  if (!payload) {
+    log("POST /api/ipl -> 400 (invalid payload)");
+    return NextResponse.json(
+      { error: "Invalid payload. Expected { leaders: [...] } or [...] ." },
+      { status: 400, headers: corsHeaders },
+    );
+  }
+
+  if (isProduction && !mongoConfigured) {
+    log("POST /api/ipl -> 503 (MongoDB required in production)");
+    return NextResponse.json(
+      {
+        error:
+          "MongoDB storage is required in production. Configure MONGODB_URI for cloud ingestion.",
+      },
+      { status: 503, headers: corsHeaders },
+    );
+  }
+
+  log("POST /api/ipl received payload", {
+    summary: snapshotSummary(payload),
+    ...(shouldLogPayload ? { payload } : {}),
+  });
+
+  const [manualUsers, currentFileSnapshot, currentMongoSnapshot] = await Promise.all([
+    readMongoRawUsers(),
+    readSnapshotFile(),
+    readMongoSnapshot(),
+  ]);
+  const previousSnapshot = currentMongoSnapshot ?? currentFileSnapshot;
+  const preservedDailyTransferUpdatedAt =
+    payload.dailyTransferUpdatedAt ??
+    currentMongoSnapshot?.dailyTransferUpdatedAt ??
+    currentFileSnapshot?.dailyTransferUpdatedAt;
+  const normalizedPayload = withPreviousSnapshotMovement(
+    {
+      ...payload,
+      dailyTransferUpdatedAt: preservedDailyTransferUpdatedAt,
+    },
+    previousSnapshot,
+  );
+  const baselineUsers = manualUsers ?? readLocalRawUsers();
+  const fileMatches = snapshotsAreEqual(currentFileSnapshot, normalizedPayload);
+  const mongoMatches = snapshotsAreEqual(currentMongoSnapshot, normalizedPayload);
+  const snapshotUnchanged = mongoConfigured ? mongoMatches : fileMatches;
+
+  log("POST /api/ipl compare", {
+    mongoConfigured, fileMatches, mongoMatches, snapshotUnchanged,
+    currentFileSnapshot: snapshotSummary(currentFileSnapshot),
+    currentMongoSnapshot: snapshotSummary(currentMongoSnapshot),
+  });
+
+  if (snapshotUnchanged) {
+    log("POST /api/ipl -> 200 (unchanged)", {
+      storage: {
+        mongodbSnapshot: mongoMatches,
+        localSnapshotFile: fileMatches,
+        mongodbRawUsers: false,
+        mongodbConfigured: Boolean(process.env.MONGODB_URI),
+        snapshotStatus: "unchanged",
+      },
+    });
+    return NextResponse.json(
+      {
+        ok: true,
+        updatedAt: normalizedPayload.updatedAt,
+        dailyTransferUpdatedAt: normalizedPayload.dailyTransferUpdatedAt,
+        count: normalizedPayload.leaders.length,
+        storage: {
+          mongodbSnapshot: mongoMatches, localSnapshotFile: fileMatches,
+          mongodbRawUsers: false, mongodbConfigured: Boolean(process.env.MONGODB_URI),
+          snapshotStatus: "unchanged",
+        },
+        rawSync: { status: "unchanged", unmatchedNames: [] },
+      },
+      { headers: corsHeaders },
+    );
+  }
+
+  const mongoStorage = await writeMongoSnapshot(normalizedPayload);
+  const fileSnapshotStored = await writeSnapshotFile(normalizedPayload);
+  const rawSync = baselineUsers
+    ? syncRawUsersWithSnapshot(baselineUsers, normalizedPayload, opts)
+    : {
+        status: "skipped" as const,
+        users: [],
+        unmatchedNames: normalizedPayload.leaders.map((leader) => leader.name),
+      };
+
+  const rawUsersStorage =
+    manualUsers && rawSync.status === "updated"
+      ? await writeMongoRawUsers(rawSync.users)
+      : { configured: Boolean(process.env.MONGODB_URI), stored: false };
+  const seedFileStorage =
+    rawSync.status === "updated"
+      ? await writeSeedDataFile(rawSync.users)
+      : { configured: allowLocalSeedDataWrites, stored: false };
+
+  log("POST /api/ipl write results", {
+    mongodbSnapshot: mongoStorage,
+    localSnapshotFile: fileSnapshotStored,
+    mongodbRawUsers: rawUsersStorage,
+    seedDataFile: seedFileStorage,
+    rawSync: {
+      status: rawSync.status, matchId: rawSync.matchId, mode: rawSync.mode,
+      completedMatches: rawSync.completedMatches,
+      unmatchedNames: rawSync.unmatchedNames,
+      usersWritten: rawSync.status === "updated" ? rawSync.users.length : 0,
+    },
+  });
+
+  return NextResponse.json(
+    {
+      ok: true,
+      updatedAt: normalizedPayload.updatedAt,
+      dailyTransferUpdatedAt: normalizedPayload.dailyTransferUpdatedAt,
+      count: normalizedPayload.leaders.length,
+      storage: {
+        mongodbSnapshot: mongoStorage.stored,
+        localSnapshotFile: fileSnapshotStored,
+        mongodbRawUsers: rawUsersStorage.stored,
+        mongodbConfigured: mongoStorage.configured,
+        snapshotStatus: mongoStorage.status,
+      },
+      seedDataFile: { stored: seedFileStorage.stored },
+      rawSync: {
+        status: rawSync.status, matchId: rawSync.matchId, mode: rawSync.mode,
+        completedMatches: rawSync.completedMatches,
+        unmatchedNames: rawSync.unmatchedNames,
+      },
+    },
+    { headers: corsHeaders },
+  );
+}