fitzroy 1.0.2 → 1.1.1

package/dist/cli.js

@@ -58,18 +58,123 @@ var init_result = __esm({
   }
 });
 
+// src/lib/date-utils.ts
+function parseFootyWireDate(dateStr, defaultYear) {
+  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 fullMatch = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (fullMatch) {
+    const [, dayStr, monthStr, yearStr] = fullMatch;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const shortMatch = /^(\d{1,2})\s+([A-Za-z]+)(?:\s+(\d{1,2}):(\d{2})(am|pm))?$/i.exec(normalised);
+  if (shortMatch && defaultYear != null) {
+    const [, dayStr, monthStr, hourStr, minStr, ampm] = shortMatch;
+    if (!dayStr || !monthStr) return null;
+    const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+    if (monthIndex === void 0) return null;
+    const day = Number.parseInt(dayStr, 10);
+    const hasTime = hourStr && minStr && ampm;
+    if (!hasTime) {
+      return buildUtcDate(defaultYear, monthStr, day);
+    }
+    let aestHours = Number.parseInt(hourStr, 10);
+    const minutes = Number.parseInt(minStr, 10);
+    if (ampm.toLowerCase() === "pm" && aestHours < 12) aestHours += 12;
+    if (ampm.toLowerCase() === "am" && aestHours === 12) aestHours = 0;
+    const date = new Date(Date.UTC(defaultYear, monthIndex, day, aestHours - 10, minutes));
+    if (Number.isNaN(date.getTime())) return null;
+    return date;
+  }
+  return null;
+}
+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, ALIAS_MAP;
+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", "Fitzroy Lions", "BL", "BRIS"],
+      ["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"],
@@ -106,6 +211,26 @@ var init_team_mapping = __esm({
       ["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) {
@@ -119,238 +244,1296 @@ var init_team_mapping = __esm({
   }
 });
 
-// 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"() {
+// 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";
-    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.optional(),
-      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({
+  }
+});
+
+// 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, year) ?? new Date(Date.UTC(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, year) ?? new Date(Date.UTC(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 normaliseDob(raw) {
+  if (!raw) return null;
+  const parsed = parseFootyWireDate(raw);
+  if (parsed) return parsed.toISOString().slice(0, 10);
+  return raw;
+}
+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: normaliseDob(dobText),
+      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, statNum, 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();
+    statNum = z.number().nullable().optional();
+    PlayerGameStatsSchema = z.object({
+      goals: statNum,
+      behinds: statNum,
+      kicks: statNum,
+      handballs: statNum,
+      disposals: statNum,
+      marks: statNum,
+      bounces: statNum,
+      tackles: statNum,
+      contestedPossessions: statNum,
+      uncontestedPossessions: statNum,
+      totalPossessions: statNum,
+      inside50s: statNum,
+      marksInside50: statNum,
+      contestedMarks: statNum,
+      hitouts: statNum,
+      onePercenters: statNum,
+      disposalEfficiency: statNum,
+      clangers: statNum,
+      freesFor: statNum,
+      freesAgainst: statNum,
+      dreamTeamPoints: statNum,
+      clearances: z.object({
+        centreClearances: statNum,
+        stoppageClearances: statNum,
+        totalClearances: statNum
+      }).passthrough().nullable().optional(),
+      rebound50s: statNum,
+      goalAssists: statNum,
+      goalAccuracy: statNum,
+      turnovers: statNum,
+      intercepts: statNum,
+      tacklesInside50: statNum,
+      shotsAtGoal: statNum,
+      metresGained: statNum,
+      scoreInvolvements: statNum,
+      ratingPoints: statNum,
+      extendedStats: z.object({
+        effectiveDisposals: statNum,
+        effectiveKicks: statNum,
+        kickEfficiency: statNum,
+        kickToHandballRatio: statNum,
+        pressureActs: statNum,
+        defHalfPressureActs: statNum,
+        spoils: statNum,
+        hitoutsToAdvantage: statNum,
+        hitoutWinPercentage: statNum,
+        hitoutToAdvantageRate: statNum,
+        groundBallGets: statNum,
+        f50GroundBallGets: statNum,
+        interceptMarks: statNum,
+        marksOnLead: statNum,
+        contestedPossessionRate: statNum,
+        contestOffOneOnOnes: statNum,
+        contestOffWins: statNum,
+        contestOffWinsPercentage: statNum,
+        contestDefOneOnOnes: statNum,
+        contestDefLosses: statNum,
+        contestDefLossPercentage: statNum,
+        centreBounceAttendances: statNum,
+        kickins: statNum,
+        kickinsPlayon: statNum,
+        ruckContests: statNum,
+        scoreLaunches: statNum
+      }).passthrough().nullable().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().nullable().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()
@@ -761,90 +1944,227 @@ var init_afl_api = __esm({
   }
 });
 
-// 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";
+// 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)
+    });
   }
-}
-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
+});
+
+// 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";
 }
-var FINALS_PATTERN;
-var init_match_results = __esm({
-  "src/transforms/match-results.ts"() {
+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();
-    FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
+    init_match_results();
   }
 });
 
@@ -865,312 +2185,198 @@ function toFixture(item, season, fallbackRoundNumber, competition) {
 }
 async function fetchFixture(query) {
   const competition = query.competition ?? "AFLM";
-  if (query.source !== "afl-api") {
-    return err(
-      new UnsupportedSourceError(
-        "Fixture data is only available from the AFL API source.",
-        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_match_results();
-  }
-});
-
-// 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 !== "afl-api") {
-    return err(
-      new UnsupportedSourceError(
-        "Ladder data is only available from the AFL API source.",
-        query.source
-      )
-    );
+  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));
   }
-  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;
+  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;
   }
-  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_ladder();
-  }
-});
-
-// 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.",
+        "Fixture data is only available from the AFL API, FootyWire, or Squiggle sources.",
         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/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));
+  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 null;
+  return ok(fixtures);
 }
-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;
+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();
   }
-  return date;
+});
+
+// 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
+  };
 }
-var MONTH_ABBREV_TO_INDEX;
-var init_date_utils = __esm({
-  "src/lib/date-utils.ts"() {
+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";
-    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]
-    ]);
+    init_parse_utils();
+    init_team_mapping();
   }
 });
 
 // src/sources/afl-tables.ts
-import * as cheerio from "cheerio";
+import * as cheerio5 from "cheerio";
 function parseSeasonPage(html, year) {
-  const $ = cheerio.load(html);
+  const $ = cheerio5.load(html);
   const results = [];
   let currentRound = 0;
   let currentRoundType = "HomeAndAway";
@@ -1178,17 +2384,18 @@ function parseSeasonPage(html, year) {
   $("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] && !$table.attr("border")) {
+    if (roundMatch?.[1] && border !== "1") {
       currentRound = Number.parseInt(roundMatch[1], 10);
       currentRoundType = inferRoundType(text);
       return;
     }
-    if (!$table.attr("border") && inferRoundType(text) === "Finals") {
+    if (border !== "1" && inferRoundType(text) === "Finals") {
       currentRoundType = "Finals";
       return;
     }
-    if ($table.attr("border") !== "1") return;
+    if (border !== "1") return;
     const rows = $table.find("tr");
     if (rows.length !== 2) return;
     const homeRow = $(rows[0]);
@@ -1265,7 +2472,7 @@ function parseDateFromInfo(text, year) {
   return parseAflTablesDate(text) ?? new Date(year, 0, 1);
 }
 function parseVenueFromInfo(html) {
-  const $ = cheerio.load(html);
+  const $ = cheerio5.load(html);
   const venueLink = $("a[href*='venues']");
   if (venueLink.length > 0) {
     return venueLink.text().trim();
@@ -1278,7 +2485,114 @@ function parseAttendanceFromInfo(text) {
   if (!match?.[1]) return null;
   return Number.parseInt(match[1].replace(/,/g, ""), 10) || null;
 }
-var AFL_TABLES_BASE, AflTablesClient;
+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());
+    });
+    const gpColIdx = headers.findIndex((h, i) => i > 0 && GP_HEADERS.has(h.toLowerCase()));
+    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;
+      if (gpColIdx >= 0 && suffix === "_for") {
+        const gpVal = Number.parseFloat($(cells[gpColIdx]).text().trim().replace(/,/g, "")) || 0;
+        entry.gamesPlayed = gpVal;
+      }
+      for (let ci = 1; ci < cells.length; ci++) {
+        if (ci === gpColIdx) continue;
+        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, GP_HEADERS, AFL_TABLES_SLUG_MAP;
 var init_afl_tables = __esm({
   "src/sources/afl-tables.ts"() {
     "use strict";
@@ -1286,6 +2600,7 @@ var init_afl_tables = __esm({
     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 {
@@ -1322,157 +2637,420 @@ var init_afl_tables = __esm({
           );
         }
       }
-    };
-  }
-});
-
-// 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;
-}
-var FOOTYWIRE_BASE, FootyWireClient;
-var init_footywire = __esm({
-  "src/sources/footywire.ts"() {
-    "use strict";
-    init_date_utils();
-    init_errors();
-    init_result();
-    init_team_mapping();
-    init_match_results();
-    FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
-    FootyWireClient = class {
-      fetchFn;
-      constructor(options) {
-        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      /**
+       * 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 the HTML content of a FootyWire page.
+       * 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 fetchHtml(url) {
+      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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-            }
+            headers: { "User-Agent": "Mozilla/5.0" }
           });
           if (!response.ok) {
             return err(
-              new ScrapeError(`FootyWire request failed: ${response.status} (${url})`, "footywire")
+              new ScrapeError(
+                `AFL Tables stats request failed: ${response.status} (${url})`,
+                "afl-tables"
+              )
             );
           }
           const html = await response.text();
-          return ok(html);
+          const entries = parseAflTablesTeamStats(html, year);
+          return ok(entries);
         } catch (cause) {
           return err(
             new ScrapeError(
-              `FootyWire request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-              "footywire"
+              `AFL Tables team stats failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
             )
           );
         }
       }
       /**
-       * Fetch season match results from FootyWire.
+       * Fetch player list from AFL Tables team page.
        *
-       * @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;
+       * 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 results = parseMatchList(htmlResult.data, year);
-          return ok(results);
+          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(
-              `Failed to parse match list: ${cause instanceof Error ? cause.message : String(cause)}`,
-              "footywire"
+              `AFL Tables player list failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
             )
           );
         }
       }
     };
+    GP_HEADERS = /* @__PURE__ */ new Set(["gm", "gp", "p", "mp", "games"]);
+    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();
   }
 });
 
@@ -1514,19 +3092,134 @@ async function fetchMatchResults(query) {
       }
       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"() {
+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();
-    init_match_results();
   }
 });
 
@@ -1636,15 +3329,26 @@ async function fetchPlayerStats(query) {
     case "afl-api": {
       const client = new AflApiClient();
       if (query.matchId) {
-        const result = await client.fetchPlayerStats(query.matchId);
-        if (!result.success) return result;
+        const [rosterResult, statsResult] = await Promise.all([
+          client.fetchMatchRoster(query.matchId),
+          client.fetchPlayerStats(query.matchId)
+        ]);
+        if (!statsResult.success) return statsResult;
+        const teamIdMap2 = /* @__PURE__ */ new Map();
+        if (rosterResult.success) {
+          const match = rosterResult.data.match;
+          teamIdMap2.set(match.homeTeamId, match.homeTeam.name);
+          teamIdMap2.set(match.awayTeamId, match.awayTeam.name);
+        }
         return ok(
           transformPlayerStats(
-            result.data,
+            statsResult.data,
             query.matchId,
             query.season,
             query.round ?? 0,
-            competition
+            competition,
+            "afl-api",
+            teamIdMap2.size > 0 ? teamIdMap2 : void 0
           )
         );
       }
@@ -1685,20 +3389,44 @@ async function fetchPlayerStats(query) {
       }
       return ok(allStats);
     }
-    case "footywire":
-      return err(
-        new UnsupportedSourceError(
-          "Player stats from FootyWire are not yet supported. Use source: 'afl-api'.",
-          "footywire"
-        )
-      );
-    case "afl-tables":
-      return err(
-        new UnsupportedSourceError(
-          "Player stats from AFL Tables are not yet supported. Use source: 'afl-api'.",
-          "afl-tables"
-        )
-      );
+    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));
   }
@@ -1709,28 +3437,63 @@ var init_player_stats2 = __esm({
     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 ?? (query?.competition ? teamTypeForComp(query.competition) : void 0);
+  const teamType = query?.teamType ?? teamTypeForComp(query?.competition ?? "AFLM");
   const result = await client.fetchTeams(teamType);
   if (!result.success) return result;
   const competition = query?.competition ?? "AFLM";
-  return ok(
-    result.data.map((t) => ({
-      teamId: String(t.id),
-      name: normaliseTeamName(t.name),
-      abbreviation: t.abbreviation ?? "",
-      competition
-    }))
-  );
+  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();
@@ -1781,11 +3544,14 @@ var init_teams = __esm({
 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();
   }
 });
@@ -1834,7 +3600,7 @@ var init_json = __esm({
 // src/cli/formatters/table.ts
 function toDisplayValue(value) {
   if (value === null || value === void 0) return "-";
-  if (value instanceof Date) return value.toISOString().slice(0, 16).replace("T", " ");
+  if (value instanceof Date) return AEST_COMPACT_FORMATTER.format(value);
   if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
@@ -1908,9 +3674,18 @@ function formatTable(data, options = {}) {
   });
   return [header, separator, ...rows].join("\n");
 }
+var AEST_COMPACT_FORMATTER;
 var init_table = __esm({
   "src/cli/formatters/table.ts"() {
     "use strict";
+    AEST_COMPACT_FORMATTER = new Intl.DateTimeFormat("en-AU", {
+      timeZone: "Australia/Melbourne",
+      day: "numeric",
+      month: "short",
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    });
   }
 });
 
@@ -1950,7 +3725,7 @@ var init_formatters = __esm({
 
 // src/cli/ui.ts
 import { spinner } from "@clack/prompts";
-import pc from "picocolors";
+import pc2 from "picocolors";
 async function withSpinner(message, fn) {
   if (!isTTY) {
     return fn();
@@ -1968,7 +3743,7 @@ async function withSpinner(message, fn) {
 }
 function showSummary(message) {
   if (!isTTY) return;
-  console.error(pc.dim(message));
+  console.error(pc2.dim(message));
 }
 var isTTY;
 var init_ui = __esm({
@@ -1978,6 +3753,86 @@ var init_ui = __esm({
   }
 });
 
+// src/cli/validation.ts
+function validateSeason(raw) {
+  const season = Number(raw);
+  if (Number.isNaN(season) || !Number.isInteger(season)) {
+    throw new Error(`Invalid season: "${raw}" \u2014 season must be a number (e.g. 2025)`);
+  }
+  if (season < 1897 || season > 2100) {
+    throw new Error(`Invalid season: ${season} \u2014 must be between 1897 and 2100`);
+  }
+  return season;
+}
+function validateOptionalSeason(raw) {
+  if (raw != null) return validateSeason(raw);
+  return void 0;
+}
+function resolveDefaultSeason(competition = "AFLM") {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  return competition === "AFLW" ? year - 1 : year;
+}
+function validateRound(raw) {
+  const round = Number(raw);
+  if (Number.isNaN(round) || !Number.isInteger(round) || round < 0) {
+    throw new Error(`Invalid round: "${raw}" \u2014 round must be a non-negative integer`);
+  }
+  return round;
+}
+function validateFormat(raw) {
+  if (raw == null) return void 0;
+  const lower = raw.toLowerCase();
+  if (VALID_FORMATS.includes(lower)) {
+    return lower;
+  }
+  throw new Error(`Invalid format: "${raw}" \u2014 valid formats are: ${VALID_FORMATS.join(", ")}`);
+}
+function validateCompetition(raw) {
+  const upper = raw.toUpperCase();
+  if (upper === "AFLM" || upper === "AFLW") {
+    return upper;
+  }
+  throw new Error(
+    `Invalid competition: "${raw}" \u2014 valid values are: ${VALID_COMPETITIONS.join(", ")}`
+  );
+}
+function validateOptionalCompetition(raw) {
+  if (raw == null) return void 0;
+  return validateCompetition(raw);
+}
+function validateSource(raw) {
+  if (VALID_SOURCES.includes(raw)) {
+    return raw;
+  }
+  throw new Error(`Invalid source: "${raw}" \u2014 valid sources are: ${VALID_SOURCES.join(", ")}`);
+}
+function resolveTeamIdentifier(raw, teams) {
+  const trimmed = raw.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  const canonical = normaliseTeamName(trimmed);
+  const byCanonical = teams.find((t) => t.name === canonical);
+  if (byCanonical) return byCanonical.teamId;
+  const lower = trimmed.toLowerCase();
+  const byName = teams.find((t) => t.name.toLowerCase() === lower);
+  if (byName) return byName.teamId;
+  const byAbbrev = teams.find((t) => t.abbreviation.toLowerCase() === lower);
+  if (byAbbrev) return byAbbrev.teamId;
+  const validNames = teams.map((t) => `${t.name} (${t.abbreviation})`).join(", ");
+  throw new Error(`Unknown team: "${raw}" \u2014 valid teams are: ${validNames}`);
+}
+var VALID_SOURCES, VALID_COMPETITIONS, VALID_FORMATS;
+var init_validation2 = __esm({
+  "src/cli/validation.ts"() {
+    "use strict";
+    init_team_mapping();
+    VALID_SOURCES = ["afl-api", "footywire", "afl-tables", "squiggle"];
+    VALID_COMPETITIONS = ["AFLM", "AFLW"];
+    VALID_FORMATS = ["table", "json", "csv"];
+  }
+});
+
 // src/cli/commands/matches.ts
 var matches_exports = {};
 __export(matches_exports, {
@@ -1991,6 +3846,7 @@ var init_matches = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS = [
       { key: "date", label: "Date", maxWidth: 16 },
       { key: "roundNumber", label: "Round", maxWidth: 6 },
@@ -2020,16 +3876,14 @@ var init_matches = __esm({
         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 season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching match results\u2026",
-          () => fetchMatchResults({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchMatchResults({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2039,7 +3893,7 @@ var init_matches = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS
         };
@@ -2062,6 +3916,7 @@ var init_stats = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS2 = [
       { key: "displayName", label: "Player", maxWidth: 22 },
       { key: "team", label: "Team", maxWidth: 18 },
@@ -2092,18 +3947,15 @@ var init_stats = __esm({
         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 season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
         const matchId = args["match-id"];
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching player stats\u2026",
-          () => fetchPlayerStats({
-            source: args.source,
-            season,
-            round,
-            matchId,
-            competition: args.competition
-          })
+          () => fetchPlayerStats({ source, season, round, matchId, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2115,7 +3967,7 @@ var init_stats = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS2
         };
@@ -2138,6 +3990,7 @@ var init_fixture2 = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS3 = [
       { key: "roundNumber", label: "Round", maxWidth: 6 },
       { key: "date", label: "Date", maxWidth: 16 },
@@ -2165,16 +4018,14 @@ var init_fixture2 = __esm({
         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 season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching fixture\u2026",
-          () => fetchFixture({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchFixture({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2184,7 +4035,7 @@ var init_fixture2 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS3
         };
@@ -2207,6 +4058,7 @@ var init_ladder3 = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS4 = [
       { key: "position", label: "Pos", maxWidth: 4 },
       { key: "team", label: "Team", maxWidth: 24 },
@@ -2236,16 +4088,14 @@ var init_ladder3 = __esm({
         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 season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching ladder\u2026",
-          () => fetchLadder({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchLadder({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2257,7 +4107,7 @@ var init_ladder3 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS4
         };
@@ -2273,6 +4123,28 @@ __export(lineup_exports, {
   lineupCommand: () => lineupCommand
 });
 import { defineCommand as defineCommand5 } from "citty";
+function flattenLineups(lineups) {
+  const rows = [];
+  for (const lineup of lineups) {
+    for (const { players, team } of [
+      { players: lineup.homePlayers, team: lineup.homeTeam },
+      { players: lineup.awayPlayers, team: lineup.awayTeam }
+    ]) {
+      for (const p of players) {
+        rows.push({
+          matchId: lineup.matchId,
+          team,
+          displayName: p.displayName,
+          jumperNumber: p.jumperNumber,
+          position: p.position,
+          isEmergency: p.isEmergency,
+          isSubstitute: p.isSubstitute
+        });
+      }
+    }
+  }
+  return rows;
+}
 var DEFAULT_COLUMNS5, lineupCommand;
 var init_lineup3 = __esm({
   "src/cli/commands/lineup.ts"() {
@@ -2280,10 +4152,13 @@ var init_lineup3 = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS5 = [
-      { key: "matchId", label: "Match", maxWidth: 12 },
-      { key: "homeTeam", label: "Home", maxWidth: 20 },
-      { key: "awayTeam", label: "Away", maxWidth: 20 }
+      { key: "matchId", label: "Match", maxWidth: 14 },
+      { key: "team", label: "Team", maxWidth: 20 },
+      { key: "displayName", label: "Player", maxWidth: 24 },
+      { key: "jumperNumber", label: "#", maxWidth: 4 },
+      { key: "position", label: "Pos", maxWidth: 12 }
     ];
     lineupCommand = defineCommand5({
       meta: {
@@ -2306,18 +4181,15 @@ var init_lineup3 = __esm({
         full: { type: "boolean", description: "Show all columns in table output" }
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = Number(args.round);
+        const season = validateSeason(args.season);
+        const round = validateRound(args.round);
         const matchId = args["match-id"];
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching lineups\u2026",
-          () => fetchLineup({
-            source: args.source,
-            season,
-            round,
-            matchId,
-            competition: args.competition
-          })
+          () => fetchLineup({ source, season, round, matchId, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2327,11 +4199,16 @@ var init_lineup3 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS5
         };
-        console.log(formatOutput(data, formatOptions));
+        const resolvedFormat = resolveFormat(formatOptions);
+        if (resolvedFormat === "json") {
+          console.log(formatOutput(data, formatOptions));
+        } else {
+          console.log(formatOutput(flattenLineups(data), formatOptions));
+        }
       }
     });
   }
@@ -2350,6 +4227,7 @@ var init_squad = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS6 = [
       { key: "displayName", label: "Player", maxWidth: 24 },
       { key: "jumperNumber", label: "#", maxWidth: 4 },
@@ -2363,7 +4241,11 @@ var init_squad = __esm({
         description: "Fetch team squad for a season"
       },
       args: {
-        "team-id": { type: "string", description: "Team ID", required: true },
+        "team-id": {
+          type: "string",
+          description: "Team ID, abbreviation, or name (e.g. 5, CARL, Carlton)",
+          required: true
+        },
         season: { type: "string", description: "Season year (e.g. 2025)", required: true },
         competition: {
           type: "string",
@@ -2376,15 +4258,21 @@ var init_squad = __esm({
         full: { type: "boolean", description: "Show all columns in table output" }
       },
       async run({ args }) {
-        const teamId = args["team-id"];
-        const season = Number(args.season);
+        const season = validateSeason(args.season);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        let teamId = args["team-id"].trim();
+        const isNumeric = /^\d+$/.test(teamId);
+        if (!isNumeric) {
+          const teamsResult = await withSpinner("Resolving team\u2026", () => fetchTeams({ competition }));
+          if (!teamsResult.success) {
+            throw teamsResult.error;
+          }
+          teamId = resolveTeamIdentifier(args["team-id"], teamsResult.data);
+        }
         const result = await withSpinner(
           "Fetching squad\u2026",
-          () => fetchSquad({
-            teamId,
-            season,
-            competition: args.competition
-          })
+          () => fetchSquad({ teamId, season, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -2394,7 +4282,7 @@ var init_squad = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS6
         };
@@ -2417,6 +4305,7 @@ var init_teams2 = __esm({
     init_index();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS7 = [
       { key: "teamId", label: "ID", maxWidth: 8 },
       { key: "name", label: "Team", maxWidth: 24 },
@@ -2437,22 +4326,26 @@ var init_teams2 = __esm({
         full: { type: "boolean", description: "Show all columns in table output" }
       },
       async run({ args }) {
+        const competition = validateOptionalCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching teams\u2026",
-          () => fetchTeams({
-            competition: args.competition,
-            teamType: args["team-type"]
-          })
+          () => fetchTeams({ competition, teamType: args["team-type"] })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
+        if (data.length === 0 && args["team-type"]) {
+          console.error(
+            `No teams found for team type "${args["team-type"]}". Try running without --team-type to see available teams.`
+          );
+        }
         showSummary(`Loaded ${data.length} teams`);
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS7
         };
@@ -2462,48 +4355,276 @@ var init_teams2 = __esm({
   }
 });
 
-// src/cli.ts
-init_errors();
-import { defineCommand as defineCommand8, runMain } from "citty";
-import pc2 from "picocolors";
-var main = defineCommand8({
-  meta: {
-    name: "fitzroy",
-    version: "1.0.2",
-    description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
-  },
-  subCommands: {
-    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)
+// 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 };
+  });
+}
+var DEFAULT_COLUMNS8, teamStatsCommand;
+var init_team_stats2 = __esm({
+  "src/cli/commands/team-stats.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    init_validation2();
+    DEFAULT_COLUMNS8 = [
+      { key: "team", label: "Team", maxWidth: 24 },
+      { key: "gamesPlayed", label: "GP", maxWidth: 5 },
+      { key: "K", label: "K", maxWidth: 6 },
+      { key: "HB", label: "HB", maxWidth: 6 },
+      { key: "D", label: "D", maxWidth: 6 },
+      { key: "M", label: "M", maxWidth: 6 },
+      { key: "G", label: "G", maxWidth: 6 },
+      { key: "B", label: "B", maxWidth: 6 },
+      { key: "T", label: "T", maxWidth: 6 },
+      { key: "I50", label: "I50", maxWidth: 6 }
+    ];
+    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 = validateSeason(args.season);
+        const source = validateSource(args.source);
+        const format = validateFormat(args.format);
+        const summaryType = args.summary;
+        const result = await withSpinner(
+          "Fetching team stats\u2026",
+          () => fetchTeamStats({ 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,
+          full: args.full,
+          columns: DEFAULT_COLUMNS8
+        };
+        console.log(formatOutput(flat, formatOptions));
+      }
+    });
+  }
+});
+
+// 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();
+    init_validation2();
+    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 = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        const season = validateOptionalSeason(args.season) ?? resolveDefaultSeason(competition);
+        const result = await withSpinner(
+          "Fetching player details\u2026",
+          () => fetchPlayerDetails({ source, team: args.team, season, 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,
+          full: args.full,
+          columns: DEFAULT_COLUMNS9
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
+});
+
+// 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();
+    init_validation2();
+    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 = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        const result = await withSpinner(
+          "Fetching coaches votes\u2026",
+          () => fetchCoachesVotes({ season, round, 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,
+          full: args.full,
+          columns: DEFAULT_COLUMNS10
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
   }
 });
+
+// src/cli.ts
+import { defineCommand as defineCommand11, runMain } from "citty";
+
+// src/cli/error-boundary.ts
+init_errors();
+import pc from "picocolors";
 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:")}
+    const issueLines = error.issues.map((i) => `  ${pc.yellow(i.path)}: ${i.message}`);
+    return `${pc.red("Validation error:")}
 ${issueLines.join("\n")}`;
   }
   if (error instanceof AflApiError) {
     const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
-    return `${pc2.red("AFL API error:")} ${error.message}${status}`;
+    return `${pc.red("AFL API error:")} ${error.message}${status}`;
   }
   if (error instanceof ScrapeError) {
     const source = error.source ? ` [${error.source}]` : "";
-    return `${pc2.red("Scrape error:")} ${error.message}${source}`;
+    return `${pc.red("Scrape error:")} ${error.message}${source}`;
   }
   if (error instanceof UnsupportedSourceError) {
-    return `${pc2.red("Unsupported source:")} ${error.message}`;
+    return `${pc.red("Unsupported source:")} ${error.message}`;
   }
   if (error instanceof Error) {
-    return `${pc2.red("Error:")} ${error.message}`;
+    return `${pc.red("Error:")} ${error.message}`;
   }
-  return `${pc2.red("Error:")} ${String(error)}`;
+  return `${pc.red("Error:")} ${String(error)}`;
 }
+
+// src/cli.ts
+var main = defineCommand11({
+  meta: {
+    name: "fitzroy",
+    version: "1.1.1",
+    description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
+  },
+  subCommands: {
+    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)
+  }
+});
 runMain(main).catch((error) => {
   console.error(formatError(error));
   process.exit(1);