cricketstudio-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,1405 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { statSync } from "node:fs";
+import { resolve as resolve2, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { z } from "zod";
+
+// src/telemetry.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function markerDir() {
+  return path.join(os.homedir(), ".cricketstudio-mcp");
+}
+function firstRunMarkerPath() {
+  return path.join(markerDir(), "first-run");
+}
+function isFirstRun() {
+  try {
+    return !fs.existsSync(firstRunMarkerPath());
+  } catch {
+    return false;
+  }
+}
+function markFirstRunDone() {
+  try {
+    fs.mkdirSync(markerDir(), { recursive: true });
+    fs.writeFileSync(firstRunMarkerPath(), (/* @__PURE__ */ new Date()).toISOString(), { flag: "wx" });
+  } catch {
+  }
+}
+function resolveVersion() {
+  try {
+    const candidates = [
+      new URL("../../package.json", import.meta.url),
+      new URL("../package.json", import.meta.url)
+    ];
+    for (const candidate of candidates) {
+      try {
+        const raw = fs.readFileSync(candidate, "utf8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function printFirstRunMessage(version) {
+  const msg = `
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  CricketStudio MCP v${version.padEnd(28)}\u2502
+\u2502  29 tools \xB7 1,307 matches \xB7 309,992 deliveries  \u2502
+\u2502                                                  \u2502
+\u2502  Building something with cricket data?           \u2502
+\u2502  Register at cricketstudio.ai/developers for     \u2502
+\u2502  API updates and early hosted-transport access.  \u2502
+\u2502                                                  \u2502
+\u2502  Set CRICKETSTUDIO_NO_TELEMETRY=1 to silence.   \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`;
+  process.stderr.write(msg);
+  markFirstRunDone();
+}
+async function sendTelemetry(payload) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5e3);
+  try {
+    await fetch("https://telemetry.cricketstudio.ai/mcp/startup", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function runStartup() {
+  if (process.env.CRICKETSTUDIO_NO_TELEMETRY === "1") {
+    return;
+  }
+  const version = resolveVersion();
+  if (isFirstRun()) {
+    printFirstRunMessage(version);
+  }
+  const payload = {
+    version,
+    nodeVersion: process.version,
+    platform: process.platform
+  };
+  if (process.env.CRICKETSTUDIO_DEV_ID) {
+    payload.devId = process.env.CRICKETSTUDIO_DEV_ID;
+  }
+  sendTelemetry(payload).catch(() => void 0);
+}
+
+// src/snapshot.ts
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = resolve(__dirname, "..");
+var SNAPSHOT_DIR = resolve(PKG_ROOT, "data", "snapshot");
+var _standings = null;
+var _trends = null;
+var _matches = null;
+var _seasonStats = void 0;
+function readJson(filename) {
+  const p = resolve(SNAPSHOT_DIR, filename);
+  if (!existsSync(p)) return null;
+  return JSON.parse(readFileSync(p, "utf8"));
+}
+function loadStandings() {
+  if (_standings !== null) return _standings;
+  const raw = readJson("standings.json");
+  _standings = raw ?? [];
+  return _standings;
+}
+function loadTrends() {
+  if (_trends !== null) return _trends;
+  const raw = readJson("trends.json");
+  if (!raw) {
+    _trends = [];
+    return _trends;
+  }
+  _trends = raw.map((t) => ({
+    id: t["id"] ?? "",
+    kind: t["kind"] ?? "",
+    hook: t["hook"] ?? t["tease"] ?? "",
+    bigStat: t["bigStat"],
+    numbers: t["numbers"]
+  }));
+  return _trends;
+}
+function loadMatches() {
+  if (_matches !== null) return _matches;
+  const raw = readJson("matches.json");
+  _matches = raw ?? [];
+  return _matches;
+}
+function loadSeasonStats() {
+  if (_seasonStats !== void 0) return _seasonStats;
+  _seasonStats = readJson("season-stats.json") ?? null;
+  return _seasonStats;
+}
+function getStandings() {
+  return loadStandings();
+}
+function getTrends() {
+  return loadTrends();
+}
+function getMatches(limit) {
+  const all = loadMatches();
+  return limit !== void 0 ? all.slice(0, limit) : all;
+}
+function getSeasonStats() {
+  return loadSeasonStats();
+}
+
+// src/tools/ipl-leaderboard.ts
+var LEADERBOARD_ASPECTS = [
+  // ── Orange / Purple cap ─────────────────────────────────────────────
+  {
+    slug: "orange-cap",
+    title: "Orange cap \u2014 most runs",
+    description: "Career top run-scorers across the IPL historical archive (1,169 matches, 18 seasons 2007/08\u20132025). All-time orange-cap leaderboard.",
+    unit: "Runs",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  {
+    slug: "purple-cap",
+    title: "Purple cap \u2014 most wickets",
+    description: "Career top wicket-takers across the IPL historical archive (1,169 matches, 18 seasons 2007/08\u20132025).",
+    unit: "Wickets",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  // ── Batting aggregates ───────────────────────────────────────────────
+  {
+    slug: "strike-rate",
+    title: "Highest batting strike rates",
+    description: "Best batting strike rates (runs per 100 balls) across IPL career. Minimum sample floor applied.",
+    unit: "Strike rate",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "batting-average",
+    title: "Best batting average",
+    description: "Highest batting averages (runs per dismissal) across IPL career. Minimum sample floor applied.",
+    unit: "Average",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-fifties",
+    title: "Most half-centuries (50s)",
+    description: "Most innings of 50\u201399 runs in IPL career (2007/08\u20132025). Centuries (100+) are counted separately.",
+    unit: "50s",
+    ascending: false,
+    floorNote: "Minimum 3 innings.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-hundreds",
+    title: "Most centuries (100s)",
+    description: "Most innings of 100+ runs in IPL career (2007/08\u20132025). T20 centuries are rare \u2014 this is the complete list.",
+    unit: "100s",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-sixes",
+    title: "Most sixes",
+    description: "Top six-hitters across captured IPL matches (career).",
+    unit: "Sixes",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-fours",
+    title: "Most fours",
+    description: "Top boundary-hitters (fours) across captured IPL matches (career).",
+    unit: "Fours",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  // ── Bowling aggregates ───────────────────────────────────────────────
+  {
+    slug: "economy-leaders",
+    title: "Best bowling economy rates",
+    description: "Lowest bowling economy rates (runs per over) across IPL career. Lower is better. Minimum sample floor applied.",
+    unit: "Economy (RPO)",
+    ascending: true,
+    floorNote: "Minimum 240 legal deliveries bowled.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "bowling-average",
+    title: "Best bowling average",
+    description: "Lowest bowling averages (runs per wicket) across IPL career. Lower is better.",
+    unit: "Average (R/W)",
+    ascending: true,
+    floorNote: "Minimum 300 legal deliveries bowled.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "bowling-strike-rate",
+    title: "Best bowling strike rate",
+    description: "Fewest balls per wicket across IPL career. Lower is better \u2014 measures how quickly a bowler takes wickets.",
+    unit: "Balls per wicket",
+    ascending: true,
+    floorNote: "Minimum 300 legal deliveries bowled.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-dot-balls",
+    title: "Most dot balls bowled",
+    description: "Most legal deliveries where the batter scored 0 runs across IPL career. Measures consistent pressure bowling.",
+    unit: "Dot balls",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  {
+    slug: "runs-conceded",
+    title: "Most runs conceded (bowling)",
+    description: "Most runs conceded while bowling across IPL career \u2014 a workload indicator for high-volume bowlers.",
+    unit: "Runs conceded",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: false
+  },
+  {
+    slug: "maiden-overs",
+    title: "Most maiden overs",
+    description: "Most complete overs (6 legal deliveries) in which the bowler conceded zero runs \u2014 no batting runs, no wides, no no-ball penalties. IPL 2026.",
+    unit: "Maiden overs",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: true
+  },
+  {
+    slug: "hat-tricks",
+    title: "Hat-tricks",
+    description: "3 wickets on 3 consecutive legal deliveries by the same bowler in the same innings. Run-outs excluded. IPL 2026.",
+    unit: "Hat-tricks",
+    ascending: false,
+    floorNote: null,
+    liveSeasonOnly: true
+  },
+  // ── Milestone / speed ────────────────────────────────────────────────
+  {
+    slug: "fastest-fifty",
+    title: "Fastest half-centuries (fewest balls to 50)",
+    description: "Fewest deliveries faced to score 50 runs in an IPL 2026 innings. Ball-by-ball verified.",
+    unit: "Balls to 50",
+    ascending: true,
+    floorNote: null,
+    liveSeasonOnly: true
+  },
+  {
+    slug: "fastest-hundred",
+    title: "Fastest centuries (fewest balls to 100)",
+    description: "Fewest deliveries faced to score 100 runs in an IPL 2026 innings. Ball-by-ball verified.",
+    unit: "Balls to 100",
+    ascending: true,
+    floorNote: null,
+    liveSeasonOnly: true
+  },
+  // ── Powerplay batting ────────────────────────────────────────────────
+  {
+    slug: "pp-runs",
+    title: "Most powerplay runs (overs 1\u20136)",
+    description: "Most runs scored in powerplay overs (1\u20136) across IPL career. Measures powerplay batting contribution.",
+    unit: "PP runs",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in powerplay.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "powerplay-runs",
+    title: "Powerplay runs \u2014 career leaders",
+    description: "Aggregate powerplay runs (overs 1\u20136) across IPL career. Alias for pp-runs; same projector.",
+    unit: "PP runs",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in powerplay.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "pp-sr-batting",
+    title: "Highest powerplay batting strike rates",
+    description: "Best batting strike rates in the powerplay (overs 1\u20136) across IPL career.",
+    unit: "PP strike rate",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in powerplay overs 1\u20136.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-sixes-pp",
+    title: "Most sixes in the powerplay",
+    description: "Most sixes hit in powerplay overs (1\u20136) across IPL career.",
+    unit: "PP sixes",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in powerplay.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-fours-pp",
+    title: "Most fours in the powerplay",
+    description: "Most fours hit in powerplay overs (1\u20136) across IPL career.",
+    unit: "PP fours",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in powerplay.",
+    liveSeasonOnly: false
+  },
+  // ── Powerplay bowling ────────────────────────────────────────────────
+  {
+    slug: "powerplay-economy",
+    title: "Best powerplay economy (overs 1\u20136)",
+    description: "Lowest bowling economy rates in the powerplay (overs 1\u20136) across IPL career. Lower is better.",
+    unit: "PP econ (RPO)",
+    ascending: true,
+    floorNote: "Minimum 18 legal deliveries bowled in overs 1\u20136.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "powerplay-wickets",
+    title: "Most powerplay wickets (overs 1\u20136)",
+    description: "Most wickets taken in powerplay overs (1\u20136) across IPL career. Measures early-over bowling impact.",
+    unit: "PP wickets",
+    ascending: false,
+    floorNote: "Minimum 18 legal deliveries in powerplay.",
+    liveSeasonOnly: false
+  },
+  // ── Middle overs batting ─────────────────────────────────────────────
+  {
+    slug: "middle-runs",
+    title: "Most middle-overs runs (overs 7\u201315)",
+    description: "Most runs scored in middle overs (7\u201315) across IPL career. The anchor phase where dot balls and wickets set up the finish.",
+    unit: "Middle runs",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in middle overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-sixes-middle",
+    title: "Most sixes in the middle overs",
+    description: "Most sixes hit in middle overs (7\u201315) across IPL career.",
+    unit: "Middle sixes",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in middle overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-fours-middle",
+    title: "Most fours in the middle overs",
+    description: "Most fours hit in middle overs (7\u201315) across IPL career.",
+    unit: "Middle fours",
+    ascending: false,
+    floorNote: "Minimum 150 balls faced in middle overs.",
+    liveSeasonOnly: false
+  },
+  // ── Middle overs bowling ─────────────────────────────────────────────
+  {
+    slug: "middle-wickets",
+    title: "Most middle-overs wickets (overs 7\u201315)",
+    description: "Most wickets taken in the middle overs (7\u201315) across IPL career.",
+    unit: "Middle wickets",
+    ascending: false,
+    floorNote: "Minimum 240 legal deliveries in middle overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "middle-economy",
+    title: "Best middle-overs economy (overs 7\u201315)",
+    description: "Lowest bowling economy rate in the middle overs (7\u201315) across IPL career. Lower is better.",
+    unit: "Middle econ (RPO)",
+    ascending: true,
+    floorNote: "Minimum 240 legal deliveries in middle overs.",
+    liveSeasonOnly: false
+  },
+  // ── Death overs batting ──────────────────────────────────────────────
+  {
+    slug: "death-runs",
+    title: "Most death-overs runs (overs 16\u201320)",
+    description: "Most runs scored in death overs (16\u201320) across IPL career. The finisher's arena.",
+    unit: "Death runs",
+    ascending: false,
+    floorNote: "Minimum 20 balls faced in death overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "death-sr-batting",
+    title: "Highest death-overs batting strike rates",
+    description: "Best batting strike rates in death overs (overs 17\u201320) across IPL career.",
+    unit: "Death SR",
+    ascending: false,
+    floorNote: "Minimum 20 balls faced in death overs (17\u201320).",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-sixes-death",
+    title: "Most sixes in death overs",
+    description: "Most sixes hit in death overs (16\u201320) across IPL career.",
+    unit: "Death sixes",
+    ascending: false,
+    floorNote: "Minimum 20 balls faced in death overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "most-fours-death",
+    title: "Most fours in death overs",
+    description: "Most fours hit in death overs (16\u201320) across IPL career.",
+    unit: "Death fours",
+    ascending: false,
+    floorNote: "Minimum 20 balls faced in death overs.",
+    liveSeasonOnly: false
+  },
+  // ── Death overs bowling ──────────────────────────────────────────────
+  {
+    slug: "death-wickets",
+    title: "Most death-overs wickets (overs 16\u201320)",
+    description: "Most wickets taken in death overs (16\u201320) across IPL career. Measures death-bowling impact.",
+    unit: "Death wickets",
+    ascending: false,
+    floorNote: "Minimum 240 legal deliveries in death overs.",
+    liveSeasonOnly: false
+  },
+  {
+    slug: "death-overs-economy",
+    title: "Best death-overs economy (overs 17\u201320)",
+    description: "Lowest bowling economy rates in death overs (overs 17\u201320) across IPL career. Lower is better.",
+    unit: "Death econ (RPO)",
+    ascending: true,
+    floorNote: "Minimum 240 legal deliveries bowled in overs 17\u201320.",
+    liveSeasonOnly: false
+  }
+];
+function getAspectMeta(slug) {
+  return LEADERBOARD_ASPECTS.find((a) => a.slug === slug) ?? null;
+}
+
+// src/index.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var SNAPSHOT_DIR2 = resolve2(__dirname2, "..", "data", "snapshot");
+var SITE = "https://players.cricketstudio.ai";
+var MLC_HUB = `${SITE}/leagues/mlc`;
+var IPL_HUB = `${SITE}/leagues/ipl`;
+function readSnapshotJson(name) {
+  const p = resolve2(SNAPSHOT_DIR2, name);
+  if (!existsSync2(p)) return null;
+  return JSON.parse(readFileSync2(p, "utf8"));
+}
+var _players = null;
+var _teams = null;
+var _venues = null;
+var _trends2 = null;
+var _h2h = null;
+var _teamH2h = null;
+var _metadata = null;
+var _seasonStats2 = null;
+var _mlcPlayers = null;
+var _mlcTeams = null;
+var _mlcMatches = null;
+var _mlcLeague = null;
+var _mlcLeaderboards = null;
+var _iplHistorical = void 0;
+var _rawMatches = null;
+var _rawStandings = null;
+var _teamIdToCode = null;
+function players() {
+  if (!_players) _players = readSnapshotJson("players.json") ?? {};
+  return _players;
+}
+function teams() {
+  if (!_teams) _teams = readSnapshotJson("teams.json") ?? [];
+  return _teams;
+}
+function venues() {
+  if (!_venues) _venues = readSnapshotJson("venues.json") ?? [];
+  return _venues;
+}
+function trendsList() {
+  if (!_trends2) _trends2 = getTrends();
+  return _trends2;
+}
+function h2hSummaries() {
+  if (!_h2h) _h2h = readSnapshotJson("h2h.json") ?? [];
+  return _h2h;
+}
+function teamH2h() {
+  if (!_teamH2h) _teamH2h = readSnapshotJson("team-h2h.json") ?? {};
+  return _teamH2h;
+}
+function metadata() {
+  if (!_metadata) _metadata = readSnapshotJson("metadata.json") ?? { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), counts: { players: 0, teams: 0, venues: 0, trends: 0, h2hPairs: 0 } };
+  return _metadata;
+}
+function seasonStats() {
+  if (!_seasonStats2) _seasonStats2 = readSnapshotJson("season-stats.json") ?? {};
+  return _seasonStats2;
+}
+function mlcPlayers() {
+  if (!_mlcPlayers) _mlcPlayers = readSnapshotJson("mlc-players.json") ?? {};
+  return _mlcPlayers;
+}
+function mlcTeams() {
+  if (!_mlcTeams) _mlcTeams = readSnapshotJson("mlc-teams.json") ?? [];
+  return _mlcTeams;
+}
+function mlcMatches() {
+  if (!_mlcMatches) _mlcMatches = readSnapshotJson("mlc-matches.json") ?? {};
+  return _mlcMatches;
+}
+function mlcLeague() {
+  if (!_mlcLeague) _mlcLeague = readSnapshotJson("mlc-league.json") ?? { seasons: [], teams: [], venues: [], playerCount: 0, totalMatches: 0, leaderboardAspects: [] };
+  return _mlcLeague;
+}
+function mlcLeaderboards() {
+  if (!_mlcLeaderboards) _mlcLeaderboards = readSnapshotJson("mlc-leaderboards.json") ?? {};
+  return _mlcLeaderboards;
+}
+function iplHistorical() {
+  if (_iplHistorical !== void 0) return _iplHistorical;
+  _iplHistorical = readSnapshotJson("ipl-historical.json");
+  return _iplHistorical;
+}
+function rawMatches() {
+  if (!_rawMatches) _rawMatches = readSnapshotJson("matches.json") ?? [];
+  return _rawMatches;
+}
+function rawMatch(id) {
+  return rawMatches().find((m) => m.id === id);
+}
+function rawStandings() {
+  if (!_rawStandings) _rawStandings = readSnapshotJson("standings.json") ?? [];
+  return _rawStandings;
+}
+function teamIdToCode(id) {
+  if (id === void 0 || id === null) return null;
+  if (!_teamIdToCode) _teamIdToCode = new Map(rawStandings().map((r) => [r.teamId, r.teamCode]));
+  return _teamIdToCode.get(id) ?? null;
+}
+var mlcPlayerUrl = (slug) => `${MLC_HUB}/players/${slug}`;
+var mlcTeamUrl = (slug) => `${MLC_HUB}/teams/${slug}`;
+var mlcMatchUrl = (id) => `${MLC_HUB}/matches/${id}`;
+var mlcMatchClaimUrl = (id, kind) => `${MLC_HUB}/matches/${id}/c/${kind}`;
+var mlcLeaderboardUrl = (aspect) => `${MLC_HUB}/leaderboards/${aspect}`;
+function dataAsOf() {
+  try {
+    return statSync(resolve2(SNAPSHOT_DIR2, "metadata.json")).mtime.toISOString();
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+function ok(payload, canonicalUrl) {
+  const enriched = { ...payload, dataAsOf: dataAsOf(), ...canonicalUrl ? { canonicalUrl } : {} };
+  return { content: [{ type: "text", text: JSON.stringify(enriched, null, 2) }] };
+}
+function notFound(message, canonicalUrl) {
+  return ok({ error: "not_found", message, hint: "Use search_players / list_trends / list_fixtures to discover valid keys." }, canonicalUrl);
+}
+var TOOLS = [
+  // ── GROUP 1: IPL 2026 Core ──────────────────────────────────────────
+  {
+    name: "get_dataset_summary",
+    description: "First call. Returns what CricketStudio covers \u2014 leagues (IPL 2026, IPL historical 18 seasons, MLC 2023\u20132026), corpus counts, surface URLs, 5 non-negotiables (sample-size floors, date windows, provenance, atomic claims, 4hr SLA), license. Use to ground subsequent queries against the real catalog of available entities.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "search_players",
+    description: "Find IPL 2026 player slugs by substring match against name, slug, or team. Case-insensitive. Returns slug + fullName + team + role. Use before get_player_profile when you have a name but not a slug.",
+    inputSchema: { type: "object", properties: { query: { type: "string", description: "Substring to match (case-insensitive)" }, limit: { type: "number", description: "Max results (default 10, max 50)" } }, required: ["query"], additionalProperties: false }
+  },
+  {
+    name: "get_player_profile",
+    description: `Full IPL 2026 player profile + all computed claims across pillars P1\u2013P5. Each claim carries sample size, period, provenance. Use for: "How is Bumrah performing?", "What are Kohli's IPL 2026 stats?". Player slugs are kebab-case (jasprit-bumrah). Use search_players first if you need the slug.`,
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string", description: "kebab-case player slug e.g. jasprit-bumrah" } }, required: ["playerSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_player_pillar",
+    description: `One content pillar for an IPL 2026 player. P1=Match recaps, P2=Moments/milestones, P3=Form & phase (powerplay/middle/death), P4=Season comparatives, P5=Notebook/narrative. Use for: "How is Bumrah bowling at the death?" \u2192 P3. "What are Kohli's best moments?" \u2192 P2.`,
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string" }, pillar: { type: "string", enum: ["P1", "P2", "P3", "P4", "P5"] } }, required: ["playerSlug", "pillar"], additionalProperties: false }
+  },
+  {
+    name: "get_standings",
+    description: "IPL 2026 final standings. RCB are champions. All 10 teams with Points/Won/Lost/NRR. Returns canonical URL \u2014 the live standings page refreshes within the 4-hour SLA; cite the URL for current data.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "get_season_stats",
+    description: "IPL 2026 season leaderboard from SETU canonical aggregate. sortBy: runs, wickets, strike_rate, economy, ducks, single_digit_outs, catches, run_outs. Optional teamCode filter. Sample-size floors apply (\u226530 balls faced for SR, \u226515 balls bowled for economy).",
+    inputSchema: { type: "object", properties: { sortBy: { type: "string", enum: ["runs", "wickets", "strike_rate", "economy", "ducks", "single_digit_outs", "catches", "run_outs"] }, teamCode: { type: "string", description: "Optional 2\u20134 letter team code e.g. MI, RCB" }, limit: { type: "number", description: "Max rows (default 15, max 100)" } }, required: ["sortBy"], additionalProperties: false }
+  },
+  {
+    name: "get_match_state",
+    description: "Result, scoreboards, and status for one IPL 2026 match from the bundled snapshot. Returns home/away teams, innings totals, toss winner, and Man of the Match. Use list_fixtures to discover matchIds. Note: live ball-by-ball is at the canonical URL.",
+    inputSchema: { type: "object", properties: { matchId: { type: "string", description: "Match id (numeric string or slug form)" } }, required: ["matchId"], additionalProperties: false }
+  },
+  {
+    name: "get_match_recap",
+    description: 'Key performers and highlights for one finished IPL 2026 match \u2014 top batter, top bowler, MOTM, milestones. Use for: "Who won the MI vs RCB match?", "What happened in match 69635?". Use list_fixtures to discover matchIds.',
+    inputSchema: { type: "object", properties: { matchId: { type: "string" } }, required: ["matchId"], additionalProperties: false }
+  },
+  {
+    name: "list_fixtures",
+    description: "All 74 IPL 2026 fixtures with optional status/team filter. Returns id, date, home, away, venue, result. Use to discover matchIds for get_match_state and get_match_recap.",
+    inputSchema: { type: "object", properties: { status: { type: "string", enum: ["all", "finished", "upcoming"], description: "Default all" }, team: { type: "string", description: "Team slug or code filter" }, limit: { type: "number", description: "Default 20, max 74" } }, additionalProperties: false }
+  },
+  {
+    name: "get_trend",
+    description: "One cross-fixture trend insight by stable id. Each trend carries bigStat, hook, and supporting numbers[]. Use list_trends to discover ids.",
+    inputSchema: { type: "object", properties: { trendId: { type: "string" } }, required: ["trendId"], additionalProperties: false }
+  },
+  {
+    name: "list_trends",
+    description: "All IPL 2026 cross-fixture trends, optionally filtered by kind: conditional, momentum, venue, toss, anomaly. Returns id + kind + hook + canonicalUrl per row.",
+    inputSchema: { type: "object", properties: { kind: { type: "string", description: "Filter by kind: conditional / momentum / venue / toss / anomaly" }, limit: { type: "number", description: "Default 30, max 100" } }, additionalProperties: false }
+  },
+  {
+    name: "get_player_h2h",
+    description: "Batter-vs-bowler head-to-head record in IPL 2026. Sample-size floor: \u22655 deliveries faced. Returns deliveries, runs, SR, dismissals, and canonical URL. Both slugs are kebab-case.",
+    inputSchema: { type: "object", properties: { batterSlug: { type: "string" }, bowlerSlug: { type: "string" } }, required: ["batterSlug", "bowlerSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_team_profile",
+    description: "IPL 2026 team metadata + canonical URL for the full server-rendered profile (record, at-home/away splits, phase strengths). Slugs: mi, csk, rcb, srh, kkr, dc, pbks, rr, lsg, gt.",
+    inputSchema: { type: "object", properties: { teamSlug: { type: "string", description: "Team slug (mi, csk, rcb, srh, kkr, dc, pbks, rr, lsg, gt)" } }, required: ["teamSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_venue_hub",
+    description: "Venue metadata + canonical URL for the full hub page (par 1st-innings score, toss-decision split, phase scoring patterns, recent matches). Sample-size floor: \u22653 fixtures. Use list_fixtures to find venue slugs.",
+    inputSchema: { type: "object", properties: { venueSlug: { type: "string" } }, required: ["venueSlug"], additionalProperties: false }
+  },
+  {
+    name: "list_atomic_claims",
+    description: `Filtered query across the full IPL 2026 atomic-claim corpus. Each claim is a single-sentence retrieval target with provenance, sample size, and canonicalUrl. Answers: "What are RCB's best claims this season?", "Show me Bumrah's P3 claims". Filter by player name, team code, or pillar.`,
+    inputSchema: { type: "object", properties: { player: { type: "string", description: "Player name substring or slug" }, team: { type: "string", description: "Team name or code" }, pillar: { type: "string", enum: ["P1", "P2", "P3", "P4", "P5"] }, limit: { type: "number", description: "Default 25, max 200" } }, additionalProperties: false }
+  },
+  {
+    name: "get_team_h2h",
+    description: "Team-vs-team head-to-head record across IPL 2026: matches, wins each way, no-results, recent meetings. Pass slugs in any order (mi, csk, rcb, srh, kkr, dc, pbks, rr, lsg, gt). Returns atomic lead claim + canonical URL.",
+    inputSchema: { type: "object", properties: { teamSlugA: { type: "string" }, teamSlugB: { type: "string" } }, required: ["teamSlugA", "teamSlugB"], additionalProperties: false }
+  },
+  {
+    name: "get_partnerships",
+    description: "Partnership stats for an IPL 2026 player \u2014 top stand partners, average partnership runs, most productive wicket-stand. Returns available data from the snapshot or redirects to the canonical player page for the full view.",
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string" } }, required: ["playerSlug"], additionalProperties: false }
+  },
+  {
+    name: "compare_players",
+    description: "Side-by-side comparison of 2\u20138 IPL 2026 players: team, role, claim count per pillar (P1\u2013P5), headline claim. Returns a canonical /compare/players?slugs=\u2026 URL. Use search_players to resolve slugs first.",
+    inputSchema: { type: "object", properties: { playerSlugs: { type: "array", items: { type: "string" }, minItems: 2, maxItems: 8 } }, required: ["playerSlugs"], additionalProperties: false }
+  },
+  {
+    name: "get_dismissal_analysis",
+    description: "IPL 2026 dismissal pattern analysis for a batter \u2014 dismissed by pace vs spin, powerplay vs death, most frequent dismissal modes. Returns available snapshot data or canonical URL for the full breakdown.",
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string" } }, required: ["playerSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_fielding_stats",
+    description: "IPL 2026 fielding: catches, run-out assists, total dismissals. Pass playerSlug for a single player, omit for the full leaderboard. Aggregated from the SETU canonical snapshot.",
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string", description: "Omit for leaderboard" }, limit: { type: "number", description: "Leaderboard rows (default 15)" } }, additionalProperties: false }
+  },
+  // ── GROUP 2: MLC ────────────────────────────────────────────────────
+  {
+    name: "get_mlc_dataset_summary",
+    description: "First call for Major League Cricket (MLC) coverage. Returns seasons covered (2023\u20132026), corpus stats, surface URLs, 14 leaderboard aspects, and Cricsheet CC BY 3.0 attribution. MLC is distinct from IPL and lives under /leagues/mlc.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "search_mlc_players",
+    description: 'Find MLC player slugs by substring match against name or slug. Cricsheet uses initials format ("F du Plessis" \u2192 f-du-plessis). Use before get_mlc_player_profile.',
+    inputSchema: { type: "object", properties: { query: { type: "string" }, limit: { type: "number", description: "Default 10, max 50" } }, required: ["query"], additionalProperties: false }
+  },
+  {
+    name: "get_mlc_player_profile",
+    description: "MLC player career profile: batting + bowling aggregates, per-season breakdown, identity bridge (Wikidata / ESPNcricinfo). Slug is kebab-case e.g. f-du-plessis. Use search_mlc_players to discover slugs.",
+    inputSchema: { type: "object", properties: { playerSlug: { type: "string" } }, required: ["playerSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_mlc_team_profile",
+    description: "One of 6 MLC franchises: los-angeles-knight-riders, mi-new-york, san-francisco-unicorns, seattle-orcas, texas-super-kings, washington-freedom. Returns seasons, match count, and hub URL.",
+    inputSchema: { type: "object", properties: { teamSlug: { type: "string" } }, required: ["teamSlug"], additionalProperties: false }
+  },
+  {
+    name: "get_mlc_match",
+    description: 'Full detail for one MLC match: teams, venue, toss, result, innings summary, officials, player of the match, plus available atomic claim cards. matchId is a Cricsheet id (e.g. "1381361"). Use list_mlc_matches to discover ids.',
+    inputSchema: { type: "object", properties: { matchId: { type: "string" } }, required: ["matchId"], additionalProperties: false }
+  },
+  {
+    name: "get_mlc_match_claim",
+    description: "One atomic claim card from an MLC match. Kinds: top-batter, top-bowler, biggest-partnership, pp-control, death-domination. Permanent citable URL at /leagues/mlc/matches/{id}/c/{kind}. Sample-size floors enforced.",
+    inputSchema: { type: "object", properties: { matchId: { type: "string" }, kind: { type: "string", enum: ["top-batter", "top-bowler", "biggest-partnership", "pp-control", "death-domination"] } }, required: ["matchId", "kind"], additionalProperties: false }
+  },
+  {
+    name: "list_mlc_matches",
+    description: "List MLC matches, optionally filtered by season (2023/2024/2025) or team slug. Returns id, date, teams, venue, result, canonicalUrl per row. Use to discover matchIds for get_mlc_match.",
+    inputSchema: { type: "object", properties: { season: { type: "string", description: "2023, 2024, or 2025" }, teamSlug: { type: "string" }, limit: { type: "number", description: "Default 30, max 200" } }, additionalProperties: false }
+  },
+  {
+    name: "list_mlc_leaderboards",
+    description: "Top-N rows of one MLC leaderboard aspect. 14 aspects include: orange-cap, purple-cap, strike-rate, economy-leaders, most-sixes, most-fours, top-knocks, best-bowling, powerplay-strike-rate, death-overs-economy. Call get_mlc_dataset_summary for the full aspect list. Sample-size floors enforced.",
+    inputSchema: { type: "object", properties: { aspect: { type: "string", description: "Leaderboard aspect slug e.g. orange-cap" }, limit: { type: "number", description: "Default 20, max 100" } }, required: ["aspect"], additionalProperties: false }
+  },
+  // ── GROUP 3: IPL Historical ─────────────────────────────────────────
+  {
+    name: "get_ipl_leaderboard",
+    description: 'IPL historical leaderboard from the 18-season Cricsheet corpus (2007/08\u20132025). 35+ aspects: orange-cap, purple-cap, most-sixes, most-fours, strike-rate, economy-leaders, most-matches, most-fifties, most-hundreds, best-bowling-avg, most-ducks, powerplay-economy, death-sr, and per-season variants. Pass season to scope to one year (e.g. "ipl-2024"). Returns canonical URL at /leagues/ipl/leaderboards/{aspect}.',
+    inputSchema: { type: "object", properties: { aspect: { type: "string", description: "Leaderboard aspect e.g. orange-cap, purple-cap, most-sixes, economy-leaders" }, season: { type: "string", description: "Optional season slug e.g. ipl-2024 (omit for all-time)" }, limit: { type: "number", description: "Default 20, max 100" } }, required: ["aspect"], additionalProperties: false }
+  }
+];
+var validators = {
+  get_dataset_summary: z.object({}).strict(),
+  search_players: z.object({ query: z.string(), limit: z.number().optional() }).strict(),
+  get_player_profile: z.object({ playerSlug: z.string() }).strict(),
+  get_player_pillar: z.object({ playerSlug: z.string(), pillar: z.enum(["P1", "P2", "P3", "P4", "P5"]) }).strict(),
+  get_standings: z.object({}).strict(),
+  get_season_stats: z.object({ sortBy: z.enum(["runs", "wickets", "strike_rate", "economy", "ducks", "single_digit_outs", "catches", "run_outs"]), teamCode: z.string().optional(), limit: z.number().optional() }).strict(),
+  get_match_state: z.object({ matchId: z.string() }).strict(),
+  get_match_recap: z.object({ matchId: z.string() }).strict(),
+  list_fixtures: z.object({ status: z.enum(["all", "finished", "upcoming"]).optional(), team: z.string().optional(), limit: z.number().optional() }).strict(),
+  get_trend: z.object({ trendId: z.string() }).strict(),
+  list_trends: z.object({ kind: z.string().optional(), limit: z.number().optional() }).strict(),
+  get_player_h2h: z.object({ batterSlug: z.string(), bowlerSlug: z.string() }).strict(),
+  get_team_profile: z.object({ teamSlug: z.string() }).strict(),
+  get_venue_hub: z.object({ venueSlug: z.string() }).strict(),
+  list_atomic_claims: z.object({ player: z.string().optional(), team: z.string().optional(), pillar: z.enum(["P1", "P2", "P3", "P4", "P5"]).optional(), limit: z.number().optional() }).strict(),
+  get_team_h2h: z.object({ teamSlugA: z.string(), teamSlugB: z.string() }).strict(),
+  get_partnerships: z.object({ playerSlug: z.string() }).strict(),
+  compare_players: z.object({ playerSlugs: z.array(z.string()).min(2).max(8) }).strict(),
+  get_dismissal_analysis: z.object({ playerSlug: z.string() }).strict(),
+  get_fielding_stats: z.object({ playerSlug: z.string().optional(), limit: z.number().optional() }).strict(),
+  get_mlc_dataset_summary: z.object({}).strict(),
+  search_mlc_players: z.object({ query: z.string(), limit: z.number().optional() }).strict(),
+  get_mlc_player_profile: z.object({ playerSlug: z.string() }).strict(),
+  get_mlc_team_profile: z.object({ teamSlug: z.string() }).strict(),
+  get_mlc_match: z.object({ matchId: z.string() }).strict(),
+  get_mlc_match_claim: z.object({ matchId: z.string(), kind: z.enum(["top-batter", "top-bowler", "biggest-partnership", "pp-control", "death-domination"]) }).strict(),
+  list_mlc_matches: z.object({ season: z.string().optional(), teamSlug: z.string().optional(), limit: z.number().optional() }).strict(),
+  list_mlc_leaderboards: z.object({ aspect: z.string(), limit: z.number().optional() }).strict(),
+  get_ipl_leaderboard: z.object({ aspect: z.string(), season: z.string().optional(), limit: z.number().optional() }).strict()
+};
+function handleDatasetSummary() {
+  const md = metadata();
+  return ok({
+    overview: "CricketStudio publishes citation-grade cricket data \u2014 atomic claims with provenance, sample-size floors, and stable canonical URLs. Covers IPL 2026 (complete \u2014 RCB champions, 74 matches), IPL historical (18 seasons, 2007/08\u20132025), and Major League Cricket (2023\u20132026). Free to read. Free to cite.",
+    coverage: {
+      ipl2026: { season: "IPL 2026", ...md.counts },
+      iplHistorical: { seasons: 18, description: "2007/08\u20132025, Cricsheet corpus, 1,169 matches" },
+      mlc: md.counts.mlc ?? { players: 0, teams: 6, matches: 0, leaderboards: 14 },
+      totalMatches: 1307,
+      totalDeliveries: 309992
+    },
+    surfaces: {
+      players: `${SITE}/players/{slug}`,
+      teams: `${SITE}/teams/{slug}`,
+      teamH2h: `${SITE}/teams/{a}/vs/{b}`,
+      venues: `${SITE}/venues/{slug}`,
+      matches: `${SITE}/matches/{fixtureId}`,
+      trends: `${SITE}/trends/{trendId}`,
+      h2h: `${SITE}/h2h/{batter-slug}-vs-{bowler-slug}`,
+      standings: `${SITE}/standings`,
+      iplHub: IPL_HUB,
+      mlcHub: MLC_HUB,
+      sitemap: `${SITE}/sitemap.xml`,
+      llmsTxt: `${SITE}/llms.txt`
+    },
+    otherLeagues: {
+      iplHistorical: "Full pre-2026 IPL corpus at /leagues/ipl \u2014 18 seasons, per-season hubs at /season/ipl-{year}. Use get_ipl_leaderboard for the 35-aspect leaderboard.",
+      mlc: "Major League Cricket at /leagues/mlc \u2014 2023\u20132026, Cricsheet CC BY 3.0. Use get_mlc_dataset_summary to start."
+    },
+    fiveNonNegotiables: [
+      "Sample-size floors enforced (\u226530 batting balls, \u226515 bowling deliveries, \u22653 venue fixtures, \u22655 H2H deliveries)",
+      "Date windows explicit on every claim",
+      "Provenance back to ball-by-ball (deterministic \u2014 numbers never pass through an LLM)",
+      "Atomic claim format under 30 words",
+      "Sub-4-hour data-freshness SLA for IPL 2026 (95th percentile)"
+    ],
+    license: { data: "CC BY 4.0", tools: "MIT", attribution: `CricketStudio \xB7 ${SITE}` },
+    snapshot: { generatedAt: md.generatedAt }
+  }, `${SITE}/`);
+}
+function handleSearchPlayers(args) {
+  const q = args.query.toLowerCase().trim();
+  const limit = Math.max(1, Math.min(50, args.limit ?? 10));
+  const results = Object.values(players()).filter((p) => p.slug.toLowerCase().includes(q) || p.fullName.toLowerCase().includes(q) || (p.team || "").toLowerCase().includes(q)).slice(0, limit).map((p) => ({ slug: p.slug, fullName: p.fullName, team: p.team, role: p.role, canonicalUrl: `${SITE}/players/${p.slug}` }));
+  return ok({ query: args.query, count: results.length, results });
+}
+function handlePlayerProfile(args) {
+  const p = players()[args.playerSlug];
+  if (!p) return notFound(`No player with slug "${args.playerSlug}". Try search_players first.`);
+  const headline = p.claims.find((c) => c.id === p.headlineClaimId) ?? p.claims[0] ?? null;
+  return ok({ slug: p.slug, fullName: p.fullName, team: p.team, role: p.role, sameAs: p.sameAs || {}, headlineClaim: headline, claims: p.claims, claimCount: p.claims.length }, `${SITE}/players/${p.slug}`);
+}
+function handlePlayerPillar(args) {
+  const p = players()[args.playerSlug];
+  if (!p) return notFound(`No player with slug "${args.playerSlug}".`);
+  const pillarNames = { P1: "Match recaps", P2: "Moments", P3: "Form & phase", P4: "Season comparatives", P5: "Notebook" };
+  const claims = p.claims.filter((c) => c.pillar === args.pillar);
+  return ok({ slug: p.slug, fullName: p.fullName, pillar: args.pillar, pillarName: pillarNames[args.pillar] ?? args.pillar, claims, claimCount: claims.length }, `${SITE}/players/${p.slug}`);
+}
+function handleStandings() {
+  const rows = getStandings();
+  if (rows.length === 0) {
+    return ok({ note: "Standings not bundled in this snapshot. See the canonical URL for the live points table." }, `${SITE}/standings`);
+  }
+  const table = rows.map((r, i) => ({
+    position: i + 1,
+    teamCode: r.teamCode,
+    played: r.played,
+    won: r.won,
+    lost: r.lost,
+    points: r.points,
+    nrr: typeof r.nrr === "number" ? Math.round(r.nrr * 1e3) / 1e3 : r.nrr
+  }));
+  return ok({
+    season: "IPL 2026",
+    status: "complete",
+    champion: "Royal Challengers Bengaluru (RCB)",
+    note: "IPL 2026 final league points table (round-robin stage \u2014 playoff knockouts excluded). RCB won the title. Top 4 qualified for the playoffs.",
+    table,
+    provenance: { source: "CricketStudio ball-by-ball aggregation", window: "IPL 2026 league stage" }
+  }, `${SITE}/standings`);
+}
+function handleSeasonStats(args) {
+  const stats = seasonStats();
+  const limit = Math.max(1, Math.min(100, args.limit ?? 15));
+  const specMap = {
+    runs: { block: "batting", field: "runs", descending: true },
+    wickets: { block: "bowling", field: "wickets", descending: true },
+    strike_rate: { block: "batting", field: "sr", descending: true, floorBalls: 30, floorDesc: "\u226530 balls faced" },
+    economy: { block: "bowling", field: "econ", descending: false, floorBalls: 15, floorDesc: "\u226515 balls bowled" },
+    ducks: { block: "batting", field: "ducks", descending: true },
+    single_digit_outs: { block: "batting", field: "singleDigitOuts", descending: true },
+    catches: { block: "fielding", field: "catches", descending: true },
+    run_outs: { block: "fielding", field: "runOutAssists", descending: true }
+  };
+  const spec = specMap[args.sortBy];
+  if (!spec) return notFound(`Unknown sortBy "${args.sortBy}".`);
+  const all = Object.entries(stats.bySlug ?? {});
+  const tc = args.teamCode ? args.teamCode.toUpperCase() : null;
+  const rows = all.filter(([, p]) => p && p[spec.block]).filter(([, p]) => tc ? (p.teamCode || "").toUpperCase() === tc : true).filter(([, p]) => p[spec.block][spec.field] !== void 0 && p[spec.block][spec.field] !== null).filter(([, p]) => spec.floorBalls ? Number(p[spec.block].balls || 0) >= spec.floorBalls : true).map(([slug, p]) => ({ slug, fullName: p.fullName, teamCode: p.teamCode, role: p.role, matches: p[spec.block].matches, balls: p[spec.block].balls, [spec.field]: p[spec.block][spec.field], canonicalUrl: `${SITE}/players/${slug}` })).sort((a, b) => spec.descending ? Number(b[spec.field]) - Number(a[spec.field]) : Number(a[spec.field]) - Number(b[spec.field])).slice(0, limit);
+  return ok({ sortBy: args.sortBy, sampleSizeFloor: spec.floorDesc, teamCode: args.teamCode, count: rows.length, rows }, `${SITE}/season/ipl-2026/${args.sortBy.replace(/_/g, "-")}`);
+}
+function handleMatchState(args) {
+  const m = rawMatch(args.matchId);
+  if (!m) return notFound(`No match "${args.matchId}" in snapshot. Use list_fixtures to discover valid ids.`, `${SITE}/matches/${args.matchId}`);
+  const tossCode = teamIdToCode(m.tossWinnerId);
+  const toss = tossCode ? { wonByCode: tossCode, elected: m.elected ?? null } : { tossElected: m.elected ?? null };
+  return ok({
+    fixtureId: m.id,
+    home: m.home,
+    homeName: m.homeName ?? null,
+    away: m.away,
+    awayName: m.awayName ?? null,
+    date: m.date,
+    venue: m.venue ?? null,
+    status: m.status,
+    result: m.result ?? null,
+    homeScore: m.homeScore ?? null,
+    awayScore: m.awayScore ?? null,
+    toss
+  }, `${SITE}/matches/${m.id}`);
+}
+function handleMatchRecap(args) {
+  const m = rawMatch(args.matchId);
+  if (!m) return notFound(`No match "${args.matchId}" in snapshot. Use list_fixtures to discover valid ids.`, `${SITE}/matches/${args.matchId}`);
+  const recap = `${m.result ?? "Result pending"}. ${m.home} ${m.homeScore ?? "\u2014"} vs ${m.away} ${m.awayScore ?? "\u2014"} at ${m.venue ?? "venue TBC"}.`;
+  return ok({
+    fixtureId: m.id,
+    recap,
+    home: m.home,
+    away: m.away,
+    date: m.date,
+    venue: m.venue ?? null,
+    result: m.result ?? null,
+    homeScore: m.homeScore ?? null,
+    awayScore: m.awayScore ?? null,
+    note: "Full 6-card recap pack (MOTM, top batter/bowler, milestones) at the canonical URL."
+  }, `${SITE}/matches/${m.id}`);
+}
+function handleListFixtures(args) {
+  const limit = Math.max(1, Math.min(74, args.limit ?? 20));
+  let all = getMatches();
+  if (args.status && args.status !== "all") {
+    const s = args.status.toLowerCase();
+    all = all.filter((m) => m.status.toLowerCase().includes(s));
+  }
+  if (args.team) {
+    const t = args.team.toLowerCase();
+    all = all.filter((m) => m.home.toLowerCase().includes(t) || m.away.toLowerCase().includes(t));
+  }
+  const rows = all.slice(0, limit).map((m) => ({ id: m.id, date: m.date, home: m.home, away: m.away, status: m.status, result: m.result ?? null, canonicalUrl: `${SITE}/matches/${m.id}` }));
+  return ok({ season: "IPL 2026", totalMatching: all.length, showing: rows.length, fixtures: rows }, `${SITE}/matches`);
+}
+function handleTrend(args) {
+  const t = trendsList().find((x) => x.id === args.trendId);
+  if (!t) return notFound(`No trend "${args.trendId}". Use list_trends to discover ids.`);
+  return ok({ ...t }, `${SITE}/trends/${t.id}`);
+}
+function handleListTrends(args) {
+  const limit = Math.max(1, Math.min(100, args.limit ?? 30));
+  let rows = trendsList();
+  if (args.kind) {
+    const k = args.kind.toLowerCase();
+    rows = rows.filter((t) => (t.kind || "").toLowerCase() === k);
+  }
+  return ok({ count: rows.length, kind: args.kind ?? "all", trends: rows.slice(0, limit).map((t) => ({ ...t, canonicalUrl: `${SITE}/trends/${t.id}` })) });
+}
+function handlePlayerH2H(args) {
+  const slug = `${args.batterSlug}-vs-${args.bowlerSlug}`;
+  const h = h2hSummaries().find((x) => x.slug === slug);
+  if (!h) {
+    return ok({
+      error: "not_found",
+      message: `No H2H record for "${slug}" in the bundled snapshot. This means one of: (a) the pair is below the \u22655-deliveries sample floor in IPL 2026, or (b) the pair is outside the bundled top-2000 matchups (the snapshot carries the highest-frequency pairs). The full head-to-head, if it exists, is rendered at the canonical URL.`,
+      pair: { batterSlug: args.batterSlug, bowlerSlug: args.bowlerSlug },
+      sampleSizeFloor: "\u22655 deliveries faced",
+      hint: "Use search_players to confirm both slugs, then retry. Canonical URL resolves the pair if it cleared the floor."
+    }, `${SITE}/h2h/${slug}`);
+  }
+  const runs = h.runs ?? 0;
+  const deliveries = h.deliveries ?? 0;
+  const dismissals = h.dismissals ?? 0;
+  const claim = `${h.batterName} scored ${runs} off ${deliveries} balls against ${h.bowlerName}${dismissals > 0 ? `, dismissed ${dismissals} time${dismissals === 1 ? "" : "s"}` : " (not dismissed)"} in IPL 2026.`;
+  return ok({ claim, batter: { slug: h.batterSlug, name: h.batterName }, bowler: { slug: h.bowlerSlug, name: h.bowlerName }, deliveries, runs, strikeRate: h.strikeRate ?? null, fours: h.fours ?? null, sixes: h.sixes ?? null, dotBalls: h.dotBalls ?? null, dismissals, window: "IPL 2026 to date", sampleSize: `${deliveries} deliveries`, sampleSizeFloor: "\u22655 deliveries faced", source: "CricketStudio ball-by-ball aggregation" }, `${SITE}/h2h/${slug}`);
+}
+function handleTeamProfile(args) {
+  const slug = args.teamSlug.toLowerCase();
+  const t = teams().find((x) => x.slug === slug || x.code.toLowerCase() === slug);
+  if (!t) return notFound(`No team "${args.teamSlug}". Valid slugs: ${teams().map((x) => x.slug).join(", ")}`);
+  const code = t.code.toLowerCase();
+  const standings = getStandings();
+  const idx = standings.findIndex((r) => (r.teamCode || "").toLowerCase() === code);
+  const sr = idx >= 0 ? standings[idx] : null;
+  const record = sr ? { position: idx + 1, played: sr.played, won: sr.won, lost: sr.lost, points: sr.points, nrr: typeof sr.nrr === "number" ? Math.round(sr.nrr * 1e3) / 1e3 : sr.nrr } : null;
+  const stats = getSeasonStats();
+  const bySlug = stats?.bySlug ?? {};
+  const squad = Object.entries(bySlug).filter(([, p]) => (p.teamCode || "").toLowerCase() === code);
+  const topBatters = squad.map(([s, p]) => ({ slug: s, name: p.fullName, runs: p.batting?.runs ?? 0, sr: p.batting?.sr ?? null, fifties: p.batting?.fifties ?? 0, hundreds: p.batting?.hundreds ?? 0 })).filter((r) => r.runs > 0).sort((a, b) => b.runs - a.runs).slice(0, 3);
+  const topBowlers = squad.map(([s, p]) => ({ slug: s, name: p.fullName, wickets: p.bowling?.wickets ?? 0, econ: p.bowling?.econ ?? null })).filter((r) => r.wickets > 0).sort((a, b) => b.wickets - a.wickets).slice(0, 3);
+  return ok({
+    slug: t.slug,
+    name: t.name,
+    code: t.code,
+    wikidataQid: t.wikidataQid,
+    season: "IPL 2026",
+    seasonStatus: "complete",
+    record,
+    squadSize: squad.length,
+    topBatters,
+    topBowlers,
+    note: "IPL 2026 season-complete team summary. Full per-phase splits + opponent breakdowns at the canonical URL."
+  }, `${SITE}/teams/${t.slug}`);
+}
+function handleVenueHub(args) {
+  const v = venues().find((x) => x.slug === args.venueSlug);
+  if (!v) return notFound(`No venue "${args.venueSlug}". Use list_fixtures to find valid venue slugs.`);
+  const normalize = (s) => (s || "").toLowerCase().replace(/[. ]/g, "").replace(/stadium/g, "");
+  const target = normalize(v.name);
+  const here = rawMatches().filter((m) => normalize(m.venue) === target);
+  let chaseEligible = 0;
+  let chaseWins = 0;
+  for (const m of here) {
+    if (!m.tossWinnerId || !m.winnerId || !m.elected) continue;
+    const chasingTeamId = m.elected === "bowling" ? m.tossWinnerId : null;
+    if (chasingTeamId === null) continue;
+    chaseEligible += 1;
+    if (m.winnerId === chasingTeamId) chaseWins += 1;
+  }
+  const recentResults = here.slice().sort((a, b) => (b.date || "").localeCompare(a.date || "")).slice(0, 3).map((m) => ({ date: m.date, teams: `${m.home} vs ${m.away}`, result: m.result ?? null }));
+  return ok({
+    slug: v.slug,
+    name: v.name,
+    city: v.city ?? null,
+    geo: v.geo,
+    matchCount: v.matchCount ?? here.length,
+    fixturesCaptured: here.length,
+    ...chaseEligible >= 3 ? { chaseWinRate: Math.round(chaseWins / chaseEligible * 100) / 100, chaseSample: `${chaseEligible} fixtures where toss-winner bowled first` } : {},
+    recentResults,
+    note: "Per-phase par scores + toss-decision splits at the canonical URL. Sample floor: \u22653 fixtures."
+  }, `${SITE}/venues/${v.slug}`);
+}
+function handleListAtomicClaims(args) {
+  const limit = Math.max(1, Math.min(200, args.limit ?? 25));
+  const out = [];
+  for (const p of Object.values(players())) {
+    if (args.player && !p.fullName.toLowerCase().includes(args.player.toLowerCase()) && p.slug !== args.player) continue;
+    if (args.team && (p.team || "").toLowerCase() !== args.team.toLowerCase()) continue;
+    for (const c of p.claims) {
+      if (args.pillar && c.pillar !== args.pillar) continue;
+      out.push({ player: p.fullName, playerSlug: p.slug, team: p.team, ...c, canonicalUrl: `${SITE}/players/${p.slug}` });
+      if (out.length >= limit) break;
+    }
+    if (out.length >= limit) break;
+  }
+  return ok({ count: out.length, claims: out });
+}
+function handleTeamH2H(args) {
+  const a = args.teamSlugA.toLowerCase().trim();
+  const b = args.teamSlugB.toLowerCase().trim();
+  if (a === b) return notFound("Team H2H needs two different team slugs.");
+  const sorted = [a, b].sort();
+  const key = `${sorted[0]}-vs-${sorted[1]}`;
+  const rec = teamH2h()[key];
+  if (!rec) return notFound(`No captured IPL 2026 meetings between "${a}" and "${b}". Valid: ${teams().map((t) => t.slug).join(", ")}.`, `${SITE}/teams/${a}/vs/${b}`);
+  const callerIsA = rec.a.slug === a;
+  const first = callerIsA ? rec.a : rec.b;
+  const second = callerIsA ? rec.b : rec.a;
+  const fw = callerIsA ? rec.aWon : rec.bWon;
+  const sw = callerIsA ? rec.bWon : rec.aWon;
+  let claim;
+  if (fw > sw) claim = `${first.code} lead ${second.code} ${fw}\u2013${sw} across ${rec.matches} captured IPL 2026 meeting${rec.matches === 1 ? "" : "s"}.`;
+  else if (sw > fw) claim = `${second.code} lead ${first.code} ${sw}\u2013${fw} across ${rec.matches} captured IPL 2026 meeting${rec.matches === 1 ? "" : "s"}.`;
+  else claim = `${first.code} and ${second.code} are level ${fw}\u2013${sw} across ${rec.matches} captured IPL 2026 meeting${rec.matches === 1 ? "" : "s"}.`;
+  return ok({ claim, teamA: first, teamB: second, matches: rec.matches, [`${first.code}_won`]: fw, [`${second.code}_won`]: sw, noResult: rec.noResult, recent: rec.recent, window: "IPL 2026 to date", sampleSize: `${rec.matches} completed fixture${rec.matches === 1 ? "" : "s"}`, source: "CricketStudio ball-by-ball aggregation" }, `${SITE}/teams/${first.slug}/vs/${second.slug}`);
+}
+function handleGetPartnerships(args) {
+  const p = players()[args.playerSlug];
+  if (!p) return notFound(`No player with slug "${args.playerSlug}".`, `${SITE}/players/${args.playerSlug}`);
+  return ok({
+    player: { slug: p.slug, fullName: p.fullName, team: p.team },
+    available: false,
+    note: "Partnership-dependency analysis (per-partner strike rate, most-frequent partners, most productive wicket-stand) is computed in the full dataset and rendered at the canonical URL; it is not included in the bundled snapshot.",
+    source: "CricketStudio ball-by-ball aggregation"
+  }, `${SITE}/players/${p.slug}`);
+}
+function handleComparePlayers(args) {
+  const rows = args.playerSlugs.map((slug) => {
+    const p = players()[slug];
+    if (!p) return { slug, error: "No player found with this slug" };
+    const byPillar = (pl) => p.claims.filter((c) => c.pillar === pl).length;
+    return { slug: p.slug, fullName: p.fullName, team: p.team, role: p.role, claimCount: p.claims.length, pillars: { P1: byPillar("P1"), P2: byPillar("P2"), P3: byPillar("P3"), P4: byPillar("P4"), P5: byPillar("P5") }, headlineClaim: p.claims[0]?.headline ?? null, canonicalUrl: `${SITE}/players/${p.slug}` };
+  });
+  const valid = rows.filter((r) => !("error" in r)).map((r) => r.slug);
+  return ok({ players: rows, note: "For deeper per-pair analysis, use get_player_h2h or get_player_pillar." }, valid.length >= 2 ? `${SITE}/compare/players?slugs=${valid.join(",")}` : void 0);
+}
+function handleDismissalAnalysis(args) {
+  const url = `${SITE}/players/${args.playerSlug}`;
+  const stats = seasonStats();
+  const p = (stats.bySlug ?? {})[args.playerSlug];
+  if (!p) {
+    return ok({
+      error: "not_found",
+      message: `No IPL 2026 batting record for slug "${args.playerSlug}" in the season-stats snapshot. Use search_players to find a valid slug, or see the canonical page.`,
+      player: { slug: args.playerSlug }
+    }, url);
+  }
+  const d = p.batting?.dismissals;
+  if (!d || typeof d !== "object") {
+    return ok({
+      player: { slug: args.playerSlug, fullName: p.fullName, team: p.teamCode ?? null },
+      note: `${p.fullName} has no recorded dismissals in IPL 2026 (not out in every captured innings, or no innings batted). The per-mode breakdown is rendered at the canonical URL when available.`,
+      available: false,
+      window: "IPL 2026",
+      source: "CricketStudio ball-by-ball aggregation"
+    }, url);
+  }
+  const modes = ["bowled", "caught", "lbw", "runOut", "hitWicket", "other"];
+  const totalDismissals = modes.reduce((sum, k) => sum + Number(d[k] ?? 0), 0);
+  let mostCommonMode = null;
+  let mostCommonCount = -1;
+  for (const k of modes) {
+    const v = Number(d[k] ?? 0);
+    if (v > mostCommonCount) {
+      mostCommonCount = v;
+      mostCommonMode = k;
+    }
+  }
+  return ok({
+    player: { slug: args.playerSlug, fullName: p.fullName, team: p.teamCode ?? null },
+    dismissals: {
+      bowled: Number(d.bowled ?? 0),
+      caught: Number(d.caught ?? 0),
+      lbw: Number(d.lbw ?? 0),
+      runOut: Number(d.runOut ?? 0),
+      hitWicket: Number(d.hitWicket ?? 0),
+      other: Number(d.other ?? 0)
+    },
+    totalDismissals,
+    mostCommonMode: totalDismissals > 0 ? mostCommonMode : null,
+    window: "IPL 2026",
+    sampleSize: `${totalDismissals} dismissal${totalDismissals === 1 ? "" : "s"}`,
+    source: "CricketStudio ball-by-ball aggregation"
+  }, url);
+}
+function handleFieldingStats(args) {
+  const stats = seasonStats();
+  const all = Object.entries(stats.bySlug ?? {}).filter(([, p]) => p && p.fielding);
+  if (args.playerSlug) {
+    const p = (stats.bySlug ?? {})[args.playerSlug];
+    if (!p) return notFound(`No player with slug "${args.playerSlug}".`, `${SITE}/players/${args.playerSlug}`);
+    const f = p.fielding || {};
+    return ok({ player: { slug: args.playerSlug, fullName: p.fullName, teamCode: p.teamCode }, catches: f.catches ?? 0, runOutAssists: f.runOutAssists ?? 0, totalDismissals: f.totalDismissals ?? 0, window: "IPL 2026 to date", source: "CricketStudio ball-by-ball aggregation" }, `${SITE}/players/${args.playerSlug}`);
+  }
+  const limit = Math.max(1, Math.min(100, args.limit ?? 15));
+  const ranked = all.sort(([, a], [, b]) => Number(b.fielding.totalDismissals || 0) - Number(a.fielding.totalDismissals || 0)).slice(0, limit).map(([slug, p], i) => ({ rank: i + 1, slug, fullName: p.fullName, teamCode: p.teamCode, catches: p.fielding.catches ?? 0, runOutAssists: p.fielding.runOutAssists ?? 0, totalDismissals: p.fielding.totalDismissals ?? 0, canonicalUrl: `${SITE}/players/${slug}` }));
+  return ok({ count: ranked.length, window: "IPL 2026 to date", rows: ranked }, `${SITE}/season/ipl-2026/catches`);
+}
+function describeMlcResult(r, teams2) {
+  if (r.outcome === "won") {
+    const winnerName = r.winnerSlug === teams2.home.slug ? teams2.home.name : teams2.away.name;
+    return `${winnerName} won by ${r.winMargin} ${r.winType}`;
+  }
+  if (r.outcome === "tie") return "tie";
+  if (r.outcome === "no-result") return "no result";
+  return "draw";
+}
+function handleMlcDatasetSummary() {
+  const lg = mlcLeague();
+  return ok({ league: "Major League Cricket", overview: "CricketStudio MLC coverage \u2014 atomic claims for every captured MLC match, sourced from Cricsheet under CC BY 3.0. Player profiles cross-link to Wikidata / ESPNcricinfo. Leaderboards, records, and per-match atomic claim cards live under /leagues/mlc/*.", coverage: { seasons: lg.seasons, totalMatches: lg.totalMatches, teams: Array.isArray(lg.teams) ? lg.teams.length : 6, venues: Array.isArray(lg.venues) ? lg.venues.length : void 0, players: lg.playerCount, ballsCaptured: lg.ballsCaptured }, seasonBreakdown: lg.seasonBreakdown, surfaces: { hub: MLC_HUB, standings: `${MLC_HUB}/standings`, matches: `${MLC_HUB}/matches`, players: `${MLC_HUB}/players`, leaderboards: `${MLC_HUB}/leaderboards`, records: `${MLC_HUB}/records` }, leaderboardAspects: lg.leaderboardAspects.map((a) => ({ slug: a.slug, title: a.title, url: mlcLeaderboardUrl(a.slug) })), provenance: { source: "Cricsheet (https://cricsheet.org)", license: "CC BY 3.0", licenseUrl: "https://creativecommons.org/licenses/by/3.0/" } }, MLC_HUB);
+}
+function handleSearchMlcPlayers(args) {
+  const q = args.query.toLowerCase().trim();
+  const limit = Math.max(1, Math.min(50, args.limit ?? 10));
+  const results = Object.values(mlcPlayers()).filter((p) => p.slug.toLowerCase().includes(q) || p.fullName.toLowerCase().includes(q)).slice(0, limit).map((p) => ({ slug: p.slug, fullName: p.fullName, teamSlugs: p.teamSlugs, matches: p.batting?.matches ?? 0, runs: p.batting?.runs ?? 0, wickets: p.bowling?.wickets ?? 0, canonicalUrl: mlcPlayerUrl(p.slug) }));
+  return ok({ query: args.query, count: results.length, players: results });
+}
+function handleMlcPlayerProfile(args) {
+  const p = mlcPlayers()[args.playerSlug];
+  if (!p) return notFound(`No MLC player with slug "${args.playerSlug}". Use search_mlc_players to discover slugs.`, mlcPlayerUrl(args.playerSlug));
+  return ok({ slug: p.slug, fullName: p.fullName, teamSlugs: p.teamSlugs, batting: p.batting, bowling: p.bowling, bySeason: p.bySeason, identity: p.identity, provenance: { source: "Cricsheet", license: "CC BY 3.0" } }, mlcPlayerUrl(p.slug));
+}
+function handleMlcTeamProfile(args) {
+  const t = mlcTeams().find((x) => x.slug === args.teamSlug.toLowerCase());
+  if (!t) return notFound(`No MLC team "${args.teamSlug}". Valid: ${mlcTeams().map((x) => x.slug).join(", ")}.`, mlcTeamUrl(args.teamSlug));
+  const squad = Object.values(mlcPlayers()).filter((p) => (p.teamSlugs || []).includes(t.slug));
+  const topBatters = squad.map((p) => ({ slug: p.slug, fullName: p.fullName, runs: p.batting?.runs ?? 0 })).filter((r) => r.runs > 0).sort((a, b) => b.runs - a.runs).slice(0, 3);
+  const topBowlers = squad.map((p) => ({ slug: p.slug, fullName: p.fullName, wickets: p.bowling?.wickets ?? 0 })).filter((r) => r.wickets > 0).sort((a, b) => b.wickets - a.wickets).slice(0, 3);
+  return ok({
+    slug: t.slug,
+    name: t.name,
+    seasons: t.seasons,
+    firstSeason: t.firstSeason,
+    lastSeason: t.lastSeason,
+    matchCount: t.matchCount,
+    squadSize: squad.length,
+    topBatters,
+    topBowlers,
+    provenance: { source: "Cricsheet", license: "CC BY 3.0" }
+  }, mlcTeamUrl(t.slug));
+}
+function handleMlcMatch(args) {
+  const m = mlcMatches()[args.matchId];
+  if (!m) return notFound(`No MLC match "${args.matchId}". Use list_mlc_matches to discover ids.`, mlcMatchUrl(args.matchId));
+  return ok({ matchId: m.matchId, season: m.season, startDate: m.startDate, matchType: m.matchType, teams: m.teams, venue: m.venue, toss: m.toss ?? null, result: m.result, resultText: describeMlcResult(m.result, m.teams), officials: m.officials ?? null, playerOfMatch: m.playerOfMatch ?? [], innings: m.innings, availableClaimKinds: m.claims.map((c) => ({ kind: c.kind, headline: c.headline, atomic: c.atomic, canonicalUrl: mlcMatchClaimUrl(m.matchId, c.kind) })), provenance: { source: "Cricsheet", license: "CC BY 3.0", matchUrl: m.attribution.matchUrl } }, mlcMatchUrl(m.matchId));
+}
+function handleMlcMatchClaim(args) {
+  const m = mlcMatches()[args.matchId];
+  if (!m) return notFound(`No MLC match "${args.matchId}".`, mlcMatchUrl(args.matchId));
+  const claim = m.claims.find((c) => c.kind === args.kind);
+  if (!claim) return notFound(`Match "${args.matchId}" did not emit a "${args.kind}" claim \u2014 sample-size floor not met. Call get_mlc_match for available kinds.`, mlcMatchClaimUrl(args.matchId, args.kind));
+  return ok({ matchId: m.matchId, kind: claim.kind, kindLabel: claim.kindLabel, atomic: claim.atomic, headline: claim.headline, subheadline: claim.subheadline, subject: claim.subject ?? null, coSubject: claim.coSubject ?? null, rows: claim.rows ?? null, sampleSize: claim.sampleSize, sampleUnit: claim.sampleUnit, fixtureUrl: mlcMatchUrl(m.matchId), provenance: { source: "Cricsheet ball-by-ball record", license: "CC BY 3.0", matchUrl: m.attribution.matchUrl, computedFrom: "Deterministic walk of balls[] \u2014 no LLM involvement in numeric values" } }, mlcMatchClaimUrl(m.matchId, claim.kind));
+}
+function handleListMlcMatches(args) {
+  const limit = Math.max(1, Math.min(200, args.limit ?? 30));
+  const all = Object.values(mlcMatches());
+  const rows = all.filter((m) => args.season ? m.season === args.season : true).filter((m) => args.teamSlug ? m.teams.home.slug === args.teamSlug || m.teams.away.slug === args.teamSlug : true).sort((a, b) => b.startDate.localeCompare(a.startDate)).slice(0, limit).map((m) => ({ matchId: m.matchId, season: m.season, startDate: m.startDate, teams: { home: m.teams.home.name, away: m.teams.away.name }, venue: m.venue.name, result: describeMlcResult(m.result, m.teams), canonicalUrl: mlcMatchUrl(m.matchId) }));
+  return ok({ count: rows.length, totalAvailable: all.length, filters: { season: args.season, teamSlug: args.teamSlug }, matches: rows }, `${MLC_HUB}/matches`);
+}
+function handleListMlcLeaderboards(args) {
+  const lbs = mlcLeaderboards();
+  const lb = lbs[args.aspect];
+  if (!lb) {
+    const validAspects = Object.keys(lbs);
+    const aspectList = validAspects.length > 0 ? validAspects.join(", ") : "orange-cap, purple-cap, strike-rate, economy-leaders, most-sixes, most-fours, top-knocks, best-bowling, most-ducks, single-digit-outs, powerplay-strike-rate, death-overs-economy, death-overs-strike-rate, powerplay-economy";
+    return notFound(`No MLC leaderboard aspect "${args.aspect}". Valid aspects: ${aspectList}.`, `${MLC_HUB}/leaderboards`);
+  }
+  const limit = Math.max(1, Math.min(100, args.limit ?? 20));
+  const rows = Array.isArray(lb.rows) ? lb.rows : [];
+  return ok({ aspect: lb.slug, title: lb.title, description: lb.description, metricLabel: lb.metricLabel, floorNote: lb.floorNote ?? null, count: Math.min(limit, rows.length), rows: rows.slice(0, limit).map((r) => ({ ...r, canonicalUrl: mlcPlayerUrl(r.slug) })), provenance: { source: "Cricsheet SETU snapshot", license: "CC BY 3.0" } }, mlcLeaderboardUrl(lb.slug));
+}
+var IPL_LB_SPECS = {
+  // ── Batting aggregates ──────────────────────────────────────────────
+  "orange-cap": { block: "batting", field: "runs", ascending: false },
+  "most-runs": { block: "batting", field: "runs", ascending: false },
+  "most-sixes": { block: "batting", field: "sixes", ascending: false },
+  "most-fours": { block: "batting", field: "fours", ascending: false },
+  "most-fifties": { block: "batting", field: "fifties", ascending: false },
+  "most-hundreds": { block: "batting", field: "hundreds", ascending: false },
+  "highest-score": { block: "batting", field: "highScore", ascending: false },
+  "top-score": { block: "batting", field: "highScore", ascending: false },
+  "strike-rate": { block: "batting", field: "sr", ascending: false, floor: (b) => Number(b.balls ?? 0) >= 30, floorNote: "\u226530 balls faced" },
+  "batting-average": { block: "batting", field: "avg", ascending: false, floor: (b) => Number(b.innings ?? 0) >= 10, floorNote: "\u226510 innings" },
+  // ── Bowling aggregates ──────────────────────────────────────────────
+  "purple-cap": { block: "bowling", field: "wickets", ascending: false },
+  "most-wickets": { block: "bowling", field: "wickets", ascending: false },
+  // career bowling block has no `balls` field, so the economy/avg floors use
+  // the available proxies (matches / wickets) — disclosed in floorNote.
+  "economy-leaders": { block: "bowling", field: "econ", ascending: true, floor: (b) => Number(b.matches ?? 0) >= 10, floorNote: "\u226510 matches bowled (career bowling block carries no ball count)" },
+  "economy": { block: "bowling", field: "econ", ascending: true, floor: (b) => Number(b.matches ?? 0) >= 10, floorNote: "\u226510 matches bowled (career bowling block carries no ball count)" },
+  "best-economy": { block: "bowling", field: "econ", ascending: true, floor: (b) => Number(b.matches ?? 0) >= 10, floorNote: "\u226510 matches bowled (career bowling block carries no ball count)" },
+  "bowling-average": { block: "bowling", field: "avg", ascending: true, floor: (b) => Number(b.wickets ?? 0) >= 10, floorNote: "\u226510 wickets" }
+};
+function handleIplLeaderboard(args) {
+  const limit = Math.max(1, Math.min(100, args.limit ?? 20));
+  const canonical = args.season ? `${SITE}/season/${args.season}/${args.aspect}` : `${IPL_HUB}/leaderboards/${args.aspect}`;
+  const validAspects = Object.keys(IPL_LB_SPECS);
+  const hist = iplHistorical();
+  if (!hist || !hist.bySlug) {
+    return ok({
+      note: "IPL historical snapshot not bundled in this release. Full leaderboards are available at the canonical URL.",
+      aspect: args.aspect,
+      season: args.season ?? "all-time",
+      canonicalSurface: canonical
+    }, canonical);
+  }
+  const spec = IPL_LB_SPECS[args.aspect];
+  if (!spec) {
+    const meta2 = getAspectMeta(args.aspect);
+    return ok({
+      error: "unknown_aspect",
+      message: meta2 ? `Aspect "${args.aspect}" is catalogued but not derivable from the bundled career snapshot (it needs phase-split / ball-level data not present in ipl-historical.json bySlug). Computable aspects: ${validAspects.join(", ")}. The full leaderboard is rendered at the canonical URL.` : `Unknown IPL leaderboard aspect "${args.aspect}". Valid aspects: ${validAspects.join(", ")}.`,
+      aspect: args.aspect,
+      validAspects
+    }, `${IPL_HUB}/leaderboards/${args.aspect}`);
+  }
+  if (args.season) {
+    return ok({
+      note: `Per-season IPL leaderboards (season "${args.season}") are rendered at the canonical URL. The MCP computes the all-time (2007/08\u20132025) leaderboard \u2014 call without the season arg for that.`,
+      aspect: args.aspect,
+      season: args.season,
+      canonicalSurface: `${SITE}/season/${args.season}/${args.aspect}`
+    }, `${SITE}/season/${args.season}/${args.aspect}`);
+  }
+  const meta = getAspectMeta(args.aspect);
+  const rows = Object.entries(hist.bySlug).map(([slug, p]) => {
+    const block = spec.block === "batting" ? p.batting : p.bowling;
+    if (!block) return null;
+    const value = block[spec.field];
+    if (value === void 0 || value === null || typeof value !== "number" || !Number.isFinite(value)) return null;
+    if (spec.floor && !spec.floor(block)) return null;
+    return { slug, fullName: p.fullName, teamSlugs: p.teamSlugs ?? [], value, block };
+  }).filter((r) => r !== null).sort((a, b) => spec.ascending ? a.value - b.value : b.value - a.value).slice(0, limit).map((r, i) => ({
+    rank: i + 1,
+    slug: r.slug,
+    fullName: r.fullName,
+    teamSlugs: r.teamSlugs,
+    value: r.value,
+    matches: r.block.matches ?? null,
+    ...spec.block === "batting" ? { innings: r.block.innings ?? null } : { wickets: r.block.wickets ?? null },
+    canonicalUrl: `${SITE}/players/${r.slug}`
+  }));
+  if (rows.length === 0) {
+    return ok({
+      note: `No players cleared the sample floor for aspect "${args.aspect}". Check the canonical URL.`,
+      aspect: args.aspect,
+      season: "all-time",
+      validAspects
+    }, canonical);
+  }
+  return ok({
+    aspect: args.aspect,
+    title: meta?.title ?? args.aspect,
+    season: "all-time (2007/08\u20132025)",
+    metric: spec.field,
+    sampleFloorNote: spec.floorNote ?? "No sample floor for this aspect.",
+    count: rows.length,
+    rows,
+    provenance: { source: "Cricsheet CC BY 3.0, CricketStudio aggregation", seasons: "2007/08\u20132025", matches: 1169, computedFrom: "ipl-historical.json bySlug career aggregates (deterministic \u2014 no LLM)" }
+  }, canonical);
+}
+var server = new Server(
+  { name: "cricketstudio", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: rawArgs } = req.params;
+  const v = validators[name];
+  if (!v) return ok({ error: "unknown_tool", tool: name, hint: "Call tools/list for the full 29-tool catalog." });
+  const parsed = v.safeParse(rawArgs ?? {});
+  if (!parsed.success) return ok({ error: "invalid_arguments", tool: name, issues: parsed.error.issues });
+  const args = parsed.data;
+  try {
+    switch (name) {
+      case "get_dataset_summary":
+        return handleDatasetSummary();
+      case "search_players":
+        return handleSearchPlayers(args);
+      case "get_player_profile":
+        return handlePlayerProfile(args);
+      case "get_player_pillar":
+        return handlePlayerPillar(args);
+      case "get_standings":
+        return handleStandings();
+      case "get_season_stats":
+        return handleSeasonStats(args);
+      case "get_match_state":
+        return handleMatchState(args);
+      case "get_match_recap":
+        return handleMatchRecap(args);
+      case "list_fixtures":
+        return handleListFixtures(args);
+      case "get_trend":
+        return handleTrend(args);
+      case "list_trends":
+        return handleListTrends(args);
+      case "get_player_h2h":
+        return handlePlayerH2H(args);
+      case "get_team_profile":
+        return handleTeamProfile(args);
+      case "get_venue_hub":
+        return handleVenueHub(args);
+      case "list_atomic_claims":
+        return handleListAtomicClaims(args);
+      case "get_team_h2h":
+        return handleTeamH2H(args);
+      case "get_partnerships":
+        return handleGetPartnerships(args);
+      case "compare_players":
+        return handleComparePlayers(args);
+      case "get_dismissal_analysis":
+        return handleDismissalAnalysis(args);
+      case "get_fielding_stats":
+        return handleFieldingStats(args);
+      case "get_mlc_dataset_summary":
+        return handleMlcDatasetSummary();
+      case "search_mlc_players":
+        return handleSearchMlcPlayers(args);
+      case "get_mlc_player_profile":
+        return handleMlcPlayerProfile(args);
+      case "get_mlc_team_profile":
+        return handleMlcTeamProfile(args);
+      case "get_mlc_match":
+        return handleMlcMatch(args);
+      case "get_mlc_match_claim":
+        return handleMlcMatchClaim(args);
+      case "list_mlc_matches":
+        return handleListMlcMatches(args);
+      case "list_mlc_leaderboards":
+        return handleListMlcLeaderboards(args);
+      case "get_ipl_leaderboard":
+        return handleIplLeaderboard(args);
+      default:
+        return ok({ error: "unknown_tool", tool: name });
+    }
+  } catch (err) {
+    return ok({ error: "tool_error", tool: name, message: err instanceof Error ? err.message : String(err) });
+  }
+});
+async function main() {
+  await runStartup();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);