fitzroy 1.0.1 → 1.1.0

package/dist/cli.js

@@ -1,83 +1,3587 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/errors.ts
+var AflApiError, ScrapeError, UnsupportedSourceError, ValidationError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    AflApiError = class extends Error {
+      constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+      }
+      name = "AflApiError";
+    };
+    ScrapeError = class extends Error {
+      constructor(message, source) {
+        super(message);
+        this.source = source;
+      }
+      name = "ScrapeError";
+    };
+    UnsupportedSourceError = class extends Error {
+      constructor(message, source) {
+        super(message);
+        this.source = source;
+      }
+      name = "UnsupportedSourceError";
+    };
+    ValidationError = class extends Error {
+      constructor(message, issues) {
+        super(message);
+        this.issues = issues;
+      }
+      name = "ValidationError";
+    };
+  }
+});
+
+// src/lib/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+var init_result = __esm({
+  "src/lib/result.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/date-utils.ts
+function parseFootyWireDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/-/g, " ");
+  const match = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (!match) {
+    return null;
+  }
+  const [, dayStr, monthStr, yearStr] = match;
+  if (!dayStr || !monthStr || !yearStr) {
+    return null;
+  }
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const year = Number.parseInt(yearStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function parseAflTablesDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/[-/]/g, " ");
+  const dmy = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (dmy) {
+    const [, dayStr, monthStr, yearStr] = dmy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const mdy = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
+  if (mdy) {
+    const [, monthStr, dayStr, yearStr] = mdy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  return null;
+}
+function buildUtcDate(year, monthStr, day) {
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+var MONTH_ABBREV_TO_INDEX;
+var init_date_utils = __esm({
+  "src/lib/date-utils.ts"() {
+    "use strict";
+    MONTH_ABBREV_TO_INDEX = /* @__PURE__ */ new Map([
+      ["jan", 0],
+      ["feb", 1],
+      ["mar", 2],
+      ["apr", 3],
+      ["may", 4],
+      ["jun", 5],
+      ["jul", 6],
+      ["aug", 7],
+      ["sep", 8],
+      ["oct", 9],
+      ["nov", 10],
+      ["dec", 11],
+      ["january", 0],
+      ["february", 1],
+      ["march", 2],
+      ["april", 3],
+      ["june", 5],
+      ["july", 6],
+      ["august", 7],
+      ["september", 8],
+      ["october", 9],
+      ["november", 10],
+      ["december", 11]
+    ]);
+  }
+});
+
+// src/lib/team-mapping.ts
+function normaliseTeamName(raw) {
+  const trimmed = raw.trim();
+  return ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+var TEAM_ALIASES, AFL_SENIOR_TEAMS, ALIAS_MAP;
+var init_team_mapping = __esm({
+  "src/lib/team-mapping.ts"() {
+    "use strict";
+    TEAM_ALIASES = [
+      ["Adelaide Crows", "Adelaide", "Crows", "ADEL", "AD"],
+      ["Brisbane Lions", "Brisbane", "Brisbane Bears", "Bears", "Lions", "Fitzroy Lions", "BL", "BRIS"],
+      ["Carlton", "Carlton Blues", "Blues", "CARL", "CA"],
+      ["Collingwood", "Collingwood Magpies", "Magpies", "COLL", "CW"],
+      ["Essendon", "Essendon Bombers", "Bombers", "ESS", "ES"],
+      ["Fremantle", "Fremantle Dockers", "Dockers", "FRE", "FR"],
+      ["Geelong Cats", "Geelong", "Cats", "GEEL", "GE"],
+      [
+        "Gold Coast Suns",
+        "Gold Coast",
+        "Gold Coast SUNS",
+        "Gold Coast Football Club",
+        "Suns",
+        "GCFC",
+        "GC"
+      ],
+      [
+        "GWS Giants",
+        "GWS",
+        "GWS GIANTS",
+        "Greater Western Sydney",
+        "Giants",
+        "Greater Western Sydney Giants",
+        "GW"
+      ],
+      ["Hawthorn", "Hawthorn Hawks", "Hawks", "HAW", "HW"],
+      ["Melbourne", "Melbourne Demons", "Demons", "MELB", "ME"],
+      ["North Melbourne", "North Melbourne Kangaroos", "Kangaroos", "Kangas", "North", "NMFC", "NM"],
+      ["Port Adelaide", "Port Adelaide Power", "Power", "Port", "PA", "PAFC"],
+      ["Richmond", "Richmond Tigers", "Tigers", "RICH", "RI"],
+      ["St Kilda", "St Kilda Saints", "Saints", "Saint Kilda", "STK", "SK"],
+      ["Sydney Swans", "Sydney", "Swans", "South Melbourne", "South Melbourne Swans", "SYD", "SY"],
+      ["West Coast Eagles", "West Coast", "Eagles", "WCE", "WC"],
+      ["Western Bulldogs", "Bulldogs", "Footscray", "Footscray Bulldogs", "WB", "WBD"],
+      // Historical / defunct VFL teams
+      ["Fitzroy", "Fitzroy Reds", "Fitzroy Gorillas", "Fitzroy Maroons", "FI"],
+      ["University", "University Blacks"]
+    ];
+    AFL_SENIOR_TEAMS = /* @__PURE__ */ new Set([
+      "Adelaide Crows",
+      "Brisbane Lions",
+      "Carlton",
+      "Collingwood",
+      "Essendon",
+      "Fremantle",
+      "Geelong Cats",
+      "Gold Coast Suns",
+      "GWS Giants",
+      "Hawthorn",
+      "Melbourne",
+      "North Melbourne",
+      "Port Adelaide",
+      "Richmond",
+      "St Kilda",
+      "Sydney Swans",
+      "West Coast Eagles",
+      "Western Bulldogs"
+    ]);
+    ALIAS_MAP = (() => {
+      const map = /* @__PURE__ */ new Map();
+      for (const [canonical, ...aliases] of TEAM_ALIASES) {
+        map.set(canonical.toLowerCase(), canonical);
+        for (const alias of aliases) {
+          map.set(alias.toLowerCase(), canonical);
+        }
+      }
+      return map;
+    })();
+  }
+});
+
+// src/lib/parse-utils.ts
+function safeInt(text) {
+  const cleaned = text.replace(/[^0-9-]/g, "").trim();
+  if (!cleaned) return null;
+  const n = Number.parseInt(cleaned, 10);
+  return Number.isNaN(n) ? null : n;
+}
+function parseIntOr0(text) {
+  const n = Number.parseInt(text.replace(/[^0-9-]/g, ""), 10);
+  return Number.isNaN(n) ? 0 : n;
+}
+function parseFloatOr0(text) {
+  const n = Number.parseFloat(text.replace(/[^0-9.-]/g, ""));
+  return Number.isNaN(n) ? 0 : n;
+}
+var init_parse_utils = __esm({
+  "src/lib/parse-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/transforms/footywire-player-stats.ts
+import * as cheerio from "cheerio";
+function cleanPlayerName(raw) {
+  return raw.replace(/[↗↙]/g, "").trim();
+}
+function parseStatsTable(html, expectedCols, rowParser) {
+  const $ = cheerio.load(html);
+  const results = [];
+  $("table").each((_i, table) => {
+    const rows = $(table).find("tr");
+    if (rows.length < 3) return;
+    const headerCells = $(rows[0]).find("td, th").map((_, c) => $(c).text().trim()).get();
+    if (headerCells[0] !== "Player" || headerCells.length < expectedCols.length) return;
+    if (!headerCells.includes(expectedCols[1])) return;
+    let teamName = "";
+    const parentTable = $(table).closest("table").parent().closest("table");
+    const teamHeader = parentTable.find("td:contains('Match Statistics')").first();
+    if (teamHeader.length > 0) {
+      const headerText = teamHeader.text().trim();
+      const match = /^(\w[\w\s]+?)\s+Match Statistics/i.exec(headerText);
+      if (match?.[1]) {
+        teamName = match[1].trim();
+      }
+    }
+    const parsed = [];
+    rows.each((j, row) => {
+      if (j === 0) return;
+      const cells = $(row).find("td").map((_, c) => $(c).text().trim()).get();
+      if (cells.length < expectedCols.length - 1) return;
+      const result = rowParser(cells);
+      if (result) parsed.push(result);
+    });
+    if (parsed.length > 0) {
+      results.push([teamName, parsed]);
+    }
+  });
+  return results;
+}
+function parseBasicRow(cells) {
+  const player = cleanPlayerName(cells[0] ?? "");
+  if (!player) return null;
+  return {
+    player,
+    kicks: parseIntOr0(cells[1] ?? "0"),
+    handballs: parseIntOr0(cells[2] ?? "0"),
+    disposals: parseIntOr0(cells[3] ?? "0"),
+    marks: parseIntOr0(cells[4] ?? "0"),
+    goals: parseIntOr0(cells[5] ?? "0"),
+    behinds: parseIntOr0(cells[6] ?? "0"),
+    tackles: parseIntOr0(cells[7] ?? "0"),
+    hitouts: parseIntOr0(cells[8] ?? "0"),
+    goalAssists: parseIntOr0(cells[9] ?? "0"),
+    inside50s: parseIntOr0(cells[10] ?? "0"),
+    clearances: parseIntOr0(cells[11] ?? "0"),
+    clangers: parseIntOr0(cells[12] ?? "0"),
+    rebound50s: parseIntOr0(cells[13] ?? "0"),
+    freesFor: parseIntOr0(cells[14] ?? "0"),
+    freesAgainst: parseIntOr0(cells[15] ?? "0"),
+    dreamTeamPoints: parseIntOr0(cells[16] ?? "0"),
+    supercoachPoints: parseIntOr0(cells[17] ?? "0")
+  };
+}
+function parseAdvancedRow(cells) {
+  const player = cleanPlayerName(cells[0] ?? "");
+  if (!player) return null;
+  return {
+    player,
+    contestedPossessions: parseIntOr0(cells[1] ?? "0"),
+    uncontestedPossessions: parseIntOr0(cells[2] ?? "0"),
+    effectiveDisposals: parseIntOr0(cells[3] ?? "0"),
+    disposalEfficiency: parseFloatOr0(cells[4] ?? "0"),
+    contestedMarks: parseIntOr0(cells[5] ?? "0"),
+    goalAssists: parseIntOr0(cells[6] ?? "0"),
+    marksInside50: parseIntOr0(cells[7] ?? "0"),
+    onePercenters: parseIntOr0(cells[8] ?? "0"),
+    bounces: parseIntOr0(cells[9] ?? "0"),
+    centreClearances: parseIntOr0(cells[10] ?? "0"),
+    stoppageClearances: parseIntOr0(cells[11] ?? "0"),
+    scoreInvolvements: parseIntOr0(cells[12] ?? "0"),
+    metresGained: parseIntOr0(cells[13] ?? "0"),
+    turnovers: parseIntOr0(cells[14] ?? "0"),
+    intercepts: parseIntOr0(cells[15] ?? "0"),
+    tacklesInside50: parseIntOr0(cells[16] ?? "0"),
+    timeOnGroundPercentage: parseFloatOr0(cells[17] ?? "0")
+  };
+}
+function parseBasicStats(html) {
+  return parseStatsTable(html, [...BASIC_COLS], parseBasicRow);
+}
+function parseAdvancedStats(html) {
+  return parseStatsTable(html, [...ADVANCED_COLS], parseAdvancedRow);
+}
+function mergeFootyWireStats(basicTeams, advancedTeams, matchId, season, roundNumber) {
+  const stats = [];
+  for (let teamIdx = 0; teamIdx < basicTeams.length; teamIdx++) {
+    const basicEntry = basicTeams[teamIdx];
+    const advancedEntry = advancedTeams[teamIdx];
+    if (!basicEntry) continue;
+    const [teamName, basicRows] = basicEntry;
+    const advancedRows = advancedEntry?.[1] ?? [];
+    const advancedByName = /* @__PURE__ */ new Map();
+    for (const adv of advancedRows) {
+      advancedByName.set(adv.player.toLowerCase(), adv);
+    }
+    for (const basic of basicRows) {
+      const nameParts = basic.player.split(/\s+/);
+      const surname = nameParts[nameParts.length - 1] ?? "";
+      const firstName = nameParts.slice(0, -1).join(" ");
+      const initial = firstName.charAt(0);
+      const abbrevName = `${initial} ${surname}`.toLowerCase();
+      const adv = advancedByName.get(abbrevName);
+      stats.push({
+        matchId: `FW_${matchId}`,
+        season,
+        roundNumber,
+        team: teamName,
+        competition: "AFLM",
+        playerId: `FW_${basic.player.replace(/\s+/g, "_")}`,
+        givenName: firstName,
+        surname,
+        displayName: basic.player,
+        jumperNumber: null,
+        kicks: basic.kicks,
+        handballs: basic.handballs,
+        disposals: basic.disposals,
+        marks: basic.marks,
+        goals: basic.goals,
+        behinds: basic.behinds,
+        tackles: basic.tackles,
+        hitouts: basic.hitouts,
+        freesFor: basic.freesFor,
+        freesAgainst: basic.freesAgainst,
+        contestedPossessions: adv?.contestedPossessions ?? null,
+        uncontestedPossessions: adv?.uncontestedPossessions ?? null,
+        contestedMarks: adv?.contestedMarks ?? null,
+        intercepts: adv?.intercepts ?? null,
+        centreClearances: adv?.centreClearances ?? null,
+        stoppageClearances: adv?.stoppageClearances ?? null,
+        totalClearances: basic.clearances,
+        inside50s: basic.inside50s,
+        rebound50s: basic.rebound50s,
+        clangers: basic.clangers,
+        turnovers: adv?.turnovers ?? null,
+        onePercenters: adv?.onePercenters ?? null,
+        bounces: adv?.bounces ?? null,
+        goalAssists: basic.goalAssists,
+        disposalEfficiency: adv?.disposalEfficiency ?? null,
+        metresGained: adv?.metresGained ?? null,
+        goalAccuracy: null,
+        marksInside50: adv?.marksInside50 ?? null,
+        tacklesInside50: adv?.tacklesInside50 ?? null,
+        shotsAtGoal: null,
+        scoreInvolvements: adv?.scoreInvolvements ?? null,
+        totalPossessions: null,
+        timeOnGroundPercentage: adv?.timeOnGroundPercentage ?? null,
+        ratingPoints: null,
+        dreamTeamPoints: basic.dreamTeamPoints,
+        effectiveDisposals: adv?.effectiveDisposals ?? null,
+        effectiveKicks: null,
+        kickEfficiency: null,
+        kickToHandballRatio: null,
+        pressureActs: null,
+        defHalfPressureActs: null,
+        spoils: null,
+        hitoutsToAdvantage: null,
+        hitoutWinPercentage: null,
+        hitoutToAdvantageRate: null,
+        groundBallGets: null,
+        f50GroundBallGets: null,
+        interceptMarks: null,
+        marksOnLead: null,
+        contestedPossessionRate: null,
+        contestOffOneOnOnes: null,
+        contestOffWins: null,
+        contestOffWinsPercentage: null,
+        contestDefOneOnOnes: null,
+        contestDefLosses: null,
+        contestDefLossPercentage: null,
+        centreBounceAttendances: null,
+        kickins: null,
+        kickinsPlayon: null,
+        ruckContests: null,
+        scoreLaunches: null,
+        source: "footywire"
+      });
+    }
+  }
+  return stats;
+}
+var BASIC_COLS, ADVANCED_COLS;
+var init_footywire_player_stats = __esm({
+  "src/transforms/footywire-player-stats.ts"() {
+    "use strict";
+    init_parse_utils();
+    BASIC_COLS = [
+      "Player",
+      "K",
+      "HB",
+      "D",
+      "M",
+      "G",
+      "B",
+      "T",
+      "HO",
+      "GA",
+      "I50",
+      "CL",
+      "CG",
+      "R50",
+      "FF",
+      "FA",
+      "AF",
+      "SC"
+    ];
+    ADVANCED_COLS = [
+      "Player",
+      "CP",
+      "UP",
+      "ED",
+      "DE",
+      "CM",
+      "GA",
+      "MI5",
+      "1%",
+      "BO",
+      "CCL",
+      "SCL",
+      "SI",
+      "MG",
+      "TO",
+      "ITC",
+      "T5",
+      "TOG"
+    ];
+  }
+});
+
+// src/transforms/match-results.ts
+function inferRoundType(roundName) {
+  return FINALS_PATTERN.test(roundName) ? "Finals" : "HomeAndAway";
+}
+function toMatchStatus(raw) {
+  switch (raw) {
+    case "CONCLUDED":
+    case "COMPLETE":
+      return "Complete";
+    case "LIVE":
+    case "IN_PROGRESS":
+      return "Live";
+    case "UPCOMING":
+    case "SCHEDULED":
+      return "Upcoming";
+    case "POSTPONED":
+      return "Postponed";
+    case "CANCELLED":
+      return "Cancelled";
+    default:
+      return "Complete";
+  }
+}
+function toQuarterScore(period) {
+  return {
+    goals: period.score.goals,
+    behinds: period.score.behinds,
+    points: period.score.totalScore
+  };
+}
+function findPeriod(periods, quarter) {
+  if (!periods) return null;
+  const period = periods.find((p) => p.periodNumber === quarter);
+  return period ? toQuarterScore(period) : null;
+}
+function transformMatchItems(items, season, competition, source = "afl-api") {
+  return items.map((item) => {
+    const homeScore = item.score?.homeTeamScore;
+    const awayScore = item.score?.awayTeamScore;
+    const homePoints = homeScore?.matchScore.totalScore ?? 0;
+    const awayPoints = awayScore?.matchScore.totalScore ?? 0;
+    return {
+      matchId: item.match.matchId,
+      season,
+      roundNumber: item.round?.roundNumber ?? 0,
+      roundType: inferRoundType(item.round?.name ?? ""),
+      date: new Date(item.match.utcStartTime),
+      venue: item.venue?.name ?? "",
+      homeTeam: normaliseTeamName(item.match.homeTeam.name),
+      awayTeam: normaliseTeamName(item.match.awayTeam.name),
+      homeGoals: homeScore?.matchScore.goals ?? 0,
+      homeBehinds: homeScore?.matchScore.behinds ?? 0,
+      homePoints,
+      awayGoals: awayScore?.matchScore.goals ?? 0,
+      awayBehinds: awayScore?.matchScore.behinds ?? 0,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: findPeriod(homeScore?.periodScore, 1),
+      q2Home: findPeriod(homeScore?.periodScore, 2),
+      q3Home: findPeriod(homeScore?.periodScore, 3),
+      q4Home: findPeriod(homeScore?.periodScore, 4),
+      q1Away: findPeriod(awayScore?.periodScore, 1),
+      q2Away: findPeriod(awayScore?.periodScore, 2),
+      q3Away: findPeriod(awayScore?.periodScore, 3),
+      q4Away: findPeriod(awayScore?.periodScore, 4),
+      status: toMatchStatus(item.match.status),
+      attendance: null,
+      venueState: item.venue?.state ?? null,
+      venueTimezone: item.venue?.timeZone ?? null,
+      homeRushedBehinds: homeScore?.rushedBehinds ?? null,
+      awayRushedBehinds: awayScore?.rushedBehinds ?? null,
+      homeMinutesInFront: homeScore?.minutesInFront ?? null,
+      awayMinutesInFront: awayScore?.minutesInFront ?? null,
+      source,
+      competition
+    };
+  });
+}
+var FINALS_PATTERN;
+var init_match_results = __esm({
+  "src/transforms/match-results.ts"() {
+    "use strict";
+    init_team_mapping();
+    FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
+  }
+});
+
+// src/sources/footywire.ts
+import * as cheerio2 from "cheerio";
+function parseMatchList(html, year) {
+  const $ = cheerio2.load(html);
+  const results = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  $("tr").each((_i, row) => {
+    const roundHeader = $(row).find("td[colspan='7']");
+    if (roundHeader.length > 0) {
+      const text = roundHeader.text().trim();
+      currentRoundType = inferRoundType(text);
+      const roundMatch = /Round\s+(\d+)/i.exec(text);
+      if (roundMatch?.[1]) {
+        currentRound = Number.parseInt(roundMatch[1], 10);
+      }
+      return;
+    }
+    const cells = $(row).find("td.data");
+    if (cells.length < 5) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    const attendance = $(cells[3]).text().trim();
+    const scoreCell = $(cells[4]);
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const scoreText = scoreCell.text().trim();
+    const scoreMatch = /(\d+)-(\d+)/.exec(scoreText);
+    if (!scoreMatch) return;
+    const homePoints = Number.parseInt(scoreMatch[1] ?? "0", 10);
+    const awayPoints = Number.parseInt(scoreMatch[2] ?? "0", 10);
+    const scoreLink = scoreCell.find("a").attr("href") ?? "";
+    const midMatch = /mid=(\d+)/.exec(scoreLink);
+    const matchId = midMatch?.[1] ? `FW_${midMatch[1]}` : `FW_${year}_R${currentRound}_${homeTeam}`;
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const homeGoals = Math.floor(homePoints / 6);
+    const homeBehinds = homePoints - homeGoals * 6;
+    const awayGoals = Math.floor(awayPoints / 6);
+    const awayBehinds = awayPoints - awayGoals * 6;
+    results.push({
+      matchId,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals,
+      homeBehinds,
+      homePoints,
+      awayGoals,
+      awayBehinds,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
+      status: "Complete",
+      attendance: attendance ? Number.parseInt(attendance, 10) || null : null,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "footywire",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+function parseFixtureList(html, year) {
+  const $ = cheerio2.load(html);
+  const fixtures = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  let gameNumber = 0;
+  $("tr").each((_i, row) => {
+    const roundHeader = $(row).find("td[colspan='7']");
+    if (roundHeader.length > 0) {
+      const text = roundHeader.text().trim();
+      currentRoundType = inferRoundType(text);
+      const roundMatch = /Round\s+(\d+)/i.exec(text);
+      if (roundMatch?.[1]) {
+        currentRound = Number.parseInt(roundMatch[1], 10);
+      }
+      return;
+    }
+    const cells = $(row).find("td.data");
+    if (cells.length < 3) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    gameNumber++;
+    const scoreCell = cells.length >= 5 ? $(cells[4]) : null;
+    const scoreText = scoreCell?.text().trim() ?? "";
+    const hasScore = /\d+-\d+/.test(scoreText);
+    fixtures.push({
+      matchId: `FW_${year}_R${currentRound}_G${gameNumber}`,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      status: hasScore ? "Complete" : "Upcoming",
+      competition: "AFLM"
+    });
+  });
+  return fixtures;
+}
+function parseFootyWireTeamStats(html, year, suffix) {
+  const $ = cheerio2.load(html);
+  const entries = [];
+  const tables = $("table");
+  const mainTable = tables.length > 10 ? $(tables[10]) : $("table.sortable").first();
+  if (mainTable.length === 0) return entries;
+  const STAT_KEYS = [
+    "K",
+    "HB",
+    "D",
+    "M",
+    "G",
+    "GA",
+    "I50",
+    "BH",
+    "T",
+    "HO",
+    "FF",
+    "FA",
+    "CL",
+    "CG",
+    "R50",
+    "AF",
+    "SC"
+  ];
+  const rows = mainTable.find("tr");
+  rows.each((rowIdx, row) => {
+    if (rowIdx === 0) return;
+    const cells = $(row).find("td");
+    if (cells.length < 20) return;
+    const teamLink = $(cells[1]).find("a");
+    const teamText = teamLink.length > 0 ? teamLink.text().trim() : $(cells[1]).text().trim();
+    const teamName = normaliseTeamName(teamText);
+    if (!teamName) return;
+    const parseNum = (cell) => Number.parseFloat(cell.text().trim()) || 0;
+    const gamesPlayed = parseNum($(cells[2]));
+    const stats = {};
+    for (let i = 0; i < STAT_KEYS.length; i++) {
+      const key = suffix === "against" ? `${STAT_KEYS[i]}_against` : STAT_KEYS[i];
+      stats[key] = parseNum($(cells[i + 3]));
+    }
+    entries.push({
+      season: year,
+      team: teamName,
+      gamesPlayed,
+      stats,
+      source: "footywire"
+    });
+  });
+  return entries;
+}
+function mergeTeamAndOppStats(teamStats, oppStats) {
+  const oppMap = /* @__PURE__ */ new Map();
+  for (const entry of oppStats) {
+    oppMap.set(entry.team, entry.stats);
+  }
+  return teamStats.map((entry) => {
+    const opp = oppMap.get(entry.team);
+    if (!opp) return entry;
+    return {
+      ...entry,
+      stats: { ...entry.stats, ...opp }
+    };
+  });
+}
+function teamNameToFootyWireSlug(teamName) {
+  return FOOTYWIRE_SLUG_MAP.get(teamName);
+}
+function parseFootyWirePlayerList(html, teamName) {
+  const $ = cheerio2.load(html);
+  const players = [];
+  let dataRows = null;
+  $("table").each((_i, table) => {
+    const firstRow = $(table).find("tr").first();
+    const cells = firstRow.find("td, th");
+    const cellTexts = cells.map((_j, c) => $(c).text().trim()).get();
+    if (cellTexts.includes("Age") && cellTexts.includes("Name")) {
+      dataRows = $(table).find("tr");
+      return false;
+    }
+  });
+  if (!dataRows) return players;
+  dataRows.each((_rowIdx, row) => {
+    const cells = $(row).find("td");
+    if (cells.length < 6) return;
+    const jumperText = $(cells[0]).text().trim();
+    const nameText = $(cells[1]).text().trim();
+    const gamesText = $(cells[2]).text().trim();
+    const dobText = cells.length > 4 ? $(cells[4]).text().trim() : "";
+    const heightText = cells.length > 5 ? $(cells[5]).text().trim() : "";
+    const origin = cells.length > 6 ? $(cells[6]).text().trim() : "";
+    const position = cells.length > 7 ? $(cells[7]).text().trim() : "";
+    const cleanedName = nameText.replace(/\nR$/, "").trim();
+    if (!cleanedName || cleanedName === "Name") return;
+    const nameParts = cleanedName.split(",").map((s) => s.trim());
+    const surname = nameParts[0] ?? "";
+    const givenName = nameParts[1] ?? "";
+    const jumperNumber = jumperText ? Number.parseInt(jumperText, 10) || null : null;
+    const gamesPlayed = gamesText ? Number.parseInt(gamesText, 10) || null : null;
+    const heightMatch = /(\d+)cm/.exec(heightText);
+    const heightCm = heightMatch?.[1] ? Number.parseInt(heightMatch[1], 10) || null : null;
+    players.push({
+      playerId: `FW_${teamName}_${surname}_${givenName}`.replace(/\s+/g, "_"),
+      givenName,
+      surname,
+      displayName: givenName ? `${givenName} ${surname}` : surname,
+      team: teamName,
+      jumperNumber,
+      position: position || null,
+      dateOfBirth: dobText || null,
+      heightCm,
+      weightKg: null,
+      gamesPlayed,
+      goals: null,
+      draftYear: null,
+      draftPosition: null,
+      draftType: null,
+      debutYear: null,
+      recruitedFrom: origin || null
+    });
+  });
+  return players;
+}
+var FOOTYWIRE_BASE, FootyWireClient, FOOTYWIRE_SLUG_MAP;
+var init_footywire = __esm({
+  "src/sources/footywire.ts"() {
+    "use strict";
+    init_date_utils();
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_footywire_player_stats();
+    init_match_results();
+    FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
+    FootyWireClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch the HTML content of any URL using this client's fetch function.
+       *
+       * Public wrapper around the internal fetchHtml for use by external modules
+       * (e.g. awards) that need to scrape FootyWire pages.
+       */
+      async fetchPage(url) {
+        return this.fetchHtml(url);
+      }
+      /**
+       * Fetch the HTML content of a FootyWire page.
+       */
+      async fetchHtml(url) {
+        try {
+          const response = await this.fetchFn(url, {
+            headers: {
+              "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`FootyWire request failed: ${response.status} (${url})`, "footywire")
+            );
+          }
+          const html = await response.text();
+          return ok(html);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `FootyWire request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch season match results from FootyWire.
+       *
+       * @param year - The season year.
+       * @returns Array of match results.
+       */
+      async fetchSeasonResults(year) {
+        const url = `${FOOTYWIRE_BASE}/ft_match_list?year=${year}`;
+        const htmlResult = await this.fetchHtml(url);
+        if (!htmlResult.success) {
+          return htmlResult;
+        }
+        try {
+          const results = parseMatchList(htmlResult.data, year);
+          return ok(results);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse match list: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch player statistics for a single match.
+       *
+       * Scrapes both the basic and advanced stats pages.
+       * Available from 2010 onwards.
+       *
+       * @param matchId - The FootyWire match ID (numeric string).
+       * @param season - The season year.
+       * @param roundNumber - The round number.
+       */
+      async fetchMatchPlayerStats(matchId, season, roundNumber) {
+        const basicUrl = `${FOOTYWIRE_BASE}/ft_match_statistics?mid=${matchId}`;
+        const advancedUrl = `${FOOTYWIRE_BASE}/ft_match_statistics?mid=${matchId}&advv=Y`;
+        const basicResult = await this.fetchHtml(basicUrl);
+        if (!basicResult.success) return basicResult;
+        const advancedResult = await this.fetchHtml(advancedUrl);
+        if (!advancedResult.success) return advancedResult;
+        try {
+          const basicTeams = parseBasicStats(basicResult.data);
+          const advancedTeams = parseAdvancedStats(advancedResult.data);
+          const stats = mergeFootyWireStats(basicTeams, advancedTeams, matchId, season, roundNumber);
+          return ok(stats);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse match stats: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch match IDs from a season's match list page.
+       *
+       * Extracts `mid=XXXX` values from score links.
+       *
+       * @param year - The season year.
+       * @returns Array of match ID strings.
+       */
+      async fetchSeasonMatchIds(year) {
+        const url = `${FOOTYWIRE_BASE}/ft_match_list?year=${year}`;
+        const htmlResult = await this.fetchHtml(url);
+        if (!htmlResult.success) return htmlResult;
+        try {
+          const $ = cheerio2.load(htmlResult.data);
+          const ids = [];
+          $(".data:nth-child(5) a").each((_i, el) => {
+            const href = $(el).attr("href") ?? "";
+            const match = /mid=(\d+)/.exec(href);
+            if (match?.[1]) {
+              ids.push(match[1]);
+            }
+          });
+          return ok(ids);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse match IDs: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch player list (team history) from FootyWire.
+       *
+       * Scrapes the team history page (e.g. `th-hawthorn-hawks`) which lists
+       * all players who have played for that team.
+       *
+       * @param teamName - Canonical team name (e.g. "Hawthorn").
+       * @returns Array of player details (without source/competition fields).
+       */
+      async fetchPlayerList(teamName) {
+        const slug = teamNameToFootyWireSlug(teamName);
+        if (!slug) {
+          return err(new ScrapeError(`No FootyWire slug mapping for team: ${teamName}`, "footywire"));
+        }
+        const url = `${FOOTYWIRE_BASE}/tp-${slug}`;
+        const htmlResult = await this.fetchHtml(url);
+        if (!htmlResult.success) return htmlResult;
+        try {
+          const players = parseFootyWirePlayerList(htmlResult.data, teamName);
+          return ok(players);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse player list: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch fixture data from FootyWire.
+       *
+       * Parses the match list page to extract scheduled matches with dates and venues.
+       *
+       * @param year - The season year.
+       * @returns Array of fixture entries.
+       */
+      async fetchSeasonFixture(year) {
+        const url = `${FOOTYWIRE_BASE}/ft_match_list?year=${year}`;
+        const htmlResult = await this.fetchHtml(url);
+        if (!htmlResult.success) return htmlResult;
+        try {
+          const fixtures = parseFixtureList(htmlResult.data, year);
+          return ok(fixtures);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse fixture list: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch team statistics from FootyWire.
+       *
+       * Scrapes team-level aggregate stats (totals or averages) for a season.
+       *
+       * @param year - The season year.
+       * @param summaryType - "totals" or "averages" (default "totals").
+       * @returns Array of team stats entries.
+       */
+      async fetchTeamStats(year, summaryType = "totals") {
+        const teamType = summaryType === "averages" ? "TA" : "TT";
+        const oppType = summaryType === "averages" ? "OA" : "OT";
+        const teamUrl = `${FOOTYWIRE_BASE}/ft_team_rankings?year=${year}&type=${teamType}&sby=2`;
+        const oppUrl = `${FOOTYWIRE_BASE}/ft_team_rankings?year=${year}&type=${oppType}&sby=2`;
+        const [teamResult, oppResult] = await Promise.all([
+          this.fetchHtml(teamUrl),
+          this.fetchHtml(oppUrl)
+        ]);
+        if (!teamResult.success) return teamResult;
+        if (!oppResult.success) return oppResult;
+        try {
+          const teamStats = parseFootyWireTeamStats(teamResult.data, year, "for");
+          const oppStats = parseFootyWireTeamStats(oppResult.data, year, "against");
+          const merged = mergeTeamAndOppStats(teamStats, oppStats);
+          return ok(merged);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse team stats: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "footywire"
+            )
+          );
+        }
+      }
+    };
+    FOOTYWIRE_SLUG_MAP = /* @__PURE__ */ new Map([
+      ["Adelaide Crows", "adelaide-crows"],
+      ["Brisbane Lions", "brisbane-lions"],
+      ["Carlton", "carlton-blues"],
+      ["Collingwood", "collingwood-magpies"],
+      ["Essendon", "essendon-bombers"],
+      ["Fremantle", "fremantle-dockers"],
+      ["Geelong Cats", "geelong-cats"],
+      ["Gold Coast Suns", "gold-coast-suns"],
+      ["GWS Giants", "greater-western-sydney-giants"],
+      ["Hawthorn", "hawthorn-hawks"],
+      ["Melbourne", "melbourne-demons"],
+      ["North Melbourne", "north-melbourne-kangaroos"],
+      ["Port Adelaide", "port-adelaide-power"],
+      ["Richmond", "richmond-tigers"],
+      ["St Kilda", "st-kilda-saints"],
+      ["Sydney Swans", "sydney-swans"],
+      ["West Coast Eagles", "west-coast-eagles"],
+      ["Western Bulldogs", "western-bulldogs"]
+    ]);
+  }
+});
+
+// src/sources/afl-coaches.ts
+import * as cheerio3 from "cheerio";
+function parseCoachesVotesHtml(html, season, roundNumber) {
+  const $ = cheerio3.load(html);
+  const clubLogos = $(".pr-md-3.votes-by-match .club_logo");
+  const homeTeams = [];
+  const awayTeams = [];
+  clubLogos.each((i, el) => {
+    const title = $(el).attr("title") ?? "";
+    if (i % 2 === 0) {
+      homeTeams.push(title);
+    } else {
+      awayTeams.push(title);
+    }
+  });
+  const rawVotes = [];
+  $(".pr-md-3.votes-by-match .col-2").each((_i, el) => {
+    const text = $(el).text().replace(/\n/g, "").replace(/\t/g, "").trim();
+    rawVotes.push(text);
+  });
+  const rawPlayers = [];
+  $(".pr-md-3.votes-by-match .col-10").each((_i, el) => {
+    const text = $(el).text().replace(/\n/g, "").replace(/\t/g, "").trim();
+    rawPlayers.push(text);
+  });
+  const votes = [];
+  let matchIndex = 0;
+  for (let i = 0; i < rawPlayers.length; i++) {
+    const playerName = rawPlayers[i] ?? "";
+    const voteText = rawVotes[i] ?? "";
+    if (playerName === "Player (Club)" && voteText === "Votes") {
+      matchIndex++;
+      continue;
+    }
+    const homeTeam = homeTeams[matchIndex - 1];
+    const awayTeam = awayTeams[matchIndex - 1];
+    if (homeTeam == null || awayTeam == null) {
+      continue;
+    }
+    const voteCount = Number(voteText);
+    if (Number.isNaN(voteCount)) {
+      continue;
+    }
+    votes.push({
+      season,
+      round: roundNumber,
+      homeTeam,
+      awayTeam,
+      playerName,
+      votes: voteCount
+    });
+  }
+  return votes;
+}
+var AflCoachesClient;
+var init_afl_coaches = __esm({
+  "src/sources/afl-coaches.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    AflCoachesClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch the HTML content of an AFLCA page.
+       */
+      async fetchHtml(url) {
+        try {
+          const response = await this.fetchFn(url, {
+            headers: {
+              "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`AFL Coaches request failed: ${response.status} (${url})`, "afl-coaches")
+            );
+          }
+          const html = await response.text();
+          return ok(html);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Coaches request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-coaches"
+            )
+          );
+        }
+      }
+      /**
+       * Build the AFLCA leaderboard URL for a given season, round, and competition.
+       *
+       * Mirrors the R package URL construction from `helper-aflcoaches.R`.
+       *
+       * @param season - Season year (e.g. 2024).
+       * @param roundNumber - Round number.
+       * @param competition - "AFLM" or "AFLW".
+       * @param isFinals - Whether this is a finals round.
+       */
+      buildUrl(season, roundNumber, competition, isFinals) {
+        const linkBase = competition === "AFLW" ? "https://aflcoaches.com.au/awards/aflw-champion-player-of-the-year-award/leaderboard/" : isFinals ? "https://aflcoaches.com.au/awards/gary-ayres-award-best-finals-player/leaderboard/" : "https://aflcoaches.com.au/awards/the-aflca-champion-player-of-the-year-award/leaderboard/";
+        const compSuffix = competition === "AFLW" ? "02" : "01";
+        const secondPart = season >= 2023 ? season + 1 : season;
+        const roundPad = String(roundNumber).padStart(2, "0");
+        return `${linkBase}${season}/${secondPart}${compSuffix}${roundPad}`;
+      }
+      /**
+       * Scrape coaches votes for a single round.
+       *
+       * @param season - Season year.
+       * @param roundNumber - Round number.
+       * @param competition - "AFLM" or "AFLW".
+       * @param isFinals - Whether this is a finals round.
+       * @returns Array of coaches vote records for that round.
+       */
+      async scrapeRoundVotes(season, roundNumber, competition, isFinals) {
+        const url = this.buildUrl(season, roundNumber, competition, isFinals);
+        const htmlResult = await this.fetchHtml(url);
+        if (!htmlResult.success) {
+          return htmlResult;
+        }
+        try {
+          const votes = parseCoachesVotesHtml(htmlResult.data, season, roundNumber);
+          return ok(votes);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Failed to parse coaches votes: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-coaches"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch coaches votes for an entire season (all rounds).
+       *
+       * Iterates over rounds 1-30, skipping rounds that return errors (e.g. byes or
+       * rounds that haven't been played yet). Finals rounds (>= 24) use the finals URL.
+       *
+       * @param season - Season year.
+       * @param competition - "AFLM" or "AFLW".
+       * @returns Combined array of coaches votes for the season.
+       */
+      async fetchSeasonVotes(season, competition) {
+        const allVotes = [];
+        const maxRound = 30;
+        for (let round = 1; round <= maxRound; round++) {
+          const isFinals = round >= 24 && season >= 2018;
+          const result = await this.scrapeRoundVotes(season, round, competition, isFinals);
+          if (result.success && result.data.length > 0) {
+            allVotes.push(...result.data);
+          }
+        }
+        if (allVotes.length === 0) {
+          return err(new ScrapeError(`No coaches votes found for season ${season}`, "afl-coaches"));
+        }
+        return ok(allVotes);
+      }
+    };
+  }
+});
+
+// src/api/coaches-votes.ts
+async function fetchCoachesVotes(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.season < 2006) {
+    return err(new ScrapeError("No coaches votes data available before 2006", "afl-coaches"));
+  }
+  if (competition === "AFLW" && query.season < 2018) {
+    return err(new ScrapeError("No AFLW coaches votes data available before 2018", "afl-coaches"));
+  }
+  const client = new AflCoachesClient();
+  let result;
+  if (query.round != null) {
+    const isFinals = query.round >= 24 && query.season >= 2018;
+    result = await client.scrapeRoundVotes(query.season, query.round, competition, isFinals);
+  } else {
+    result = await client.fetchSeasonVotes(query.season, competition);
+  }
+  if (!result.success) {
+    return result;
+  }
+  let votes = result.data;
+  if (query.team != null) {
+    const normalisedTeam = normaliseTeamName(query.team);
+    votes = votes.filter(
+      (v) => normaliseTeamName(v.homeTeam) === normalisedTeam || normaliseTeamName(v.awayTeam) === normalisedTeam
+    );
+    if (votes.length === 0) {
+      return ok([]);
+    }
+  }
+  return ok(votes);
+}
+var init_coaches_votes = __esm({
+  "src/api/coaches-votes.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_coaches();
+  }
+});
+
+// src/lib/validation.ts
+import { z } from "zod/v4";
+var AflApiTokenSchema, CompetitionSchema, CompetitionListSchema, CompseasonSchema, CompseasonListSchema, RoundSchema, RoundListSchema, ScoreSchema, PeriodScoreSchema, TeamScoreSchema, CfsMatchTeamSchema, CfsMatchSchema, CfsScoreSchema, CfsVenueSchema, MatchItemSchema, MatchItemListSchema, CfsPlayerInnerSchema, PlayerGameStatsSchema, PlayerStatsItemSchema, PlayerStatsListSchema, RosterPlayerSchema, TeamPlayersSchema, MatchRosterSchema, TeamItemSchema, TeamListSchema, SquadPlayerInnerSchema, SquadPlayerItemSchema, SquadSchema, SquadListSchema, WinLossRecordSchema, LadderEntryRawSchema, LadderResponseSchema;
+var init_validation = __esm({
+  "src/lib/validation.ts"() {
+    "use strict";
+    AflApiTokenSchema = z.object({
+      token: z.string(),
+      disclaimer: z.string().optional()
+    }).passthrough();
+    CompetitionSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      code: z.string().optional()
+    }).passthrough();
+    CompetitionListSchema = z.object({
+      competitions: z.array(CompetitionSchema)
+    }).passthrough();
+    CompseasonSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      shortName: z.string().optional(),
+      currentRoundNumber: z.number().optional()
+    }).passthrough();
+    CompseasonListSchema = z.object({
+      compSeasons: z.array(CompseasonSchema)
+    }).passthrough();
+    RoundSchema = z.object({
+      id: z.number(),
+      /** Provider ID used by /cfs/ endpoints (e.g. "CD_R202501401"). */
+      providerId: z.string().optional(),
+      name: z.string(),
+      abbreviation: z.string().optional(),
+      roundNumber: z.number(),
+      utcStartTime: z.string().optional(),
+      utcEndTime: z.string().optional()
+    }).passthrough();
+    RoundListSchema = z.object({
+      rounds: z.array(RoundSchema)
+    }).passthrough();
+    ScoreSchema = z.object({
+      totalScore: z.number(),
+      goals: z.number(),
+      behinds: z.number(),
+      superGoals: z.number().nullable().optional()
+    }).passthrough();
+    PeriodScoreSchema = z.object({
+      periodNumber: z.number(),
+      score: ScoreSchema
+    }).passthrough();
+    TeamScoreSchema = z.object({
+      matchScore: ScoreSchema,
+      periodScore: z.array(PeriodScoreSchema).optional(),
+      rushedBehinds: z.number().optional(),
+      minutesInFront: z.number().optional()
+    }).passthrough();
+    CfsMatchTeamSchema = z.object({
+      name: z.string(),
+      teamId: z.string(),
+      abbr: z.string().optional(),
+      nickname: z.string().optional()
+    }).passthrough();
+    CfsMatchSchema = z.object({
+      matchId: z.string(),
+      name: z.string().optional(),
+      status: z.string(),
+      utcStartTime: z.string(),
+      homeTeamId: z.string(),
+      awayTeamId: z.string(),
+      homeTeam: CfsMatchTeamSchema,
+      awayTeam: CfsMatchTeamSchema,
+      round: z.string().optional(),
+      abbr: z.string().optional()
+    }).passthrough();
+    CfsScoreSchema = z.object({
+      status: z.string(),
+      matchId: z.string(),
+      homeTeamScore: TeamScoreSchema,
+      awayTeamScore: TeamScoreSchema
+    }).passthrough();
+    CfsVenueSchema = z.object({
+      name: z.string(),
+      venueId: z.string().optional(),
+      state: z.string().optional(),
+      timeZone: z.string().optional()
+    }).passthrough();
+    MatchItemSchema = z.object({
+      match: CfsMatchSchema,
+      score: CfsScoreSchema.nullish(),
+      venue: CfsVenueSchema.optional(),
+      round: z.object({
+        name: z.string(),
+        roundId: z.string(),
+        roundNumber: z.number()
+      }).passthrough().optional()
+    }).passthrough();
+    MatchItemListSchema = z.object({
+      roundId: z.string().optional(),
+      items: z.array(MatchItemSchema)
+    }).passthrough();
+    CfsPlayerInnerSchema = z.object({
+      playerId: z.string(),
+      playerName: z.object({
+        givenName: z.string(),
+        surname: z.string()
+      }).passthrough(),
+      captain: z.boolean().optional(),
+      playerJumperNumber: z.number().optional()
+    }).passthrough();
+    PlayerGameStatsSchema = z.object({
+      goals: z.number().optional(),
+      behinds: z.number().optional(),
+      kicks: z.number().optional(),
+      handballs: z.number().optional(),
+      disposals: z.number().optional(),
+      marks: z.number().optional(),
+      bounces: z.number().optional(),
+      tackles: z.number().optional(),
+      contestedPossessions: z.number().optional(),
+      uncontestedPossessions: z.number().optional(),
+      totalPossessions: z.number().optional(),
+      inside50s: z.number().optional(),
+      marksInside50: z.number().optional(),
+      contestedMarks: z.number().optional(),
+      hitouts: z.number().optional(),
+      onePercenters: z.number().optional(),
+      disposalEfficiency: z.number().optional(),
+      clangers: z.number().optional(),
+      freesFor: z.number().optional(),
+      freesAgainst: z.number().optional(),
+      dreamTeamPoints: z.number().optional(),
+      clearances: z.object({
+        centreClearances: z.number().optional(),
+        stoppageClearances: z.number().optional(),
+        totalClearances: z.number().optional()
+      }).passthrough().optional(),
+      rebound50s: z.number().optional(),
+      goalAssists: z.number().optional(),
+      goalAccuracy: z.number().optional(),
+      turnovers: z.number().optional(),
+      intercepts: z.number().optional(),
+      tacklesInside50: z.number().optional(),
+      shotsAtGoal: z.number().optional(),
+      metresGained: z.number().optional(),
+      scoreInvolvements: z.number().optional(),
+      ratingPoints: z.number().optional(),
+      extendedStats: z.object({
+        effectiveDisposals: z.number().optional(),
+        effectiveKicks: z.number().optional(),
+        kickEfficiency: z.number().optional(),
+        kickToHandballRatio: z.number().optional(),
+        pressureActs: z.number().optional(),
+        defHalfPressureActs: z.number().optional(),
+        spoils: z.number().optional(),
+        hitoutsToAdvantage: z.number().optional(),
+        hitoutWinPercentage: z.number().optional(),
+        hitoutToAdvantageRate: z.number().optional(),
+        groundBallGets: z.number().optional(),
+        f50GroundBallGets: z.number().optional(),
+        interceptMarks: z.number().optional(),
+        marksOnLead: z.number().optional(),
+        contestedPossessionRate: z.number().optional(),
+        contestOffOneOnOnes: z.number().optional(),
+        contestOffWins: z.number().optional(),
+        contestOffWinsPercentage: z.number().optional(),
+        contestDefOneOnOnes: z.number().optional(),
+        contestDefLosses: z.number().optional(),
+        contestDefLossPercentage: z.number().optional(),
+        centreBounceAttendances: z.number().optional(),
+        kickins: z.number().optional(),
+        kickinsPlayon: z.number().optional(),
+        ruckContests: z.number().optional(),
+        scoreLaunches: z.number().optional()
+      }).passthrough().optional()
+    }).passthrough();
+    PlayerStatsItemSchema = z.object({
+      player: z.object({
+        player: z.object({
+          position: z.string().optional(),
+          player: CfsPlayerInnerSchema
+        }).passthrough(),
+        jumperNumber: z.number().optional()
+      }).passthrough(),
+      teamId: z.string(),
+      playerStats: z.object({
+        stats: PlayerGameStatsSchema,
+        timeOnGroundPercentage: z.number().optional()
+      }).passthrough()
+    }).passthrough();
+    PlayerStatsListSchema = z.object({
+      homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
+      awayTeamPlayerStats: z.array(PlayerStatsItemSchema)
+    }).passthrough();
+    RosterPlayerSchema = z.object({
+      player: z.object({
+        position: z.string().optional(),
+        player: CfsPlayerInnerSchema
+      }).passthrough(),
+      jumperNumber: z.number().optional()
+    }).passthrough();
+    TeamPlayersSchema = z.object({
+      teamId: z.string(),
+      players: z.array(RosterPlayerSchema)
+    }).passthrough();
+    MatchRosterSchema = z.object({
+      match: CfsMatchSchema,
+      teamPlayers: z.array(TeamPlayersSchema)
+    }).passthrough();
+    TeamItemSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      abbreviation: z.string().optional(),
+      teamType: z.string().optional()
+    }).passthrough();
+    TeamListSchema = z.object({
+      teams: z.array(TeamItemSchema)
+    }).passthrough();
+    SquadPlayerInnerSchema = z.object({
+      id: z.number(),
+      providerId: z.string().optional(),
+      firstName: z.string(),
+      surname: z.string(),
+      dateOfBirth: z.string().optional(),
+      heightInCm: z.number().optional(),
+      weightInKg: z.number().optional(),
+      draftYear: z.string().optional(),
+      draftPosition: z.string().optional(),
+      draftType: z.string().optional(),
+      debutYear: z.string().optional(),
+      recruitedFrom: z.string().optional()
+    }).passthrough();
+    SquadPlayerItemSchema = z.object({
+      player: SquadPlayerInnerSchema,
+      jumperNumber: z.number().optional(),
+      position: z.string().optional()
+    }).passthrough();
+    SquadSchema = z.object({
+      team: z.object({
+        name: z.string()
+      }).passthrough().optional(),
+      players: z.array(SquadPlayerItemSchema)
+    }).passthrough();
+    SquadListSchema = z.object({
+      squad: SquadSchema
+    }).passthrough();
+    WinLossRecordSchema = z.object({
+      wins: z.number(),
+      losses: z.number(),
+      draws: z.number(),
+      played: z.number().optional()
+    }).passthrough();
+    LadderEntryRawSchema = z.object({
+      position: z.number(),
+      team: z.object({
+        name: z.string(),
+        id: z.number().optional(),
+        abbreviation: z.string().optional()
+      }).passthrough(),
+      played: z.number().optional(),
+      pointsFor: z.number().optional(),
+      pointsAgainst: z.number().optional(),
+      thisSeasonRecord: z.object({
+        aggregatePoints: z.number().optional(),
+        percentage: z.number().optional(),
+        winLossRecord: WinLossRecordSchema.optional()
+      }).passthrough().optional(),
+      form: z.string().optional()
+    }).passthrough();
+    LadderResponseSchema = z.object({
+      ladders: z.array(
+        z.object({
+          entries: z.array(LadderEntryRawSchema)
+        }).passthrough()
+      ),
+      round: z.object({
+        roundNumber: z.number(),
+        name: z.string().optional()
+      }).passthrough().optional()
+    }).passthrough();
+  }
+});
+
+// src/sources/afl-api.ts
+var TOKEN_URL, API_BASE, CFS_BASE, AflApiClient;
+var init_afl_api = __esm({
+  "src/sources/afl-api.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_validation();
+    TOKEN_URL = "https://api.afl.com.au/cfs/afl/WMCTok";
+    API_BASE = "https://aflapi.afl.com.au/afl/v2";
+    CFS_BASE = "https://api.afl.com.au/cfs/afl";
+    AflApiClient = class {
+      fetchFn;
+      tokenUrl;
+      cachedToken = null;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+        this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
+      }
+      /**
+       * Authenticate with the WMCTok token endpoint and cache the token.
+       *
+       * @returns The access token on success, or an error Result.
+       */
+      async authenticate() {
+        try {
+          const response = await this.fetchFn(this.tokenUrl, {
+            method: "POST",
+            headers: { "Content-Length": "0" }
+          });
+          if (!response.ok) {
+            return err(new AflApiError(`Token request failed: ${response.status}`, response.status));
+          }
+          const json = await response.json();
+          const parsed = AflApiTokenSchema.safeParse(json);
+          if (!parsed.success) {
+            return err(new AflApiError("Invalid token response format"));
+          }
+          const ttlMs = 30 * 60 * 1e3;
+          this.cachedToken = {
+            accessToken: parsed.data.token,
+            expiresAt: Date.now() + ttlMs
+          };
+          return ok(parsed.data.token);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `Token request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Whether the cached token is still valid (not expired).
+       */
+      get isAuthenticated() {
+        return this.cachedToken !== null && Date.now() < this.cachedToken.expiresAt;
+      }
+      /**
+       * Perform an authenticated fetch, automatically adding the bearer token.
+       * Retries once on 401 by re-authenticating.
+       *
+       * @param url - The URL to fetch.
+       * @param init - Additional fetch options.
+       * @returns The Response on success, or an error Result.
+       */
+      async authedFetch(url, init) {
+        if (!this.isAuthenticated) {
+          const authResult = await this.authenticate();
+          if (!authResult.success) {
+            return authResult;
+          }
+        }
+        const doFetch = async () => {
+          const token = this.cachedToken;
+          if (!token) {
+            throw new AflApiError("No cached token available");
+          }
+          const headers = new Headers(init?.headers);
+          headers.set("x-media-mis-token", token.accessToken);
+          return this.fetchFn(url, { ...init, headers });
+        };
+        try {
+          let response = await doFetch();
+          if (response.status === 401) {
+            const authResult = await this.authenticate();
+            if (!authResult.success) {
+              return authResult;
+            }
+            response = await doFetch();
+          }
+          if (!response.ok) {
+            return err(
+              new AflApiError(
+                `Request failed: ${response.status} ${response.statusText}`,
+                response.status
+              )
+            );
+          }
+          return ok(response);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Fetch JSON from a URL, validate with a Zod schema, and return a typed Result.
+       *
+       * @param url - The URL to fetch.
+       * @param schema - Zod schema to validate the response against.
+       * @returns Validated data on success, or an error Result.
+       */
+      async fetchJson(url, schema) {
+        const isPublic = url.startsWith(API_BASE);
+        let response;
+        if (isPublic) {
+          try {
+            response = await this.fetchFn(url);
+            if (!response.ok) {
+              return err(
+                new AflApiError(
+                  `Request failed: ${response.status} ${response.statusText}`,
+                  response.status
+                )
+              );
+            }
+          } catch (cause) {
+            return err(
+              new AflApiError(
+                `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+              )
+            );
+          }
+        } else {
+          const fetchResult = await this.authedFetch(url);
+          if (!fetchResult.success) {
+            return fetchResult;
+          }
+          response = fetchResult.data;
+        }
+        try {
+          const json = await response.json();
+          const parsed = schema.safeParse(json);
+          if (!parsed.success) {
+            return err(
+              new ValidationError("Response validation failed", [
+                { path: url, message: String(parsed.error) }
+              ])
+            );
+          }
+          return ok(parsed.data);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `JSON parse failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Resolve a competition code (e.g. "AFLM") to its API competition ID.
+       *
+       * @param code - The competition code to resolve.
+       * @returns The competition ID string on success.
+       */
+      async resolveCompetitionId(code) {
+        const result = await this.fetchJson(
+          `${API_BASE}/competitions?pageSize=50`,
+          CompetitionListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        const apiCode = code === "AFLM" ? "AFL" : code;
+        const competition = result.data.competitions.find((c) => c.code === apiCode);
+        if (!competition) {
+          return err(new AflApiError(`Competition not found for code: ${code}`));
+        }
+        return ok(competition.id);
+      }
+      /**
+       * Resolve a season (compseason) ID from a competition ID and year.
+       *
+       * @param competitionId - The competition ID (from {@link resolveCompetitionId}).
+       * @param year - The season year (e.g. 2024).
+       * @returns The compseason ID string on success.
+       */
+      async resolveSeasonId(competitionId, year) {
+        const result = await this.fetchJson(
+          `${API_BASE}/competitions/${competitionId}/compseasons?pageSize=100`,
+          CompseasonListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        const yearStr = String(year);
+        const season = result.data.compSeasons.find((cs) => cs.name.includes(yearStr));
+        if (!season) {
+          return err(new AflApiError(`Season not found for year: ${year}`));
+        }
+        return ok(season.id);
+      }
+      /**
+       * Resolve a season ID from a competition code and year in one step.
+       *
+       * @param code - The competition code (e.g. "AFLM").
+       * @param year - The season year (e.g. 2025).
+       * @returns The compseason ID on success.
+       */
+      async resolveCompSeason(code, year) {
+        const compResult = await this.resolveCompetitionId(code);
+        if (!compResult.success) return compResult;
+        return this.resolveSeasonId(compResult.data, year);
+      }
+      /**
+       * Fetch all rounds for a season with their metadata.
+       *
+       * @param seasonId - The compseason ID (from {@link resolveSeasonId}).
+       * @returns Array of round objects on success.
+       */
+      async resolveRounds(seasonId) {
+        const result = await this.fetchJson(
+          `${API_BASE}/compseasons/${seasonId}/rounds?pageSize=50`,
+          RoundListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        return ok(result.data.rounds);
+      }
+      /**
+       * Fetch match items for a round using the /cfs/ endpoint.
+       *
+       * @param roundProviderId - The round provider ID (e.g. "CD_R202501401").
+       * @returns Array of match items on success.
+       */
+      async fetchRoundMatchItems(roundProviderId) {
+        const result = await this.fetchJson(
+          `${CFS_BASE}/matchItems/round/${roundProviderId}`,
+          MatchItemListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        return ok(result.data.items);
+      }
+      /**
+       * Fetch match items for a round by resolving the round provider ID from season and round number.
+       *
+       * @param seasonId - The compseason ID.
+       * @param roundNumber - The round number.
+       * @returns Array of match items on success.
+       */
+      async fetchRoundMatchItemsByNumber(seasonId, roundNumber) {
+        const roundsResult = await this.resolveRounds(seasonId);
+        if (!roundsResult.success) {
+          return roundsResult;
+        }
+        const round = roundsResult.data.find((r) => r.roundNumber === roundNumber);
+        if (!round?.providerId) {
+          return err(new AflApiError(`Round not found or missing providerId: round ${roundNumber}`));
+        }
+        return this.fetchRoundMatchItems(round.providerId);
+      }
+      /**
+       * Fetch match items for all completed rounds in a season.
+       *
+       * @param seasonId - The compseason ID.
+       * @returns Aggregated array of match items from all completed rounds.
+       */
+      async fetchSeasonMatchItems(seasonId) {
+        const roundsResult = await this.resolveRounds(seasonId);
+        if (!roundsResult.success) {
+          return roundsResult;
+        }
+        const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
+        const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+        const allItems = [];
+        for (const result of results) {
+          if (!result.success) {
+            return result;
+          }
+          const concluded = result.data.filter(
+            (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
+          );
+          allItems.push(...concluded);
+        }
+        return ok(allItems);
+      }
+      /**
+       * Fetch per-player statistics for a match.
+       *
+       * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+       * @returns Player stats list with home and away arrays.
+       */
+      async fetchPlayerStats(matchProviderId) {
+        return this.fetchJson(
+          `${CFS_BASE}/playerStats/match/${matchProviderId}`,
+          PlayerStatsListSchema
+        );
+      }
+      /**
+       * Fetch match roster (lineup) for a match.
+       *
+       * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+       * @returns Match roster with team players.
+       */
+      async fetchMatchRoster(matchProviderId) {
+        return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
+      }
+      /**
+       * Fetch team list, optionally filtered by team type.
+       *
+       * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
+       * @returns Array of team items.
+       */
+      async fetchTeams(teamType) {
+        const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
+        if (!result.success) {
+          return result;
+        }
+        if (teamType) {
+          return ok(result.data.teams.filter((t) => t.teamType === teamType));
+        }
+        return ok(result.data.teams);
+      }
+      /**
+       * Fetch squad (roster) for a team in a specific season.
+       *
+       * @param teamId - The numeric team ID.
+       * @param compSeasonId - The compseason ID.
+       * @returns Squad list response.
+       */
+      async fetchSquad(teamId, compSeasonId) {
+        return this.fetchJson(
+          `${API_BASE}/squads?teamId=${teamId}&compSeasonId=${compSeasonId}`,
+          SquadListSchema
+        );
+      }
+      /**
+       * Fetch ladder standings for a season (optionally for a specific round).
+       *
+       * @param seasonId - The compseason ID.
+       * @param roundId - Optional round ID (numeric `id`, not `providerId`).
+       * @returns Ladder response with entries.
+       */
+      async fetchLadder(seasonId, roundId) {
+        let url = `${API_BASE}/compseasons/${seasonId}/ladders`;
+        if (roundId != null) {
+          url += `?roundId=${roundId}`;
+        }
+        return this.fetchJson(url, LadderResponseSchema);
+      }
+    };
+  }
+});
+
+// src/lib/squiggle-validation.ts
+import { z as z2 } from "zod";
+var SquiggleGameSchema, SquiggleGamesResponseSchema, SquiggleStandingSchema, SquiggleStandingsResponseSchema;
+var init_squiggle_validation = __esm({
+  "src/lib/squiggle-validation.ts"() {
+    "use strict";
+    SquiggleGameSchema = z2.object({
+      id: z2.number(),
+      year: z2.number(),
+      round: z2.number(),
+      roundname: z2.string(),
+      hteam: z2.string(),
+      ateam: z2.string(),
+      hteamid: z2.number(),
+      ateamid: z2.number(),
+      hscore: z2.number().nullable(),
+      ascore: z2.number().nullable(),
+      hgoals: z2.number().nullable(),
+      agoals: z2.number().nullable(),
+      hbehinds: z2.number().nullable(),
+      abehinds: z2.number().nullable(),
+      winner: z2.string().nullable(),
+      winnerteamid: z2.number().nullable(),
+      venue: z2.string(),
+      date: z2.string(),
+      localtime: z2.string(),
+      tz: z2.string(),
+      unixtime: z2.number(),
+      timestr: z2.string().nullable(),
+      complete: z2.number(),
+      is_final: z2.number(),
+      is_grand_final: z2.number(),
+      updated: z2.string()
+    });
+    SquiggleGamesResponseSchema = z2.object({
+      games: z2.array(SquiggleGameSchema)
+    });
+    SquiggleStandingSchema = z2.object({
+      id: z2.number(),
+      name: z2.string(),
+      rank: z2.number(),
+      played: z2.number(),
+      wins: z2.number(),
+      losses: z2.number(),
+      draws: z2.number(),
+      pts: z2.number(),
+      for: z2.number(),
+      against: z2.number(),
+      percentage: z2.number(),
+      goals_for: z2.number(),
+      goals_against: z2.number(),
+      behinds_for: z2.number(),
+      behinds_against: z2.number()
+    });
+    SquiggleStandingsResponseSchema = z2.object({
+      standings: z2.array(SquiggleStandingSchema)
+    });
+  }
+});
+
+// src/sources/squiggle.ts
+var SQUIGGLE_BASE, USER_AGENT, SquiggleClient;
+var init_squiggle = __esm({
+  "src/sources/squiggle.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_squiggle_validation();
+    SQUIGGLE_BASE = "https://api.squiggle.com.au/";
+    USER_AGENT = "fitzRoy-ts/1.0 (https://github.com/jackemcpherson/fitzRoy-ts)";
+    SquiggleClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch JSON from the Squiggle API.
+       */
+      async fetchJson(params) {
+        const url = `${SQUIGGLE_BASE}?${params.toString()}`;
+        try {
+          const response = await this.fetchFn(url, {
+            headers: { "User-Agent": USER_AGENT }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`Squiggle request failed: ${response.status} (${url})`, "squiggle")
+            );
+          }
+          const json = await response.json();
+          return ok(json);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `Squiggle request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "squiggle"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch games (match results or fixture) from the Squiggle API.
+       *
+       * @param year - Season year.
+       * @param round - Optional round number.
+       * @param complete - Optional completion filter (100 = complete, omit for all).
+       */
+      async fetchGames(year, round, complete) {
+        const params = new URLSearchParams({ q: "games", year: String(year) });
+        if (round != null) params.set("round", String(round));
+        if (complete != null) params.set("complete", String(complete));
+        const result = await this.fetchJson(params);
+        if (!result.success) return result;
+        const parsed = SquiggleGamesResponseSchema.safeParse(result.data);
+        if (!parsed.success) {
+          return err(
+            new ScrapeError(`Invalid Squiggle games response: ${parsed.error.message}`, "squiggle")
+          );
+        }
+        return ok(parsed.data);
+      }
+      /**
+       * Fetch standings (ladder) from the Squiggle API.
+       *
+       * @param year - Season year.
+       * @param round - Optional round number.
+       */
+      async fetchStandings(year, round) {
+        const params = new URLSearchParams({ q: "standings", year: String(year) });
+        if (round != null) params.set("round", String(round));
+        const result = await this.fetchJson(params);
+        if (!result.success) return result;
+        const parsed = SquiggleStandingsResponseSchema.safeParse(result.data);
+        if (!parsed.success) {
+          return err(
+            new ScrapeError(`Invalid Squiggle standings response: ${parsed.error.message}`, "squiggle")
+          );
+        }
+        return ok(parsed.data);
+      }
+    };
+  }
+});
+
+// src/transforms/squiggle.ts
+function toMatchStatus2(complete) {
+  if (complete === 100) return "Complete";
+  if (complete > 0) return "Live";
+  return "Upcoming";
+}
+function transformSquiggleGamesToResults(games, season) {
+  return games.filter((g) => g.complete === 100).map((g) => ({
+    matchId: `SQ_${g.id}`,
+    season,
+    roundNumber: g.round,
+    roundType: inferRoundType(g.roundname),
+    date: new Date(g.unixtime * 1e3),
+    venue: g.venue,
+    homeTeam: normaliseTeamName(g.hteam),
+    awayTeam: normaliseTeamName(g.ateam),
+    homeGoals: g.hgoals ?? 0,
+    homeBehinds: g.hbehinds ?? 0,
+    homePoints: g.hscore ?? 0,
+    awayGoals: g.agoals ?? 0,
+    awayBehinds: g.abehinds ?? 0,
+    awayPoints: g.ascore ?? 0,
+    margin: (g.hscore ?? 0) - (g.ascore ?? 0),
+    q1Home: null,
+    q2Home: null,
+    q3Home: null,
+    q4Home: null,
+    q1Away: null,
+    q2Away: null,
+    q3Away: null,
+    q4Away: null,
+    status: "Complete",
+    attendance: null,
+    venueState: null,
+    venueTimezone: g.tz || null,
+    homeRushedBehinds: null,
+    awayRushedBehinds: null,
+    homeMinutesInFront: null,
+    awayMinutesInFront: null,
+    source: "squiggle",
+    competition: "AFLM"
+  }));
+}
+function transformSquiggleGamesToFixture(games, season) {
+  return games.map((g) => ({
+    matchId: `SQ_${g.id}`,
+    season,
+    roundNumber: g.round,
+    roundType: inferRoundType(g.roundname),
+    date: new Date(g.unixtime * 1e3),
+    venue: g.venue,
+    homeTeam: normaliseTeamName(g.hteam),
+    awayTeam: normaliseTeamName(g.ateam),
+    status: toMatchStatus2(g.complete),
+    competition: "AFLM"
+  }));
+}
+function transformSquiggleStandings(standings) {
+  return standings.map((s) => ({
+    position: s.rank,
+    team: normaliseTeamName(s.name),
+    played: s.played,
+    wins: s.wins,
+    losses: s.losses,
+    draws: s.draws,
+    pointsFor: s.for,
+    pointsAgainst: s.against,
+    percentage: s.percentage,
+    premiershipsPoints: s.pts,
+    form: null
+  }));
+}
+var init_squiggle2 = __esm({
+  "src/transforms/squiggle.ts"() {
+    "use strict";
+    init_team_mapping();
+    init_match_results();
+  }
+});
+
+// src/api/fixture.ts
+function toFixture(item, season, fallbackRoundNumber, competition) {
+  return {
+    matchId: item.match.matchId,
+    season,
+    roundNumber: item.round?.roundNumber ?? fallbackRoundNumber,
+    roundType: inferRoundType(item.round?.name ?? ""),
+    date: new Date(item.match.utcStartTime),
+    venue: item.venue?.name ?? "",
+    homeTeam: normaliseTeamName(item.match.homeTeam.name),
+    awayTeam: normaliseTeamName(item.match.awayTeam.name),
+    status: toMatchStatus(item.match.status),
+    competition
+  };
+}
+async function fetchFixture(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source === "squiggle") {
+    const client2 = new SquiggleClient();
+    const result = await client2.fetchGames(query.season, query.round ?? void 0);
+    if (!result.success) return result;
+    return ok(transformSquiggleGamesToFixture(result.data.games, query.season));
+  }
+  if (query.source === "footywire") {
+    const fwClient = new FootyWireClient();
+    const result = await fwClient.fetchSeasonFixture(query.season);
+    if (!result.success) return result;
+    if (query.round != null) {
+      return ok(result.data.filter((f) => f.roundNumber === query.round));
+    }
+    return result;
+  }
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Fixture data is only available from the AFL API, FootyWire, or Squiggle sources.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  if (query.round != null) {
+    const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
+    if (!itemsResult.success) return itemsResult;
+    return ok(itemsResult.data.map((item) => toFixture(item, query.season, 0, competition)));
+  }
+  const roundsResult = await client.resolveRounds(seasonResult.data);
+  if (!roundsResult.success) return roundsResult;
+  const roundProviderIds = roundsResult.data.flatMap(
+    (r) => r.providerId ? [{ providerId: r.providerId, roundNumber: r.roundNumber }] : []
+  );
+  const roundResults = await Promise.all(
+    roundProviderIds.map((r) => client.fetchRoundMatchItems(r.providerId))
+  );
+  const fixtures = [];
+  for (let i = 0; i < roundResults.length; i++) {
+    const result = roundResults[i];
+    if (!result?.success) continue;
+    const roundNumber = roundProviderIds[i]?.roundNumber ?? 0;
+    for (const item of result.data) {
+      fixtures.push(toFixture(item, query.season, roundNumber, competition));
+    }
+  }
+  return ok(fixtures);
+}
+var init_fixture = __esm({
+  "src/api/fixture.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_api();
+    init_footywire();
+    init_squiggle();
+    init_match_results();
+    init_squiggle2();
+  }
+});
+
+// src/transforms/afl-tables-player-stats.ts
+import * as cheerio4 from "cheerio";
+function parseName(raw) {
+  const cleaned = raw.replace(/[↑↓]/g, "").trim();
+  const parts = cleaned.split(",").map((s) => s.trim());
+  const surname = parts[0] ?? "";
+  const givenName = parts[1] ?? "";
+  return {
+    givenName,
+    surname,
+    displayName: givenName ? `${givenName} ${surname}` : surname
+  };
+}
+function parseAflTablesGameStats(html, matchId, season, roundNumber) {
+  const $ = cheerio4.load(html);
+  const stats = [];
+  $("table.sortable").each((_tableIdx, table) => {
+    const headerText = $(table).find("thead tr").first().text().trim();
+    const teamMatch = /^(\w[\w\s]+?)\s+Match Statistics/i.exec(headerText);
+    if (!teamMatch) return;
+    const teamName = normaliseTeamName(teamMatch[1]?.trim() ?? "");
+    $(table).find("tbody tr").each((_rowIdx, row) => {
+      const cells = $(row).find("td").map((_, c) => $(c).text().trim()).get();
+      if (cells.length < 24) return;
+      const jumperStr = cells[0] ?? "";
+      const jumperNumber = safeInt(jumperStr.replace(/[↑↓]/g, ""));
+      const { givenName, surname, displayName } = parseName(cells[1] ?? "");
+      stats.push({
+        matchId: `AT_${matchId}`,
+        season,
+        roundNumber,
+        team: teamName,
+        competition: "AFLM",
+        playerId: `AT_${displayName.replace(/\s+/g, "_")}`,
+        givenName,
+        surname,
+        displayName,
+        jumperNumber,
+        kicks: safeInt(cells[2] ?? ""),
+        handballs: safeInt(cells[4] ?? ""),
+        disposals: safeInt(cells[5] ?? ""),
+        marks: safeInt(cells[3] ?? ""),
+        goals: safeInt(cells[6] ?? ""),
+        behinds: safeInt(cells[7] ?? ""),
+        tackles: safeInt(cells[9] ?? ""),
+        hitouts: safeInt(cells[8] ?? ""),
+        freesFor: safeInt(cells[14] ?? ""),
+        freesAgainst: safeInt(cells[15] ?? ""),
+        contestedPossessions: safeInt(cells[17] ?? ""),
+        uncontestedPossessions: safeInt(cells[18] ?? ""),
+        contestedMarks: safeInt(cells[19] ?? ""),
+        intercepts: null,
+        centreClearances: null,
+        stoppageClearances: null,
+        totalClearances: safeInt(cells[12] ?? ""),
+        inside50s: safeInt(cells[11] ?? ""),
+        rebound50s: safeInt(cells[10] ?? ""),
+        clangers: safeInt(cells[13] ?? ""),
+        turnovers: null,
+        onePercenters: safeInt(cells[21] ?? ""),
+        bounces: safeInt(cells[22] ?? ""),
+        goalAssists: safeInt(cells[23] ?? ""),
+        disposalEfficiency: null,
+        metresGained: null,
+        goalAccuracy: null,
+        marksInside50: safeInt(cells[20] ?? ""),
+        tacklesInside50: null,
+        shotsAtGoal: null,
+        scoreInvolvements: null,
+        totalPossessions: null,
+        timeOnGroundPercentage: safeInt(cells[24] ?? ""),
+        ratingPoints: null,
+        dreamTeamPoints: null,
+        effectiveDisposals: null,
+        effectiveKicks: null,
+        kickEfficiency: null,
+        kickToHandballRatio: null,
+        pressureActs: null,
+        defHalfPressureActs: null,
+        spoils: null,
+        hitoutsToAdvantage: null,
+        hitoutWinPercentage: null,
+        hitoutToAdvantageRate: null,
+        groundBallGets: null,
+        f50GroundBallGets: null,
+        interceptMarks: null,
+        marksOnLead: null,
+        contestedPossessionRate: null,
+        contestOffOneOnOnes: null,
+        contestOffWins: null,
+        contestOffWinsPercentage: null,
+        contestDefOneOnOnes: null,
+        contestDefLosses: null,
+        contestDefLossPercentage: null,
+        centreBounceAttendances: null,
+        kickins: null,
+        kickinsPlayon: null,
+        ruckContests: null,
+        scoreLaunches: null,
+        source: "afl-tables"
+      });
+    });
+  });
+  return stats;
+}
+function extractGameUrls(seasonHtml) {
+  const $ = cheerio4.load(seasonHtml);
+  const urls = [];
+  $("tr:nth-child(2) td:nth-child(4) a").each((_i, el) => {
+    const href = $(el).attr("href");
+    if (href) {
+      urls.push(href.replace("..", "https://afltables.com/afl"));
+    }
+  });
+  return urls;
+}
+var init_afl_tables_player_stats = __esm({
+  "src/transforms/afl-tables-player-stats.ts"() {
+    "use strict";
+    init_parse_utils();
+    init_team_mapping();
+  }
+});
+
+// src/sources/afl-tables.ts
+import * as cheerio5 from "cheerio";
+function parseSeasonPage(html, year) {
+  const $ = cheerio5.load(html);
+  const results = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  let matchCounter = 0;
+  $("table").each((_i, table) => {
+    const $table = $(table);
+    const text = $table.text().trim();
+    const border = $table.attr("border");
+    const roundMatch = /^Round\s+(\d+)/i.exec(text);
+    if (roundMatch?.[1] && border !== "1") {
+      currentRound = Number.parseInt(roundMatch[1], 10);
+      currentRoundType = inferRoundType(text);
+      return;
+    }
+    if (border !== "1" && inferRoundType(text) === "Finals") {
+      currentRoundType = "Finals";
+      return;
+    }
+    if (border !== "1") return;
+    const rows = $table.find("tr");
+    if (rows.length !== 2) return;
+    const homeRow = $(rows[0]);
+    const awayRow = $(rows[1]);
+    const homeCells = homeRow.find("td");
+    const awayCells = awayRow.find("td");
+    if (homeCells.length < 4 || awayCells.length < 3) return;
+    const homeTeam = normaliseTeamName($(homeCells[0]).find("a").text().trim());
+    const awayTeam = normaliseTeamName($(awayCells[0]).find("a").text().trim());
+    if (!homeTeam || !awayTeam) return;
+    const homeQuarters = parseQuarterScores($(homeCells[1]).text());
+    const awayQuarters = parseQuarterScores($(awayCells[1]).text());
+    const homePoints = Number.parseInt($(homeCells[2]).text().trim(), 10) || 0;
+    const awayPoints = Number.parseInt($(awayCells[2]).text().trim(), 10) || 0;
+    const infoText = $(homeCells[3]).text().trim();
+    const date = parseDateFromInfo(infoText, year);
+    const venue = parseVenueFromInfo($(homeCells[3]).html() ?? "");
+    const attendance = parseAttendanceFromInfo(infoText);
+    const homeFinal = homeQuarters[3];
+    const awayFinal = awayQuarters[3];
+    matchCounter++;
+    results.push({
+      matchId: `AT_${year}_${matchCounter}`,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals: homeFinal?.goals ?? 0,
+      homeBehinds: homeFinal?.behinds ?? 0,
+      homePoints,
+      awayGoals: awayFinal?.goals ?? 0,
+      awayBehinds: awayFinal?.behinds ?? 0,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: homeQuarters[0] ?? null,
+      q2Home: homeQuarters[1] ?? null,
+      q3Home: homeQuarters[2] ?? null,
+      q4Home: homeQuarters[3] ?? null,
+      q1Away: awayQuarters[0] ?? null,
+      q2Away: awayQuarters[1] ?? null,
+      q3Away: awayQuarters[2] ?? null,
+      q4Away: awayQuarters[3] ?? null,
+      status: "Complete",
+      attendance,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "afl-tables",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+function parseQuarterScores(text) {
+  const clean = text.replace(/\u00a0/g, " ").trim();
+  const matches = [...clean.matchAll(/(\d+)\.(\d+)/g)];
+  return matches.map((m) => {
+    const goals = Number.parseInt(m[1] ?? "0", 10);
+    const behinds = Number.parseInt(m[2] ?? "0", 10);
+    return { goals, behinds, points: goals * 6 + behinds };
+  });
+}
+function parseDateFromInfo(text, year) {
+  const dateMatch = /(\d{1,2}-[A-Z][a-z]{2}-\d{4})/.exec(text);
+  if (dateMatch?.[1]) {
+    return parseAflTablesDate(dateMatch[1]) ?? new Date(year, 0, 1);
+  }
+  return parseAflTablesDate(text) ?? new Date(year, 0, 1);
+}
+function parseVenueFromInfo(html) {
+  const $ = cheerio5.load(html);
+  const venueLink = $("a[href*='venues']");
+  if (venueLink.length > 0) {
+    return venueLink.text().trim();
+  }
+  const venueMatch = /Venue:\s*(.+?)(?:<|$)/i.exec(html);
+  return venueMatch?.[1]?.trim() ?? "";
+}
+function parseAttendanceFromInfo(text) {
+  const match = /Att:\s*([\d,]+)/i.exec(text);
+  if (!match?.[1]) return null;
+  return Number.parseInt(match[1].replace(/,/g, ""), 10) || null;
+}
+function parseAflTablesTeamStats(html, year) {
+  const $ = cheerio5.load(html);
+  const teamMap = /* @__PURE__ */ new Map();
+  const tables = $("table");
+  function parseTable(tableIdx, suffix) {
+    if (tableIdx >= tables.length) return;
+    const $table = $(tables[tableIdx]);
+    const rows = $table.find("tr");
+    if (rows.length < 2) return;
+    const headers = [];
+    $(rows[0]).find("td, th").each((_ci, cell) => {
+      headers.push($(cell).text().trim());
+    });
+    for (let ri = 1; ri < rows.length; ri++) {
+      const cells = $(rows[ri]).find("td");
+      if (cells.length < 3) continue;
+      const teamText = $(cells[0]).text().trim();
+      if (teamText === "Totals" || !teamText) continue;
+      const teamName = normaliseTeamName(teamText);
+      if (!teamName) continue;
+      if (!teamMap.has(teamName)) {
+        teamMap.set(teamName, { gamesPlayed: 0, stats: {} });
+      }
+      const entry = teamMap.get(teamName);
+      if (!entry) continue;
+      for (let ci = 1; ci < cells.length; ci++) {
+        const header = headers[ci];
+        if (!header) continue;
+        const value = Number.parseFloat($(cells[ci]).text().trim().replace(/,/g, "")) || 0;
+        entry.stats[`${header}${suffix}`] = value;
+      }
+    }
+  }
+  parseTable(1, "_for");
+  parseTable(2, "_against");
+  const entries = [];
+  for (const [team, data] of teamMap) {
+    entries.push({
+      season: year,
+      team,
+      gamesPlayed: data.gamesPlayed,
+      stats: data.stats,
+      source: "afl-tables"
+    });
+  }
+  return entries;
+}
+function teamNameToAflTablesSlug(teamName) {
+  return AFL_TABLES_SLUG_MAP.get(teamName);
+}
+function parseAflTablesPlayerList(html, teamName) {
+  const $ = cheerio5.load(html);
+  const players = [];
+  const table = $("table.sortable").first();
+  if (table.length === 0) return players;
+  const rows = table.find("tbody tr");
+  rows.each((_ri, row) => {
+    const cells = $(row).find("td");
+    if (cells.length < 8) return;
+    const jumperText = $(cells[1]).text().trim();
+    const playerText = $(cells[2]).text().trim();
+    if (!playerText) return;
+    const nameParts = playerText.split(",").map((s) => s.trim());
+    const surname = nameParts[0] ?? "";
+    const givenName = nameParts[1] ?? "";
+    const dobText = $(cells[3]).text().trim();
+    const htText = $(cells[4]).text().trim();
+    const wtText = $(cells[5]).text().trim();
+    const gamesRaw = $(cells[6]).text().trim();
+    const gamesMatch = /^(\d+)/.exec(gamesRaw);
+    const goalsText = $(cells[7]).text().trim();
+    const debutText = cells.length > 9 ? $(cells[9]).text().trim() : "";
+    const heightCm = htText ? Number.parseInt(htText, 10) || null : null;
+    const weightKg = wtText ? Number.parseInt(wtText, 10) || null : null;
+    const gamesPlayed = gamesMatch?.[1] ? Number.parseInt(gamesMatch[1], 10) || null : null;
+    const goalsScored = goalsText ? Number.parseInt(goalsText, 10) || null : null;
+    const jumperNumber = jumperText ? Number.parseInt(jumperText, 10) || null : null;
+    const debutYearMatch = /(\d{4})/.exec(debutText);
+    const debutYear = debutYearMatch?.[1] ? Number.parseInt(debutYearMatch[1], 10) || null : null;
+    players.push({
+      playerId: `AT_${teamName}_${surname}_${givenName}`.replace(/\s+/g, "_"),
+      givenName,
+      surname,
+      displayName: givenName ? `${givenName} ${surname}` : surname,
+      team: teamName,
+      jumperNumber,
+      position: null,
+      dateOfBirth: dobText || null,
+      heightCm,
+      weightKg,
+      gamesPlayed,
+      goals: goalsScored,
+      draftYear: null,
+      draftPosition: null,
+      draftType: null,
+      debutYear,
+      recruitedFrom: null
+    });
+  });
+  return players;
+}
+var AFL_TABLES_BASE, AflTablesClient, AFL_TABLES_SLUG_MAP;
+var init_afl_tables = __esm({
+  "src/sources/afl-tables.ts"() {
+    "use strict";
+    init_date_utils();
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_tables_player_stats();
+    init_match_results();
+    AFL_TABLES_BASE = "https://afltables.com/afl/seas";
+    AflTablesClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch season match results from AFL Tables.
+       *
+       * @param year - The season year (1897 to present).
+       * @returns Array of match results.
+       */
+      async fetchSeasonResults(year) {
+        const url = `${AFL_TABLES_BASE}/${year}.html`;
+        try {
+          const response = await this.fetchFn(url, {
+            headers: { "User-Agent": "Mozilla/5.0" }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`AFL Tables request failed: ${response.status} (${url})`, "afl-tables")
+            );
+          }
+          const html = await response.text();
+          const results = parseSeasonPage(html, year);
+          return ok(results);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Tables request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch player statistics for an entire season from AFL Tables.
+       *
+       * Scrapes individual game pages linked from the season page.
+       *
+       * @param year - The season year.
+       */
+      async fetchSeasonPlayerStats(year) {
+        const seasonUrl = `${AFL_TABLES_BASE}/${year}.html`;
+        try {
+          const seasonResponse = await this.fetchFn(seasonUrl, {
+            headers: { "User-Agent": "Mozilla/5.0" }
+          });
+          if (!seasonResponse.ok) {
+            return err(
+              new ScrapeError(
+                `AFL Tables request failed: ${seasonResponse.status} (${seasonUrl})`,
+                "afl-tables"
+              )
+            );
+          }
+          const seasonHtml = await seasonResponse.text();
+          const gameUrls = extractGameUrls(seasonHtml);
+          if (gameUrls.length === 0) {
+            return ok([]);
+          }
+          const results = parseSeasonPage(seasonHtml, year);
+          const allStats = [];
+          const batchSize = 5;
+          for (let i = 0; i < gameUrls.length; i += batchSize) {
+            const batch = gameUrls.slice(i, i + batchSize);
+            const batchResults = await Promise.all(
+              batch.map(async (gameUrl, batchIdx) => {
+                try {
+                  const resp = await this.fetchFn(gameUrl, {
+                    headers: { "User-Agent": "Mozilla/5.0" }
+                  });
+                  if (!resp.ok) return [];
+                  const html = await resp.text();
+                  const urlMatch = /\/(\d+)\.html$/.exec(gameUrl);
+                  const matchId = urlMatch?.[1] ?? `${year}_${i + batchIdx}`;
+                  const globalIdx = i + batchIdx;
+                  const roundNumber = results[globalIdx]?.roundNumber ?? 0;
+                  return parseAflTablesGameStats(html, matchId, year, roundNumber);
+                } catch {
+                  return [];
+                }
+              })
+            );
+            for (const stats of batchResults) {
+              allStats.push(...stats);
+            }
+            if (i + batchSize < gameUrls.length) {
+              await new Promise((resolve) => setTimeout(resolve, 300));
+            }
+          }
+          return ok(allStats);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Tables player stats failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch team statistics from AFL Tables.
+       *
+       * Scrapes the season stats page which includes per-team aggregate stats.
+       *
+       * @param year - The season year.
+       * @returns Array of team stats entries.
+       */
+      async fetchTeamStats(year) {
+        const url = `https://afltables.com/afl/stats/${year}s.html`;
+        try {
+          const response = await this.fetchFn(url, {
+            headers: { "User-Agent": "Mozilla/5.0" }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(
+                `AFL Tables stats request failed: ${response.status} (${url})`,
+                "afl-tables"
+              )
+            );
+          }
+          const html = await response.text();
+          const entries = parseAflTablesTeamStats(html, year);
+          return ok(entries);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Tables team stats failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
+            )
+          );
+        }
+      }
+      /**
+       * Fetch player list from AFL Tables team page.
+       *
+       * Scrapes the team index page (e.g. `teams/swans_idx.html`) which lists
+       * all players who have played for that team historically.
+       *
+       * @param teamName - Canonical team name (e.g. "Sydney Swans").
+       * @returns Array of player details (without source/competition fields).
+       */
+      async fetchPlayerList(teamName) {
+        const slug = teamNameToAflTablesSlug(teamName);
+        if (!slug) {
+          return err(new ScrapeError(`No AFL Tables slug mapping for team: ${teamName}`, "afl-tables"));
+        }
+        const url = `https://afltables.com/afl/stats/alltime/${slug}.html`;
+        try {
+          const response = await this.fetchFn(url, {
+            headers: { "User-Agent": "Mozilla/5.0" }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`AFL Tables request failed: ${response.status} (${url})`, "afl-tables")
+            );
+          }
+          const html = await response.text();
+          const players = parseAflTablesPlayerList(html, teamName);
+          return ok(players);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Tables player list failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
+            )
+          );
+        }
+      }
+    };
+    AFL_TABLES_SLUG_MAP = /* @__PURE__ */ new Map([
+      ["Adelaide Crows", "adelaide"],
+      ["Brisbane Lions", "brisbane"],
+      ["Carlton", "carlton"],
+      ["Collingwood", "collingwood"],
+      ["Essendon", "essendon"],
+      ["Fremantle", "fremantle"],
+      ["Geelong Cats", "geelong"],
+      ["Gold Coast Suns", "goldcoast"],
+      ["GWS Giants", "gws"],
+      ["Hawthorn", "hawthorn"],
+      ["Melbourne", "melbourne"],
+      ["North Melbourne", "kangaroos"],
+      ["Port Adelaide", "padelaide"],
+      ["Richmond", "richmond"],
+      ["St Kilda", "stkilda"],
+      ["Sydney Swans", "swans"],
+      ["West Coast Eagles", "westcoast"],
+      ["Western Bulldogs", "bullldogs"],
+      ["Fitzroy", "fitzroy"],
+      ["University", "university"]
+    ]);
+  }
+});
+
+// src/transforms/computed-ladder.ts
+function computeLadder(results, upToRound) {
+  const teams = /* @__PURE__ */ new Map();
+  const filtered = upToRound != null ? results.filter((r) => r.roundType === "HomeAndAway" && r.roundNumber <= upToRound) : results.filter((r) => r.roundType === "HomeAndAway");
+  for (const match of filtered) {
+    if (match.status !== "Complete") continue;
+    const home = getOrCreate(teams, match.homeTeam);
+    const away = getOrCreate(teams, match.awayTeam);
+    home.played++;
+    away.played++;
+    home.pointsFor += match.homePoints;
+    home.pointsAgainst += match.awayPoints;
+    away.pointsFor += match.awayPoints;
+    away.pointsAgainst += match.homePoints;
+    if (match.homePoints > match.awayPoints) {
+      home.wins++;
+      away.losses++;
+    } else if (match.awayPoints > match.homePoints) {
+      away.wins++;
+      home.losses++;
+    } else {
+      home.draws++;
+      away.draws++;
+    }
+  }
+  const entries = [...teams.entries()].map(([teamName, acc]) => {
+    const percentage = acc.pointsAgainst === 0 ? 0 : acc.pointsFor / acc.pointsAgainst * 100;
+    const premiershipsPoints = acc.wins * 4 + acc.draws * 2;
+    return {
+      position: 0,
+      // filled below after sorting
+      team: teamName,
+      played: acc.played,
+      wins: acc.wins,
+      losses: acc.losses,
+      draws: acc.draws,
+      pointsFor: acc.pointsFor,
+      pointsAgainst: acc.pointsAgainst,
+      percentage,
+      premiershipsPoints,
+      form: null
+    };
+  });
+  entries.sort((a, b) => {
+    if (b.premiershipsPoints !== a.premiershipsPoints) {
+      return b.premiershipsPoints - a.premiershipsPoints;
+    }
+    return b.percentage - a.percentage;
+  });
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry) {
+      entries[i] = { ...entry, position: i + 1 };
+    }
+  }
+  return entries;
+}
+function getOrCreate(map, team) {
+  let acc = map.get(team);
+  if (!acc) {
+    acc = { played: 0, wins: 0, losses: 0, draws: 0, pointsFor: 0, pointsAgainst: 0 };
+    map.set(team, acc);
+  }
+  return acc;
+}
+var init_computed_ladder = __esm({
+  "src/transforms/computed-ladder.ts"() {
+    "use strict";
+  }
+});
+
+// src/transforms/ladder.ts
+function transformLadderEntries(entries) {
+  return entries.map((entry) => {
+    const record = entry.thisSeasonRecord;
+    const wl = record?.winLossRecord;
+    return {
+      position: entry.position,
+      team: normaliseTeamName(entry.team.name),
+      played: entry.played ?? wl?.played ?? 0,
+      wins: wl?.wins ?? 0,
+      losses: wl?.losses ?? 0,
+      draws: wl?.draws ?? 0,
+      pointsFor: entry.pointsFor ?? 0,
+      pointsAgainst: entry.pointsAgainst ?? 0,
+      percentage: record?.percentage ?? 0,
+      premiershipsPoints: record?.aggregatePoints ?? 0,
+      form: entry.form ?? null
+    };
+  });
+}
+var init_ladder = __esm({
+  "src/transforms/ladder.ts"() {
+    "use strict";
+    init_team_mapping();
+  }
+});
+
+// src/api/ladder.ts
+async function fetchLadder(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source === "squiggle") {
+    const client2 = new SquiggleClient();
+    const result = await client2.fetchStandings(query.season, query.round ?? void 0);
+    if (!result.success) return result;
+    return ok({
+      season: query.season,
+      roundNumber: query.round ?? null,
+      entries: transformSquiggleStandings(result.data.standings),
+      competition
+    });
+  }
+  if (query.source === "afl-tables") {
+    const atClient = new AflTablesClient();
+    const resultsResult = await atClient.fetchSeasonResults(query.season);
+    if (!resultsResult.success) return resultsResult;
+    const entries2 = computeLadder(resultsResult.data, query.round ?? void 0);
+    return ok({
+      season: query.season,
+      roundNumber: query.round ?? null,
+      entries: entries2,
+      competition
+    });
+  }
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Ladder data is only available from the AFL API, AFL Tables, or Squiggle sources.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  let roundId;
+  if (query.round != null) {
+    const roundsResult = await client.resolveRounds(seasonResult.data);
+    if (!roundsResult.success) return roundsResult;
+    const round = roundsResult.data.find((r) => r.roundNumber === query.round);
+    if (round) {
+      roundId = round.id;
+    }
+  }
+  const ladderResult = await client.fetchLadder(seasonResult.data, roundId);
+  if (!ladderResult.success) return ladderResult;
+  const firstLadder = ladderResult.data.ladders[0];
+  const entries = firstLadder ? transformLadderEntries(firstLadder.entries) : [];
+  return ok({
+    season: query.season,
+    roundNumber: ladderResult.data.round?.roundNumber ?? null,
+    entries,
+    competition
+  });
+}
+var init_ladder2 = __esm({
+  "src/api/ladder.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_afl_tables();
+    init_squiggle();
+    init_computed_ladder();
+    init_ladder();
+    init_squiggle2();
+  }
+});
+
+// src/transforms/lineup.ts
+function transformMatchRoster(roster, season, roundNumber, competition) {
+  const homeTeamId = roster.match.homeTeamId;
+  const awayTeamId = roster.match.awayTeamId;
+  const homeTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === homeTeamId);
+  const awayTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === awayTeamId);
+  const mapPlayers = (players) => players.map((p) => {
+    const inner = p.player.player;
+    const position = p.player.position ?? null;
+    return {
+      playerId: inner.playerId,
+      givenName: inner.playerName.givenName,
+      surname: inner.playerName.surname,
+      displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+      jumperNumber: p.jumperNumber ?? null,
+      position,
+      isEmergency: position !== null && EMERGENCY_POSITIONS.has(position),
+      isSubstitute: position !== null && SUBSTITUTE_POSITIONS.has(position)
+    };
+  });
+  return {
+    matchId: roster.match.matchId,
+    season,
+    roundNumber,
+    homeTeam: normaliseTeamName(roster.match.homeTeam.name),
+    awayTeam: normaliseTeamName(roster.match.awayTeam.name),
+    homePlayers: homeTeamPlayers ? mapPlayers(homeTeamPlayers.players) : [],
+    awayPlayers: awayTeamPlayers ? mapPlayers(awayTeamPlayers.players) : [],
+    competition
+  };
+}
+var EMERGENCY_POSITIONS, SUBSTITUTE_POSITIONS;
+var init_lineup = __esm({
+  "src/transforms/lineup.ts"() {
+    "use strict";
+    init_team_mapping();
+    EMERGENCY_POSITIONS = /* @__PURE__ */ new Set(["EMG", "EMERG"]);
+    SUBSTITUTE_POSITIONS = /* @__PURE__ */ new Set(["SUB", "INT"]);
+  }
+});
+
+// src/api/lineup.ts
+async function fetchLineup(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Lineup data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  if (query.matchId) {
+    const rosterResult = await client.fetchMatchRoster(query.matchId);
+    if (!rosterResult.success) return rosterResult;
+    return ok([transformMatchRoster(rosterResult.data, query.season, query.round, competition)]);
+  }
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  const matchItems = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
+  if (!matchItems.success) return matchItems;
+  if (matchItems.data.length === 0) {
+    return err(new AflApiError(`No matches found for round ${query.round}`));
+  }
+  const rosterResults = await Promise.all(
+    matchItems.data.map((item) => client.fetchMatchRoster(item.match.matchId))
+  );
+  const lineups = [];
+  for (const rosterResult of rosterResults) {
+    if (!rosterResult.success) return rosterResult;
+    lineups.push(transformMatchRoster(rosterResult.data, query.season, query.round, competition));
+  }
+  return ok(lineups);
+}
+var init_lineup2 = __esm({
+  "src/api/lineup.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_lineup();
+  }
+});
+
+// src/api/match-results.ts
+async function fetchMatchResults(query) {
+  const competition = query.competition ?? "AFLM";
+  switch (query.source) {
+    case "afl-api": {
+      const client = new AflApiClient();
+      const seasonResult = await client.resolveCompSeason(competition, query.season);
+      if (!seasonResult.success) return seasonResult;
+      if (query.round != null) {
+        const itemsResult2 = await client.fetchRoundMatchItemsByNumber(
+          seasonResult.data,
+          query.round
+        );
+        if (!itemsResult2.success) return itemsResult2;
+        return ok(transformMatchItems(itemsResult2.data, query.season, competition));
+      }
+      const itemsResult = await client.fetchSeasonMatchItems(seasonResult.data);
+      if (!itemsResult.success) return itemsResult;
+      return ok(transformMatchItems(itemsResult.data, query.season, competition));
+    }
+    case "footywire": {
+      const client = new FootyWireClient();
+      const result = await client.fetchSeasonResults(query.season);
+      if (!result.success) return result;
+      if (query.round != null) {
+        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      }
+      return result;
+    }
+    case "afl-tables": {
+      const client = new AflTablesClient();
+      const result = await client.fetchSeasonResults(query.season);
+      if (!result.success) return result;
+      if (query.round != null) {
+        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      }
+      return result;
+    }
+    case "squiggle": {
+      const client = new SquiggleClient();
+      const result = await client.fetchGames(query.season, query.round ?? void 0, 100);
+      if (!result.success) return result;
+      return ok(transformSquiggleGamesToResults(result.data.games, query.season));
+    }
+    default:
+      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+  }
+}
+var init_match_results2 = __esm({
+  "src/api/match-results.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_afl_tables();
+    init_footywire();
+    init_squiggle();
+    init_match_results();
+    init_squiggle2();
+  }
+});
+
+// src/api/player-details.ts
+async function resolveTeamId(client, teamName, competition) {
+  const teamType = competition === "AFLW" ? "WOMEN" : "MEN";
+  const result = await client.fetchTeams(teamType);
+  if (!result.success) return result;
+  const normalised = normaliseTeamName(teamName);
+  const match = result.data.find((t) => normaliseTeamName(t.name) === normalised);
+  if (!match) {
+    return err(new ValidationError(`Team not found: ${teamName}`));
+  }
+  return ok(String(match.id));
+}
+async function fetchFromAflApi(query) {
+  const client = new AflApiClient();
+  const competition = query.competition ?? "AFLM";
+  const season = query.season ?? (/* @__PURE__ */ new Date()).getFullYear();
+  const [teamIdResult, seasonResult] = await Promise.all([
+    resolveTeamId(client, query.team, competition),
+    client.resolveCompSeason(competition, season)
+  ]);
+  if (!teamIdResult.success) return teamIdResult;
+  if (!seasonResult.success) return seasonResult;
+  const teamId = Number.parseInt(teamIdResult.data, 10);
+  if (Number.isNaN(teamId)) {
+    return err(new ValidationError(`Invalid team ID: ${teamIdResult.data}`));
+  }
+  const squadResult = await client.fetchSquad(teamId, seasonResult.data);
+  if (!squadResult.success) return squadResult;
+  const teamName = normaliseTeamName(squadResult.data.squad.team?.name ?? query.team);
+  const players = squadResult.data.squad.players.map((p) => ({
+    playerId: p.player.providerId ?? String(p.player.id),
+    givenName: p.player.firstName,
+    surname: p.player.surname,
+    displayName: `${p.player.firstName} ${p.player.surname}`,
+    team: teamName,
+    jumperNumber: p.jumperNumber ?? null,
+    position: p.position ?? null,
+    dateOfBirth: p.player.dateOfBirth ?? null,
+    heightCm: p.player.heightInCm ?? null,
+    weightKg: p.player.weightInKg ?? null,
+    gamesPlayed: null,
+    goals: null,
+    draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
+    draftPosition: p.player.draftPosition ? Number.parseInt(p.player.draftPosition, 10) || null : null,
+    draftType: p.player.draftType ?? null,
+    debutYear: p.player.debutYear ? Number.parseInt(p.player.debutYear, 10) || null : null,
+    recruitedFrom: p.player.recruitedFrom ?? null,
+    source: "afl-api",
+    competition
+  }));
+  return ok(players);
+}
+async function fetchFromFootyWire(query) {
+  const client = new FootyWireClient();
+  const competition = query.competition ?? "AFLM";
+  const teamName = normaliseTeamName(query.team);
+  const result = await client.fetchPlayerList(teamName);
+  if (!result.success) return result;
+  const players = result.data.map((p) => ({
+    ...p,
+    source: "footywire",
+    competition
+  }));
+  return ok(players);
+}
+async function fetchFromAflTables(query) {
+  const client = new AflTablesClient();
+  const competition = query.competition ?? "AFLM";
+  const teamName = normaliseTeamName(query.team);
+  const result = await client.fetchPlayerList(teamName);
+  if (!result.success) return result;
+  const players = result.data.map((p) => ({
+    ...p,
+    source: "afl-tables",
+    competition
+  }));
+  return ok(players);
+}
+async function fetchPlayerDetails(query) {
+  switch (query.source) {
+    case "afl-api":
+      return fetchFromAflApi(query);
+    case "footywire":
+      return fetchFromFootyWire(query);
+    case "afl-tables":
+      return fetchFromAflTables(query);
+    default:
+      return err(
+        new UnsupportedSourceError(
+          `Source "${query.source}" is not supported for player details. Use "afl-api", "footywire", or "afl-tables".`,
+          query.source
+        )
+      );
+  }
+}
+var init_player_details = __esm({
+  "src/api/player-details.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_api();
+    init_afl_tables();
+    init_footywire();
+  }
+});
+
+// src/transforms/player-stats.ts
+function toNullable(value) {
+  return value ?? null;
+}
+function transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap) {
+  const inner = item.player.player.player;
+  const stats = item.playerStats.stats;
+  const clearances = stats.clearances;
+  return {
+    matchId,
+    season,
+    roundNumber,
+    team: normaliseTeamName(teamIdMap?.get(item.teamId) ?? item.teamId),
+    competition,
+    playerId: inner.playerId,
+    givenName: inner.playerName.givenName,
+    surname: inner.playerName.surname,
+    displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+    jumperNumber: item.player.jumperNumber ?? null,
+    kicks: toNullable(stats.kicks),
+    handballs: toNullable(stats.handballs),
+    disposals: toNullable(stats.disposals),
+    marks: toNullable(stats.marks),
+    goals: toNullable(stats.goals),
+    behinds: toNullable(stats.behinds),
+    tackles: toNullable(stats.tackles),
+    hitouts: toNullable(stats.hitouts),
+    freesFor: toNullable(stats.freesFor),
+    freesAgainst: toNullable(stats.freesAgainst),
+    contestedPossessions: toNullable(stats.contestedPossessions),
+    uncontestedPossessions: toNullable(stats.uncontestedPossessions),
+    contestedMarks: toNullable(stats.contestedMarks),
+    intercepts: toNullable(stats.intercepts),
+    centreClearances: toNullable(clearances?.centreClearances),
+    stoppageClearances: toNullable(clearances?.stoppageClearances),
+    totalClearances: toNullable(clearances?.totalClearances),
+    inside50s: toNullable(stats.inside50s),
+    rebound50s: toNullable(stats.rebound50s),
+    clangers: toNullable(stats.clangers),
+    turnovers: toNullable(stats.turnovers),
+    onePercenters: toNullable(stats.onePercenters),
+    bounces: toNullable(stats.bounces),
+    goalAssists: toNullable(stats.goalAssists),
+    disposalEfficiency: toNullable(stats.disposalEfficiency),
+    metresGained: toNullable(stats.metresGained),
+    goalAccuracy: toNullable(stats.goalAccuracy),
+    marksInside50: toNullable(stats.marksInside50),
+    tacklesInside50: toNullable(stats.tacklesInside50),
+    shotsAtGoal: toNullable(stats.shotsAtGoal),
+    scoreInvolvements: toNullable(stats.scoreInvolvements),
+    totalPossessions: toNullable(stats.totalPossessions),
+    timeOnGroundPercentage: toNullable(item.playerStats.timeOnGroundPercentage),
+    ratingPoints: toNullable(stats.ratingPoints),
+    dreamTeamPoints: toNullable(stats.dreamTeamPoints),
+    effectiveDisposals: toNullable(stats.extendedStats?.effectiveDisposals),
+    effectiveKicks: toNullable(stats.extendedStats?.effectiveKicks),
+    kickEfficiency: toNullable(stats.extendedStats?.kickEfficiency),
+    kickToHandballRatio: toNullable(stats.extendedStats?.kickToHandballRatio),
+    pressureActs: toNullable(stats.extendedStats?.pressureActs),
+    defHalfPressureActs: toNullable(stats.extendedStats?.defHalfPressureActs),
+    spoils: toNullable(stats.extendedStats?.spoils),
+    hitoutsToAdvantage: toNullable(stats.extendedStats?.hitoutsToAdvantage),
+    hitoutWinPercentage: toNullable(stats.extendedStats?.hitoutWinPercentage),
+    hitoutToAdvantageRate: toNullable(stats.extendedStats?.hitoutToAdvantageRate),
+    groundBallGets: toNullable(stats.extendedStats?.groundBallGets),
+    f50GroundBallGets: toNullable(stats.extendedStats?.f50GroundBallGets),
+    interceptMarks: toNullable(stats.extendedStats?.interceptMarks),
+    marksOnLead: toNullable(stats.extendedStats?.marksOnLead),
+    contestedPossessionRate: toNullable(stats.extendedStats?.contestedPossessionRate),
+    contestOffOneOnOnes: toNullable(stats.extendedStats?.contestOffOneOnOnes),
+    contestOffWins: toNullable(stats.extendedStats?.contestOffWins),
+    contestOffWinsPercentage: toNullable(stats.extendedStats?.contestOffWinsPercentage),
+    contestDefOneOnOnes: toNullable(stats.extendedStats?.contestDefOneOnOnes),
+    contestDefLosses: toNullable(stats.extendedStats?.contestDefLosses),
+    contestDefLossPercentage: toNullable(stats.extendedStats?.contestDefLossPercentage),
+    centreBounceAttendances: toNullable(stats.extendedStats?.centreBounceAttendances),
+    kickins: toNullable(stats.extendedStats?.kickins),
+    kickinsPlayon: toNullable(stats.extendedStats?.kickinsPlayon),
+    ruckContests: toNullable(stats.extendedStats?.ruckContests),
+    scoreLaunches: toNullable(stats.extendedStats?.scoreLaunches),
+    source
+  };
+}
+function transformPlayerStats(data, matchId, season, roundNumber, competition, source = "afl-api", teamIdMap) {
+  const home = data.homeTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  const away = data.awayTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  return [...home, ...away];
+}
+var init_player_stats = __esm({
+  "src/transforms/player-stats.ts"() {
+    "use strict";
+    init_team_mapping();
+  }
+});
+
+// src/api/player-stats.ts
+async function fetchPlayerStats(query) {
+  const competition = query.competition ?? "AFLM";
+  switch (query.source) {
+    case "afl-api": {
+      const client = new AflApiClient();
+      if (query.matchId) {
+        const result = await client.fetchPlayerStats(query.matchId);
+        if (!result.success) return result;
+        return ok(
+          transformPlayerStats(
+            result.data,
+            query.matchId,
+            query.season,
+            query.round ?? 0,
+            competition
+          )
+        );
+      }
+      const seasonResult = await client.resolveCompSeason(competition, query.season);
+      if (!seasonResult.success) return seasonResult;
+      const roundNumber = query.round ?? 1;
+      const matchItemsResult = await client.fetchRoundMatchItemsByNumber(
+        seasonResult.data,
+        roundNumber
+      );
+      if (!matchItemsResult.success) return matchItemsResult;
+      const teamIdMap = /* @__PURE__ */ new Map();
+      for (const item of matchItemsResult.data) {
+        teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
+        teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
+      }
+      const statsResults = await Promise.all(
+        matchItemsResult.data.map((item) => client.fetchPlayerStats(item.match.matchId))
+      );
+      const allStats = [];
+      for (let i = 0; i < statsResults.length; i++) {
+        const statsResult = statsResults[i];
+        if (!statsResult?.success)
+          return statsResult ?? err(new AflApiError("Missing stats result"));
+        const item = matchItemsResult.data[i];
+        if (!item) continue;
+        allStats.push(
+          ...transformPlayerStats(
+            statsResult.data,
+            item.match.matchId,
+            query.season,
+            roundNumber,
+            competition,
+            "afl-api",
+            teamIdMap
+          )
+        );
+      }
+      return ok(allStats);
+    }
+    case "footywire": {
+      const fwClient = new FootyWireClient();
+      const idsResult = await fwClient.fetchSeasonMatchIds(query.season);
+      if (!idsResult.success) return idsResult;
+      const matchIds = idsResult.data;
+      if (matchIds.length === 0) {
+        return ok([]);
+      }
+      const allStats = [];
+      const batchSize = 5;
+      for (let i = 0; i < matchIds.length; i += batchSize) {
+        const batch = matchIds.slice(i, i + batchSize);
+        const results = await Promise.all(
+          batch.map((mid) => fwClient.fetchMatchPlayerStats(mid, query.season, query.round ?? 0))
+        );
+        for (const result of results) {
+          if (result.success) {
+            allStats.push(...result.data);
+          }
+        }
+        if (i + batchSize < matchIds.length) {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+      }
+      if (query.round != null) {
+        return ok(allStats.filter((s) => s.roundNumber === query.round));
+      }
+      return ok(allStats);
+    }
+    case "afl-tables": {
+      const atClient = new AflTablesClient();
+      const atResult = await atClient.fetchSeasonPlayerStats(query.season);
+      if (!atResult.success) return atResult;
+      if (query.round != null) {
+        return ok(atResult.data.filter((s) => s.roundNumber === query.round));
+      }
+      return atResult;
+    }
+    default:
+      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+  }
+}
+var init_player_stats2 = __esm({
+  "src/api/player-stats.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_afl_tables();
+    init_footywire();
+    init_player_stats();
+  }
+});
+
+// src/api/team-stats.ts
+async function fetchTeamStats(query) {
+  const summaryType = query.summaryType ?? "totals";
+  switch (query.source) {
+    case "footywire": {
+      const client = new FootyWireClient();
+      return client.fetchTeamStats(query.season, summaryType);
+    }
+    case "afl-tables": {
+      const client = new AflTablesClient();
+      return client.fetchTeamStats(query.season);
+    }
+    case "afl-api":
+    case "squiggle":
+      return err(
+        new UnsupportedSourceError(
+          `Team stats are not available from ${query.source}. Use "footywire" or "afl-tables".`,
+          query.source
+        )
+      );
+    default:
+      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+  }
+}
+var init_team_stats = __esm({
+  "src/api/team-stats.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_tables();
+    init_footywire();
+  }
+});
+
+// src/api/teams.ts
+function teamTypeForComp(comp) {
+  return comp === "AFLW" ? "WOMEN" : "MEN";
+}
+async function fetchTeams(query) {
+  const client = new AflApiClient();
+  const teamType = query?.teamType ?? teamTypeForComp(query?.competition ?? "AFLM");
+  const result = await client.fetchTeams(teamType);
+  if (!result.success) return result;
+  const competition = query?.competition ?? "AFLM";
+  const teams = result.data.map((t) => ({
+    teamId: String(t.id),
+    name: normaliseTeamName(t.name),
+    abbreviation: t.abbreviation ?? "",
+    competition
+  })).filter((t) => AFL_SENIOR_TEAMS.has(t.name));
+  return ok(teams);
+}
+async function fetchSquad(query) {
+  const client = new AflApiClient();
+  const competition = query.competition ?? "AFLM";
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  const teamId = Number.parseInt(query.teamId, 10);
+  if (Number.isNaN(teamId)) {
+    return err(new ValidationError(`Invalid team ID: ${query.teamId}`));
+  }
+  const squadResult = await client.fetchSquad(teamId, seasonResult.data);
+  if (!squadResult.success) return squadResult;
+  const players = squadResult.data.squad.players.map((p) => ({
+    playerId: p.player.providerId ?? String(p.player.id),
+    givenName: p.player.firstName,
+    surname: p.player.surname,
+    displayName: `${p.player.firstName} ${p.player.surname}`,
+    jumperNumber: p.jumperNumber ?? null,
+    position: p.position ?? null,
+    dateOfBirth: p.player.dateOfBirth ? new Date(p.player.dateOfBirth) : null,
+    heightCm: p.player.heightInCm ?? null,
+    weightKg: p.player.weightInKg ?? null,
+    draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
+    draftPosition: p.player.draftPosition ? Number.parseInt(p.player.draftPosition, 10) || null : null,
+    draftType: p.player.draftType ?? null,
+    debutYear: p.player.debutYear ? Number.parseInt(p.player.debutYear, 10) || null : null,
+    recruitedFrom: p.player.recruitedFrom ?? null
+  }));
+  return ok({
+    teamId: query.teamId,
+    teamName: normaliseTeamName(squadResult.data.squad.team?.name ?? query.teamId),
+    season: query.season,
+    players,
+    competition
+  });
+}
+var init_teams = __esm({
+  "src/api/teams.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_api();
+  }
+});
 
 // src/index.ts
-var init_src = () => {};
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_coaches_votes();
+    init_fixture();
+    init_ladder2();
+    init_lineup2();
+    init_match_results2();
+    init_player_details();
+    init_player_stats2();
+    init_team_stats();
+    init_teams();
+  }
+});
 
 // src/cli/formatters/csv.ts
 function escapeField(value) {
-  if (value.includes(",") || value.includes('"') || value.includes(`
-`) || value.includes("\r")) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
     return `"${value.replace(/"/g, '""')}"`;
   }
   return value;
 }
 function toStringValue(value) {
-  if (value === null || value === undefined)
-    return "";
-  if (value instanceof Date)
-    return value.toISOString();
-  if (typeof value === "object")
-    return JSON.stringify(value);
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
 function formatCsv(data) {
-  if (data.length === 0)
-    return "";
+  if (data.length === 0) return "";
   const firstRow = data[0];
-  if (!firstRow)
-    return "";
+  if (!firstRow) return "";
   const headers = Object.keys(firstRow);
   const lines = [headers.map(escapeField).join(",")];
   for (const row of data) {
     const values = headers.map((h) => escapeField(toStringValue(row[h])));
     lines.push(values.join(","));
   }
-  return lines.join(`
-`);
+  return lines.join("\n");
 }
+var init_csv = __esm({
+  "src/cli/formatters/csv.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/json.ts
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
+var init_json = __esm({
+  "src/cli/formatters/json.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/table.ts
 function toDisplayValue(value) {
-  if (value === null || value === undefined)
-    return "-";
-  if (value instanceof Date)
-    return value.toISOString().slice(0, 16).replace("T", " ");
-  if (typeof value === "object")
-    return JSON.stringify(value);
+  if (value === null || value === void 0) return "-";
+  if (value instanceof Date) return value.toISOString().slice(0, 16).replace("T", " ");
+  if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
 function truncate(str, maxLen) {
-  if (str.length <= maxLen)
-    return str;
-  return `${str.slice(0, maxLen - 1)}…`;
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 1)}\u2026`;
 }
 function formatTable(data, options = {}) {
-  if (data.length === 0)
-    return "No data.";
+  if (data.length === 0) return "No data.";
   const firstRow = data[0];
-  if (!firstRow)
-    return "No data.";
+  if (!firstRow) return "No data.";
   const termWidth = options.terminalWidth ?? process.stdout.columns ?? 120;
   const allKeys = Object.keys(firstRow);
   let columns;
@@ -88,78 +3592,72 @@ function formatTable(data, options = {}) {
   }
   const colWidths = columns.map((col) => (col.label ?? col.key).length);
   for (const row of data) {
-    for (let i = 0;i < columns.length; i++) {
+    for (let i = 0; i < columns.length; i++) {
       const col = columns[i];
-      if (!col)
-        continue;
+      if (!col) continue;
       const len = toDisplayValue(row[col.key]).length;
       const current = colWidths[i];
-      if (current !== undefined && len > current) {
+      if (current !== void 0 && len > current) {
         colWidths[i] = len;
       }
     }
   }
-  for (let i = 0;i < columns.length; i++) {
+  for (let i = 0; i < columns.length; i++) {
     const col = columns[i];
     const width = colWidths[i];
-    if (!col || width === undefined)
-      continue;
+    if (!col || width === void 0) continue;
     colWidths[i] = Math.min(col.maxWidth ?? 30, width);
   }
   const gap = 2;
   const visibleCols = [];
   let usedWidth = 0;
-  for (let i = 0;i < columns.length; i++) {
+  for (let i = 0; i < columns.length; i++) {
     const colWidth = colWidths[i];
-    if (colWidth === undefined)
-      continue;
+    if (colWidth === void 0) continue;
     const needed = usedWidth > 0 ? colWidth + gap : colWidth;
-    if (usedWidth + needed > termWidth && visibleCols.length > 0)
-      break;
+    if (usedWidth + needed > termWidth && visibleCols.length > 0) break;
     visibleCols.push(i);
     usedWidth += needed;
   }
   const headerParts = visibleCols.map((i) => {
     const col = columns[i];
     const width = colWidths[i];
-    if (!col || width === undefined)
-      return "";
+    if (!col || width === void 0) return "";
     const label = (col.label ?? col.key).toUpperCase();
     return truncate(label, width).padEnd(width);
   });
   const header = headerParts.join("  ");
   const separator = visibleCols.map((i) => {
     const width = colWidths[i];
-    if (width === undefined)
-      return "";
-    return "─".repeat(width);
+    if (width === void 0) return "";
+    return "\u2500".repeat(width);
   }).join("  ");
   const rows = data.map((row) => {
     const parts = visibleCols.map((i) => {
       const col = columns[i];
       const width = colWidths[i];
-      if (!col || width === undefined)
-        return "";
+      if (!col || width === void 0) return "";
       const val = toDisplayValue(row[col.key]);
       return truncate(val, width).padEnd(width);
     });
     return parts.join("  ");
   });
-  return [header, separator, ...rows].join(`
-`);
+  return [header, separator, ...rows].join("\n");
 }
+var init_table = __esm({
+  "src/cli/formatters/table.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/index.ts
 function resolveFormat(options) {
-  if (options.json)
-    return "json";
-  if (options.csv)
-    return "csv";
+  if (options.json) return "json";
+  if (options.csv) return "csv";
   if (options.format === "json" || options.format === "csv" || options.format === "table") {
     return options.format;
   }
-  if (!process.stdout.isTTY)
-    return "json";
+  if (!process.stdout.isTTY) return "json";
   return "table";
 }
 function formatOutput(data, options) {
@@ -177,7 +3675,14 @@ function formatOutput(data, options) {
       });
   }
 }
-var init_formatters = () => {};
+var init_formatters = __esm({
+  "src/cli/formatters/index.ts"() {
+    "use strict";
+    init_csv();
+    init_json();
+    init_table();
+  }
+});
 
 // src/cli/ui.ts
 import { spinner } from "@clack/prompts";
@@ -198,517 +3703,747 @@ async function withSpinner(message, fn) {
   }
 }
 function showSummary(message) {
-  if (!isTTY)
-    return;
+  if (!isTTY) return;
   console.error(pc.dim(message));
 }
 var isTTY;
-var init_ui = __esm(() => {
-  isTTY = process.stdout.isTTY === true;
+var init_ui = __esm({
+  "src/cli/ui.ts"() {
+    "use strict";
+    isTTY = process.stdout.isTTY === true;
+  }
 });
 
 // src/cli/commands/matches.ts
-var exports_matches = {};
-__export(exports_matches, {
+var matches_exports = {};
+__export(matches_exports, {
   matchesCommand: () => matchesCommand
 });
 import { defineCommand } from "citty";
 var DEFAULT_COLUMNS, matchesCommand;
-var init_matches = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS = [
-    { key: "date", label: "Date", maxWidth: 16 },
-    { key: "roundNumber", label: "Round", maxWidth: 6 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 },
-    { key: "homePoints", label: "H.Pts", maxWidth: 6 },
-    { key: "awayPoints", label: "A.Pts", maxWidth: 6 },
-    { key: "venue", label: "Venue", maxWidth: 24 }
-  ];
-  matchesCommand = defineCommand({
-    meta: {
-      name: "matches",
-      description: "Fetch match results for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_matches = __esm({
+  "src/cli/commands/matches.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS = [
+      { key: "date", label: "Date", maxWidth: 16 },
+      { key: "roundNumber", label: "Round", maxWidth: 6 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 },
+      { key: "homePoints", label: "H.Pts", maxWidth: 6 },
+      { key: "awayPoints", label: "A.Pts", maxWidth: 6 },
+      { key: "venue", label: "Venue", maxWidth: 24 }
+    ];
+    matchesCommand = defineCommand({
+      meta: {
+        name: "matches",
+        description: "Fetch match results for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching match results…", () => fetchMatchResults({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} matches for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching match results\u2026",
+          () => fetchMatchResults({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} matches for ${season}${round ? ` round ${round}` : ""}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/stats.ts
-var exports_stats = {};
-__export(exports_stats, {
+var stats_exports = {};
+__export(stats_exports, {
   statsCommand: () => statsCommand
 });
 import { defineCommand as defineCommand2 } from "citty";
 var DEFAULT_COLUMNS2, statsCommand;
-var init_stats = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS2 = [
-    { key: "displayName", label: "Player", maxWidth: 22 },
-    { key: "team", label: "Team", maxWidth: 18 },
-    { key: "disposals", label: "Disp", maxWidth: 6 },
-    { key: "kicks", label: "Kicks", maxWidth: 6 },
-    { key: "handballs", label: "HB", maxWidth: 6 },
-    { key: "marks", label: "Marks", maxWidth: 6 },
-    { key: "goals", label: "Goals", maxWidth: 6 }
-  ];
-  statsCommand = defineCommand2({
-    meta: {
-      name: "stats",
-      description: "Fetch player statistics for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      "match-id": { type: "string", description: "Specific match ID" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_stats = __esm({
+  "src/cli/commands/stats.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS2 = [
+      { key: "displayName", label: "Player", maxWidth: 22 },
+      { key: "team", label: "Team", maxWidth: 18 },
+      { key: "disposals", label: "Disp", maxWidth: 6 },
+      { key: "kicks", label: "Kicks", maxWidth: 6 },
+      { key: "handballs", label: "HB", maxWidth: 6 },
+      { key: "marks", label: "Marks", maxWidth: 6 },
+      { key: "goals", label: "Goals", maxWidth: 6 }
+    ];
+    statsCommand = defineCommand2({
+      meta: {
+        name: "stats",
+        description: "Fetch player statistics for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const matchId = args["match-id"];
-      const result = await withSpinner("Fetching player stats…", () => fetchPlayerStats({
-        source: args.source,
-        season,
-        round,
-        matchId,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS2
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        "match-id": { type: "string", description: "Specific match ID" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const matchId = args["match-id"];
+        const result = await withSpinner(
+          "Fetching player stats\u2026",
+          () => fetchPlayerStats({
+            source: args.source,
+            season,
+            round,
+            matchId,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(
+          `Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`
+        );
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS2
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/fixture.ts
-var exports_fixture = {};
-__export(exports_fixture, {
+var fixture_exports = {};
+__export(fixture_exports, {
   fixtureCommand: () => fixtureCommand
 });
 import { defineCommand as defineCommand3 } from "citty";
 var DEFAULT_COLUMNS3, fixtureCommand;
-var init_fixture = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS3 = [
-    { key: "roundNumber", label: "Round", maxWidth: 6 },
-    { key: "date", label: "Date", maxWidth: 16 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 },
-    { key: "venue", label: "Venue", maxWidth: 24 }
-  ];
-  fixtureCommand = defineCommand3({
-    meta: {
-      name: "fixture",
-      description: "Fetch fixture/schedule for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_fixture2 = __esm({
+  "src/cli/commands/fixture.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS3 = [
+      { key: "roundNumber", label: "Round", maxWidth: 6 },
+      { key: "date", label: "Date", maxWidth: 16 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 },
+      { key: "venue", label: "Venue", maxWidth: 24 }
+    ];
+    fixtureCommand = defineCommand3({
+      meta: {
+        name: "fixture",
+        description: "Fetch fixture/schedule for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching fixture…", () => fetchFixture({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} fixtures for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS3
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching fixture\u2026",
+          () => fetchFixture({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} fixtures for ${season}${round ? ` round ${round}` : ""}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS3
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/ladder.ts
-var exports_ladder = {};
-__export(exports_ladder, {
+var ladder_exports = {};
+__export(ladder_exports, {
   ladderCommand: () => ladderCommand
 });
 import { defineCommand as defineCommand4 } from "citty";
 var DEFAULT_COLUMNS4, ladderCommand;
-var init_ladder = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS4 = [
-    { key: "position", label: "Pos", maxWidth: 4 },
-    { key: "team", label: "Team", maxWidth: 24 },
-    { key: "wins", label: "W", maxWidth: 4 },
-    { key: "losses", label: "L", maxWidth: 4 },
-    { key: "draws", label: "D", maxWidth: 4 },
-    { key: "percentage", label: "Pct", maxWidth: 8 },
-    { key: "premiershipsPoints", label: "Pts", maxWidth: 5 }
-  ];
-  ladderCommand = defineCommand4({
-    meta: {
-      name: "ladder",
-      description: "Fetch ladder standings for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_ladder3 = __esm({
+  "src/cli/commands/ladder.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS4 = [
+      { key: "position", label: "Pos", maxWidth: 4 },
+      { key: "team", label: "Team", maxWidth: 24 },
+      { key: "wins", label: "W", maxWidth: 4 },
+      { key: "losses", label: "L", maxWidth: 4 },
+      { key: "draws", label: "D", maxWidth: 4 },
+      { key: "percentage", label: "Pct", maxWidth: 8 },
+      { key: "premiershipsPoints", label: "Pts", maxWidth: 5 }
+    ];
+    ladderCommand = defineCommand4({
+      meta: {
+        name: "ladder",
+        description: "Fetch ladder standings for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching ladder…", () => fetchLadder({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ladder for ${season}${round ? ` round ${round}` : ""} (${data.entries.length} teams)`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS4
-      };
-      console.log(formatOutput(data.entries, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching ladder\u2026",
+          () => fetchLadder({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(
+          `Loaded ladder for ${season}${round ? ` round ${round}` : ""} (${data.entries.length} teams)`
+        );
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS4
+        };
+        console.log(formatOutput(data.entries, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/lineup.ts
-var exports_lineup = {};
-__export(exports_lineup, {
+var lineup_exports = {};
+__export(lineup_exports, {
   lineupCommand: () => lineupCommand
 });
 import { defineCommand as defineCommand5 } from "citty";
 var DEFAULT_COLUMNS5, lineupCommand;
-var init_lineup = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS5 = [
-    { key: "matchId", label: "Match", maxWidth: 12 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 }
-  ];
-  lineupCommand = defineCommand5({
-    meta: {
-      name: "lineup",
-      description: "Fetch match lineups for a round"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number", required: true },
-      "match-id": { type: "string", description: "Specific match ID" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_lineup3 = __esm({
+  "src/cli/commands/lineup.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS5 = [
+      { key: "matchId", label: "Match", maxWidth: 12 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 }
+    ];
+    lineupCommand = defineCommand5({
+      meta: {
+        name: "lineup",
+        description: "Fetch match lineups for a round"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = Number(args.round);
-      const matchId = args["match-id"];
-      const result = await withSpinner("Fetching lineups…", () => fetchLineup({
-        source: args.source,
-        season,
-        round,
-        matchId,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} lineups for ${season} round ${round}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS5
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number", required: true },
+        "match-id": { type: "string", description: "Specific match ID" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = Number(args.round);
+        const matchId = args["match-id"];
+        const result = await withSpinner(
+          "Fetching lineups\u2026",
+          () => fetchLineup({
+            source: args.source,
+            season,
+            round,
+            matchId,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} lineups for ${season} round ${round}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS5
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/squad.ts
-var exports_squad = {};
-__export(exports_squad, {
+var squad_exports = {};
+__export(squad_exports, {
   squadCommand: () => squadCommand
 });
 import { defineCommand as defineCommand6 } from "citty";
 var DEFAULT_COLUMNS6, squadCommand;
-var init_squad = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS6 = [
-    { key: "displayName", label: "Player", maxWidth: 24 },
-    { key: "jumperNumber", label: "#", maxWidth: 4 },
-    { key: "position", label: "Pos", maxWidth: 12 },
-    { key: "heightCm", label: "Ht", maxWidth: 5 },
-    { key: "weightKg", label: "Wt", maxWidth: 5 }
-  ];
-  squadCommand = defineCommand6({
-    meta: {
-      name: "squad",
-      description: "Fetch team squad for a season"
-    },
-    args: {
-      "team-id": { type: "string", description: "Team ID", required: true },
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_squad = __esm({
+  "src/cli/commands/squad.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS6 = [
+      { key: "displayName", label: "Player", maxWidth: 24 },
+      { key: "jumperNumber", label: "#", maxWidth: 4 },
+      { key: "position", label: "Pos", maxWidth: 12 },
+      { key: "heightCm", label: "Ht", maxWidth: 5 },
+      { key: "weightKg", label: "Wt", maxWidth: 5 }
+    ];
+    squadCommand = defineCommand6({
+      meta: {
+        name: "squad",
+        description: "Fetch team squad for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const teamId = args["team-id"];
-      const season = Number(args.season);
-      const result = await withSpinner("Fetching squad…", () => fetchSquad({
-        teamId,
-        season,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.players.length} players for ${data.teamName} ${season}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS6
-      };
-      console.log(formatOutput(data.players, formatOptions));
-    }
-  });
+      args: {
+        "team-id": { type: "string", description: "Team ID", required: true },
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const teamId = args["team-id"];
+        const season = Number(args.season);
+        const result = await withSpinner(
+          "Fetching squad\u2026",
+          () => fetchSquad({
+            teamId,
+            season,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.players.length} players for ${data.teamName} ${season}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS6
+        };
+        console.log(formatOutput(data.players, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/teams.ts
-var exports_teams = {};
-__export(exports_teams, {
+var teams_exports = {};
+__export(teams_exports, {
   teamsCommand: () => teamsCommand
 });
 import { defineCommand as defineCommand7 } from "citty";
 var DEFAULT_COLUMNS7, teamsCommand;
-var init_teams = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS7 = [
-    { key: "teamId", label: "ID", maxWidth: 8 },
-    { key: "name", label: "Team", maxWidth: 24 },
-    { key: "abbreviation", label: "Abbr", maxWidth: 6 },
-    { key: "competition", label: "Comp", maxWidth: 6 }
-  ];
-  teamsCommand = defineCommand7({
-    meta: {
-      name: "teams",
-      description: "Fetch team list"
-    },
-    args: {
-      competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
-      "team-type": { type: "string", description: "Team type filter" },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const result = await withSpinner("Fetching teams…", () => fetchTeams({
-        competition: args.competition,
-        teamType: args["team-type"]
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} teams`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS7
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+var init_teams2 = __esm({
+  "src/cli/commands/teams.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS7 = [
+      { key: "teamId", label: "ID", maxWidth: 8 },
+      { key: "name", label: "Team", maxWidth: 24 },
+      { key: "abbreviation", label: "Abbr", maxWidth: 6 },
+      { key: "competition", label: "Comp", maxWidth: 6 }
+    ];
+    teamsCommand = defineCommand7({
+      meta: {
+        name: "teams",
+        description: "Fetch team list"
+      },
+      args: {
+        competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
+        "team-type": { type: "string", description: "Team type filter" },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const result = await withSpinner(
+          "Fetching teams\u2026",
+          () => fetchTeams({
+            competition: args.competition,
+            teamType: args["team-type"]
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} teams`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS7
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
-// src/cli.ts
-import { defineCommand as defineCommand8, runMain } from "citty";
-import pc2 from "picocolors";
-
-// src/lib/errors.ts
-class AflApiError extends Error {
-  statusCode;
-  name = "AflApiError";
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-  }
+// src/cli/commands/team-stats.ts
+var team_stats_exports = {};
+__export(team_stats_exports, {
+  teamStatsCommand: () => teamStatsCommand
+});
+import { defineCommand as defineCommand8 } from "citty";
+function flattenEntries(data) {
+  return data.map((entry) => {
+    const { stats, ...rest } = entry;
+    return { ...rest, ...stats };
+  });
 }
-
-class ScrapeError extends Error {
-  source;
-  name = "ScrapeError";
-  constructor(message, source) {
-    super(message);
-    this.source = source;
+var DEFAULT_COLUMNS8, teamStatsCommand;
+var init_team_stats2 = __esm({
+  "src/cli/commands/team-stats.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS8 = [
+      { key: "team", label: "Team", maxWidth: 24 },
+      { key: "gamesPlayed", label: "GP", maxWidth: 5 }
+    ];
+    teamStatsCommand = defineCommand8({
+      meta: {
+        name: "team-stats",
+        description: "Fetch team aggregate statistics for a season"
+      },
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
+        source: {
+          type: "string",
+          description: "Data source (footywire, afl-tables)",
+          default: "footywire"
+        },
+        summary: { type: "string", description: "Summary type: totals or averages", default: "totals" },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const summaryType = args.summary;
+        const result = await withSpinner(
+          "Fetching team stats\u2026",
+          () => fetchTeamStats({
+            source: args.source,
+            season,
+            summaryType
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded stats for ${data.length} teams (${season}, ${summaryType})`);
+        const flat = flattenEntries(data);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS8
+        };
+        console.log(formatOutput(flat, formatOptions));
+      }
+    });
   }
-}
+});
 
-class UnsupportedSourceError extends Error {
-  source;
-  name = "UnsupportedSourceError";
-  constructor(message, source) {
-    super(message);
-    this.source = source;
+// src/cli/commands/player-details.ts
+var player_details_exports = {};
+__export(player_details_exports, {
+  playerDetailsCommand: () => playerDetailsCommand
+});
+import { defineCommand as defineCommand9 } from "citty";
+var DEFAULT_COLUMNS9, playerDetailsCommand;
+var init_player_details2 = __esm({
+  "src/cli/commands/player-details.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS9 = [
+      { key: "displayName", label: "Player", maxWidth: 24 },
+      { key: "jumperNumber", label: "#", maxWidth: 4 },
+      { key: "position", label: "Pos", maxWidth: 12 },
+      { key: "heightCm", label: "Ht", maxWidth: 5 },
+      { key: "weightKg", label: "Wt", maxWidth: 5 },
+      { key: "gamesPlayed", label: "Games", maxWidth: 6 },
+      { key: "dateOfBirth", label: "DOB", maxWidth: 12 }
+    ];
+    playerDetailsCommand = defineCommand9({
+      meta: {
+        name: "player-details",
+        description: "Fetch player biographical details for a team"
+      },
+      args: {
+        team: { type: "positional", description: "Team name (e.g. Carlton, Hawthorn)", required: true },
+        source: {
+          type: "string",
+          description: "Data source: afl-api, footywire, afl-tables",
+          default: "afl-api"
+        },
+        season: { type: "string", description: "Season year (for AFL API source, e.g. 2025)" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const source = args.source;
+        const season = args.season ? Number(args.season) : void 0;
+        const result = await withSpinner(
+          "Fetching player details\u2026",
+          () => fetchPlayerDetails({
+            source,
+            team: args.team,
+            season,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} players for ${args.team} (${source})`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS9
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
   }
-}
+});
 
-class ValidationError extends Error {
-  issues;
-  name = "ValidationError";
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
+// src/cli/commands/coaches-votes.ts
+var coaches_votes_exports = {};
+__export(coaches_votes_exports, {
+  coachesVotesCommand: () => coachesVotesCommand
+});
+import { defineCommand as defineCommand10 } from "citty";
+var DEFAULT_COLUMNS10, coachesVotesCommand;
+var init_coaches_votes2 = __esm({
+  "src/cli/commands/coaches-votes.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS10 = [
+      { key: "season", label: "Season", maxWidth: 8 },
+      { key: "round", label: "Round", maxWidth: 6 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 },
+      { key: "playerName", label: "Player", maxWidth: 30 },
+      { key: "votes", label: "Votes", maxWidth: 6 }
+    ];
+    coachesVotesCommand = defineCommand10({
+      meta: {
+        name: "coaches-votes",
+        description: "Fetch AFLCA coaches votes for a season"
+      },
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
+        round: { type: "string", description: "Round number" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        team: { type: "string", description: "Filter by team name" },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching coaches votes\u2026",
+          () => fetchCoachesVotes({
+            season,
+            round,
+            competition: args.competition,
+            team: args.team
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        const teamSuffix = args.team ? ` for ${args.team}` : "";
+        const roundSuffix = round ? ` round ${round}` : "";
+        showSummary(`Loaded ${data.length} vote records for ${season}${roundSuffix}${teamSuffix}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS10
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
   }
-}
+});
 
 // src/cli.ts
-var main = defineCommand8({
+init_errors();
+import { defineCommand as defineCommand11, runMain } from "citty";
+import pc2 from "picocolors";
+var main = defineCommand11({
   meta: {
     name: "fitzroy",
-    version: "1.0.1",
-    description: "CLI for fetching AFL data — match results, player stats, fixtures, ladders, and more"
+    version: "1.1.0",
+    description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
   },
   subCommands: {
-    matches: () => Promise.resolve().then(() => (init_matches(), exports_matches)).then((m) => m.matchesCommand),
-    stats: () => Promise.resolve().then(() => (init_stats(), exports_stats)).then((m) => m.statsCommand),
-    fixture: () => Promise.resolve().then(() => (init_fixture(), exports_fixture)).then((m) => m.fixtureCommand),
-    ladder: () => Promise.resolve().then(() => (init_ladder(), exports_ladder)).then((m) => m.ladderCommand),
-    lineup: () => Promise.resolve().then(() => (init_lineup(), exports_lineup)).then((m) => m.lineupCommand),
-    squad: () => Promise.resolve().then(() => (init_squad(), exports_squad)).then((m) => m.squadCommand),
-    teams: () => Promise.resolve().then(() => (init_teams(), exports_teams)).then((m) => m.teamsCommand)
+    matches: () => Promise.resolve().then(() => (init_matches(), matches_exports)).then((m) => m.matchesCommand),
+    stats: () => Promise.resolve().then(() => (init_stats(), stats_exports)).then((m) => m.statsCommand),
+    fixture: () => Promise.resolve().then(() => (init_fixture2(), fixture_exports)).then((m) => m.fixtureCommand),
+    ladder: () => Promise.resolve().then(() => (init_ladder3(), ladder_exports)).then((m) => m.ladderCommand),
+    lineup: () => Promise.resolve().then(() => (init_lineup3(), lineup_exports)).then((m) => m.lineupCommand),
+    squad: () => Promise.resolve().then(() => (init_squad(), squad_exports)).then((m) => m.squadCommand),
+    teams: () => Promise.resolve().then(() => (init_teams2(), teams_exports)).then((m) => m.teamsCommand),
+    "team-stats": () => Promise.resolve().then(() => (init_team_stats2(), team_stats_exports)).then((m) => m.teamStatsCommand),
+    "player-details": () => Promise.resolve().then(() => (init_player_details2(), player_details_exports)).then((m) => m.playerDetailsCommand),
+    "coaches-votes": () => Promise.resolve().then(() => (init_coaches_votes2(), coaches_votes_exports)).then((m) => m.coachesVotesCommand)
   }
 });
 function formatError(error) {
   if (error instanceof ValidationError && error.issues) {
     const issueLines = error.issues.map((i) => `  ${pc2.yellow(i.path)}: ${i.message}`);
     return `${pc2.red("Validation error:")}
-${issueLines.join(`
-`)}`;
+${issueLines.join("\n")}`;
   }
   if (error instanceof AflApiError) {
     const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";