fitzroy 1.0.2 → 1.1.0

package/dist/index.js

@@ -36,10 +36,128 @@ function err(error) {
   return { success: false, error };
 }
 
+// src/sources/footywire.ts
+import * as cheerio2 from "cheerio";
+
+// src/lib/date-utils.ts
+function parseAflApiDate(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  return date;
+}
+function parseFootyWireDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/-/g, " ");
+  const match = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (!match) {
+    return null;
+  }
+  const [, dayStr, monthStr, yearStr] = match;
+  if (!dayStr || !monthStr || !yearStr) {
+    return null;
+  }
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const year = Number.parseInt(yearStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function parseAflTablesDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/[-/]/g, " ");
+  const dmy = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (dmy) {
+    const [, dayStr, monthStr, yearStr] = dmy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const mdy = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
+  if (mdy) {
+    const [, monthStr, dayStr, yearStr] = mdy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  return null;
+}
+function toAestString(date) {
+  const formatter = new Intl.DateTimeFormat("en-AU", {
+    timeZone: "Australia/Melbourne",
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZoneName: "short"
+  });
+  return formatter.format(date);
+}
+var 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]
+]);
+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;
+}
+
 // src/lib/team-mapping.ts
 var 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"],
@@ -76,6 +194,26 @@ var TEAM_ALIASES = [
   ["Fitzroy", "Fitzroy Reds", "Fitzroy Gorillas", "Fitzroy Maroons", "FI"],
   ["University", "University Blacks"]
 ];
+var 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"
+]);
 var ALIAS_MAP = (() => {
   const map = /* @__PURE__ */ new Map();
   for (const [canonical, ...aliases] of TEAM_ALIASES) {
@@ -91,1007 +229,2188 @@ function normaliseTeamName(raw) {
   return ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
 }
 
-// src/lib/validation.ts
-import { z } from "zod/v4";
-var AflApiTokenSchema = z.object({
-  token: z.string(),
-  disclaimer: z.string().optional()
-}).passthrough();
-var CompetitionSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  code: z.string().optional()
-}).passthrough();
-var CompetitionListSchema = z.object({
-  competitions: z.array(CompetitionSchema)
-}).passthrough();
-var CompseasonSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  shortName: z.string().optional(),
-  currentRoundNumber: z.number().optional()
-}).passthrough();
-var CompseasonListSchema = z.object({
-  compSeasons: z.array(CompseasonSchema)
-}).passthrough();
-var 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();
-var RoundListSchema = z.object({
-  rounds: z.array(RoundSchema)
-}).passthrough();
-var ScoreSchema = z.object({
-  totalScore: z.number(),
-  goals: z.number(),
-  behinds: z.number(),
-  superGoals: z.number().nullable().optional()
-}).passthrough();
-var PeriodScoreSchema = z.object({
-  periodNumber: z.number(),
-  score: ScoreSchema
-}).passthrough();
-var TeamScoreSchema = z.object({
-  matchScore: ScoreSchema,
-  periodScore: z.array(PeriodScoreSchema).optional(),
-  rushedBehinds: z.number().optional(),
-  minutesInFront: z.number().optional()
-}).passthrough();
-var CfsMatchTeamSchema = z.object({
-  name: z.string(),
-  teamId: z.string(),
-  abbr: z.string().optional(),
-  nickname: z.string().optional()
-}).passthrough();
-var 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();
-var CfsScoreSchema = z.object({
-  status: z.string(),
-  matchId: z.string(),
-  homeTeamScore: TeamScoreSchema,
-  awayTeamScore: TeamScoreSchema
-}).passthrough();
-var CfsVenueSchema = z.object({
-  name: z.string(),
-  venueId: z.string().optional(),
-  state: z.string().optional(),
-  timeZone: z.string().optional()
-}).passthrough();
-var 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();
-var MatchItemListSchema = z.object({
-  roundId: z.string().optional(),
-  items: z.array(MatchItemSchema)
-}).passthrough();
-var 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();
-var 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();
-var 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();
-var PlayerStatsListSchema = z.object({
-  homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
-  awayTeamPlayerStats: z.array(PlayerStatsItemSchema)
-}).passthrough();
-var RosterPlayerSchema = z.object({
-  player: z.object({
-    position: z.string().optional(),
-    player: CfsPlayerInnerSchema
-  }).passthrough(),
-  jumperNumber: z.number().optional()
-}).passthrough();
-var TeamPlayersSchema = z.object({
-  teamId: z.string(),
-  players: z.array(RosterPlayerSchema)
-}).passthrough();
-var MatchRosterSchema = z.object({
-  match: CfsMatchSchema,
-  teamPlayers: z.array(TeamPlayersSchema)
-}).passthrough();
-var TeamItemSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  abbreviation: z.string().optional(),
-  teamType: z.string().optional()
-}).passthrough();
-var TeamListSchema = z.object({
-  teams: z.array(TeamItemSchema)
-}).passthrough();
-var 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();
-var SquadPlayerItemSchema = z.object({
-  player: SquadPlayerInnerSchema,
-  jumperNumber: z.number().optional(),
-  position: z.string().optional()
-}).passthrough();
-var SquadSchema = z.object({
-  team: z.object({
-    name: z.string()
-  }).passthrough().optional(),
-  players: z.array(SquadPlayerItemSchema)
-}).passthrough();
-var SquadListSchema = z.object({
-  squad: SquadSchema
-}).passthrough();
-var WinLossRecordSchema = z.object({
-  wins: z.number(),
-  losses: z.number(),
-  draws: z.number(),
-  played: z.number().optional()
-}).passthrough();
-var LadderEntryRawSchema = z.object({
-  position: z.number(),
-  team: z.object({
-    name: z.string(),
-    id: z.number().optional(),
-    abbreviation: z.string().optional()
-  }).passthrough(),
-  played: z.number().optional(),
-  pointsFor: z.number().optional(),
-  pointsAgainst: z.number().optional(),
-  thisSeasonRecord: z.object({
-    aggregatePoints: z.number().optional(),
-    percentage: z.number().optional(),
-    winLossRecord: WinLossRecordSchema.optional()
-  }).passthrough().optional(),
-  form: z.string().optional()
-}).passthrough();
-var LadderResponseSchema = z.object({
-  ladders: z.array(
-    z.object({
-      entries: z.array(LadderEntryRawSchema)
-    }).passthrough()
-  ),
-  round: z.object({
-    roundNumber: z.number(),
-    name: z.string().optional()
-  }).passthrough().optional()
-}).passthrough();
+// src/transforms/footywire-player-stats.ts
+import * as cheerio from "cheerio";
 
-// src/sources/afl-api.ts
-var TOKEN_URL = "https://api.afl.com.au/cfs/afl/WMCTok";
-var API_BASE = "https://aflapi.afl.com.au/afl/v2";
-var CFS_BASE = "https://api.afl.com.au/cfs/afl";
-var AflApiClient = class {
-  fetchFn;
-  tokenUrl;
-  cachedToken = null;
-  constructor(options) {
-    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
-    this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
-  }
-  /**
-   * Authenticate with the WMCTok token endpoint and cache the token.
-   *
-   * @returns The access token on success, or an error Result.
-   */
-  async authenticate() {
-    try {
-      const response = await this.fetchFn(this.tokenUrl, {
-        method: "POST",
-        headers: { "Content-Length": "0" }
-      });
-      if (!response.ok) {
-        return err(new AflApiError(`Token request failed: ${response.status}`, response.status));
-      }
-      const json = await response.json();
-      const parsed = AflApiTokenSchema.safeParse(json);
-      if (!parsed.success) {
-        return err(new AflApiError("Invalid token response format"));
+// 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;
+}
+
+// src/transforms/footywire-player-stats.ts
+var BASIC_COLS = [
+  "Player",
+  "K",
+  "HB",
+  "D",
+  "M",
+  "G",
+  "B",
+  "T",
+  "HO",
+  "GA",
+  "I50",
+  "CL",
+  "CG",
+  "R50",
+  "FF",
+  "FA",
+  "AF",
+  "SC"
+];
+var ADVANCED_COLS = [
+  "Player",
+  "CP",
+  "UP",
+  "ED",
+  "DE",
+  "CM",
+  "GA",
+  "MI5",
+  "1%",
+  "BO",
+  "CCL",
+  "SCL",
+  "SI",
+  "MG",
+  "TO",
+  "ITC",
+  "T5",
+  "TOG"
+];
+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 ttlMs = 30 * 60 * 1e3;
-      this.cachedToken = {
-        accessToken: parsed.data.token,
-        expiresAt: Date.now() + ttlMs
-      };
-      return ok(parsed.data.token);
-    } catch (cause) {
-      return err(
-        new AflApiError(
-          `Token request failed: ${cause instanceof Error ? cause.message : String(cause)}`
-        )
-      );
     }
-  }
-  /**
-   * Whether the cached token is still valid (not expired).
-   */
-  get isAuthenticated() {
-    return this.cachedToken !== null && Date.now() < this.cachedToken.expiresAt;
-  }
-  /**
-   * Perform an authenticated fetch, automatically adding the bearer token.
-   * Retries once on 401 by re-authenticating.
-   *
-   * @param url - The URL to fetch.
-   * @param init - Additional fetch options.
-   * @returns The Response on success, or an error Result.
-   */
-  async authedFetch(url, init) {
-    if (!this.isAuthenticated) {
-      const authResult = await this.authenticate();
-      if (!authResult.success) {
-        return authResult;
-      }
+    const 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]);
     }
-    const doFetch = async () => {
-      const token = this.cachedToken;
-      if (!token) {
-        throw new AflApiError("No cached token available");
-      }
-      const headers = new Headers(init?.headers);
-      headers.set("x-media-mis-token", token.accessToken);
-      return this.fetchFn(url, { ...init, headers });
-    };
-    try {
-      let response = await doFetch();
-      if (response.status === 401) {
-        const authResult = await this.authenticate();
-        if (!authResult.success) {
-          return authResult;
-        }
-        response = await doFetch();
-      }
-      if (!response.ok) {
-        return err(
-          new AflApiError(
-            `Request failed: ${response.status} ${response.statusText}`,
-            response.status
-          )
-        );
-      }
-      return ok(response);
-    } catch (cause) {
-      return err(
-        new AflApiError(
-          `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
-        )
-      );
+  });
+  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;
+}
+
+// src/transforms/match-results.ts
+var FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
+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
+    };
+  });
+}
+
+// src/sources/footywire.ts
+var FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
+var FootyWireClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
   }
   /**
-   * Fetch JSON from a URL, validate with a Zod schema, and return a typed Result.
+   * Fetch the HTML content of any URL using this client's fetch function.
    *
-   * @param url - The URL to fetch.
-   * @param schema - Zod schema to validate the response against.
-   * @returns Validated data on success, or an error Result.
+   * Public wrapper around the internal fetchHtml for use by external modules
+   * (e.g. awards) that need to scrape FootyWire pages.
    */
-  async fetchJson(url, schema) {
-    const isPublic = url.startsWith(API_BASE);
-    let response;
-    if (isPublic) {
-      try {
-        response = await this.fetchFn(url);
-        if (!response.ok) {
-          return err(
-            new AflApiError(
-              `Request failed: ${response.status} ${response.statusText}`,
-              response.status
-            )
-          );
-        }
-      } catch (cause) {
-        return err(
-          new AflApiError(
-            `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
-          )
-        );
-      }
-    } else {
-      const fetchResult = await this.authedFetch(url);
-      if (!fetchResult.success) {
-        return fetchResult;
-      }
-      response = fetchResult.data;
-    }
+  async fetchPage(url) {
+    return this.fetchHtml(url);
+  }
+  /**
+   * Fetch the HTML content of a FootyWire page.
+   */
+  async fetchHtml(url) {
     try {
-      const json = await response.json();
-      const parsed = schema.safeParse(json);
-      if (!parsed.success) {
+      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 ValidationError("Response validation failed", [
-            { path: url, message: String(parsed.error) }
-          ])
+          new ScrapeError(`FootyWire request failed: ${response.status} (${url})`, "footywire")
         );
       }
-      return ok(parsed.data);
+      const html = await response.text();
+      return ok(html);
     } catch (cause) {
       return err(
-        new AflApiError(
-          `JSON parse failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        new ScrapeError(
+          `FootyWire request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "footywire"
         )
       );
     }
   }
   /**
-   * Resolve a competition code (e.g. "AFLM") to its API competition ID.
+   * Fetch season match results from FootyWire.
    *
-   * @param code - The competition code to resolve.
-   * @returns The competition ID string on success.
+   * @param year - The season year.
+   * @returns Array of match results.
    */
-  async resolveCompetitionId(code) {
-    const result = await this.fetchJson(
-      `${API_BASE}/competitions?pageSize=50`,
-      CompetitionListSchema
-    );
-    if (!result.success) {
-      return result;
+  async fetchSeasonResults(year) {
+    const url = `${FOOTYWIRE_BASE}/ft_match_list?year=${year}`;
+    const htmlResult = await this.fetchHtml(url);
+    if (!htmlResult.success) {
+      return htmlResult;
     }
-    const apiCode = code === "AFLM" ? "AFL" : code;
-    const competition = result.data.competitions.find((c) => c.code === apiCode);
-    if (!competition) {
-      return err(new AflApiError(`Competition not found for code: ${code}`));
+    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"
+        )
+      );
     }
-    return ok(competition.id);
   }
   /**
-   * Resolve a season (compseason) ID from a competition ID and year.
+   * Fetch player statistics for a single match.
    *
-   * @param competitionId - The competition ID (from {@link resolveCompetitionId}).
-   * @param year - The season year (e.g. 2024).
-   * @returns The compseason ID string on success.
+   * 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 resolveSeasonId(competitionId, year) {
-    const result = await this.fetchJson(
-      `${API_BASE}/competitions/${competitionId}/compseasons?pageSize=100`,
-      CompseasonListSchema
-    );
-    if (!result.success) {
-      return result;
-    }
-    const yearStr = String(year);
-    const season = result.data.compSeasons.find((cs) => cs.name.includes(yearStr));
-    if (!season) {
-      return err(new AflApiError(`Season not found for year: ${year}`));
+  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"
+        )
+      );
     }
-    return ok(season.id);
   }
   /**
-   * Resolve a season ID from a competition code and year in one step.
+   * Fetch match IDs from a season's match list page.
    *
-   * @param code - The competition code (e.g. "AFLM").
-   * @param year - The season year (e.g. 2025).
-   * @returns The compseason ID on success.
+   * Extracts `mid=XXXX` values from score links.
+   *
+   * @param year - The season year.
+   * @returns Array of match ID strings.
    */
-  async resolveCompSeason(code, year) {
-    const compResult = await this.resolveCompetitionId(code);
-    if (!compResult.success) return compResult;
-    return this.resolveSeasonId(compResult.data, year);
+  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 all rounds for a season with their metadata.
+   * Fetch player list (team history) from FootyWire.
    *
-   * @param seasonId - The compseason ID (from {@link resolveSeasonId}).
-   * @returns Array of round objects on success.
+   * 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 resolveRounds(seasonId) {
-    const result = await this.fetchJson(
-      `${API_BASE}/compseasons/${seasonId}/rounds?pageSize=50`,
-      RoundListSchema
-    );
-    if (!result.success) {
-      return result;
+  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"
+        )
+      );
     }
-    return ok(result.data.rounds);
   }
   /**
-   * Fetch match items for a round using the /cfs/ endpoint.
+   * Fetch fixture data from FootyWire.
    *
-   * @param roundProviderId - The round provider ID (e.g. "CD_R202501401").
-   * @returns Array of match items on success.
+   * Parses the match list page to extract scheduled matches with dates and venues.
+   *
+   * @param year - The season year.
+   * @returns Array of fixture entries.
    */
-  async fetchRoundMatchItems(roundProviderId) {
-    const result = await this.fetchJson(
-      `${CFS_BASE}/matchItems/round/${roundProviderId}`,
-      MatchItemListSchema
-    );
-    if (!result.success) {
-      return result;
+  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"
+        )
+      );
     }
-    return ok(result.data.items);
   }
   /**
-   * Fetch match items for a round by resolving the round provider ID from season and round number.
+   * Fetch team statistics from FootyWire.
    *
-   * @param seasonId - The compseason ID.
-   * @param roundNumber - The round number.
-   * @returns Array of match items on success.
+   * 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 fetchRoundMatchItemsByNumber(seasonId, roundNumber) {
-    const roundsResult = await this.resolveRounds(seasonId);
-    if (!roundsResult.success) {
-      return roundsResult;
+  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"
+        )
+      );
     }
-    const round = roundsResult.data.find((r) => r.roundNumber === roundNumber);
-    if (!round?.providerId) {
-      return err(new AflApiError(`Round not found or missing providerId: round ${roundNumber}`));
+  }
+};
+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;
     }
-    return this.fetchRoundMatchItems(round.providerId);
+    const cells = $(row).find("td.data");
+    if (cells.length < 5) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    const attendance = $(cells[3]).text().trim();
+    const scoreCell = $(cells[4]);
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const scoreText = scoreCell.text().trim();
+    const scoreMatch = /(\d+)-(\d+)/.exec(scoreText);
+    if (!scoreMatch) return;
+    const homePoints = Number.parseInt(scoreMatch[1] ?? "0", 10);
+    const awayPoints = Number.parseInt(scoreMatch[2] ?? "0", 10);
+    const scoreLink = scoreCell.find("a").attr("href") ?? "";
+    const midMatch = /mid=(\d+)/.exec(scoreLink);
+    const matchId = midMatch?.[1] ? `FW_${midMatch[1]}` : `FW_${year}_R${currentRound}_${homeTeam}`;
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const homeGoals = Math.floor(homePoints / 6);
+    const homeBehinds = homePoints - homeGoals * 6;
+    const awayGoals = Math.floor(awayPoints / 6);
+    const awayBehinds = awayPoints - awayGoals * 6;
+    results.push({
+      matchId,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals,
+      homeBehinds,
+      homePoints,
+      awayGoals,
+      awayBehinds,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
+      status: "Complete",
+      attendance: attendance ? Number.parseInt(attendance, 10) || null : null,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "footywire",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+function parseFixtureList(html, year) {
+  const $ = cheerio2.load(html);
+  const fixtures = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  let gameNumber = 0;
+  $("tr").each((_i, row) => {
+    const roundHeader = $(row).find("td[colspan='7']");
+    if (roundHeader.length > 0) {
+      const text = roundHeader.text().trim();
+      currentRoundType = inferRoundType(text);
+      const roundMatch = /Round\s+(\d+)/i.exec(text);
+      if (roundMatch?.[1]) {
+        currentRound = Number.parseInt(roundMatch[1], 10);
+      }
+      return;
+    }
+    const cells = $(row).find("td.data");
+    if (cells.length < 3) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    gameNumber++;
+    const scoreCell = cells.length >= 5 ? $(cells[4]) : null;
+    const scoreText = scoreCell?.text().trim() ?? "";
+    const hasScore = /\d+-\d+/.test(scoreText);
+    fixtures.push({
+      matchId: `FW_${year}_R${currentRound}_G${gameNumber}`,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      status: hasScore ? "Complete" : "Upcoming",
+      competition: "AFLM"
+    });
+  });
+  return fixtures;
+}
+function parseFootyWireTeamStats(html, year, suffix) {
+  const $ = cheerio2.load(html);
+  const entries = [];
+  const tables = $("table");
+  const mainTable = tables.length > 10 ? $(tables[10]) : $("table.sortable").first();
+  if (mainTable.length === 0) return entries;
+  const STAT_KEYS = [
+    "K",
+    "HB",
+    "D",
+    "M",
+    "G",
+    "GA",
+    "I50",
+    "BH",
+    "T",
+    "HO",
+    "FF",
+    "FA",
+    "CL",
+    "CG",
+    "R50",
+    "AF",
+    "SC"
+  ];
+  const rows = mainTable.find("tr");
+  rows.each((rowIdx, row) => {
+    if (rowIdx === 0) return;
+    const cells = $(row).find("td");
+    if (cells.length < 20) return;
+    const teamLink = $(cells[1]).find("a");
+    const teamText = teamLink.length > 0 ? teamLink.text().trim() : $(cells[1]).text().trim();
+    const teamName = normaliseTeamName(teamText);
+    if (!teamName) return;
+    const parseNum = (cell) => Number.parseFloat(cell.text().trim()) || 0;
+    const gamesPlayed = parseNum($(cells[2]));
+    const stats = {};
+    for (let i = 0; i < STAT_KEYS.length; i++) {
+      const key = suffix === "against" ? `${STAT_KEYS[i]}_against` : STAT_KEYS[i];
+      stats[key] = parseNum($(cells[i + 3]));
+    }
+    entries.push({
+      season: year,
+      team: teamName,
+      gamesPlayed,
+      stats,
+      source: "footywire"
+    });
+  });
+  return entries;
+}
+function mergeTeamAndOppStats(teamStats, oppStats) {
+  const oppMap = /* @__PURE__ */ new Map();
+  for (const entry of oppStats) {
+    oppMap.set(entry.team, entry.stats);
+  }
+  return teamStats.map((entry) => {
+    const opp = oppMap.get(entry.team);
+    if (!opp) return entry;
+    return {
+      ...entry,
+      stats: { ...entry.stats, ...opp }
+    };
+  });
+}
+var 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"]
+]);
+function teamNameToFootyWireSlug(teamName) {
+  return FOOTYWIRE_SLUG_MAP.get(teamName);
+}
+function parseFootyWirePlayerList(html, teamName) {
+  const $ = cheerio2.load(html);
+  const players = [];
+  let dataRows = null;
+  $("table").each((_i, table) => {
+    const firstRow = $(table).find("tr").first();
+    const cells = firstRow.find("td, th");
+    const cellTexts = cells.map((_j, c) => $(c).text().trim()).get();
+    if (cellTexts.includes("Age") && cellTexts.includes("Name")) {
+      dataRows = $(table).find("tr");
+      return false;
+    }
+  });
+  if (!dataRows) return players;
+  dataRows.each((_rowIdx, row) => {
+    const cells = $(row).find("td");
+    if (cells.length < 6) return;
+    const jumperText = $(cells[0]).text().trim();
+    const nameText = $(cells[1]).text().trim();
+    const gamesText = $(cells[2]).text().trim();
+    const dobText = cells.length > 4 ? $(cells[4]).text().trim() : "";
+    const heightText = cells.length > 5 ? $(cells[5]).text().trim() : "";
+    const origin = cells.length > 6 ? $(cells[6]).text().trim() : "";
+    const position = cells.length > 7 ? $(cells[7]).text().trim() : "";
+    const cleanedName = nameText.replace(/\nR$/, "").trim();
+    if (!cleanedName || cleanedName === "Name") return;
+    const nameParts = cleanedName.split(",").map((s) => s.trim());
+    const surname = nameParts[0] ?? "";
+    const givenName = nameParts[1] ?? "";
+    const jumperNumber = jumperText ? Number.parseInt(jumperText, 10) || null : null;
+    const gamesPlayed = gamesText ? Number.parseInt(gamesText, 10) || null : null;
+    const heightMatch = /(\d+)cm/.exec(heightText);
+    const heightCm = heightMatch?.[1] ? Number.parseInt(heightMatch[1], 10) || null : null;
+    players.push({
+      playerId: `FW_${teamName}_${surname}_${givenName}`.replace(/\s+/g, "_"),
+      givenName,
+      surname,
+      displayName: givenName ? `${givenName} ${surname}` : surname,
+      team: teamName,
+      jumperNumber,
+      position: position || null,
+      dateOfBirth: dobText || null,
+      heightCm,
+      weightKg: null,
+      gamesPlayed,
+      goals: null,
+      draftYear: null,
+      draftPosition: null,
+      draftType: null,
+      debutYear: null,
+      recruitedFrom: origin || null
+    });
+  });
+  return players;
+}
+
+// src/transforms/awards.ts
+import * as cheerio3 from "cheerio";
+function parseBrownlowVotes(html, season) {
+  const $ = cheerio3.load(html);
+  const results = [];
+  $("table").each((_i, table) => {
+    const rows = $(table).find("tr");
+    if (rows.length < 5) return;
+    const firstDataRow = $(rows[1]);
+    const cells = firstDataRow.find("td");
+    if (cells.length !== 9) return;
+    const headerRow = $(rows[0]);
+    const headerCells = headerRow.find("td, th");
+    const firstHeader = headerCells.first().text().trim().toLowerCase();
+    const startIdx = firstHeader === "player" || firstHeader === "" ? 1 : 0;
+    rows.each((j, row) => {
+      if (j < startIdx) return;
+      const tds = $(row).find("td");
+      if (tds.length < 9) return;
+      const player = $(tds[0]).text().trim();
+      const team = $(tds[1]).text().trim();
+      if (!player || player.toLowerCase() === "player") return;
+      const votes3 = safeInt($(tds[2]).text()) ?? 0;
+      const votes2 = safeInt($(tds[3]).text()) ?? 0;
+      const votes1 = safeInt($(tds[4]).text()) ?? 0;
+      const gamesPolled = safeInt($(tds[6]).text());
+      results.push({
+        type: "brownlow",
+        season,
+        player,
+        team,
+        votes: votes3 * 3 + votes2 * 2 + votes1,
+        votes3,
+        votes2,
+        votes1,
+        gamesPolled
+      });
+    });
+  });
+  return results;
+}
+function parseAllAustralian(html, season) {
+  const $ = cheerio3.load(html);
+  const results = [];
+  const rows = $("tr");
+  rows.each((_i, row) => {
+    const tds = $(row).find("td");
+    if (tds.length < 2) return;
+    const position = $(tds[0]).text().trim();
+    if (!position) return;
+    const validPositions = ["FB", "HB", "C", "HF", "FF", "FOL", "IC", "EMG"];
+    if (!validPositions.includes(position)) return;
+    tds.each((cellIdx, cell) => {
+      if (cellIdx === 0) return;
+      const playerLink = $(cell).find("a");
+      const playerName = playerLink.text().trim();
+      const teamSpan = $(cell).find("span.playerflag");
+      const team = teamSpan.text().trim();
+      if (playerName && team) {
+        results.push({
+          type: "all-australian",
+          season,
+          position,
+          player: playerName,
+          team
+        });
+      }
+    });
+  });
+  return results;
+}
+function parseRisingStarNominations(html, season) {
+  const $ = cheerio3.load(html);
+  const results = [];
+  const tables = $("table");
+  let targetRows = null;
+  tables.each((_i, table) => {
+    const rows = $(table).find("tr");
+    if (rows.length < 5) return;
+    const firstRow = $(rows[0]);
+    const headerCells = firstRow.find("td, th").map((_, c) => $(c).text().trim()).get();
+    if (headerCells.length >= 15 && (headerCells[0]?.toLowerCase().includes("round") || headerCells[0]?.toLowerCase().includes("rnd"))) {
+      targetRows = rows;
+      return false;
+    }
+  });
+  if (!targetRows) return results;
+  targetRows.each((_j, row) => {
+    if (_j === 0) return;
+    const tds = $(row).find("td");
+    if (tds.length < 15) return;
+    const roundText = $(tds[0]).text().trim();
+    const round = safeInt(roundText);
+    if (round == null) return;
+    const player = $(tds[1]).text().trim();
+    const team = $(tds[2]).text().trim();
+    const opponent = $(tds[3]).text().trim();
+    if (!player || player.toLowerCase() === "name") return;
+    results.push({
+      type: "rising-star",
+      season,
+      round,
+      player,
+      team,
+      opponent,
+      kicks: safeInt($(tds[4]).text()),
+      handballs: safeInt($(tds[5]).text()),
+      disposals: safeInt($(tds[6]).text()),
+      marks: safeInt($(tds[7]).text()),
+      goals: safeInt($(tds[8]).text()),
+      behinds: safeInt($(tds[9]).text()),
+      tackles: safeInt($(tds[10]).text())
+    });
+  });
+  return results;
+}
+
+// src/api/awards.ts
+var FOOTYWIRE_BASE2 = "https://www.footywire.com/afl/footy";
+async function fetchAwards(query) {
+  const client = new FootyWireClient();
+  switch (query.award) {
+    case "brownlow": {
+      const url = `${FOOTYWIRE_BASE2}/brownlow_medal?year=${query.season}`;
+      const htmlResult = await client.fetchPage(url);
+      if (!htmlResult.success) return htmlResult;
+      const votes = parseBrownlowVotes(htmlResult.data, query.season);
+      if (votes.length === 0) {
+        return err(
+          new ScrapeError(`No Brownlow data found for season ${query.season}`, "footywire")
+        );
+      }
+      return ok(votes);
+    }
+    case "all-australian": {
+      const url = `${FOOTYWIRE_BASE2}/all_australian_selection?year=${query.season}`;
+      const htmlResult = await client.fetchPage(url);
+      if (!htmlResult.success) return htmlResult;
+      const selections = parseAllAustralian(htmlResult.data, query.season);
+      if (selections.length === 0) {
+        return err(
+          new ScrapeError(`No All-Australian data found for season ${query.season}`, "footywire")
+        );
+      }
+      return ok(selections);
+    }
+    case "rising-star": {
+      const url = `${FOOTYWIRE_BASE2}/rising_star_nominations?year=${query.season}`;
+      const htmlResult = await client.fetchPage(url);
+      if (!htmlResult.success) return htmlResult;
+      const nominations = parseRisingStarNominations(htmlResult.data, query.season);
+      if (nominations.length === 0) {
+        return err(
+          new ScrapeError(`No Rising Star data found for season ${query.season}`, "footywire")
+        );
+      }
+      return ok(nominations);
+    }
+    default:
+      return err(new ScrapeError(`Unknown award type: ${query.award}`, "footywire"));
+  }
+}
+
+// src/sources/afl-coaches.ts
+import * as cheerio4 from "cheerio";
+var AflCoachesClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
   }
   /**
-   * Fetch match items for all completed rounds in a season.
-   *
-   * @param seasonId - The compseason ID.
-   * @returns Aggregated array of match items from all completed rounds.
+   * Fetch the HTML content of an AFLCA page.
    */
-  async fetchSeasonMatchItems(seasonId) {
-    const roundsResult = await this.resolveRounds(seasonId);
-    if (!roundsResult.success) {
-      return roundsResult;
-    }
-    const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
-    const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
-    const allItems = [];
-    for (const result of results) {
-      if (!result.success) {
-        return result;
+  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 concluded = result.data.filter(
-        (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
+      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"
+        )
       );
-      allItems.push(...concluded);
     }
-    return ok(allItems);
   }
   /**
-   * Fetch per-player statistics for a match.
+   * Build the AFLCA leaderboard URL for a given season, round, and competition.
    *
-   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
-   * @returns Player stats list with home and away arrays.
+   * 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.
    */
-  async fetchPlayerStats(matchProviderId) {
-    return this.fetchJson(
-      `${CFS_BASE}/playerStats/match/${matchProviderId}`,
-      PlayerStatsListSchema
-    );
+  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}`;
   }
   /**
-   * Fetch match roster (lineup) for a match.
+   * Scrape coaches votes for a single round.
    *
-   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
-   * @returns Match roster with team players.
+   * @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 fetchMatchRoster(matchProviderId) {
-    return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
+  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);
+  }
+};
+function parseCoachesVotesHtml(html, season, roundNumber) {
+  const $ = cheerio4.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;
+}
+
+// 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);
+}
+
+// src/lib/validation.ts
+import { z } from "zod/v4";
+var AflApiTokenSchema = z.object({
+  token: z.string(),
+  disclaimer: z.string().optional()
+}).passthrough();
+var CompetitionSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  code: z.string().optional()
+}).passthrough();
+var CompetitionListSchema = z.object({
+  competitions: z.array(CompetitionSchema)
+}).passthrough();
+var CompseasonSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  shortName: z.string().optional(),
+  currentRoundNumber: z.number().optional()
+}).passthrough();
+var CompseasonListSchema = z.object({
+  compSeasons: z.array(CompseasonSchema)
+}).passthrough();
+var 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();
+var RoundListSchema = z.object({
+  rounds: z.array(RoundSchema)
+}).passthrough();
+var ScoreSchema = z.object({
+  totalScore: z.number(),
+  goals: z.number(),
+  behinds: z.number(),
+  superGoals: z.number().nullable().optional()
+}).passthrough();
+var PeriodScoreSchema = z.object({
+  periodNumber: z.number(),
+  score: ScoreSchema
+}).passthrough();
+var TeamScoreSchema = z.object({
+  matchScore: ScoreSchema,
+  periodScore: z.array(PeriodScoreSchema).optional(),
+  rushedBehinds: z.number().optional(),
+  minutesInFront: z.number().optional()
+}).passthrough();
+var CfsMatchTeamSchema = z.object({
+  name: z.string(),
+  teamId: z.string(),
+  abbr: z.string().optional(),
+  nickname: z.string().optional()
+}).passthrough();
+var 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();
+var CfsScoreSchema = z.object({
+  status: z.string(),
+  matchId: z.string(),
+  homeTeamScore: TeamScoreSchema,
+  awayTeamScore: TeamScoreSchema
+}).passthrough();
+var CfsVenueSchema = z.object({
+  name: z.string(),
+  venueId: z.string().optional(),
+  state: z.string().optional(),
+  timeZone: z.string().optional()
+}).passthrough();
+var 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();
+var MatchItemListSchema = z.object({
+  roundId: z.string().optional(),
+  items: z.array(MatchItemSchema)
+}).passthrough();
+var 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();
+var 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();
+var 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();
+var PlayerStatsListSchema = z.object({
+  homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
+  awayTeamPlayerStats: z.array(PlayerStatsItemSchema)
+}).passthrough();
+var RosterPlayerSchema = z.object({
+  player: z.object({
+    position: z.string().optional(),
+    player: CfsPlayerInnerSchema
+  }).passthrough(),
+  jumperNumber: z.number().optional()
+}).passthrough();
+var TeamPlayersSchema = z.object({
+  teamId: z.string(),
+  players: z.array(RosterPlayerSchema)
+}).passthrough();
+var MatchRosterSchema = z.object({
+  match: CfsMatchSchema,
+  teamPlayers: z.array(TeamPlayersSchema)
+}).passthrough();
+var TeamItemSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  abbreviation: z.string().optional(),
+  teamType: z.string().optional()
+}).passthrough();
+var TeamListSchema = z.object({
+  teams: z.array(TeamItemSchema)
+}).passthrough();
+var 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();
+var SquadPlayerItemSchema = z.object({
+  player: SquadPlayerInnerSchema,
+  jumperNumber: z.number().optional(),
+  position: z.string().optional()
+}).passthrough();
+var SquadSchema = z.object({
+  team: z.object({
+    name: z.string()
+  }).passthrough().optional(),
+  players: z.array(SquadPlayerItemSchema)
+}).passthrough();
+var SquadListSchema = z.object({
+  squad: SquadSchema
+}).passthrough();
+var WinLossRecordSchema = z.object({
+  wins: z.number(),
+  losses: z.number(),
+  draws: z.number(),
+  played: z.number().optional()
+}).passthrough();
+var LadderEntryRawSchema = z.object({
+  position: z.number(),
+  team: z.object({
+    name: z.string(),
+    id: z.number().optional(),
+    abbreviation: z.string().optional()
+  }).passthrough(),
+  played: z.number().optional(),
+  pointsFor: z.number().optional(),
+  pointsAgainst: z.number().optional(),
+  thisSeasonRecord: z.object({
+    aggregatePoints: z.number().optional(),
+    percentage: z.number().optional(),
+    winLossRecord: WinLossRecordSchema.optional()
+  }).passthrough().optional(),
+  form: z.string().optional()
+}).passthrough();
+var LadderResponseSchema = z.object({
+  ladders: z.array(
+    z.object({
+      entries: z.array(LadderEntryRawSchema)
+    }).passthrough()
+  ),
+  round: z.object({
+    roundNumber: z.number(),
+    name: z.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+
+// src/sources/afl-api.ts
+var TOKEN_URL = "https://api.afl.com.au/cfs/afl/WMCTok";
+var API_BASE = "https://aflapi.afl.com.au/afl/v2";
+var CFS_BASE = "https://api.afl.com.au/cfs/afl";
+var AflApiClient = class {
+  fetchFn;
+  tokenUrl;
+  cachedToken = null;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+    this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
   }
   /**
-   * Fetch team list, optionally filtered by team type.
+   * Authenticate with the WMCTok token endpoint and cache the token.
    *
-   * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
-   * @returns Array of team items.
+   * @returns The access token on success, or an error Result.
    */
-  async fetchTeams(teamType) {
-    const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
-    if (!result.success) {
-      return result;
-    }
-    if (teamType) {
-      return ok(result.data.teams.filter((t) => t.teamType === teamType));
+  async authenticate() {
+    try {
+      const response = await this.fetchFn(this.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Length": "0" }
+      });
+      if (!response.ok) {
+        return err(new AflApiError(`Token request failed: ${response.status}`, response.status));
+      }
+      const json = await response.json();
+      const parsed = AflApiTokenSchema.safeParse(json);
+      if (!parsed.success) {
+        return err(new AflApiError("Invalid token response format"));
+      }
+      const ttlMs = 30 * 60 * 1e3;
+      this.cachedToken = {
+        accessToken: parsed.data.token,
+        expiresAt: Date.now() + ttlMs
+      };
+      return ok(parsed.data.token);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `Token request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
     }
-    return ok(result.data.teams);
   }
   /**
-   * Fetch squad (roster) for a team in a specific season.
-   *
-   * @param teamId - The numeric team ID.
-   * @param compSeasonId - The compseason ID.
-   * @returns Squad list response.
+   * Whether the cached token is still valid (not expired).
    */
-  async fetchSquad(teamId, compSeasonId) {
-    return this.fetchJson(
-      `${API_BASE}/squads?teamId=${teamId}&compSeasonId=${compSeasonId}`,
-      SquadListSchema
-    );
+  get isAuthenticated() {
+    return this.cachedToken !== null && Date.now() < this.cachedToken.expiresAt;
   }
   /**
-   * Fetch ladder standings for a season (optionally for a specific round).
+   * Perform an authenticated fetch, automatically adding the bearer token.
+   * Retries once on 401 by re-authenticating.
    *
-   * @param seasonId - The compseason ID.
-   * @param roundId - Optional round ID (numeric `id`, not `providerId`).
-   * @returns Ladder response with entries.
+   * @param url - The URL to fetch.
+   * @param init - Additional fetch options.
+   * @returns The Response on success, or an error Result.
    */
-  async fetchLadder(seasonId, roundId) {
-    let url = `${API_BASE}/compseasons/${seasonId}/ladders`;
-    if (roundId != null) {
-      url += `?roundId=${roundId}`;
+  async authedFetch(url, init) {
+    if (!this.isAuthenticated) {
+      const authResult = await this.authenticate();
+      if (!authResult.success) {
+        return authResult;
+      }
     }
-    return this.fetchJson(url, LadderResponseSchema);
-  }
-};
-
-// src/transforms/match-results.ts
-var FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
-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
+    const doFetch = async () => {
+      const token = this.cachedToken;
+      if (!token) {
+        throw new AflApiError("No cached token available");
+      }
+      const headers = new Headers(init?.headers);
+      headers.set("x-media-mis-token", token.accessToken);
+      return this.fetchFn(url, { ...init, headers });
     };
-  });
-}
-
-// src/api/fixture.ts
-function toFixture(item, season, fallbackRoundNumber, competition) {
-  return {
-    matchId: item.match.matchId,
-    season,
-    roundNumber: item.round?.roundNumber ?? fallbackRoundNumber,
-    roundType: inferRoundType(item.round?.name ?? ""),
-    date: new Date(item.match.utcStartTime),
-    venue: item.venue?.name ?? "",
-    homeTeam: normaliseTeamName(item.match.homeTeam.name),
-    awayTeam: normaliseTeamName(item.match.awayTeam.name),
-    status: toMatchStatus(item.match.status),
-    competition
-  };
-}
-async function fetchFixture(query) {
-  const competition = query.competition ?? "AFLM";
-  if (query.source !== "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)));
+    try {
+      let response = await doFetch();
+      if (response.status === 401) {
+        const authResult = await this.authenticate();
+        if (!authResult.success) {
+          return authResult;
+        }
+        response = await doFetch();
+      }
+      if (!response.ok) {
+        return err(
+          new AflApiError(
+            `Request failed: ${response.status} ${response.statusText}`,
+            response.status
+          )
+        );
+      }
+      return ok(response);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
+    }
   }
-  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));
+  /**
+   * Fetch JSON from a URL, validate with a Zod schema, and return a typed Result.
+   *
+   * @param url - The URL to fetch.
+   * @param schema - Zod schema to validate the response against.
+   * @returns Validated data on success, or an error Result.
+   */
+  async fetchJson(url, schema) {
+    const isPublic = url.startsWith(API_BASE);
+    let response;
+    if (isPublic) {
+      try {
+        response = await this.fetchFn(url);
+        if (!response.ok) {
+          return err(
+            new AflApiError(
+              `Request failed: ${response.status} ${response.statusText}`,
+              response.status
+            )
+          );
+        }
+      } catch (cause) {
+        return err(
+          new AflApiError(
+            `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+          )
+        );
+      }
+    } else {
+      const fetchResult = await this.authedFetch(url);
+      if (!fetchResult.success) {
+        return fetchResult;
+      }
+      response = fetchResult.data;
+    }
+    try {
+      const json = await response.json();
+      const parsed = schema.safeParse(json);
+      if (!parsed.success) {
+        return err(
+          new ValidationError("Response validation failed", [
+            { path: url, message: String(parsed.error) }
+          ])
+        );
+      }
+      return ok(parsed.data);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `JSON parse failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
     }
   }
-  return ok(fixtures);
-}
-
-// 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
-    };
-  });
-}
-
-// 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
-      )
+  /**
+   * Resolve a competition code (e.g. "AFLM") to its API competition ID.
+   *
+   * @param code - The competition code to resolve.
+   * @returns The competition ID string on success.
+   */
+  async resolveCompetitionId(code) {
+    const result = await this.fetchJson(
+      `${API_BASE}/competitions?pageSize=50`,
+      CompetitionListSchema
     );
-  }
-  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 (!result.success) {
+      return result;
+    }
+    const apiCode = code === "AFLM" ? "AFL" : code;
+    const competition = result.data.competitions.find((c) => c.code === apiCode);
+    if (!competition) {
+      return err(new AflApiError(`Competition not found for code: ${code}`));
     }
+    return ok(competition.id);
   }
-  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
-  });
-}
-
-// src/transforms/lineup.ts
-var EMERGENCY_POSITIONS = /* @__PURE__ */ new Set(["EMG", "EMERG"]);
-var SUBSTITUTE_POSITIONS = /* @__PURE__ */ new Set(["SUB", "INT"]);
-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
-  };
-}
-
-// 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
-      )
+  /**
+   * Resolve a season (compseason) ID from a competition ID and year.
+   *
+   * @param competitionId - The competition ID (from {@link resolveCompetitionId}).
+   * @param year - The season year (e.g. 2024).
+   * @returns The compseason ID string on success.
+   */
+  async resolveSeasonId(competitionId, year) {
+    const result = await this.fetchJson(
+      `${API_BASE}/competitions/${competitionId}/compseasons?pageSize=100`,
+      CompseasonListSchema
     );
+    if (!result.success) {
+      return result;
+    }
+    const yearStr = String(year);
+    const season = result.data.compSeasons.find((cs) => cs.name.includes(yearStr));
+    if (!season) {
+      return err(new AflApiError(`Season not found for year: ${year}`));
+    }
+    return ok(season.id);
   }
-  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)]);
+  /**
+   * Resolve a season ID from a competition code and year in one step.
+   *
+   * @param code - The competition code (e.g. "AFLM").
+   * @param year - The season year (e.g. 2025).
+   * @returns The compseason ID on success.
+   */
+  async resolveCompSeason(code, year) {
+    const compResult = await this.resolveCompetitionId(code);
+    if (!compResult.success) return compResult;
+    return this.resolveSeasonId(compResult.data, year);
   }
-  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}`));
+  /**
+   * Fetch all rounds for a season with their metadata.
+   *
+   * @param seasonId - The compseason ID (from {@link resolveSeasonId}).
+   * @returns Array of round objects on success.
+   */
+  async resolveRounds(seasonId) {
+    const result = await this.fetchJson(
+      `${API_BASE}/compseasons/${seasonId}/rounds?pageSize=50`,
+      RoundListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data.rounds);
+  }
+  /**
+   * Fetch match items for a round using the /cfs/ endpoint.
+   *
+   * @param roundProviderId - The round provider ID (e.g. "CD_R202501401").
+   * @returns Array of match items on success.
+   */
+  async fetchRoundMatchItems(roundProviderId) {
+    const result = await this.fetchJson(
+      `${CFS_BASE}/matchItems/round/${roundProviderId}`,
+      MatchItemListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data.items);
   }
-  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));
+  /**
+   * Fetch match items for a round by resolving the round provider ID from season and round number.
+   *
+   * @param seasonId - The compseason ID.
+   * @param roundNumber - The round number.
+   * @returns Array of match items on success.
+   */
+  async fetchRoundMatchItemsByNumber(seasonId, roundNumber) {
+    const roundsResult = await this.resolveRounds(seasonId);
+    if (!roundsResult.success) {
+      return roundsResult;
+    }
+    const round = roundsResult.data.find((r) => r.roundNumber === roundNumber);
+    if (!round?.providerId) {
+      return err(new AflApiError(`Round not found or missing providerId: round ${roundNumber}`));
+    }
+    return this.fetchRoundMatchItems(round.providerId);
   }
-  return ok(lineups);
-}
-
-// src/sources/afl-tables.ts
-import * as cheerio from "cheerio";
-
-// src/lib/date-utils.ts
-function parseAflApiDate(iso) {
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) {
-    return null;
+  /**
+   * Fetch match items for all completed rounds in a season.
+   *
+   * @param seasonId - The compseason ID.
+   * @returns Aggregated array of match items from all completed rounds.
+   */
+  async fetchSeasonMatchItems(seasonId) {
+    const roundsResult = await this.resolveRounds(seasonId);
+    if (!roundsResult.success) {
+      return roundsResult;
+    }
+    const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
+    const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+    const allItems = [];
+    for (const result of results) {
+      if (!result.success) {
+        return result;
+      }
+      const concluded = result.data.filter(
+        (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
+      );
+      allItems.push(...concluded);
+    }
+    return ok(allItems);
   }
-  return date;
-}
-function parseFootyWireDate(dateStr) {
-  const trimmed = dateStr.trim();
-  if (trimmed === "") {
-    return null;
+  /**
+   * Fetch per-player statistics for a match.
+   *
+   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+   * @returns Player stats list with home and away arrays.
+   */
+  async fetchPlayerStats(matchProviderId) {
+    return this.fetchJson(
+      `${CFS_BASE}/playerStats/match/${matchProviderId}`,
+      PlayerStatsListSchema
+    );
   }
-  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;
+  /**
+   * Fetch match roster (lineup) for a match.
+   *
+   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+   * @returns Match roster with team players.
+   */
+  async fetchMatchRoster(matchProviderId) {
+    return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
   }
-  const [, dayStr, monthStr, yearStr] = match;
-  if (!dayStr || !monthStr || !yearStr) {
-    return null;
+  /**
+   * Fetch team list, optionally filtered by team type.
+   *
+   * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
+   * @returns Array of team items.
+   */
+  async fetchTeams(teamType) {
+    const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
+    if (!result.success) {
+      return result;
+    }
+    if (teamType) {
+      return ok(result.data.teams.filter((t) => t.teamType === teamType));
+    }
+    return ok(result.data.teams);
   }
-  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
-  if (monthIndex === void 0) {
-    return null;
+  /**
+   * Fetch squad (roster) for a team in a specific season.
+   *
+   * @param teamId - The numeric team ID.
+   * @param compSeasonId - The compseason ID.
+   * @returns Squad list response.
+   */
+  async fetchSquad(teamId, compSeasonId) {
+    return this.fetchJson(
+      `${API_BASE}/squads?teamId=${teamId}&compSeasonId=${compSeasonId}`,
+      SquadListSchema
+    );
   }
-  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;
+  /**
+   * Fetch ladder standings for a season (optionally for a specific round).
+   *
+   * @param seasonId - The compseason ID.
+   * @param roundId - Optional round ID (numeric `id`, not `providerId`).
+   * @returns Ladder response with entries.
+   */
+  async fetchLadder(seasonId, roundId) {
+    let url = `${API_BASE}/compseasons/${seasonId}/ladders`;
+    if (roundId != null) {
+      url += `?roundId=${roundId}`;
+    }
+    return this.fetchJson(url, LadderResponseSchema);
   }
-  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
-    return null;
+};
+
+// src/lib/squiggle-validation.ts
+import { z as z2 } from "zod";
+var 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()
+});
+var SquiggleGamesResponseSchema = z2.object({
+  games: z2.array(SquiggleGameSchema)
+});
+var 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()
+});
+var SquiggleStandingsResponseSchema = z2.object({
+  standings: z2.array(SquiggleStandingSchema)
+});
+
+// src/sources/squiggle.ts
+var SQUIGGLE_BASE = "https://api.squiggle.com.au/";
+var USER_AGENT = "fitzRoy-ts/1.0 (https://github.com/jackemcpherson/fitzRoy-ts)";
+var SquiggleClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
   }
-  return date;
-}
-function parseAflTablesDate(dateStr) {
-  const trimmed = dateStr.trim();
-  if (trimmed === "") {
-    return null;
+  /**
+   * 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"
+        )
+      );
+    }
   }
-  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));
+  /**
+   * 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);
   }
-  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));
+  /**
+   * 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);
   }
-  return null;
+};
+
+// src/transforms/squiggle.ts
+function toMatchStatus2(complete) {
+  if (complete === 100) return "Complete";
+  if (complete > 0) return "Live";
+  return "Upcoming";
 }
-function toAestString(date) {
-  const formatter = new Intl.DateTimeFormat("en-AU", {
-    timeZone: "Australia/Melbourne",
-    weekday: "short",
-    day: "numeric",
-    month: "short",
-    year: "numeric",
-    hour: "numeric",
-    minute: "2-digit",
-    hour12: true,
-    timeZoneName: "short"
-  });
-  return formatter.format(date);
+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"
+  }));
 }
-var 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]
-]);
-function buildUtcDate(year, monthStr, day) {
-  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
-  if (monthIndex === void 0) {
-    return null;
+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
+  }));
+}
+
+// src/api/fixture.ts
+function toFixture(item, season, fallbackRoundNumber, competition) {
+  return {
+    matchId: item.match.matchId,
+    season,
+    roundNumber: item.round?.roundNumber ?? fallbackRoundNumber,
+    roundType: inferRoundType(item.round?.name ?? ""),
+    date: new Date(item.match.utcStartTime),
+    venue: item.venue?.name ?? "",
+    homeTeam: normaliseTeamName(item.match.homeTeam.name),
+    awayTeam: normaliseTeamName(item.match.awayTeam.name),
+    status: toMatchStatus(item.match.status),
+    competition
+  };
+}
+async function fetchFixture(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source === "squiggle") {
+    const client2 = new SquiggleClient();
+    const result = await client2.fetchGames(query.season, query.round ?? void 0);
+    if (!result.success) return result;
+    return ok(transformSquiggleGamesToFixture(result.data.games, query.season));
   }
-  const date = new Date(Date.UTC(year, monthIndex, day));
-  if (Number.isNaN(date.getTime())) {
-    return null;
+  if (query.source === "footywire") {
+    const fwClient = new FootyWireClient();
+    const result = await fwClient.fetchSeasonFixture(query.season);
+    if (!result.success) return result;
+    if (query.round != null) {
+      return ok(result.data.filter((f) => f.roundNumber === query.round));
+    }
+    return result;
   }
-  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
-    return null;
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Fixture data is only available from the AFL API, FootyWire, or Squiggle sources.",
+        query.source
+      )
+    );
   }
-  return date;
+  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);
+}
+
+// src/sources/afl-tables.ts
+import * as cheerio6 from "cheerio";
+
+// src/transforms/afl-tables-player-stats.ts
+import * as cheerio5 from "cheerio";
+function parseName(raw) {
+  const cleaned = raw.replace(/[↑↓]/g, "").trim();
+  const parts = cleaned.split(",").map((s) => s.trim());
+  const surname = parts[0] ?? "";
+  const givenName = parts[1] ?? "";
+  return {
+    givenName,
+    surname,
+    displayName: givenName ? `${givenName} ${surname}` : surname
+  };
+}
+function parseAflTablesGameStats(html, matchId, season, roundNumber) {
+  const $ = cheerio5.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 $ = cheerio5.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;
 }
 
 // src/sources/afl-tables.ts
@@ -1130,9 +2449,145 @@ var AflTablesClient = class {
       );
     }
   }
+  /**
+   * Fetch player statistics for an entire season from AFL Tables.
+   *
+   * Scrapes individual game pages linked from the season page.
+   *
+   * @param year - The season year.
+   */
+  async fetchSeasonPlayerStats(year) {
+    const seasonUrl = `${AFL_TABLES_BASE}/${year}.html`;
+    try {
+      const seasonResponse = await this.fetchFn(seasonUrl, {
+        headers: { "User-Agent": "Mozilla/5.0" }
+      });
+      if (!seasonResponse.ok) {
+        return err(
+          new ScrapeError(
+            `AFL Tables request failed: ${seasonResponse.status} (${seasonUrl})`,
+            "afl-tables"
+          )
+        );
+      }
+      const seasonHtml = await seasonResponse.text();
+      const gameUrls = extractGameUrls(seasonHtml);
+      if (gameUrls.length === 0) {
+        return ok([]);
+      }
+      const results = parseSeasonPage(seasonHtml, year);
+      const allStats = [];
+      const batchSize = 5;
+      for (let i = 0; i < gameUrls.length; i += batchSize) {
+        const batch = gameUrls.slice(i, i + batchSize);
+        const batchResults = await Promise.all(
+          batch.map(async (gameUrl, batchIdx) => {
+            try {
+              const resp = await this.fetchFn(gameUrl, {
+                headers: { "User-Agent": "Mozilla/5.0" }
+              });
+              if (!resp.ok) return [];
+              const html = await resp.text();
+              const urlMatch = /\/(\d+)\.html$/.exec(gameUrl);
+              const matchId = urlMatch?.[1] ?? `${year}_${i + batchIdx}`;
+              const globalIdx = i + batchIdx;
+              const roundNumber = results[globalIdx]?.roundNumber ?? 0;
+              return parseAflTablesGameStats(html, matchId, year, roundNumber);
+            } catch {
+              return [];
+            }
+          })
+        );
+        for (const stats of batchResults) {
+          allStats.push(...stats);
+        }
+        if (i + batchSize < gameUrls.length) {
+          await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+      }
+      return ok(allStats);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `AFL Tables player stats failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-tables"
+        )
+      );
+    }
+  }
+  /**
+   * Fetch team statistics from AFL Tables.
+   *
+   * Scrapes the season stats page which includes per-team aggregate stats.
+   *
+   * @param year - The season year.
+   * @returns Array of team stats entries.
+   */
+  async fetchTeamStats(year) {
+    const url = `https://afltables.com/afl/stats/${year}s.html`;
+    try {
+      const response = await this.fetchFn(url, {
+        headers: { "User-Agent": "Mozilla/5.0" }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(
+            `AFL Tables stats request failed: ${response.status} (${url})`,
+            "afl-tables"
+          )
+        );
+      }
+      const html = await response.text();
+      const entries = parseAflTablesTeamStats(html, year);
+      return ok(entries);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `AFL Tables team stats failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-tables"
+        )
+      );
+    }
+  }
+  /**
+   * Fetch player list from AFL Tables team page.
+   *
+   * Scrapes the team index page (e.g. `teams/swans_idx.html`) which lists
+   * all players who have played for that team historically.
+   *
+   * @param teamName - Canonical team name (e.g. "Sydney Swans").
+   * @returns Array of player details (without source/competition fields).
+   */
+  async fetchPlayerList(teamName) {
+    const slug = teamNameToAflTablesSlug(teamName);
+    if (!slug) {
+      return err(new ScrapeError(`No AFL Tables slug mapping for team: ${teamName}`, "afl-tables"));
+    }
+    const url = `https://afltables.com/afl/stats/alltime/${slug}.html`;
+    try {
+      const response = await this.fetchFn(url, {
+        headers: { "User-Agent": "Mozilla/5.0" }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(`AFL Tables request failed: ${response.status} (${url})`, "afl-tables")
+        );
+      }
+      const html = await response.text();
+      const players = parseAflTablesPlayerList(html, teamName);
+      return ok(players);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `AFL Tables player list failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-tables"
+        )
+      );
+    }
+  }
 };
 function parseSeasonPage(html, year) {
-  const $ = cheerio.load(html);
+  const $ = cheerio6.load(html);
   const results = [];
   let currentRound = 0;
   let currentRoundType = "HomeAndAway";
@@ -1140,17 +2595,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]);
@@ -1227,7 +2683,7 @@ function parseDateFromInfo(text, year) {
   return parseAflTablesDate(text) ?? new Date(year, 0, 1);
 }
 function parseVenueFromInfo(html) {
-  const $ = cheerio.load(html);
+  const $ = cheerio6.load(html);
   const venueLink = $("a[href*='venues']");
   if (venueLink.length > 0) {
     return venueLink.text().trim();
@@ -1240,144 +2696,342 @@ function parseAttendanceFromInfo(text) {
   if (!match?.[1]) return null;
   return Number.parseInt(match[1].replace(/,/g, ""), 10) || null;
 }
+function parseAflTablesTeamStats(html, year) {
+  const $ = cheerio6.load(html);
+  const teamMap = /* @__PURE__ */ new Map();
+  const tables = $("table");
+  function parseTable(tableIdx, suffix) {
+    if (tableIdx >= tables.length) return;
+    const $table = $(tables[tableIdx]);
+    const rows = $table.find("tr");
+    if (rows.length < 2) return;
+    const headers = [];
+    $(rows[0]).find("td, th").each((_ci, cell) => {
+      headers.push($(cell).text().trim());
+    });
+    for (let ri = 1; ri < rows.length; ri++) {
+      const cells = $(rows[ri]).find("td");
+      if (cells.length < 3) continue;
+      const teamText = $(cells[0]).text().trim();
+      if (teamText === "Totals" || !teamText) continue;
+      const teamName = normaliseTeamName(teamText);
+      if (!teamName) continue;
+      if (!teamMap.has(teamName)) {
+        teamMap.set(teamName, { gamesPlayed: 0, stats: {} });
+      }
+      const entry = teamMap.get(teamName);
+      if (!entry) continue;
+      for (let ci = 1; ci < cells.length; ci++) {
+        const header = headers[ci];
+        if (!header) continue;
+        const value = Number.parseFloat($(cells[ci]).text().trim().replace(/,/g, "")) || 0;
+        entry.stats[`${header}${suffix}`] = value;
+      }
+    }
+  }
+  parseTable(1, "_for");
+  parseTable(2, "_against");
+  const entries = [];
+  for (const [team, data] of teamMap) {
+    entries.push({
+      season: year,
+      team,
+      gamesPlayed: data.gamesPlayed,
+      stats: data.stats,
+      source: "afl-tables"
+    });
+  }
+  return entries;
+}
+var 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"]
+]);
+function teamNameToAflTablesSlug(teamName) {
+  return AFL_TABLES_SLUG_MAP.get(teamName);
+}
+function parseAflTablesPlayerList(html, teamName) {
+  const $ = cheerio6.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;
+}
+
+// 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;
+}
+
+// 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
+    };
+  });
+}
+
+// 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
+  });
+}
+
+// src/transforms/lineup.ts
+var EMERGENCY_POSITIONS = /* @__PURE__ */ new Set(["EMG", "EMERG"]);
+var SUBSTITUTE_POSITIONS = /* @__PURE__ */ new Set(["SUB", "INT"]);
+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
+  };
+}
 
-// src/sources/footywire.ts
-import * as cheerio2 from "cheerio";
-var FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
-var FootyWireClient = class {
-  fetchFn;
-  constructor(options) {
-    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+// 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
+      )
+    );
   }
-  /**
-   * 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"
-        )
-      );
-    }
+  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)]);
   }
-  /**
-   * 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"
-        )
-      );
-    }
+  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}`));
   }
-};
-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;
+  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);
 }
 
 // src/api/match-results.ts
@@ -1418,11 +3072,113 @@ 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));
   }
 }
 
+// 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
+        )
+      );
+  }
+}
+
 // src/transforms/player-stats.ts
 function toNullable(value) {
   return value ?? null;
@@ -1572,18 +3328,67 @@ 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":
+    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));
+  }
+}
+
+// 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(
-          "Player stats from AFL Tables are not yet supported. Use source: 'afl-api'.",
-          "afl-tables"
+          `Team stats are not available from ${query.source}. Use "footywire" or "afl-tables".`,
+          query.source
         )
       );
     default:
@@ -1597,18 +3402,17 @@ function teamTypeForComp(comp) {
 }
 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();
@@ -1659,6 +3463,7 @@ export {
   AflApiClient,
   AflApiError,
   AflApiTokenSchema,
+  AflCoachesClient,
   AflTablesClient,
   CfsMatchSchema,
   CfsMatchTeamSchema,
@@ -1687,20 +3492,30 @@ export {
   SquadPlayerInnerSchema,
   SquadPlayerItemSchema,
   SquadSchema,
+  SquiggleClient,
+  SquiggleGameSchema,
+  SquiggleGamesResponseSchema,
+  SquiggleStandingSchema,
+  SquiggleStandingsResponseSchema,
   TeamItemSchema,
   TeamListSchema,
   TeamPlayersSchema,
   TeamScoreSchema,
   UnsupportedSourceError,
   ValidationError,
+  computeLadder,
   err,
+  fetchAwards,
+  fetchCoachesVotes,
   fetchFixture,
   fetchFryziggStats,
   fetchLadder,
   fetchLineup,
   fetchMatchResults,
+  fetchPlayerDetails,
   fetchPlayerStats,
   fetchSquad,
+  fetchTeamStats,
   fetchTeams,
   inferRoundType,
   normaliseTeamName,
@@ -1712,5 +3527,8 @@ export {
   transformLadderEntries,
   transformMatchItems,
   transformMatchRoster,
-  transformPlayerStats
+  transformPlayerStats,
+  transformSquiggleGamesToFixture,
+  transformSquiggleGamesToResults,
+  transformSquiggleStandings
 };