fitzroy 1.8.0 → 2.0.0

package/dist/index.js

@@ -20,12 +20,25 @@ var UnsupportedSourceError = class extends Error {
   }
   name = "UnsupportedSourceError";
 };
-function aflwUnsupportedError(source) {
-  return new UnsupportedSourceError(
-    `AFLW data is not available from ${source}. Use --source afl-api for AFLW data.`,
-    source
-  );
-}
+var UnsupportedCompetitionError = class extends Error {
+  constructor(message, source, competition, suggestion) {
+    super(message);
+    this.source = source;
+    this.competition = competition;
+    this.suggestion = suggestion;
+  }
+  name = "UnsupportedCompetitionError";
+};
+var OutOfRangeError = class extends Error {
+  constructor(message, source, competition, season, suggestion) {
+    super(message);
+    this.source = source;
+    this.competition = competition;
+    this.season = season;
+    this.suggestion = suggestion;
+  }
+  name = "OutOfRangeError";
+};
 var ValidationError = class extends Error {
   constructor(message, issues) {
     super(message);
@@ -41,142 +54,39 @@ function ok(data) {
 function err(error) {
   return { success: false, error };
 }
-
-// src/sources/footywire.ts
-import * as cheerio2 from "cheerio";
-
-// src/lib/date-utils.ts
-function parseDate(raw, defaultYear) {
-  if (typeof raw === "number") {
-    const date = new Date(raw * 1e3);
-    return Number.isNaN(date.getTime()) ? null : date;
-  }
-  const trimmed = raw.trim();
-  if (trimmed === "") return null;
-  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
-    const stripped = trimmed.replace(/[Zz]$|[+-]\d{2}:\d{2}$/, "");
-    const utc = stripped.includes("T") ? `${stripped}Z` : `${stripped}T00:00:00Z`;
-    const date = new Date(utc);
-    return Number.isNaN(date.getTime()) ? null : date;
-  }
-  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
-  const normalised = withoutDow.replace(/[-/]/g, " ");
-  const fullMatch = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
-  if (fullMatch) {
-    const [, dayStr, monthStr, yearStr] = fullMatch;
-    if (dayStr && monthStr && yearStr) {
-      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
-    }
-  }
-  const mdyMatch = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
-  if (mdyMatch) {
-    const [, monthStr, dayStr, yearStr] = mdyMatch;
-    if (dayStr && monthStr && yearStr) {
-      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
-    }
-  }
-  const shortMatch = /^(\d{1,2})\s+([A-Za-z]+)(?:\s+(\d{1,2}):(\d{2})(am|pm))?$/i.exec(normalised);
-  if (shortMatch && defaultYear != null) {
-    const [, dayStr, monthStr, hourStr, minStr, ampm] = shortMatch;
-    if (!dayStr || !monthStr) return null;
-    const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
-    if (monthIndex === void 0) return null;
-    const day = Number.parseInt(dayStr, 10);
-    if (!hourStr || !minStr || !ampm) {
-      return buildUtcDate(defaultYear, monthStr, day);
+var Result = {
+  /** Transform the success value of a Result. Errors pass through unchanged. */
+  map(result, fn) {
+    return result.success ? ok(fn(result.data)) : result;
+  },
+  /** Chain a Result-returning function. Errors short-circuit. */
+  flatMap(result, fn) {
+    return result.success ? fn(result.data) : result;
+  },
+  /**
+   * Chain an async Result-returning function. Errors short-circuit without
+   * invoking `fn`.
+   */
+  async flatMapAsync(result, fn) {
+    return result.success ? fn(result.data) : result;
+  },
+  /**
+   * Collect an array of Results into a single Result of an array. Returns
+   * the first error encountered, or `ok` of all successful values.
+   */
+  all(results) {
+    const data = [];
+    for (const r of results) {
+      if (!r.success) return r;
+      data.push(r.data);
     }
-    let hours = Number.parseInt(hourStr, 10);
-    const minutes = Number.parseInt(minStr, 10);
-    if (ampm.toLowerCase() === "pm" && hours < 12) hours += 12;
-    if (ampm.toLowerCase() === "am" && hours === 12) hours = 0;
-    const date = melbourneLocalToUtc(defaultYear, monthIndex, day, hours, minutes);
-    return Number.isNaN(date.getTime()) ? null : date;
-  }
-  return null;
-}
-function parseAflApiDate(iso) {
-  return parseDate(iso);
-}
-function parseAflApiMatchTime(iso) {
-  return parseDate(iso);
-}
-function parseFootyWireDate(dateStr, defaultYear) {
-  return parseDate(dateStr, defaultYear);
-}
-function parseAflTablesDate(dateStr) {
-  return parseDate(dateStr);
-}
-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 resolveDefaultSeason(competition = "AFLM") {
-  const year = (/* @__PURE__ */ new Date()).getFullYear();
-  return competition === "AFLW" ? year - 1 : year;
-}
-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 melbourneLocalToUtc(year, monthIndex, day, hours, minutes) {
-  const aestGuess = new Date(Date.UTC(year, monthIndex, day, hours - 10, minutes));
-  const parts = new Intl.DateTimeFormat("en-AU", {
-    timeZone: "Australia/Melbourne",
-    day: "2-digit",
-    hour: "2-digit",
-    hour12: false
-  }).formatToParts(aestGuess);
-  const getNum = (type) => Number(parts.find((p) => p.type === type)?.value);
-  if (getNum("day") === day && getNum("hour") === hours % 24) {
-    return aestGuess;
-  }
-  return new Date(Date.UTC(year, monthIndex, day, hours - 11, minutes));
-}
-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 ok(data);
+  },
+  /** Transform the error value of a Result. Successes pass through unchanged. */
+  mapErr(result, fn) {
+    return result.success ? result : err(fn(result.error));
   }
-  return date;
-}
+};
 
 // src/lib/team-mapping.ts
 var TEAM_ALIASES = [
@@ -273,85 +183,374 @@ var AFL_API_TEAM_IDS = /* @__PURE__ */ new Map([
   ["CD_T140", "Western Bulldogs"]
 ]);
 
-// src/lib/venue-mapping.ts
-var VENUE_ALIASES = [
-  ["MCG", "M.C.G.", "Melbourne Cricket Ground"],
-  ["SCG", "S.C.G.", "Sydney Cricket Ground"],
-  ["Marvel Stadium", "Docklands", "Etihad Stadium", "Telstra Dome", "Colonial Stadium"],
-  ["Kardinia Park", "GMHBA Stadium", "Simonds Stadium", "Skilled Stadium"],
-  ["Gabba", "The Gabba", "Brisbane Cricket Ground"],
-  [
-    "Sydney Showground",
-    "ENGIE Stadium",
-    "GIANTS Stadium",
-    "Showground Stadium",
-    "Sydney Showground Stadium"
-  ],
-  ["Accor Stadium", "Stadium Australia", "ANZ Stadium", "Homebush"],
-  ["Carrara", "People First Stadium", "Heritage Bank Stadium", "Metricon Stadium"],
-  ["Perth Stadium", "Optus Stadium"],
-  ["Adelaide Oval"],
-  ["Manuka Oval", "Corroboree Group Oval Manuka"],
-  ["Blundstone Arena", "Bellerive Oval"],
-  ["UTAS Stadium", "York Park", "University of Tasmania Stadium", "Aurora Stadium"],
-  ["TIO Stadium", "Marrara Oval"],
-  ["Traeger Park", "TIO Traeger Park"],
-  ["Mars Stadium", "Eureka Stadium"],
-  ["Cazalys Stadium", "Cazaly's Stadium"],
-  ["Jiangwan Stadium"],
-  ["Riverway Stadium"],
-  ["Norwood Oval"],
-  ["Subiaco Oval", "Subiaco"],
-  ["Football Park", "AAMI Stadium"],
-  ["Princes Park", "Ikon Park"],
-  ["Blacktown International Sportspark"],
-  ["Barossa Park", "Barossa Oval", "Adelaide Hills"],
-  ["Ninja Stadium", "Summit Sports Park"]
-];
-var VENUE_ALIAS_MAP = (() => {
-  const map = /* @__PURE__ */ new Map();
-  for (const [canonical, ...aliases] of VENUE_ALIASES) {
-    map.set(canonical.toLowerCase(), canonical);
-    for (const alias of aliases) {
-      map.set(alias.toLowerCase(), canonical);
+// src/sources/afl-coaches.ts
+import * as cheerio from "cheerio";
+var AflCoachesClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Fetch the HTML content of an AFLCA page.
+   */
+  async fetchHtml(url) {
+    try {
+      const response = await this.fetchFn(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(`AFL Coaches request failed: ${response.status} (${url})`, "afl-coaches")
+        );
+      }
+      const html = await response.text();
+      return ok(html);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `AFL Coaches request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-coaches"
+        )
+      );
     }
   }
-  return map;
-})();
-function normaliseVenueName(raw) {
-  const trimmed = raw.trim();
-  return VENUE_ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
-}
-
-// src/transforms/footywire-player-stats.ts
-import * as cheerio from "cheerio";
-
-// 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",
+  /**
+   * Build the AFLCA leaderboard URL for a given season, round, and competition.
+   *
+   * Mirrors the R package URL construction from `helper-aflcoaches.R`.
+   *
+   * @param season - Season year (e.g. 2024).
+   * @param roundNumber - Round number.
+   * @param competition - "AFLM" or "AFLW".
+   * @param isFinals - Whether this is a finals round.
+   */
+  buildUrl(season, roundNumber, competition, isFinals) {
+    const linkBase = competition === "AFLW" ? "https://aflcoaches.com.au/awards/aflw-champion-player-of-the-year-award/leaderboard/" : isFinals ? "https://aflcoaches.com.au/awards/gary-ayres-award-best-finals-player/leaderboard/" : "https://aflcoaches.com.au/awards/the-aflca-champion-player-of-the-year-award/leaderboard/";
+    const compSuffix = competition === "AFLW" ? "02" : "01";
+    const secondPart = season >= 2023 ? season + 1 : season;
+    const roundPad = String(roundNumber).padStart(2, "0");
+    return `${linkBase}${season}/${secondPart}${compSuffix}${roundPad}`;
+  }
+  /**
+   * Scrape coaches votes for a single round.
+   *
+   * @param season - Season year.
+   * @param roundNumber - Round number.
+   * @param competition - "AFLM" or "AFLW".
+   * @param isFinals - Whether this is a finals round.
+   * @returns Array of coaches vote records for that round.
+   */
+  async scrapeRoundVotes(season, roundNumber, competition, isFinals) {
+    const url = this.buildUrl(season, roundNumber, competition, isFinals);
+    const htmlResult = await this.fetchHtml(url);
+    if (!htmlResult.success) {
+      return htmlResult;
+    }
+    try {
+      const votes = parseCoachesVotesHtml(htmlResult.data, season, roundNumber);
+      return ok(votes);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `Failed to parse coaches votes: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-coaches"
+        )
+      );
+    }
+  }
+  /**
+   * Fetch coaches votes for an entire season (all rounds).
+   *
+   * Iterates over rounds 1-30, skipping rounds that return errors (e.g. byes or
+   * rounds that haven't been played yet). Finals rounds (>= 24) use the finals URL.
+   *
+   * @param season - Season year.
+   * @param competition - "AFLM" or "AFLW".
+   * @returns Combined array of coaches votes for the season.
+   */
+  async fetchSeasonVotes(season, competition) {
+    const allVotes = [];
+    const maxRound = 30;
+    for (let round = 1; round <= maxRound; round++) {
+      const isFinals = round >= 24 && season >= 2018;
+      const result = await this.scrapeRoundVotes(season, round, competition, isFinals);
+      if (result.success && result.data.length > 0) {
+        allVotes.push(...result.data);
+      }
+    }
+    if (allVotes.length === 0) {
+      return err(new ScrapeError(`No coaches votes found for season ${season}`, "afl-coaches"));
+    }
+    return ok(allVotes);
+  }
+};
+function parseCoachesVotesHtml(html, season, roundNumber) {
+  const $ = cheerio.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({
+      type: "coaches",
+      season,
+      round: roundNumber,
+      homeTeam,
+      awayTeam,
+      playerName,
+      votes: voteCount
+    });
+  }
+  return votes;
+}
+
+// src/sources/footywire.ts
+import * as cheerio3 from "cheerio";
+
+// src/lib/date-utils.ts
+function parseDate(raw, defaultYear) {
+  if (typeof raw === "number") {
+    const date = new Date(raw * 1e3);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "") return null;
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    const stripped = trimmed.replace(/[Zz]$|[+-]\d{2}:\d{2}$/, "");
+    const utc = stripped.includes("T") ? `${stripped}Z` : `${stripped}T00:00:00Z`;
+    const date = new Date(utc);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/[-/]/g, " ");
+  const fullMatch = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (fullMatch) {
+    const [, dayStr, monthStr, yearStr] = fullMatch;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const mdyMatch = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
+  if (mdyMatch) {
+    const [, monthStr, dayStr, yearStr] = mdyMatch;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const shortMatch = /^(\d{1,2})\s+([A-Za-z]+)(?:\s+(\d{1,2}):(\d{2})(am|pm))?$/i.exec(normalised);
+  if (shortMatch && defaultYear != null) {
+    const [, dayStr, monthStr, hourStr, minStr, ampm] = shortMatch;
+    if (!dayStr || !monthStr) return null;
+    const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+    if (monthIndex === void 0) return null;
+    const day = Number.parseInt(dayStr, 10);
+    if (!hourStr || !minStr || !ampm) {
+      return buildUtcDate(defaultYear, monthStr, day);
+    }
+    let hours = Number.parseInt(hourStr, 10);
+    const minutes = Number.parseInt(minStr, 10);
+    if (ampm.toLowerCase() === "pm" && hours < 12) hours += 12;
+    if (ampm.toLowerCase() === "am" && hours === 12) hours = 0;
+    const date = melbourneLocalToUtc(defaultYear, monthIndex, day, hours, minutes);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+function parseAflApiDate(iso) {
+  return parseDate(iso);
+}
+function parseAflApiMatchTime(iso) {
+  return parseDate(iso);
+}
+function parseFootyWireDate(dateStr, defaultYear) {
+  return parseDate(dateStr, defaultYear);
+}
+function parseAflTablesDate(dateStr) {
+  return parseDate(dateStr);
+}
+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 melbourneLocalToUtc(year, monthIndex, day, hours, minutes) {
+  const aestGuess = new Date(Date.UTC(year, monthIndex, day, hours - 10, minutes));
+  const parts = new Intl.DateTimeFormat("en-AU", {
+    timeZone: "Australia/Melbourne",
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false
+  }).formatToParts(aestGuess);
+  const getNum = (type) => Number(parts.find((p) => p.type === type)?.value);
+  if (getNum("day") === day && getNum("hour") === hours % 24) {
+    return aestGuess;
+  }
+  return new Date(Date.UTC(year, monthIndex, day, hours - 11, minutes));
+}
+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/venue-mapping.ts
+var VENUE_ALIASES = [
+  ["MCG", "M.C.G.", "Melbourne Cricket Ground"],
+  ["SCG", "S.C.G.", "Sydney Cricket Ground"],
+  ["Marvel Stadium", "Docklands", "Etihad Stadium", "Telstra Dome", "Colonial Stadium"],
+  ["Kardinia Park", "GMHBA Stadium", "Simonds Stadium", "Skilled Stadium"],
+  ["Gabba", "The Gabba", "Brisbane Cricket Ground"],
+  [
+    "Sydney Showground",
+    "ENGIE Stadium",
+    "GIANTS Stadium",
+    "Showground Stadium",
+    "Sydney Showground Stadium"
+  ],
+  ["Accor Stadium", "Stadium Australia", "ANZ Stadium", "Homebush"],
+  ["Carrara", "People First Stadium", "Heritage Bank Stadium", "Metricon Stadium"],
+  ["Perth Stadium", "Optus Stadium"],
+  ["Adelaide Oval"],
+  ["Manuka Oval", "Corroboree Group Oval Manuka"],
+  ["Blundstone Arena", "Bellerive Oval"],
+  ["UTAS Stadium", "York Park", "University of Tasmania Stadium", "Aurora Stadium"],
+  ["TIO Stadium", "Marrara Oval"],
+  ["Traeger Park", "TIO Traeger Park"],
+  ["Mars Stadium", "Eureka Stadium"],
+  ["Cazalys Stadium", "Cazaly's Stadium"],
+  ["Jiangwan Stadium"],
+  ["Riverway Stadium"],
+  ["Norwood Oval"],
+  ["Subiaco Oval", "Subiaco"],
+  ["Football Park", "AAMI Stadium"],
+  ["Princes Park", "Ikon Park"],
+  ["Blacktown International Sportspark"],
+  ["Barossa Park", "Barossa Oval", "Adelaide Hills"],
+  ["Ninja Stadium", "Summit Sports Park"]
+];
+var VENUE_ALIAS_MAP = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [canonical, ...aliases] of VENUE_ALIASES) {
+    map.set(canonical.toLowerCase(), canonical);
+    for (const alias of aliases) {
+      map.set(alias.toLowerCase(), canonical);
+    }
+  }
+  return map;
+})();
+function normaliseVenueName(raw) {
+  const trimmed = raw.trim();
+  return VENUE_ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+
+// src/transforms/footywire-player-stats.ts
+import * as cheerio2 from "cheerio";
+
+// 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",
@@ -387,7 +586,7 @@ function cleanPlayerName(raw) {
   return raw.replace(/[↗↙]/g, "").trim();
 }
 function parseStatsTable(html, expectedCols, rowParser) {
-  const $ = cheerio.load(html);
+  const $ = cheerio2.load(html);
   const results = [];
   $("table").each((_i, table) => {
     const rows = $(table).find("tr");
@@ -644,8 +843,9 @@ 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;
+    const homePoints = homeScore ? homeScore.matchScore.totalScore : null;
+    const awayPoints = awayScore ? awayScore.matchScore.totalScore : null;
+    const margin = homePoints !== null && awayPoints !== null ? homePoints - awayPoints : null;
     return {
       matchId: item.match.matchId,
       season,
@@ -656,13 +856,13 @@ function transformMatchItems(items, season, competition, source = "afl-api") {
       venue: item.venue?.name ? normaliseVenueName(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,
+      homeGoals: homeScore ? homeScore.matchScore.goals : null,
+      homeBehinds: homeScore ? homeScore.matchScore.behinds : null,
       homePoints,
-      awayGoals: awayScore?.matchScore.goals ?? 0,
-      awayBehinds: awayScore?.matchScore.behinds ?? 0,
+      awayGoals: awayScore ? awayScore.matchScore.goals : null,
+      awayBehinds: awayScore ? awayScore.matchScore.behinds : null,
       awayPoints,
-      margin: homePoints - awayPoints,
+      margin,
       q1Home: findPeriod(homeScore?.periodScore, 1),
       q2Home: findPeriod(homeScore?.periodScore, 2),
       q3Home: findPeriod(homeScore?.periodScore, 3),
@@ -798,7 +998,7 @@ var FootyWireClient = class {
     const htmlResult = await this.fetchHtml(url);
     if (!htmlResult.success) return htmlResult;
     try {
-      const $ = cheerio2.load(htmlResult.data);
+      const $ = cheerio3.load(htmlResult.data);
       const entries = [];
       let currentRound = 0;
       let lastHARound = 0;
@@ -924,7 +1124,7 @@ var FootyWireClient = class {
   }
 };
 function parseMatchList(html, year) {
-  const $ = cheerio2.load(html);
+  const $ = cheerio3.load(html);
   const results = [];
   let currentRound = 0;
   let lastHARound = 0;
@@ -1015,7 +1215,7 @@ function parseMatchList(html, year) {
   return results;
 }
 function parseFixtureList(html, year) {
-  const $ = cheerio2.load(html);
+  const $ = cheerio3.load(html);
   const fixtures = [];
   let currentRound = 0;
   let lastHARound = 0;
@@ -1057,18 +1257,45 @@ function parseFixtureList(html, year) {
       season: year,
       roundNumber: currentRound,
       roundType: currentRoundType,
+      roundName: null,
       date,
       venue: normaliseVenueName(venue),
       homeTeam,
       awayTeam,
+      homeGoals: null,
+      homeBehinds: null,
+      homePoints: null,
+      awayGoals: null,
+      awayBehinds: null,
+      awayPoints: null,
+      margin: null,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
       status: hasScore ? "Complete" : "Upcoming",
+      attendance: null,
+      weatherTempCelsius: null,
+      weatherType: null,
+      roundCode: null,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "footywire",
       competition: "AFLM"
     });
   });
   return fixtures;
 }
 function parseFootyWireTeamStats(html, year, suffix) {
-  const $ = cheerio2.load(html);
+  const $ = cheerio3.load(html);
   const entries = [];
   const tables = $("table");
   const mainTable = tables.length > 10 ? $(tables[10]) : $("table.sortable").first();
@@ -1162,7 +1389,7 @@ function normaliseDob(raw) {
   return raw;
 }
 function parseFootyWirePlayerList(html, teamName) {
-  const $ = cheerio2.load(html);
+  const $ = cheerio3.load(html);
   const players = [];
   let dataRows = null;
   $("table").each((_i, table) => {
@@ -1218,9 +1445,9 @@ function parseFootyWirePlayerList(html, teamName) {
 }
 
 // src/transforms/awards.ts
-import * as cheerio3 from "cheerio";
+import * as cheerio4 from "cheerio";
 function parseBrownlowVotes(html, season) {
-  const $ = cheerio3.load(html);
+  const $ = cheerio4.load(html);
   const results = [];
   $("table").each((_i, table) => {
     const rows = $(table).find("tr");
@@ -1259,7 +1486,7 @@ function parseBrownlowVotes(html, season) {
   return results;
 }
 function parseAllAustralian(html, season) {
-  const $ = cheerio3.load(html);
+  const $ = cheerio4.load(html);
   const results = [];
   const rows = $("tr");
   rows.each((_i, row) => {
@@ -1289,7 +1516,7 @@ function parseAllAustralian(html, season) {
   return results;
 }
 function parseRisingStarNominations(html, season) {
-  const $ = cheerio3.load(html);
+  const $ = cheerio4.load(html);
   const results = [];
   const tables = $("table");
   let targetRows = null;
@@ -1334,255 +1561,175 @@ function parseRisingStarNominations(html, season) {
   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);
+// src/lib/concurrency.ts
+async function batchedMap(items, fn, options) {
+  const batchSize = options?.batchSize ?? 5;
+  const delayMs = options?.delayMs ?? 0;
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(fn));
+    results.push(...batchResults);
+    if (delayMs > 0 && i + batchSize < items.length) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
-    default:
-      return err(new ScrapeError(`Unknown award type: ${query.award}`, "footywire"));
   }
+  return results;
 }
 
-// src/sources/afl-coaches.ts
-import * as cheerio4 from "cheerio";
-var AflCoachesClient = class {
-  fetchFn;
-  constructor(options) {
-    this.fetchFn = options?.fetchFn ?? globalThis.fetch.bind(globalThis);
-  }
-  /**
-   * Fetch the HTML content of an AFLCA page.
-   */
-  async fetchHtml(url) {
-    try {
-      const response = await this.fetchFn(url, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-        }
-      });
-      if (!response.ok) {
-        return err(
-          new ScrapeError(`AFL Coaches request failed: ${response.status} (${url})`, "afl-coaches")
-        );
-      }
-      const html = await response.text();
-      return ok(html);
-    } catch (cause) {
-      return err(
-        new ScrapeError(
-          `AFL Coaches request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-          "afl-coaches"
-        )
-      );
-    }
-  }
-  /**
-   * Build the AFLCA leaderboard URL for a given season, round, and competition.
-   *
-   * Mirrors the R package URL construction from `helper-aflcoaches.R`.
-   *
-   * @param season - Season year (e.g. 2024).
-   * @param roundNumber - Round number.
-   * @param competition - "AFLM" or "AFLW".
-   * @param isFinals - Whether this is a finals round.
-   */
-  buildUrl(season, roundNumber, competition, isFinals) {
-    const linkBase = competition === "AFLW" ? "https://aflcoaches.com.au/awards/aflw-champion-player-of-the-year-award/leaderboard/" : isFinals ? "https://aflcoaches.com.au/awards/gary-ayres-award-best-finals-player/leaderboard/" : "https://aflcoaches.com.au/awards/the-aflca-champion-player-of-the-year-award/leaderboard/";
-    const compSuffix = competition === "AFLW" ? "02" : "01";
-    const secondPart = season >= 2023 ? season + 1 : season;
-    const roundPad = String(roundNumber).padStart(2, "0");
-    return `${linkBase}${season}/${secondPart}${compSuffix}${roundPad}`;
-  }
-  /**
-   * Scrape coaches votes for a single round.
-   *
-   * @param season - Season year.
-   * @param roundNumber - Round number.
-   * @param competition - "AFLM" or "AFLW".
-   * @param isFinals - Whether this is a finals round.
-   * @returns Array of coaches vote records for that round.
-   */
-  async scrapeRoundVotes(season, roundNumber, competition, isFinals) {
-    const url = this.buildUrl(season, roundNumber, competition, isFinals);
-    const htmlResult = await this.fetchHtml(url);
-    if (!htmlResult.success) {
-      return htmlResult;
-    }
-    try {
-      const votes = parseCoachesVotesHtml(htmlResult.data, season, roundNumber);
-      return ok(votes);
-    } catch (cause) {
-      return err(
-        new ScrapeError(
-          `Failed to parse coaches votes: ${cause instanceof Error ? cause.message : String(cause)}`,
-          "afl-coaches"
-        )
-      );
-    }
-  }
-  /**
-   * Fetch coaches votes for an entire season (all rounds).
-   *
-   * Iterates over rounds 1-30, skipping rounds that return errors (e.g. byes or
-   * rounds that haven't been played yet). Finals rounds (>= 24) use the finals URL.
-   *
-   * @param season - Season year.
-   * @param competition - "AFLM" or "AFLW".
-   * @returns Combined array of coaches votes for the season.
-   */
-  async fetchSeasonVotes(season, competition) {
-    const allVotes = [];
-    const maxRound = 30;
-    for (let round = 1; round <= maxRound; round++) {
-      const isFinals = round >= 24 && season >= 2018;
-      const result = await this.scrapeRoundVotes(season, round, competition, isFinals);
-      if (result.success && result.data.length > 0) {
-        allVotes.push(...result.data);
-      }
-    }
-    if (allVotes.length === 0) {
-      return err(new ScrapeError(`No coaches votes found for season ${season}`, "afl-coaches"));
-    }
-    return ok(allVotes);
-  }
-};
-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);
+// 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
+    };
   });
-  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/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/lib/concurrency.ts
-async function batchedMap(items, fn, options) {
-  const batchSize = options?.batchSize ?? 5;
-  const delayMs = options?.delayMs ?? 0;
-  const results = [];
-  for (let i = 0; i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize);
-    const batchResults = await Promise.all(batch.map(fn));
-    results.push(...batchResults);
-    if (delayMs > 0 && i + batchSize < items.length) {
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-  }
-  return results;
+// src/transforms/player-stats.ts
+function toNullable(value) {
+  return value ?? null;
+}
+function transformOne(item, ctx) {
+  const inner = item.player.player.player;
+  const stats = item.playerStats?.stats;
+  const clearances = stats?.clearances;
+  return {
+    matchId: ctx.matchId,
+    season: ctx.season,
+    roundNumber: ctx.roundNumber,
+    team: normaliseTeamName(
+      ctx.teamIdMap?.get(item.teamId) ?? AFL_API_TEAM_IDS.get(item.teamId) ?? item.teamId
+    ),
+    competition: ctx.competition,
+    date: ctx.date ?? null,
+    homeTeam: ctx.homeTeam ?? null,
+    awayTeam: ctx.awayTeam ?? null,
+    playerId: inner.playerId,
+    givenName: inner.playerName.givenName,
+    surname: inner.playerName.surname,
+    displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+    jumperNumber: item.player.jumperNumber ?? null,
+    kicks: toNullable(stats?.kicks),
+    handballs: toNullable(stats?.handballs),
+    disposals: toNullable(stats?.disposals),
+    marks: toNullable(stats?.marks),
+    goals: toNullable(stats?.goals),
+    behinds: toNullable(stats?.behinds),
+    tackles: toNullable(stats?.tackles),
+    hitouts: toNullable(stats?.hitouts),
+    freesFor: toNullable(stats?.freesFor),
+    freesAgainst: toNullable(stats?.freesAgainst),
+    contestedPossessions: toNullable(stats?.contestedPossessions),
+    uncontestedPossessions: toNullable(stats?.uncontestedPossessions),
+    contestedMarks: toNullable(stats?.contestedMarks),
+    intercepts: toNullable(stats?.intercepts),
+    centreClearances: toNullable(clearances?.centreClearances),
+    stoppageClearances: toNullable(clearances?.stoppageClearances),
+    totalClearances: toNullable(clearances?.totalClearances),
+    inside50s: toNullable(stats?.inside50s),
+    rebound50s: toNullable(stats?.rebound50s),
+    clangers: toNullable(stats?.clangers),
+    turnovers: toNullable(stats?.turnovers),
+    onePercenters: toNullable(stats?.onePercenters),
+    bounces: toNullable(stats?.bounces),
+    goalAssists: toNullable(stats?.goalAssists),
+    disposalEfficiency: toNullable(stats?.disposalEfficiency),
+    metresGained: toNullable(stats?.metresGained),
+    goalAccuracy: toNullable(stats?.goalAccuracy),
+    marksInside50: toNullable(stats?.marksInside50),
+    tacklesInside50: toNullable(stats?.tacklesInside50),
+    shotsAtGoal: toNullable(stats?.shotsAtGoal),
+    scoreInvolvements: toNullable(stats?.scoreInvolvements),
+    totalPossessions: toNullable(stats?.totalPossessions),
+    timeOnGroundPercentage: toNullable(item.playerStats?.timeOnGroundPercentage),
+    ratingPoints: toNullable(stats?.ratingPoints),
+    position: item.player.player.position ?? null,
+    goalEfficiency: toNullable(stats?.goalEfficiency),
+    shotEfficiency: toNullable(stats?.shotEfficiency),
+    interchangeCounts: toNullable(stats?.interchangeCounts),
+    brownlowVotes: toNullable(stats?.brownlowVotes),
+    supercoachScore: null,
+    dreamTeamPoints: toNullable(stats?.dreamTeamPoints),
+    effectiveDisposals: toNullable(stats?.extendedStats?.effectiveDisposals),
+    effectiveKicks: toNullable(stats?.extendedStats?.effectiveKicks),
+    kickEfficiency: toNullable(stats?.extendedStats?.kickEfficiency),
+    kickToHandballRatio: toNullable(stats?.extendedStats?.kickToHandballRatio),
+    pressureActs: toNullable(stats?.extendedStats?.pressureActs),
+    defHalfPressureActs: toNullable(stats?.extendedStats?.defHalfPressureActs),
+    spoils: toNullable(stats?.extendedStats?.spoils),
+    hitoutsToAdvantage: toNullable(stats?.extendedStats?.hitoutsToAdvantage),
+    hitoutWinPercentage: toNullable(stats?.extendedStats?.hitoutWinPercentage),
+    hitoutToAdvantageRate: toNullable(stats?.extendedStats?.hitoutToAdvantageRate),
+    groundBallGets: toNullable(stats?.extendedStats?.groundBallGets),
+    f50GroundBallGets: toNullable(stats?.extendedStats?.f50GroundBallGets),
+    interceptMarks: toNullable(stats?.extendedStats?.interceptMarks),
+    marksOnLead: toNullable(stats?.extendedStats?.marksOnLead),
+    contestedPossessionRate: toNullable(stats?.extendedStats?.contestedPossessionRate),
+    contestOffOneOnOnes: toNullable(stats?.extendedStats?.contestOffOneOnOnes),
+    contestOffWins: toNullable(stats?.extendedStats?.contestOffWins),
+    contestOffWinsPercentage: toNullable(stats?.extendedStats?.contestOffWinsPercentage),
+    contestDefOneOnOnes: toNullable(stats?.extendedStats?.contestDefOneOnOnes),
+    contestDefLosses: toNullable(stats?.extendedStats?.contestDefLosses),
+    contestDefLossPercentage: toNullable(stats?.extendedStats?.contestDefLossPercentage),
+    centreBounceAttendances: toNullable(stats?.extendedStats?.centreBounceAttendances),
+    kickins: toNullable(stats?.extendedStats?.kickins),
+    kickinsPlayon: toNullable(stats?.extendedStats?.kickinsPlayon),
+    ruckContests: toNullable(stats?.extendedStats?.ruckContests),
+    scoreLaunches: toNullable(stats?.extendedStats?.scoreLaunches),
+    source: ctx.source
+  };
+}
+function transformPlayerStats(data, ctx) {
+  const home = (data.homeTeamPlayerStats ?? []).map((item) => transformOne(item, ctx));
+  const away = (data.awayTeamPlayerStats ?? []).map((item) => transformOne(item, ctx));
+  return [...home, ...away];
 }
 
 // src/lib/validation.ts
@@ -1885,6 +2032,18 @@ var USER_AGENT = "fitzroy/2 (https://github.com/jackemcpherson/fitzRoy-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 AFL_API_COMP_IDS = {
+  AFLM: 1,
+  AFLW: 3,
+  VFL: 7,
+  VFLW: 11
+};
+var AFL_API_TEAM_TYPES = {
+  AFLM: "MEN",
+  AFLW: "WOMEN",
+  VFL: "VFL_MEN",
+  VFLW: "VFL_WOMEN"
+};
 var AflApiClient = class {
   fetchFn;
   tokenUrl;
@@ -2059,23 +2218,16 @@ var AflApiClient = class {
   /**
    * Resolve a competition code (e.g. "AFLM") to its API competition ID.
    *
+   * Returns the hardcoded mapping from {@link AFL_API_COMP_IDS}. The previous
+   * implementation looked up by `code` field on `/competitions`, but four
+   * competitions share `code="AFL"` (Premiership, Preseason, Origin,
+   * Indigenous All Stars), so the lookup was load-bearing on response order.
+   *
    * @param code - The competition code to resolve.
-   * @returns The competition ID string on success.
+   * @returns The competition ID on success.
    */
   async resolveCompetitionId(code) {
-    const result = await this.fetchJson(
-      `${API_BASE}/competitions?pageSize=50`,
-      CompetitionListSchema
-    );
-    if (!result.success) {
-      return result;
-    }
-    const apiCode = code === "AFLM" ? "AFL" : code;
-    const competition = result.data.competitions.find((c) => c.code === apiCode);
-    if (!competition) {
-      return err(new AflApiError(`Competition not found for code: ${code}`));
-    }
-    return ok(competition.id);
+    return ok(AFL_API_COMP_IDS[code]);
   }
   /**
    * Resolve a season (compseason) ID from a competition ID and year.
@@ -2167,22 +2319,23 @@ var AflApiClient = class {
    * @param seasonId - The compseason ID.
    * @returns Aggregated array of match items from all completed rounds.
    */
-  async fetchSeasonMatchItems(seasonId) {
+  async fetchSeasonMatchItems(seasonId, options) {
     const roundsResult = await this.resolveRounds(seasonId);
     if (!roundsResult.success) {
       return roundsResult;
     }
     const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
     const results = await batchedMap(providerIds, (id) => this.fetchRoundMatchItems(id));
+    const includeUpcoming = options?.includeUpcoming ?? false;
     const allItems = [];
     for (const result of results) {
       if (!result.success) {
         return result;
       }
-      const concluded = result.data.filter(
+      const items = includeUpcoming ? result.data : result.data.filter(
         (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
       );
-      allItems.push(...concluded);
+      allItems.push(...items);
     }
     return ok(allItems);
   }
@@ -2208,17 +2361,21 @@ var AflApiClient = class {
     return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
   }
   /**
-   * Fetch team list, optionally filtered by team type.
+   * Fetch team list, optionally filtered by competition.
+   *
+   * Pass a `CompetitionCode` to scope the result to that competition's teams
+   * (uses {@link AFL_API_TEAM_TYPES} internally).
    *
-   * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
+   * @param competition - Optional CompetitionCode filter (e.g. "AFLM", "VFL").
    * @returns Array of team items.
    */
-  async fetchTeams(teamType) {
-    const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
+  async fetchTeams(competition) {
+    const result = await this.fetchJson(`${API_BASE}/teams?pageSize=500`, TeamListSchema);
     if (!result.success) {
       return result;
     }
-    if (teamType) {
+    if (competition) {
+      const teamType = AFL_API_TEAM_TYPES[competition];
       return ok(result.data.teams.filter((t) => t.teamType === teamType));
     }
     return ok(result.data.teams);
@@ -2252,281 +2409,282 @@ var AflApiClient = class {
   }
 };
 
-// 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_AGENT2 = "fitzRoy-ts/1.0 (https://github.com/jackemcpherson/fitzRoy-ts)";
-var SquiggleClient = class {
-  fetchFn;
-  constructor(options) {
-    this.fetchFn = options?.fetchFn ?? globalThis.fetch.bind(globalThis);
+// src/sources/adapters/afl-api.ts
+var AFL_API_COVERAGE = /* @__PURE__ */ new Map([
+  ["AFLM", { minSeason: 2012 }],
+  ["AFLW", { minSeason: 2017 }],
+  ["VFL", { minSeason: 2021 }],
+  ["VFLW", { minSeason: 2021 }]
+]);
+var AflApiMatchSource = class {
+  constructor(client = new AflApiClient()) {
+    this.client = client;
   }
-  /**
-   * 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_AGENT2 }
-      });
-      if (!response.ok) {
-        return err(
-          new ScrapeError(`Squiggle request failed: ${response.status} (${url})`, "squiggle")
-        );
+  id = "afl-api";
+  coverage = AFL_API_COVERAGE;
+  async fetchMatches(query) {
+    const competition = query.competition ?? "AFLM";
+    const seasonResult = await this.client.resolveCompSeason(competition, query.season);
+    if (!seasonResult.success) return seasonResult;
+    const includeUpcoming = query.status !== "Complete";
+    const itemsResult = query.round != null ? await this.client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round) : await this.client.fetchSeasonMatchItems(seasonResult.data, { includeUpcoming });
+    if (!itemsResult.success) return itemsResult;
+    return ok(transformMatchItems(itemsResult.data, query.season, competition));
+  }
+};
+var AflApiPlayerStatsSource = class {
+  constructor(client = new AflApiClient()) {
+    this.client = client;
+  }
+  id = "afl-api";
+  coverage = AFL_API_COVERAGE;
+  async fetchPlayerStats(query) {
+    const competition = query.competition ?? "AFLM";
+    if (query.matchId) {
+      const [rosterResult, statsResult] = await Promise.all([
+        this.client.fetchMatchRoster(query.matchId),
+        this.client.fetchPlayerStats(query.matchId)
+      ]);
+      if (!statsResult.success) return statsResult;
+      const teamIdMap2 = new Map(AFL_API_TEAM_IDS);
+      if (rosterResult.success) {
+        const match = rosterResult.data.match;
+        teamIdMap2.set(match.homeTeamId, normaliseTeamName(match.homeTeam.name));
+        teamIdMap2.set(match.awayTeamId, normaliseTeamName(match.awayTeam.name));
       }
-      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"
-        )
+      return ok(
+        transformPlayerStats(statsResult.data, {
+          matchId: query.matchId,
+          season: query.season,
+          roundNumber: query.round ?? 0,
+          competition,
+          source: "afl-api",
+          teamIdMap: teamIdMap2
+        })
       );
     }
-  }
-  /**
-   * 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")
+    const seasonResult = await this.client.resolveCompSeason(competition, query.season);
+    if (!seasonResult.success) return seasonResult;
+    const matchItemsResult = query.round != null ? await this.client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round) : await this.client.fetchSeasonMatchItems(seasonResult.data);
+    if (!matchItemsResult.success) return matchItemsResult;
+    const teamIdMap = /* @__PURE__ */ new Map();
+    for (const item of matchItemsResult.data) {
+      teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
+      teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
+    }
+    const statsResults = await batchedMap(
+      matchItemsResult.data,
+      (item) => this.client.fetchPlayerStats(item.match.matchId)
+    );
+    const allStats = [];
+    for (let i = 0; i < statsResults.length; i++) {
+      const statsResult = statsResults[i];
+      if (!statsResult?.success) {
+        return statsResult ?? err(new AflApiError("Missing stats result"));
+      }
+      const item = matchItemsResult.data[i];
+      if (!item) continue;
+      allStats.push(
+        ...transformPlayerStats(statsResult.data, {
+          matchId: item.match.matchId,
+          season: query.season,
+          roundNumber: item.round?.roundNumber ?? query.round ?? 0,
+          competition,
+          source: "afl-api",
+          teamIdMap,
+          date: parseDate(item.match.utcStartTime) ?? new Date(item.match.utcStartTime),
+          homeTeam: normaliseTeamName(item.match.homeTeam.name),
+          awayTeam: normaliseTeamName(item.match.awayTeam.name)
+        })
       );
     }
-    return ok(parsed.data);
+    return ok(allStats);
   }
-  /**
-   * 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")
-      );
+};
+var AflApiSquadSource = class {
+  constructor(client = new AflApiClient()) {
+    this.client = client;
+  }
+  id = "afl-api";
+  coverage = AFL_API_COVERAGE;
+  async fetchSquad(query) {
+    const competition = query.competition ?? "AFLM";
+    const seasonResult = await this.client.resolveCompSeason(competition, query.season);
+    if (!seasonResult.success) return seasonResult;
+    const teamIdResult = await this.resolveTeamId(query.team, competition);
+    if (!teamIdResult.success) return teamIdResult;
+    const squadResult = await this.client.fetchSquad(teamIdResult.data, seasonResult.data);
+    if (!squadResult.success) return squadResult;
+    const players = squadResult.data.squad.players.map((p) => ({
+      playerId: p.player.providerId ?? String(p.player.id),
+      givenName: p.player.firstName,
+      surname: p.player.surname,
+      displayName: `${p.player.firstName} ${p.player.surname}`,
+      jumperNumber: p.jumperNumber ?? null,
+      position: p.position ?? null,
+      dateOfBirth: p.player.dateOfBirth ? parseDate(p.player.dateOfBirth) : null,
+      heightCm: p.player.heightInCm || null,
+      weightKg: p.player.weightInKg || null,
+      draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
+      draftPosition: p.player.draftPosition ? Number.parseInt(p.player.draftPosition, 10) || null : null,
+      draftType: p.player.draftType ?? null,
+      debutYear: p.player.debutYear ? Number.parseInt(p.player.debutYear, 10) || null : null,
+      recruitedFrom: p.player.recruitedFrom ?? null
+    }));
+    return ok({
+      teamId: String(teamIdResult.data),
+      teamName: normaliseTeamName(squadResult.data.squad.team?.name ?? query.team),
+      season: query.season,
+      players,
+      competition
+    });
+  }
+  /** Resolve a canonical team name to the AFL API's numeric team ID. */
+  async resolveTeamId(teamName, competition) {
+    const teamsResult = await this.client.fetchTeams(competition);
+    if (!teamsResult.success) return teamsResult;
+    const normalised = normaliseTeamName(teamName);
+    const match = teamsResult.data.find((t) => normaliseTeamName(t.name) === normalised);
+    if (!match) {
+      return err(new ValidationError(`Team not found in ${competition}: ${teamName}`));
     }
-    return ok(parsed.data);
+    return ok(match.id);
   }
 };
-
-// src/transforms/squiggle.ts
-function toMatchStatus2(complete) {
-  if (complete === 100) return "Complete";
-  if (complete > 0) return "Live";
-  return "Upcoming";
-}
-function transformSquiggleGamesToResults(games, season) {
-  return games.filter((g) => g.complete === 100).map((g) => ({
-    matchId: `SQ_${g.id}`,
-    season,
-    roundNumber: g.round,
-    roundType: inferRoundType(g.roundname),
-    roundName: g.roundname || null,
-    date: parseDate(g.unixtime) ?? new Date(g.unixtime * 1e3),
-    venue: normaliseVenueName(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,
-    weatherTempCelsius: null,
-    weatherType: null,
-    roundCode: toRoundCode(g.roundname),
-    venueState: null,
-    venueTimezone: g.tz || null,
-    homeRushedBehinds: null,
-    awayRushedBehinds: null,
-    homeMinutesInFront: null,
-    awayMinutesInFront: null,
-    source: "squiggle",
-    competition: "AFLM"
-  }));
-}
-function transformSquiggleGamesToFixture(games, season) {
-  return games.map((g) => ({
-    matchId: `SQ_${g.id}`,
-    season,
-    roundNumber: g.round,
-    roundType: inferRoundType(g.roundname),
-    date: parseDate(g.unixtime) ?? new Date(g.unixtime * 1e3),
-    venue: normaliseVenueName(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: parseDate(item.match.utcStartTime) ?? new Date(item.match.utcStartTime),
-    venue: normaliseVenueName(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") {
-    if (competition === "AFLW") return err(aflwUnsupportedError("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));
+var AflApiLineupSource = class {
+  constructor(client = new AflApiClient()) {
+    this.client = client;
   }
-  if (query.source === "footywire") {
-    if (competition === "AFLW") return err(aflwUnsupportedError("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));
+  id = "afl-api";
+  coverage = AFL_API_COVERAGE;
+  async fetchLineup(query) {
+    const competition = query.competition ?? "AFLM";
+    if (query.matchId) {
+      const rosterResult = await this.client.fetchMatchRoster(query.matchId);
+      if (!rosterResult.success) return rosterResult;
+      return ok([transformMatchRoster(rosterResult.data, query.season, query.round, competition)]);
     }
-    return result;
-  }
-  if (query.source !== "afl-api") {
-    return err(
-      new UnsupportedSourceError(
-        "Fixture data is only available from the AFL API, FootyWire, or Squiggle sources.",
-        query.source
-      )
+    const seasonResult = await this.client.resolveCompSeason(competition, query.season);
+    if (!seasonResult.success) return seasonResult;
+    const matchItems = await this.client.fetchRoundMatchItemsByNumber(
+      seasonResult.data,
+      query.round
+    );
+    if (!matchItems.success) return matchItems;
+    if (matchItems.data.length === 0) {
+      return err(new AflApiError(`No matches found for round ${query.round}`));
+    }
+    const rosterResults = await batchedMap(
+      matchItems.data,
+      (item) => this.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);
   }
-  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)));
+};
+var AflApiLadderSource = class {
+  constructor(client = new AflApiClient()) {
+    this.client = client;
   }
-  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 batchedMap(
-    roundProviderIds,
-    (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));
+  id = "afl-api";
+  coverage = AFL_API_COVERAGE;
+  async fetchLadder(query) {
+    const competition = query.competition ?? "AFLM";
+    const seasonResult = await this.client.resolveCompSeason(competition, query.season);
+    if (!seasonResult.success) return seasonResult;
+    let roundId;
+    if (query.round != null) {
+      const roundsResult = await this.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 this.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/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;
+    if (match.homePoints === null || match.awayPoints === null) continue;
+    const homePoints = match.homePoints;
+    const awayPoints = match.awayPoints;
+    const home = getOrCreate(teams, match.homeTeam);
+    const away = getOrCreate(teams, match.awayTeam);
+    home.played++;
+    away.played++;
+    home.pointsFor += homePoints;
+    home.pointsAgainst += awayPoints;
+    away.pointsFor += awayPoints;
+    away.pointsAgainst += homePoints;
+    if (homePoints > awayPoints) {
+      home.wins++;
+      away.losses++;
+    } else if (awayPoints > 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 ok(fixtures);
+  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/sources/afl-tables.ts
@@ -3076,1043 +3234,1209 @@ function parseAflTablesPlayerList(html, teamName) {
       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
-    };
+      draftType: null,
+      debutYear,
+      recruitedFrom: null
+    });
   });
+  return players;
 }
 
-// src/api/ladder.ts
-async function fetchLadder(query) {
-  const competition = query.competition ?? "AFLM";
-  if (query.source === "squiggle") {
-    if (competition === "AFLW") return err(aflwUnsupportedError("squiggle"));
-    const client2 = new SquiggleClient();
-    const result = await client2.fetchStandings(query.season, query.round ?? void 0);
+// src/sources/adapters/afl-tables.ts
+var AFL_TABLES_MATCH_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 1897 }]]);
+var AFL_TABLES_PLAYER_STATS_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 1965 }]]);
+var AFL_TABLES_TEAM_STATS_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 1965 }]]);
+var AFL_TABLES_LADDER_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 1897 }]]);
+var AFL_TABLES_SQUAD_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 1897 }]]);
+var AflTablesMatchSource = class {
+  constructor(client = new AflTablesClient()) {
+    this.client = client;
+  }
+  id = "afl-tables";
+  coverage = AFL_TABLES_MATCH_COVERAGE;
+  async fetchMatches(query) {
+    const result = await this.client.fetchSeasonResults(query.season);
+    if (!result.success) return result;
+    const filtered = query.round != null ? result.data.filter((m) => m.roundNumber === query.round) : result.data;
+    return ok(filtered);
+  }
+};
+var AflTablesPlayerStatsSource = class {
+  constructor(client = new AflTablesClient()) {
+    this.client = client;
+  }
+  id = "afl-tables";
+  coverage = AFL_TABLES_PLAYER_STATS_COVERAGE;
+  async fetchPlayerStats(query) {
+    const result = await this.client.fetchSeasonPlayerStats(query.season);
+    if (!result.success) return result;
+    if (query.round != null) {
+      return ok(result.data.filter((s) => s.roundNumber === query.round));
+    }
+    return result;
+  }
+};
+var AflTablesTeamStatsSource = class {
+  constructor(client = new AflTablesClient()) {
+    this.client = client;
+  }
+  id = "afl-tables";
+  coverage = AFL_TABLES_TEAM_STATS_COVERAGE;
+  async fetchTeamStats(query) {
+    const summaryType = query.summaryType ?? "totals";
+    const statsResult = await this.client.fetchTeamStats(query.season);
+    if (!statsResult.success) return statsResult;
+    const needsGp = statsResult.data.some((e) => e.gamesPlayed === 0);
+    const gpMap = /* @__PURE__ */ new Map();
+    if (needsGp) {
+      const resultsResult = await this.client.fetchSeasonResults(query.season);
+      if (resultsResult.success) {
+        for (const m of resultsResult.data) {
+          const home = normaliseTeamName(m.homeTeam);
+          const away = normaliseTeamName(m.awayTeam);
+          gpMap.set(home, (gpMap.get(home) ?? 0) + 1);
+          gpMap.set(away, (gpMap.get(away) ?? 0) + 1);
+        }
+      }
+    }
+    const enriched = statsResult.data.map((entry) => ({
+      ...entry,
+      gamesPlayed: gpMap.get(normaliseTeamName(entry.team)) ?? entry.gamesPlayed
+    }));
+    if (summaryType === "averages") {
+      return ok(
+        enriched.map((entry) => ({
+          ...entry,
+          stats: Object.fromEntries(
+            Object.entries(entry.stats).map(([k, v]) => [
+              k,
+              entry.gamesPlayed > 0 ? +(v / entry.gamesPlayed).toFixed(1) : 0
+            ])
+          )
+        }))
+      );
+    }
+    return ok(enriched);
+  }
+};
+var AflTablesSquadSource = class {
+  constructor(client = new AflTablesClient()) {
+    this.client = client;
+  }
+  id = "afl-tables";
+  coverage = AFL_TABLES_SQUAD_COVERAGE;
+  async fetchSquad(query) {
+    const competition = query.competition ?? "AFLM";
+    const teamName = normaliseTeamName(query.team);
+    const result = await this.client.fetchPlayerList(teamName);
     if (!result.success) return result;
+    const players = result.data.map((p) => ({
+      playerId: p.playerId,
+      givenName: p.givenName,
+      surname: p.surname,
+      displayName: p.displayName,
+      jumperNumber: p.jumperNumber,
+      position: p.position,
+      dateOfBirth: p.dateOfBirth ? parseDate(p.dateOfBirth) : null,
+      heightCm: p.heightCm,
+      weightKg: p.weightKg,
+      draftYear: p.draftYear,
+      draftPosition: p.draftPosition,
+      draftType: p.draftType,
+      debutYear: p.debutYear,
+      recruitedFrom: p.recruitedFrom,
+      gamesPlayed: p.gamesPlayed,
+      goals: p.goals
+    }));
     return ok({
+      teamId: teamName,
+      teamName,
       season: query.season,
-      roundNumber: query.round ?? null,
-      entries: transformSquiggleStandings(result.data.standings),
+      players,
       competition
     });
   }
-  if (query.source === "afl-tables") {
-    if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
-    const atClient = new AflTablesClient();
-    const resultsResult = await atClient.fetchSeasonResults(query.season);
+};
+var AflTablesLadderSource = class {
+  constructor(client = new AflTablesClient()) {
+    this.client = client;
+  }
+  id = "afl-tables";
+  coverage = AFL_TABLES_LADDER_COVERAGE;
+  async fetchLadder(query) {
+    const competition = query.competition ?? "AFLM";
+    const resultsResult = await this.client.fetchSeasonResults(query.season);
     if (!resultsResult.success) return resultsResult;
-    const entries2 = computeLadder(resultsResult.data, query.round ?? void 0);
+    const entries = computeLadder(resultsResult.data, query.round ?? void 0);
     return ok({
       season: query.season,
       roundNumber: query.round ?? null,
-      entries: entries2,
+      entries,
       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
-      )
+};
+
+// src/sources/adapters/footywire.ts
+var FOOTYWIRE_MATCH_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2010 }]]);
+var FOOTYWIRE_PLAYER_STATS_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2010 }]]);
+var FOOTYWIRE_TEAM_STATS_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2010 }]]);
+var FOOTYWIRE_SQUAD_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2010 }]]);
+var FootyWireMatchSource = class {
+  constructor(client = new FootyWireClient()) {
+    this.client = client;
+  }
+  id = "footywire";
+  coverage = FOOTYWIRE_MATCH_COVERAGE;
+  async fetchMatches(query) {
+    const result = await this.client.fetchSeasonFixture(query.season);
+    if (!result.success) return result;
+    const filtered = query.round != null ? result.data.filter((m) => m.roundNumber === query.round) : result.data;
+    return ok(filtered);
+  }
+};
+var FootyWirePlayerStatsSource = class {
+  constructor(client = new FootyWireClient()) {
+    this.client = client;
+  }
+  id = "footywire";
+  coverage = FOOTYWIRE_PLAYER_STATS_COVERAGE;
+  async fetchPlayerStats(query) {
+    const idsResult = await this.client.fetchSeasonMatchIds(query.season);
+    if (!idsResult.success) return idsResult;
+    const entries = query.round != null ? idsResult.data.filter((e) => e.roundNumber === query.round) : idsResult.data;
+    if (entries.length === 0) return ok([]);
+    const results = await batchedMap(
+      entries,
+      (e) => this.client.fetchMatchPlayerStats(e.matchId, query.season, e.roundNumber),
+      { batchSize: 5, delayMs: 500 }
     );
+    const allStats = [];
+    for (const result of results) {
+      if (result.success) {
+        allStats.push(...result.data);
+      }
+    }
+    return ok(allStats);
   }
-  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;
+};
+var FootyWireSquadSource = class {
+  constructor(client = new FootyWireClient()) {
+    this.client = client;
+  }
+  id = "footywire";
+  coverage = FOOTYWIRE_SQUAD_COVERAGE;
+  async fetchSquad(query) {
+    const competition = query.competition ?? "AFLM";
+    const teamName = normaliseTeamName(query.team);
+    const result = await this.client.fetchPlayerList(teamName);
+    if (!result.success) return result;
+    const players = result.data.map((p) => ({
+      playerId: p.playerId,
+      givenName: p.givenName,
+      surname: p.surname,
+      displayName: p.displayName,
+      jumperNumber: p.jumperNumber,
+      position: p.position,
+      dateOfBirth: p.dateOfBirth ? parseDate(p.dateOfBirth) : null,
+      heightCm: p.heightCm,
+      weightKg: p.weightKg,
+      draftYear: p.draftYear,
+      draftPosition: p.draftPosition,
+      draftType: p.draftType,
+      debutYear: p.debutYear,
+      recruitedFrom: p.recruitedFrom,
+      gamesPlayed: p.gamesPlayed,
+      goals: p.goals
+    }));
+    return ok({
+      teamId: teamName,
+      teamName,
+      season: query.season,
+      players,
+      competition
+    });
+  }
+};
+var FootyWireTeamStatsSource = class {
+  constructor(client = new FootyWireClient()) {
+    this.client = client;
+  }
+  id = "footywire";
+  coverage = FOOTYWIRE_TEAM_STATS_COVERAGE;
+  async fetchTeamStats(query) {
+    const summaryType = query.summaryType ?? "totals";
+    return this.client.fetchTeamStats(query.season, summaryType);
+  }
+};
+
+// src/transforms/fryzigg-player-stats.ts
+var REQUIRED_COLUMN_GROUPS = [
+  ["match_id"],
+  ["match_date", "date"],
+  ["player_id"],
+  ["player_team", "team"]
+];
+var AFLM_COLUMNS = {
+  date: "match_date",
+  homeTeam: "match_home_team",
+  awayTeam: "match_away_team",
+  team: "player_team",
+  round: "match_round",
+  jumperNumber: "guernsey_number",
+  firstName: "player_first_name",
+  lastName: "player_last_name",
+  playerName: void 0,
+  freesFor: "free_kicks_for",
+  freesAgainst: "free_kicks_against",
+  totalClearances: "clearances",
+  inside50s: "inside_fifties",
+  rebound50s: "rebounds",
+  disposalEfficiency: "disposal_efficiency_percentage",
+  marksInside50: "marks_inside_fifty",
+  tacklesInside50: "tackles_inside_fifty",
+  timeOnGround: "time_on_ground_percentage",
+  position: "player_position",
+  dreamTeamPoints: "afl_fantasy_score",
+  totalPossessions: void 0
+};
+var AFLW_COLUMNS = {
+  date: "date",
+  homeTeam: "home_team",
+  awayTeam: "away_team",
+  team: "team",
+  round: "fixture_round",
+  jumperNumber: "number",
+  firstName: void 0,
+  lastName: void 0,
+  playerName: "player_name",
+  freesFor: "frees_for",
+  freesAgainst: "frees_against",
+  totalClearances: "total_clearances",
+  inside50s: "inside50s",
+  rebound50s: "rebound50s",
+  disposalEfficiency: "disposal_efficiency",
+  marksInside50: "marks_inside50",
+  tacklesInside50: "tackles_inside50",
+  timeOnGround: "time_on_ground",
+  position: "position",
+  dreamTeamPoints: "fantasy_score",
+  totalPossessions: "total_possessions"
+};
+function transformFryziggPlayerStats(frame, options) {
+  const colIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < frame.names.length; i++) {
+    const name = frame.names[i];
+    if (name !== void 0) {
+      colIndex.set(name, i);
+    }
+  }
+  for (const group of REQUIRED_COLUMN_GROUPS) {
+    if (!group.some((name) => colIndex.has(name))) {
+      return err(
+        new ScrapeError(
+          `Fryzigg data frame missing required column: "${group.join('" or "')}"`,
+          "fryzigg"
+        )
+      );
+    }
+  }
+  const getCol = (name) => {
+    if (name === void 0) return void 0;
+    const idx = colIndex.get(name);
+    if (idx === void 0) return void 0;
+    return frame.columns[idx];
+  };
+  const isAflw = options.competition === "AFLW";
+  const mapping = isAflw ? AFLW_COLUMNS : AFLM_COLUMNS;
+  const cols = {
+    matchId: getCol("match_id"),
+    date: getCol(mapping.date),
+    homeTeam: getCol(mapping.homeTeam),
+    awayTeam: getCol(mapping.awayTeam),
+    team: getCol(mapping.team),
+    round: getCol(mapping.round),
+    jumperNumber: getCol(mapping.jumperNumber),
+    playerId: getCol("player_id"),
+    firstName: getCol(mapping.firstName),
+    lastName: getCol(mapping.lastName),
+    playerName: getCol(mapping.playerName),
+    kicks: getCol("kicks"),
+    handballs: getCol("handballs"),
+    disposals: getCol("disposals"),
+    marks: getCol("marks"),
+    goals: getCol("goals"),
+    behinds: getCol("behinds"),
+    tackles: getCol("tackles"),
+    hitouts: getCol("hitouts"),
+    freesFor: getCol(mapping.freesFor),
+    freesAgainst: getCol(mapping.freesAgainst),
+    contestedPossessions: getCol("contested_possessions"),
+    uncontestedPossessions: getCol("uncontested_possessions"),
+    contestedMarks: getCol("contested_marks"),
+    intercepts: getCol("intercepts"),
+    centreClearances: getCol("centre_clearances"),
+    stoppageClearances: getCol("stoppage_clearances"),
+    totalClearances: getCol(mapping.totalClearances),
+    inside50s: getCol(mapping.inside50s),
+    rebound50s: getCol(mapping.rebound50s),
+    clangers: getCol("clangers"),
+    turnovers: getCol("turnovers"),
+    onePercenters: getCol("one_percenters"),
+    bounces: getCol("bounces"),
+    goalAssists: getCol("goal_assists"),
+    disposalEfficiency: getCol(mapping.disposalEfficiency),
+    metresGained: getCol("metres_gained"),
+    marksInside50: getCol(mapping.marksInside50),
+    tacklesInside50: getCol(mapping.tacklesInside50),
+    shotsAtGoal: getCol("shots_at_goal"),
+    scoreInvolvements: getCol("score_involvements"),
+    totalPossessions: getCol(mapping.totalPossessions),
+    timeOnGround: getCol(mapping.timeOnGround),
+    ratingPoints: getCol("rating_points"),
+    position: getCol(mapping.position),
+    brownlowVotes: getCol("brownlow_votes"),
+    supercoachScore: getCol("supercoach_score"),
+    dreamTeamPoints: getCol(mapping.dreamTeamPoints),
+    effectiveDisposals: getCol("effective_disposals"),
+    effectiveKicks: getCol("effective_kicks"),
+    pressureActs: getCol("pressure_acts"),
+    defHalfPressureActs: getCol("def_half_pressure_acts"),
+    spoils: getCol("spoils"),
+    hitoutsToAdvantage: getCol("hitouts_to_advantage"),
+    hitoutWinPercentage: getCol("hitout_win_percentage"),
+    groundBallGets: getCol("ground_ball_gets"),
+    f50GroundBallGets: getCol("f50_ground_ball_gets"),
+    interceptMarks: getCol("intercept_marks"),
+    marksOnLead: getCol("marks_on_lead"),
+    contestOffOneOnOnes: getCol("contest_off_one_on_ones"),
+    contestOffWins: getCol("contest_off_wins"),
+    contestDefOneOnOnes: getCol("contest_def_one_on_ones"),
+    contestDefLosses: getCol("contest_def_losses"),
+    ruckContests: getCol("ruck_contests"),
+    scoreLaunches: getCol("score_launches")
+  };
+  const dateCol = cols.date;
+  const roundCol = cols.round;
+  const nRows = dateCol ? dateCol.length : 0;
+  const hasFilters = options.season !== void 0 || options.round !== void 0;
+  let rowIndices = null;
+  let rowCount = nRows;
+  if (hasFilters) {
+    const matching = [];
+    for (let i = 0; i < nRows; i++) {
+      if (options.season !== void 0) {
+        const dateStr = dateCol?.[i];
+        if (typeof dateStr !== "string") continue;
+        const year = Number(dateStr.slice(0, 4));
+        if (year !== options.season) continue;
+      }
+      if (options.round !== void 0 && roundCol) {
+        const roundVal = roundCol[i];
+        const roundNum = typeof roundVal === "string" ? Number(roundVal) : roundVal;
+        if (roundNum !== options.round) continue;
+      }
+      matching.push(i);
     }
+    rowIndices = matching;
+    rowCount = matching.length;
+  }
+  const stats = new Array(rowCount);
+  for (let j = 0; j < rowCount; j++) {
+    const i = rowIndices ? rowIndices[j] : j;
+    stats[j] = mapRow(i, cols, isAflw, options.competition);
+  }
+  return ok(stats);
+}
+function numAt(column, i) {
+  if (!column) return null;
+  const v = column[i];
+  return typeof v === "number" ? v : null;
+}
+function strAt(column, i) {
+  if (!column) return null;
+  const v = column[i];
+  return typeof v === "string" ? v : null;
+}
+function roundAt(column, i) {
+  if (!column) return 0;
+  const v = column[i];
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isNaN(n) ? 0 : n;
   }
-  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
-  });
+  return 0;
 }
-
-// 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)
-    };
-  });
+function mapRow(i, c, isAflw, competition) {
+  const dateStr = strAt(c.date, i);
+  let firstName;
+  let lastName;
+  if (isAflw) {
+    const playerName = strAt(c.playerName, i) ?? "";
+    const commaIdx = playerName.indexOf(", ");
+    firstName = commaIdx >= 0 ? playerName.slice(0, commaIdx) : playerName;
+    lastName = commaIdx >= 0 ? playerName.slice(commaIdx + 2) : "";
+  } else {
+    firstName = strAt(c.firstName, i) ?? "";
+    lastName = strAt(c.lastName, i) ?? "";
+  }
+  const team = strAt(c.team, i) ?? "";
+  const homeTeam = strAt(c.homeTeam, i);
+  const awayTeam = strAt(c.awayTeam, i);
   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
+    matchId: String(c.matchId?.[i] ?? ""),
+    season: dateStr ? Number(dateStr.slice(0, 4)) : 0,
+    roundNumber: roundAt(c.round, i),
+    team: normaliseTeamName(team),
+    competition,
+    date: dateStr ? parseDate(dateStr) : null,
+    homeTeam: homeTeam ? normaliseTeamName(homeTeam) : null,
+    awayTeam: awayTeam ? normaliseTeamName(awayTeam) : null,
+    playerId: String(c.playerId?.[i] ?? ""),
+    givenName: firstName,
+    surname: lastName,
+    displayName: `${firstName} ${lastName}`.trim(),
+    jumperNumber: numAt(c.jumperNumber, i),
+    kicks: numAt(c.kicks, i),
+    handballs: numAt(c.handballs, i),
+    disposals: numAt(c.disposals, i),
+    marks: numAt(c.marks, i),
+    goals: numAt(c.goals, i),
+    behinds: numAt(c.behinds, i),
+    tackles: numAt(c.tackles, i),
+    hitouts: numAt(c.hitouts, i),
+    freesFor: numAt(c.freesFor, i),
+    freesAgainst: numAt(c.freesAgainst, i),
+    contestedPossessions: numAt(c.contestedPossessions, i),
+    uncontestedPossessions: numAt(c.uncontestedPossessions, i),
+    contestedMarks: numAt(c.contestedMarks, i),
+    intercepts: numAt(c.intercepts, i),
+    centreClearances: numAt(c.centreClearances, i),
+    stoppageClearances: numAt(c.stoppageClearances, i),
+    totalClearances: numAt(c.totalClearances, i),
+    inside50s: numAt(c.inside50s, i),
+    rebound50s: numAt(c.rebound50s, i),
+    clangers: numAt(c.clangers, i),
+    turnovers: numAt(c.turnovers, i),
+    onePercenters: numAt(c.onePercenters, i),
+    bounces: numAt(c.bounces, i),
+    goalAssists: numAt(c.goalAssists, i),
+    disposalEfficiency: numAt(c.disposalEfficiency, i),
+    metresGained: numAt(c.metresGained, i),
+    goalAccuracy: null,
+    marksInside50: numAt(c.marksInside50, i),
+    tacklesInside50: numAt(c.tacklesInside50, i),
+    shotsAtGoal: numAt(c.shotsAtGoal, i),
+    scoreInvolvements: numAt(c.scoreInvolvements, i),
+    totalPossessions: numAt(c.totalPossessions, i),
+    timeOnGroundPercentage: numAt(c.timeOnGround, i),
+    ratingPoints: numAt(c.ratingPoints, i),
+    position: strAt(c.position, i),
+    goalEfficiency: null,
+    shotEfficiency: null,
+    interchangeCounts: null,
+    brownlowVotes: numAt(c.brownlowVotes, i),
+    supercoachScore: numAt(c.supercoachScore, i),
+    dreamTeamPoints: numAt(c.dreamTeamPoints, i),
+    effectiveDisposals: numAt(c.effectiveDisposals, i),
+    effectiveKicks: numAt(c.effectiveKicks, i),
+    kickEfficiency: null,
+    kickToHandballRatio: null,
+    pressureActs: numAt(c.pressureActs, i),
+    defHalfPressureActs: numAt(c.defHalfPressureActs, i),
+    spoils: numAt(c.spoils, i),
+    hitoutsToAdvantage: numAt(c.hitoutsToAdvantage, i),
+    hitoutWinPercentage: numAt(c.hitoutWinPercentage, i),
+    hitoutToAdvantageRate: null,
+    groundBallGets: numAt(c.groundBallGets, i),
+    f50GroundBallGets: numAt(c.f50GroundBallGets, i),
+    interceptMarks: numAt(c.interceptMarks, i),
+    marksOnLead: numAt(c.marksOnLead, i),
+    contestedPossessionRate: null,
+    contestOffOneOnOnes: numAt(c.contestOffOneOnOnes, i),
+    contestOffWins: numAt(c.contestOffWins, i),
+    contestOffWinsPercentage: null,
+    contestDefOneOnOnes: numAt(c.contestDefOneOnOnes, i),
+    contestDefLosses: numAt(c.contestDefLosses, i),
+    contestDefLossPercentage: null,
+    centreBounceAttendances: null,
+    kickins: null,
+    kickinsPlayon: null,
+    ruckContests: numAt(c.ruckContests, i),
+    scoreLaunches: numAt(c.scoreLaunches, i),
+    source: "fryzigg"
   };
 }
 
-// src/api/lineup.ts
-async function fetchLineup(query) {
-  const competition = query.competition ?? "AFLM";
-  if (query.source !== "afl-api") {
-    return err(
-      new UnsupportedSourceError(
-        "Lineup data is only available from the AFL API source.",
-        query.source
-      )
-    );
-  }
-  const client = new AflApiClient();
-  if (query.matchId) {
-    const rosterResult = await client.fetchMatchRoster(query.matchId);
-    if (!rosterResult.success) return rosterResult;
-    return ok([transformMatchRoster(rosterResult.data, query.season, query.round, competition)]);
-  }
-  const seasonResult = await client.resolveCompSeason(competition, query.season);
-  if (!seasonResult.success) return seasonResult;
-  const matchItems = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
-  if (!matchItems.success) return matchItems;
-  if (matchItems.data.length === 0) {
-    return err(new AflApiError(`No matches found for round ${query.round}`));
-  }
-  const rosterResults = await batchedMap(
-    matchItems.data,
-    (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));
+// src/sources/fryzigg.ts
+import { isDataFrame, parseRds, RdsError } from "@jackemcpherson/rds-js";
+var FRYZIGG_URLS = {
+  AFLM: "http://www.fryziggafl.net/static/fryziggafl.rds",
+  AFLW: "http://www.fryziggafl.net/static/aflw_player_stats.rds"
+};
+var USER_AGENT2 = "fitzRoy-ts/1.0 (https://github.com/jackemcpherson/fitzRoy-ts)";
+var FryziggClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch.bind(globalThis);
   }
-  return ok(lineups);
-}
-
-// src/api/match-results.ts
-async function fetchMatchResults(query) {
-  const competition = query.competition ?? "AFLM";
-  switch (query.source) {
-    case "afl-api": {
-      const client = new AflApiClient();
-      const seasonResult = await client.resolveCompSeason(competition, query.season);
-      if (!seasonResult.success) return seasonResult;
-      if (query.round != null) {
-        const itemsResult2 = await client.fetchRoundMatchItemsByNumber(
-          seasonResult.data,
-          query.round
+  /**
+   * Fetch the full player statistics dataset for a competition.
+   *
+   * Returns column-major DataFrame from rds-js. The caller is responsible
+   * for filtering rows and mapping to domain types.
+   *
+   * @param competition - AFLM or AFLW.
+   * @returns Column-major DataFrame with all rows, or an error.
+   */
+  async fetchPlayerStats(competition) {
+    const url = FRYZIGG_URLS[competition];
+    if (!url) {
+      return err(new ScrapeError(`Fryzigg does not publish ${competition} data`, "fryzigg"));
+    }
+    try {
+      const response = await this.fetchFn(url, {
+        headers: { "User-Agent": USER_AGENT2 }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(`Fryzigg request failed: ${response.status} (${url})`, "fryzigg")
         );
-        if (!itemsResult2.success) return itemsResult2;
-        return ok(transformMatchItems(itemsResult2.data, query.season, competition));
       }
-      const itemsResult = await client.fetchSeasonMatchItems(seasonResult.data);
-      if (!itemsResult.success) return itemsResult;
-      return ok(transformMatchItems(itemsResult.data, query.season, competition));
-    }
-    case "footywire": {
-      if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
-      const client = new FootyWireClient();
-      const result = await client.fetchSeasonResults(query.season);
-      if (!result.success) return result;
-      if (query.round != null) {
-        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      const buffer = new Uint8Array(await response.arrayBuffer());
+      const result = await parseRds(buffer);
+      if (!isDataFrame(result)) {
+        return err(new ScrapeError("Fryzigg RDS file did not contain a data frame", "fryzigg"));
       }
-      return result;
-    }
-    case "afl-tables": {
-      if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
-      const client = new AflTablesClient();
-      const result = await client.fetchSeasonResults(query.season);
-      if (!result.success) return result;
-      if (query.round != null) {
-        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      return ok(result);
+    } catch (cause) {
+      if (cause instanceof RdsError) {
+        return err(new ScrapeError(`Fryzigg RDS parse error: ${cause.message}`, "fryzigg"));
       }
-      return result;
-    }
-    case "squiggle": {
-      if (competition === "AFLW") return err(aflwUnsupportedError("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));
+      return err(
+        new ScrapeError(
+          `Fryzigg request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "fryzigg"
+        )
+      );
     }
-    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}`));
+// src/sources/adapters/fryzigg.ts
+var FRYZIGG_PLAYER_STATS_COVERAGE = /* @__PURE__ */ new Map([
+  ["AFLM", { minSeason: 2012 }],
+  ["AFLW", { minSeason: 2017 }]
+]);
+var FryziggPlayerStatsSource = class {
+  constructor(client = new FryziggClient()) {
+    this.client = client;
   }
-  return ok(String(match.id));
-}
-function mapSquadToPlayerDetails(data, fallbackTeamName, competition) {
-  const resolvedName = normaliseTeamName(data.squad.team?.name ?? fallbackTeamName);
-  return 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: resolvedName,
-    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
-  }));
+  id = "fryzigg";
+  coverage = FRYZIGG_PLAYER_STATS_COVERAGE;
+  async fetchPlayerStats(query) {
+    const competition = query.competition ?? "AFLM";
+    const result = await this.client.fetchPlayerStats(competition);
+    if (!result.success) return result;
+    return transformFryziggPlayerStats(result.data, {
+      competition,
+      season: query.season,
+      round: query.round
+    });
+  }
+};
+
+// src/sources/adapters/registry.ts
+var CapabilityRegistry = class {
+  constructor(defaultSource) {
+    this.defaultSource = defaultSource;
+  }
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.id, adapter);
+  }
+  get(id) {
+    return this.adapters.get(id);
+  }
+  list() {
+    return [...this.adapters.keys()];
+  }
+  all() {
+    return [...this.adapters.values()];
+  }
+};
+var matchRegistry = new CapabilityRegistry("afl-api");
+var playerStatsRegistry = new CapabilityRegistry("afl-api");
+var teamStatsRegistry = new CapabilityRegistry("afl-tables");
+var squadRegistry = new CapabilityRegistry("afl-api");
+var lineupRegistry = new CapabilityRegistry("afl-api");
+var ladderRegistry = new CapabilityRegistry("afl-api");
+
+// src/transforms/squiggle.ts
+function toMatchStatus2(complete) {
+  if (complete === 100) return "Complete";
+  if (complete > 0) return "Live";
+  return "Upcoming";
 }
-async function fetchFromAflApi(query) {
-  const client = new AflApiClient();
-  const competition = query.competition ?? "AFLM";
-  const season = query.season ?? resolveDefaultSeason(competition);
-  const seasonResult = await client.resolveCompSeason(competition, season);
-  if (!seasonResult.success) return seasonResult;
-  if (query.team) {
-    const teamIdResult = await resolveTeamId(client, query.team, competition);
-    if (!teamIdResult.success) return teamIdResult;
-    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;
-    return ok(mapSquadToPlayerDetails(squadResult.data, query.team, competition));
-  }
-  const teamType = competition === "AFLW" ? "WOMEN" : "MEN";
-  const teamsResult = await client.fetchTeams(teamType);
-  if (!teamsResult.success) return teamsResult;
-  const teamEntries = teamsResult.data.map((t) => ({
-    id: Number.parseInt(String(t.id), 10),
-    name: normaliseTeamName(t.name)
+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),
+    roundName: g.roundname || null,
+    date: parseDate(g.unixtime) ?? new Date(g.unixtime * 1e3),
+    venue: normaliseVenueName(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,
+    weatherTempCelsius: null,
+    weatherType: null,
+    roundCode: toRoundCode(g.roundname),
+    venueState: null,
+    venueTimezone: g.tz || null,
+    homeRushedBehinds: null,
+    awayRushedBehinds: null,
+    homeMinutesInFront: null,
+    awayMinutesInFront: null,
+    source: "squiggle",
+    competition: "AFLM"
   }));
-  const results = await batchedMap(
-    teamEntries,
-    (entry) => client.fetchSquad(entry.id, seasonResult.data)
-  );
-  const allPlayers = [];
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    const entry = teamEntries[i];
-    if (result?.success && entry) {
-      allPlayers.push(...mapSquadToPlayerDetails(result.data, entry.name, competition));
-    }
-  }
-  return ok(allPlayers);
 }
-async function fetchAllTeamsFromScraper(fetchFn, source, competition) {
-  const teamNames = [...AFL_SENIOR_TEAMS];
-  const results = await batchedMap(teamNames, (name) => fetchFn(name));
-  const allPlayers = [];
-  for (const result of results) {
-    if (result.success) {
-      allPlayers.push(...result.data.map((p) => ({ ...p, source, competition })));
-    }
-  }
-  return ok(allPlayers);
-}
-async function fetchFromFootyWire(query) {
-  const competition = query.competition ?? "AFLM";
-  if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
-  const client = new FootyWireClient();
-  if (query.team) {
-    const teamName = normaliseTeamName(query.team);
-    const result = await client.fetchPlayerList(teamName);
-    if (!result.success) return result;
-    return ok(result.data.map((p) => ({ ...p, source: "footywire", competition })));
-  }
-  return fetchAllTeamsFromScraper((name) => client.fetchPlayerList(name), "footywire", competition);
-}
-async function fetchFromAflTables(query) {
-  const competition = query.competition ?? "AFLM";
-  if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
-  const client = new AflTablesClient();
-  if (query.team) {
-    const teamName = normaliseTeamName(query.team);
-    const result = await client.fetchPlayerList(teamName);
-    if (!result.success) return result;
-    return ok(result.data.map((p) => ({ ...p, source: "afl-tables", competition })));
-  }
-  return fetchAllTeamsFromScraper(
-    (name) => client.fetchPlayerList(name),
-    "afl-tables",
-    competition
-  );
+function transformSquiggleGamesToFixture(games, season) {
+  return games.map((g) => {
+    const status = toMatchStatus2(g.complete);
+    const isComplete = status === "Complete";
+    return {
+      matchId: `SQ_${g.id}`,
+      season,
+      roundNumber: g.round,
+      roundType: inferRoundType(g.roundname),
+      roundName: g.roundname || null,
+      date: parseDate(g.unixtime) ?? new Date(g.unixtime * 1e3),
+      venue: normaliseVenueName(g.venue),
+      homeTeam: normaliseTeamName(g.hteam),
+      awayTeam: normaliseTeamName(g.ateam),
+      homeGoals: isComplete ? g.hgoals ?? 0 : null,
+      homeBehinds: isComplete ? g.hbehinds ?? 0 : null,
+      homePoints: isComplete ? g.hscore ?? 0 : null,
+      awayGoals: isComplete ? g.agoals ?? 0 : null,
+      awayBehinds: isComplete ? g.abehinds ?? 0 : null,
+      awayPoints: isComplete ? g.ascore ?? 0 : null,
+      margin: isComplete ? (g.hscore ?? 0) - (g.ascore ?? 0) : null,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
+      status,
+      attendance: null,
+      weatherTempCelsius: null,
+      weatherType: null,
+      roundCode: toRoundCode(g.roundname),
+      venueState: null,
+      venueTimezone: g.tz || null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "squiggle",
+      competition: "AFLM"
+    };
+  });
 }
-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
-        )
-      );
-  }
+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/sources/fryzigg.ts
-import { isDataFrame, parseRds, RdsError } from "@jackemcpherson/rds-js";
-var FRYZIGG_URLS = {
-  AFLM: "http://www.fryziggafl.net/static/fryziggafl.rds",
-  AFLW: "http://www.fryziggafl.net/static/aflw_player_stats.rds"
-};
+// 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_AGENT3 = "fitzRoy-ts/1.0 (https://github.com/jackemcpherson/fitzRoy-ts)";
-var FryziggClient = class {
+var SquiggleClient = class {
   fetchFn;
   constructor(options) {
     this.fetchFn = options?.fetchFn ?? globalThis.fetch.bind(globalThis);
   }
   /**
-   * Fetch the full player statistics dataset for a competition.
-   *
-   * Returns column-major DataFrame from rds-js. The caller is responsible
-   * for filtering rows and mapping to domain types.
-   *
-   * @param competition - AFLM or AFLW.
-   * @returns Column-major DataFrame with all rows, or an error.
+   * Fetch JSON from the Squiggle API.
    */
-  async fetchPlayerStats(competition) {
-    const url = FRYZIGG_URLS[competition];
+  async fetchJson(params) {
+    const url = `${SQUIGGLE_BASE}?${params.toString()}`;
     try {
       const response = await this.fetchFn(url, {
         headers: { "User-Agent": USER_AGENT3 }
       });
       if (!response.ok) {
         return err(
-          new ScrapeError(`Fryzigg request failed: ${response.status} (${url})`, "fryzigg")
+          new ScrapeError(`Squiggle request failed: ${response.status} (${url})`, "squiggle")
         );
       }
-      const buffer = new Uint8Array(await response.arrayBuffer());
-      const result = await parseRds(buffer);
-      if (!isDataFrame(result)) {
-        return err(new ScrapeError("Fryzigg RDS file did not contain a data frame", "fryzigg"));
-      }
-      return ok(result);
+      const json = await response.json();
+      return ok(json);
     } catch (cause) {
-      if (cause instanceof RdsError) {
-        return err(new ScrapeError(`Fryzigg RDS parse error: ${cause.message}`, "fryzigg"));
-      }
       return err(
         new ScrapeError(
-          `Fryzigg request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-          "fryzigg"
+          `Squiggle request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "squiggle"
         )
       );
     }
   }
-};
-
-// src/transforms/fryzigg-player-stats.ts
-var REQUIRED_COLUMN_GROUPS = [
-  ["match_id"],
-  ["match_date", "date"],
-  ["player_id"],
-  ["player_team", "team"]
-];
-var AFLM_COLUMNS = {
-  date: "match_date",
-  homeTeam: "match_home_team",
-  awayTeam: "match_away_team",
-  team: "player_team",
-  round: "match_round",
-  jumperNumber: "guernsey_number",
-  firstName: "player_first_name",
-  lastName: "player_last_name",
-  playerName: void 0,
-  freesFor: "free_kicks_for",
-  freesAgainst: "free_kicks_against",
-  totalClearances: "clearances",
-  inside50s: "inside_fifties",
-  rebound50s: "rebounds",
-  disposalEfficiency: "disposal_efficiency_percentage",
-  marksInside50: "marks_inside_fifty",
-  tacklesInside50: "tackles_inside_fifty",
-  timeOnGround: "time_on_ground_percentage",
-  position: "player_position",
-  dreamTeamPoints: "afl_fantasy_score",
-  totalPossessions: void 0
-};
-var AFLW_COLUMNS = {
-  date: "date",
-  homeTeam: "home_team",
-  awayTeam: "away_team",
-  team: "team",
-  round: "fixture_round",
-  jumperNumber: "number",
-  firstName: void 0,
-  lastName: void 0,
-  playerName: "player_name",
-  freesFor: "frees_for",
-  freesAgainst: "frees_against",
-  totalClearances: "total_clearances",
-  inside50s: "inside50s",
-  rebound50s: "rebound50s",
-  disposalEfficiency: "disposal_efficiency",
-  marksInside50: "marks_inside50",
-  tacklesInside50: "tackles_inside50",
-  timeOnGround: "time_on_ground",
-  position: "position",
-  dreamTeamPoints: "fantasy_score",
-  totalPossessions: "total_possessions"
-};
-function transformFryziggPlayerStats(frame, options) {
-  const colIndex = /* @__PURE__ */ new Map();
-  for (let i = 0; i < frame.names.length; i++) {
-    const name = frame.names[i];
-    if (name !== void 0) {
-      colIndex.set(name, i);
+  /**
+   * 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);
   }
-  for (const group of REQUIRED_COLUMN_GROUPS) {
-    if (!group.some((name) => colIndex.has(name))) {
+  /**
+   * 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(
-          `Fryzigg data frame missing required column: "${group.join('" or "')}"`,
-          "fryzigg"
-        )
+        new ScrapeError(`Invalid Squiggle standings response: ${parsed.error.message}`, "squiggle")
       );
     }
+    return ok(parsed.data);
   }
-  const getCol = (name) => {
-    if (name === void 0) return void 0;
-    const idx = colIndex.get(name);
-    if (idx === void 0) return void 0;
-    return frame.columns[idx];
-  };
-  const isAflw = options.competition === "AFLW";
-  const mapping = isAflw ? AFLW_COLUMNS : AFLM_COLUMNS;
-  const cols = {
-    matchId: getCol("match_id"),
-    date: getCol(mapping.date),
-    homeTeam: getCol(mapping.homeTeam),
-    awayTeam: getCol(mapping.awayTeam),
-    team: getCol(mapping.team),
-    round: getCol(mapping.round),
-    jumperNumber: getCol(mapping.jumperNumber),
-    playerId: getCol("player_id"),
-    firstName: getCol(mapping.firstName),
-    lastName: getCol(mapping.lastName),
-    playerName: getCol(mapping.playerName),
-    kicks: getCol("kicks"),
-    handballs: getCol("handballs"),
-    disposals: getCol("disposals"),
-    marks: getCol("marks"),
-    goals: getCol("goals"),
-    behinds: getCol("behinds"),
-    tackles: getCol("tackles"),
-    hitouts: getCol("hitouts"),
-    freesFor: getCol(mapping.freesFor),
-    freesAgainst: getCol(mapping.freesAgainst),
-    contestedPossessions: getCol("contested_possessions"),
-    uncontestedPossessions: getCol("uncontested_possessions"),
-    contestedMarks: getCol("contested_marks"),
-    intercepts: getCol("intercepts"),
-    centreClearances: getCol("centre_clearances"),
-    stoppageClearances: getCol("stoppage_clearances"),
-    totalClearances: getCol(mapping.totalClearances),
-    inside50s: getCol(mapping.inside50s),
-    rebound50s: getCol(mapping.rebound50s),
-    clangers: getCol("clangers"),
-    turnovers: getCol("turnovers"),
-    onePercenters: getCol("one_percenters"),
-    bounces: getCol("bounces"),
-    goalAssists: getCol("goal_assists"),
-    disposalEfficiency: getCol(mapping.disposalEfficiency),
-    metresGained: getCol("metres_gained"),
-    marksInside50: getCol(mapping.marksInside50),
-    tacklesInside50: getCol(mapping.tacklesInside50),
-    shotsAtGoal: getCol("shots_at_goal"),
-    scoreInvolvements: getCol("score_involvements"),
-    totalPossessions: getCol(mapping.totalPossessions),
-    timeOnGround: getCol(mapping.timeOnGround),
-    ratingPoints: getCol("rating_points"),
-    position: getCol(mapping.position),
-    brownlowVotes: getCol("brownlow_votes"),
-    supercoachScore: getCol("supercoach_score"),
-    dreamTeamPoints: getCol(mapping.dreamTeamPoints),
-    effectiveDisposals: getCol("effective_disposals"),
-    effectiveKicks: getCol("effective_kicks"),
-    pressureActs: getCol("pressure_acts"),
-    defHalfPressureActs: getCol("def_half_pressure_acts"),
-    spoils: getCol("spoils"),
-    hitoutsToAdvantage: getCol("hitouts_to_advantage"),
-    hitoutWinPercentage: getCol("hitout_win_percentage"),
-    groundBallGets: getCol("ground_ball_gets"),
-    f50GroundBallGets: getCol("f50_ground_ball_gets"),
-    interceptMarks: getCol("intercept_marks"),
-    marksOnLead: getCol("marks_on_lead"),
-    contestOffOneOnOnes: getCol("contest_off_one_on_ones"),
-    contestOffWins: getCol("contest_off_wins"),
-    contestDefOneOnOnes: getCol("contest_def_one_on_ones"),
-    contestDefLosses: getCol("contest_def_losses"),
-    ruckContests: getCol("ruck_contests"),
-    scoreLaunches: getCol("score_launches")
-  };
-  const dateCol = cols.date;
-  const roundCol = cols.round;
-  const nRows = dateCol ? dateCol.length : 0;
-  const hasFilters = options.season !== void 0 || options.round !== void 0;
-  let rowIndices = null;
-  let rowCount = nRows;
-  if (hasFilters) {
-    const matching = [];
-    for (let i = 0; i < nRows; i++) {
-      if (options.season !== void 0) {
-        const dateStr = dateCol?.[i];
-        if (typeof dateStr !== "string") continue;
-        const year = Number(dateStr.slice(0, 4));
-        if (year !== options.season) continue;
-      }
-      if (options.round !== void 0 && roundCol) {
-        const roundVal = roundCol[i];
-        const roundNum = typeof roundVal === "string" ? Number(roundVal) : roundVal;
-        if (roundNum !== options.round) continue;
-      }
-      matching.push(i);
-    }
-    rowIndices = matching;
-    rowCount = matching.length;
+};
+
+// src/sources/adapters/squiggle.ts
+var SQUIGGLE_MATCH_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2012 }]]);
+var SQUIGGLE_LADDER_COVERAGE = /* @__PURE__ */ new Map([["AFLM", { minSeason: 2012 }]]);
+var SquiggleMatchSource = class {
+  constructor(client = new SquiggleClient()) {
+    this.client = client;
   }
-  const stats = new Array(rowCount);
-  for (let j = 0; j < rowCount; j++) {
-    const i = rowIndices ? rowIndices[j] : j;
-    stats[j] = mapRow(i, cols, isAflw, options.competition);
+  id = "squiggle";
+  coverage = SQUIGGLE_MATCH_COVERAGE;
+  async fetchMatches(query) {
+    const result = await this.client.fetchGames(query.season, query.round ?? void 0, 100);
+    if (!result.success) return result;
+    return ok(transformSquiggleGamesToFixture(result.data.games, query.season));
   }
-  return ok(stats);
-}
-function numAt(column, i) {
-  if (!column) return null;
-  const v = column[i];
-  return typeof v === "number" ? v : null;
-}
-function strAt(column, i) {
-  if (!column) return null;
-  const v = column[i];
-  return typeof v === "string" ? v : null;
-}
-function roundAt(column, i) {
-  if (!column) return 0;
-  const v = column[i];
-  if (typeof v === "number") return v;
-  if (typeof v === "string") {
-    const n = Number(v);
-    return Number.isNaN(n) ? 0 : n;
+};
+var SquiggleLadderSource = class {
+  constructor(client = new SquiggleClient()) {
+    this.client = client;
   }
-  return 0;
-}
-function mapRow(i, c, isAflw, competition) {
-  const dateStr = strAt(c.date, i);
-  let firstName;
-  let lastName;
-  if (isAflw) {
-    const playerName = strAt(c.playerName, i) ?? "";
-    const commaIdx = playerName.indexOf(", ");
-    firstName = commaIdx >= 0 ? playerName.slice(0, commaIdx) : playerName;
-    lastName = commaIdx >= 0 ? playerName.slice(commaIdx + 2) : "";
-  } else {
-    firstName = strAt(c.firstName, i) ?? "";
-    lastName = strAt(c.lastName, i) ?? "";
+  id = "squiggle";
+  coverage = SQUIGGLE_LADDER_COVERAGE;
+  async fetchLadder(query) {
+    const competition = query.competition ?? "AFLM";
+    const result = await this.client.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
+    });
   }
-  const team = strAt(c.team, i) ?? "";
-  const homeTeam = strAt(c.homeTeam, i);
-  const awayTeam = strAt(c.awayTeam, i);
-  return {
-    matchId: String(c.matchId?.[i] ?? ""),
-    season: dateStr ? Number(dateStr.slice(0, 4)) : 0,
-    roundNumber: roundAt(c.round, i),
-    team: normaliseTeamName(team),
-    competition,
-    date: dateStr ? parseDate(dateStr) : null,
-    homeTeam: homeTeam ? normaliseTeamName(homeTeam) : null,
-    awayTeam: awayTeam ? normaliseTeamName(awayTeam) : null,
-    playerId: String(c.playerId?.[i] ?? ""),
-    givenName: firstName,
-    surname: lastName,
-    displayName: `${firstName} ${lastName}`.trim(),
-    jumperNumber: numAt(c.jumperNumber, i),
-    kicks: numAt(c.kicks, i),
-    handballs: numAt(c.handballs, i),
-    disposals: numAt(c.disposals, i),
-    marks: numAt(c.marks, i),
-    goals: numAt(c.goals, i),
-    behinds: numAt(c.behinds, i),
-    tackles: numAt(c.tackles, i),
-    hitouts: numAt(c.hitouts, i),
-    freesFor: numAt(c.freesFor, i),
-    freesAgainst: numAt(c.freesAgainst, i),
-    contestedPossessions: numAt(c.contestedPossessions, i),
-    uncontestedPossessions: numAt(c.uncontestedPossessions, i),
-    contestedMarks: numAt(c.contestedMarks, i),
-    intercepts: numAt(c.intercepts, i),
-    centreClearances: numAt(c.centreClearances, i),
-    stoppageClearances: numAt(c.stoppageClearances, i),
-    totalClearances: numAt(c.totalClearances, i),
-    inside50s: numAt(c.inside50s, i),
-    rebound50s: numAt(c.rebound50s, i),
-    clangers: numAt(c.clangers, i),
-    turnovers: numAt(c.turnovers, i),
-    onePercenters: numAt(c.onePercenters, i),
-    bounces: numAt(c.bounces, i),
-    goalAssists: numAt(c.goalAssists, i),
-    disposalEfficiency: numAt(c.disposalEfficiency, i),
-    metresGained: numAt(c.metresGained, i),
-    goalAccuracy: null,
-    marksInside50: numAt(c.marksInside50, i),
-    tacklesInside50: numAt(c.tacklesInside50, i),
-    shotsAtGoal: numAt(c.shotsAtGoal, i),
-    scoreInvolvements: numAt(c.scoreInvolvements, i),
-    totalPossessions: numAt(c.totalPossessions, i),
-    timeOnGroundPercentage: numAt(c.timeOnGround, i),
-    ratingPoints: numAt(c.ratingPoints, i),
-    position: strAt(c.position, i),
-    goalEfficiency: null,
-    shotEfficiency: null,
-    interchangeCounts: null,
-    brownlowVotes: numAt(c.brownlowVotes, i),
-    supercoachScore: numAt(c.supercoachScore, i),
-    dreamTeamPoints: numAt(c.dreamTeamPoints, i),
-    effectiveDisposals: numAt(c.effectiveDisposals, i),
-    effectiveKicks: numAt(c.effectiveKicks, i),
-    kickEfficiency: null,
-    kickToHandballRatio: null,
-    pressureActs: numAt(c.pressureActs, i),
-    defHalfPressureActs: numAt(c.defHalfPressureActs, i),
-    spoils: numAt(c.spoils, i),
-    hitoutsToAdvantage: numAt(c.hitoutsToAdvantage, i),
-    hitoutWinPercentage: numAt(c.hitoutWinPercentage, i),
-    hitoutToAdvantageRate: null,
-    groundBallGets: numAt(c.groundBallGets, i),
-    f50GroundBallGets: numAt(c.f50GroundBallGets, i),
-    interceptMarks: numAt(c.interceptMarks, i),
-    marksOnLead: numAt(c.marksOnLead, i),
-    contestedPossessionRate: null,
-    contestOffOneOnOnes: numAt(c.contestOffOneOnOnes, i),
-    contestOffWins: numAt(c.contestOffWins, i),
-    contestOffWinsPercentage: null,
-    contestDefOneOnOnes: numAt(c.contestDefOneOnOnes, i),
-    contestDefLosses: numAt(c.contestDefLosses, i),
-    contestDefLossPercentage: null,
-    centreBounceAttendances: null,
-    kickins: null,
-    kickinsPlayon: null,
-    ruckContests: numAt(c.ruckContests, i),
-    scoreLaunches: numAt(c.scoreLaunches, i),
-    source: "fryzigg"
-  };
+};
+
+// src/sources/adapters/coverage.ts
+function checkCoverage(coverage, request, suggestion) {
+  const range = coverage.get(request.competition);
+  if (!range) {
+    return err(
+      new UnsupportedCompetitionError(
+        `${request.source} does not provide ${request.operation} data for ${request.competition}`,
+        request.source,
+        request.competition,
+        suggestion
+      )
+    );
+  }
+  if (request.season < range.minSeason) {
+    return err(
+      new OutOfRangeError(
+        `${request.source} only covers ${request.competition} ${request.operation} from ${range.minSeason}; you asked for ${request.season}`,
+        request.source,
+        request.competition,
+        request.season,
+        suggestion
+      )
+    );
+  }
+  if (range.maxSeason != null && request.season > range.maxSeason) {
+    return err(
+      new OutOfRangeError(
+        `${request.source} only covers ${request.competition} ${request.operation} up to ${range.maxSeason}; you asked for ${request.season}`,
+        request.source,
+        request.competition,
+        request.season,
+        suggestion
+      )
+    );
+  }
+  return ok(void 0);
 }
-
-// src/transforms/player-stats.ts
-function toNullable(value) {
-  return value ?? null;
+function unsupportedSourceForOperation(source, operation, registered) {
+  return new UnsupportedSourceError(
+    `${source} does not provide ${operation} data. Supported sources: ${registered.join(", ")}.`,
+    source
+  );
 }
-function transformOne(item, ctx) {
-  const inner = item.player.player.player;
-  const stats = item.playerStats?.stats;
-  const clearances = stats?.clearances;
-  return {
-    matchId: ctx.matchId,
-    season: ctx.season,
-    roundNumber: ctx.roundNumber,
-    team: normaliseTeamName(
-      ctx.teamIdMap?.get(item.teamId) ?? AFL_API_TEAM_IDS.get(item.teamId) ?? item.teamId
-    ),
-    competition: ctx.competition,
-    date: ctx.date ?? null,
-    homeTeam: ctx.homeTeam ?? null,
-    awayTeam: ctx.awayTeam ?? null,
-    playerId: inner.playerId,
-    givenName: inner.playerName.givenName,
-    surname: inner.playerName.surname,
-    displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
-    jumperNumber: item.player.jumperNumber ?? null,
-    kicks: toNullable(stats?.kicks),
-    handballs: toNullable(stats?.handballs),
-    disposals: toNullable(stats?.disposals),
-    marks: toNullable(stats?.marks),
-    goals: toNullable(stats?.goals),
-    behinds: toNullable(stats?.behinds),
-    tackles: toNullable(stats?.tackles),
-    hitouts: toNullable(stats?.hitouts),
-    freesFor: toNullable(stats?.freesFor),
-    freesAgainst: toNullable(stats?.freesAgainst),
-    contestedPossessions: toNullable(stats?.contestedPossessions),
-    uncontestedPossessions: toNullable(stats?.uncontestedPossessions),
-    contestedMarks: toNullable(stats?.contestedMarks),
-    intercepts: toNullable(stats?.intercepts),
-    centreClearances: toNullable(clearances?.centreClearances),
-    stoppageClearances: toNullable(clearances?.stoppageClearances),
-    totalClearances: toNullable(clearances?.totalClearances),
-    inside50s: toNullable(stats?.inside50s),
-    rebound50s: toNullable(stats?.rebound50s),
-    clangers: toNullable(stats?.clangers),
-    turnovers: toNullable(stats?.turnovers),
-    onePercenters: toNullable(stats?.onePercenters),
-    bounces: toNullable(stats?.bounces),
-    goalAssists: toNullable(stats?.goalAssists),
-    disposalEfficiency: toNullable(stats?.disposalEfficiency),
-    metresGained: toNullable(stats?.metresGained),
-    goalAccuracy: toNullable(stats?.goalAccuracy),
-    marksInside50: toNullable(stats?.marksInside50),
-    tacklesInside50: toNullable(stats?.tacklesInside50),
-    shotsAtGoal: toNullable(stats?.shotsAtGoal),
-    scoreInvolvements: toNullable(stats?.scoreInvolvements),
-    totalPossessions: toNullable(stats?.totalPossessions),
-    timeOnGroundPercentage: toNullable(item.playerStats?.timeOnGroundPercentage),
-    ratingPoints: toNullable(stats?.ratingPoints),
-    position: item.player.player.position ?? null,
-    goalEfficiency: toNullable(stats?.goalEfficiency),
-    shotEfficiency: toNullable(stats?.shotEfficiency),
-    interchangeCounts: toNullable(stats?.interchangeCounts),
-    brownlowVotes: toNullable(stats?.brownlowVotes),
-    supercoachScore: null,
-    dreamTeamPoints: toNullable(stats?.dreamTeamPoints),
-    effectiveDisposals: toNullable(stats?.extendedStats?.effectiveDisposals),
-    effectiveKicks: toNullable(stats?.extendedStats?.effectiveKicks),
-    kickEfficiency: toNullable(stats?.extendedStats?.kickEfficiency),
-    kickToHandballRatio: toNullable(stats?.extendedStats?.kickToHandballRatio),
-    pressureActs: toNullable(stats?.extendedStats?.pressureActs),
-    defHalfPressureActs: toNullable(stats?.extendedStats?.defHalfPressureActs),
-    spoils: toNullable(stats?.extendedStats?.spoils),
-    hitoutsToAdvantage: toNullable(stats?.extendedStats?.hitoutsToAdvantage),
-    hitoutWinPercentage: toNullable(stats?.extendedStats?.hitoutWinPercentage),
-    hitoutToAdvantageRate: toNullable(stats?.extendedStats?.hitoutToAdvantageRate),
-    groundBallGets: toNullable(stats?.extendedStats?.groundBallGets),
-    f50GroundBallGets: toNullable(stats?.extendedStats?.f50GroundBallGets),
-    interceptMarks: toNullable(stats?.extendedStats?.interceptMarks),
-    marksOnLead: toNullable(stats?.extendedStats?.marksOnLead),
-    contestedPossessionRate: toNullable(stats?.extendedStats?.contestedPossessionRate),
-    contestOffOneOnOnes: toNullable(stats?.extendedStats?.contestOffOneOnOnes),
-    contestOffWins: toNullable(stats?.extendedStats?.contestOffWins),
-    contestOffWinsPercentage: toNullable(stats?.extendedStats?.contestOffWinsPercentage),
-    contestDefOneOnOnes: toNullable(stats?.extendedStats?.contestDefOneOnOnes),
-    contestDefLosses: toNullable(stats?.extendedStats?.contestDefLosses),
-    contestDefLossPercentage: toNullable(stats?.extendedStats?.contestDefLossPercentage),
-    centreBounceAttendances: toNullable(stats?.extendedStats?.centreBounceAttendances),
-    kickins: toNullable(stats?.extendedStats?.kickins),
-    kickinsPlayon: toNullable(stats?.extendedStats?.kickinsPlayon),
-    ruckContests: toNullable(stats?.extendedStats?.ruckContests),
-    scoreLaunches: toNullable(stats?.extendedStats?.scoreLaunches),
-    source: ctx.source
-  };
+function findAlternativeSource(adapters, request) {
+  for (const adapter of adapters) {
+    if (adapter.id === request.source) continue;
+    const range = adapter.coverage.get(request.competition);
+    if (!range) continue;
+    if (request.season < range.minSeason) continue;
+    if (range.maxSeason != null && request.season > range.maxSeason) continue;
+    return adapter.id;
+  }
+  return void 0;
 }
-function transformPlayerStats(data, ctx) {
-  const home = (data.homeTeamPlayerStats ?? []).map((item) => transformOne(item, ctx));
-  const away = (data.awayTeamPlayerStats ?? []).map((item) => transformOne(item, ctx));
-  return [...home, ...away];
+
+// src/sources/adapters/dispatch.ts
+function dispatch(registry, operation, query) {
+  const adapter = registry.get(query.source);
+  if (!adapter) {
+    return err(unsupportedSourceForOperation(query.source, operation, registry.list()));
+  }
+  const competition = query.competition ?? "AFLM";
+  const alternative = findAlternativeSource(registry.all(), {
+    source: query.source,
+    competition,
+    season: query.season
+  });
+  const suggestion = alternative ? `--source ${alternative}` : void 0;
+  const coverage = checkCoverage(
+    adapter.coverage,
+    { source: query.source, operation, competition, season: query.season },
+    suggestion
+  );
+  if (!coverage.success) return coverage;
+  return ok(adapter);
 }
 
+// src/sources/adapters/index.ts
+matchRegistry.register(new AflApiMatchSource());
+matchRegistry.register(new FootyWireMatchSource());
+matchRegistry.register(new AflTablesMatchSource());
+matchRegistry.register(new SquiggleMatchSource());
+playerStatsRegistry.register(new AflApiPlayerStatsSource());
+playerStatsRegistry.register(new FootyWirePlayerStatsSource());
+playerStatsRegistry.register(new AflTablesPlayerStatsSource());
+playerStatsRegistry.register(new FryziggPlayerStatsSource());
+teamStatsRegistry.register(new FootyWireTeamStatsSource());
+teamStatsRegistry.register(new AflTablesTeamStatsSource());
+squadRegistry.register(new AflApiSquadSource());
+squadRegistry.register(new FootyWireSquadSource());
+squadRegistry.register(new AflTablesSquadSource());
+lineupRegistry.register(new AflApiLineupSource());
+ladderRegistry.register(new AflApiLadderSource());
+ladderRegistry.register(new AflTablesLadderSource());
+ladderRegistry.register(new SquiggleLadderSource());
+
 // src/api/player-stats.ts
 async function fetchPlayerStats(query) {
-  const competition = query.competition ?? "AFLM";
-  switch (query.source) {
-    case "afl-api": {
-      const client = new AflApiClient();
-      if (query.matchId) {
-        const [rosterResult, statsResult] = await Promise.all([
-          client.fetchMatchRoster(query.matchId),
-          client.fetchPlayerStats(query.matchId)
-        ]);
-        if (!statsResult.success) return statsResult;
-        const teamIdMap2 = new Map(AFL_API_TEAM_IDS);
-        if (rosterResult.success) {
-          const match = rosterResult.data.match;
-          teamIdMap2.set(match.homeTeamId, normaliseTeamName(match.homeTeam.name));
-          teamIdMap2.set(match.awayTeamId, normaliseTeamName(match.awayTeam.name));
-        }
-        return ok(
-          transformPlayerStats(statsResult.data, {
-            matchId: query.matchId,
-            season: query.season,
-            roundNumber: query.round ?? 0,
-            competition,
-            source: "afl-api",
-            teamIdMap: teamIdMap2
-          })
-        );
-      }
-      const seasonResult = await client.resolveCompSeason(competition, query.season);
-      if (!seasonResult.success) return seasonResult;
-      const matchItemsResult = query.round != null ? await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round) : await client.fetchSeasonMatchItems(seasonResult.data);
-      if (!matchItemsResult.success) return matchItemsResult;
-      const teamIdMap = /* @__PURE__ */ new Map();
-      for (const item of matchItemsResult.data) {
-        teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
-        teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
-      }
-      const statsResults = await batchedMap(
-        matchItemsResult.data,
-        (item) => client.fetchPlayerStats(item.match.matchId)
+  const adapterR = dispatch(playerStatsRegistry, "player stats", query);
+  return Result.flatMapAsync(adapterR, (a) => a.fetchPlayerStats(query));
+}
+
+// src/api/awards.ts
+var FOOTYWIRE_BASE2 = "https://www.footywire.com/afl/footy";
+async function fetchAwards(query) {
+  switch (query.award) {
+    case "brownlow":
+      return fetchFootyWireAward(
+        `${FOOTYWIRE_BASE2}/brownlow_medal?year=${query.season}`,
+        (html) => parseBrownlowVotes(html, query.season),
+        "Brownlow",
+        query.season
       );
-      const allStats = [];
-      for (let i = 0; i < statsResults.length; i++) {
-        const statsResult = statsResults[i];
-        if (!statsResult?.success)
-          return statsResult ?? err(new AflApiError("Missing stats result"));
-        const item = matchItemsResult.data[i];
-        if (!item) continue;
-        allStats.push(
-          ...transformPlayerStats(statsResult.data, {
-            matchId: item.match.matchId,
-            season: query.season,
-            roundNumber: item.round?.roundNumber ?? query.round ?? 0,
-            competition,
-            source: "afl-api",
-            teamIdMap,
-            date: parseDate(item.match.utcStartTime) ?? new Date(item.match.utcStartTime),
-            homeTeam: normaliseTeamName(item.match.homeTeam.name),
-            awayTeam: normaliseTeamName(item.match.awayTeam.name)
-          })
-        );
-      }
-      return ok(allStats);
-    }
-    case "footywire": {
-      if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
-      const fwClient = new FootyWireClient();
-      const idsResult = await fwClient.fetchSeasonMatchIds(query.season);
-      if (!idsResult.success) return idsResult;
-      const entries = query.round != null ? idsResult.data.filter((e) => e.roundNumber === query.round) : idsResult.data;
-      if (entries.length === 0) {
-        return ok([]);
-      }
-      const allStats = [];
-      const batchSize = 5;
-      for (let i = 0; i < entries.length; i += batchSize) {
-        const batch = entries.slice(i, i + batchSize);
-        const results = await Promise.all(
-          batch.map((e) => fwClient.fetchMatchPlayerStats(e.matchId, query.season, e.roundNumber))
-        );
-        for (const result of results) {
-          if (result.success) {
-            allStats.push(...result.data);
-          }
-        }
-        if (i + batchSize < entries.length) {
-          await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-      }
-      return ok(allStats);
-    }
-    case "afl-tables": {
-      if (competition === "AFLW") return err(aflwUnsupportedError("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;
-    }
-    case "fryzigg": {
-      const fzClient = new FryziggClient();
-      const fzResult = await fzClient.fetchPlayerStats(competition);
-      if (!fzResult.success) return fzResult;
-      return transformFryziggPlayerStats(fzResult.data, {
-        competition,
-        season: query.season,
-        round: query.round
+    case "all-australian":
+      return fetchFootyWireAward(
+        `${FOOTYWIRE_BASE2}/all_australian_selection?year=${query.season}`,
+        (html) => parseAllAustralian(html, query.season),
+        "All-Australian",
+        query.season
+      );
+    case "rising-star":
+      return fetchFootyWireAward(
+        `${FOOTYWIRE_BASE2}/rising_star_nominations?year=${query.season}`,
+        (html) => parseRisingStarNominations(html, query.season),
+        "Rising Star",
+        query.season
+      );
+    case "coaches":
+      return fetchCoachesVotes(query);
+    case "coleman":
+      return fetchColemanLeaderboard(query);
+    default:
+      return err(
+        new ScrapeError(`Unknown award type: ${query.award}`, "footywire")
+      );
+  }
+}
+async function fetchFootyWireAward(url, parse, label, season) {
+  const client = new FootyWireClient();
+  const htmlResult = await client.fetchPage(url);
+  if (!htmlResult.success) return htmlResult;
+  const data = parse(htmlResult.data);
+  if (data.length === 0) {
+    return err(new ScrapeError(`No ${label} data found for season ${season}`, "footywire"));
+  }
+  return ok(data);
+}
+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"));
+  }
+  if (competition === "VFL" || competition === "VFLW") {
+    return err(
+      new ScrapeError(`No coaches votes data available for ${competition}`, "afl-coaches")
+    );
+  }
+  const client = new AflCoachesClient();
+  const result = query.round != null ? await client.scrapeRoundVotes(
+    query.season,
+    query.round,
+    competition,
+    query.round >= 24 && query.season >= 2018
+  ) : await client.fetchSeasonVotes(query.season, competition);
+  if (!result.success) return result;
+  let votes = result.data;
+  if (query.team != null) {
+    const target = normaliseTeamName(query.team);
+    votes = votes.filter(
+      (v) => normaliseTeamName(v.homeTeam) === target || normaliseTeamName(v.awayTeam) === target
+    );
+  }
+  return ok(votes);
+}
+async function fetchColemanLeaderboard(query) {
+  const competition = query.competition ?? "AFLM";
+  if (competition === "VFL" || competition === "VFLW") {
+    return err(
+      new ScrapeError(
+        `Coleman Medal is not awarded in ${competition}; use Coleman-equivalent stats query`,
+        "afl-api"
+      )
+    );
+  }
+  const statsR = await fetchPlayerStats({
+    source: "afl-api",
+    season: query.season,
+    competition
+  });
+  return Result.map(statsR, (stats) => rankColemanFromStats(stats, query.season, query.limit));
+}
+function rankColemanFromStats(stats, season, limit) {
+  const accumulator = /* @__PURE__ */ new Map();
+  for (const s of stats) {
+    if (s.goals == null) continue;
+    const key = s.playerId;
+    const existing = accumulator.get(key);
+    if (existing) {
+      existing.goals += s.goals;
+      existing.gamesPlayed += 1;
+    } else {
+      accumulator.set(key, {
+        player: s.displayName,
+        team: s.team,
+        goals: s.goals,
+        gamesPlayed: 1
       });
     }
-    default:
-      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
   }
+  const ranked = [...accumulator.values()].filter((entry) => entry.goals > 0).sort((a, b) => b.goals - a.goals);
+  let lastGoals = -1;
+  let lastPosition = 0;
+  const leaderboard = ranked.map((entry, index) => {
+    const position = entry.goals === lastGoals ? lastPosition : index + 1;
+    lastGoals = entry.goals;
+    lastPosition = position;
+    return {
+      type: "coleman",
+      season,
+      position,
+      player: entry.player,
+      team: entry.team,
+      goals: entry.goals,
+      gamesPlayed: entry.gamesPlayed
+    };
+  });
+  return limit != null ? leaderboard.slice(0, limit) : leaderboard;
 }
 
-// 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();
-      const statsResult = await client.fetchTeamStats(query.season);
-      if (!statsResult.success) return statsResult;
-      const needsGp = statsResult.data.some((e) => e.gamesPlayed === 0);
-      const gpMap = /* @__PURE__ */ new Map();
-      if (needsGp) {
-        const resultsResult = await client.fetchSeasonResults(query.season);
-        if (resultsResult.success) {
-          for (const m of resultsResult.data) {
-            const home = normaliseTeamName(m.homeTeam);
-            const away = normaliseTeamName(m.awayTeam);
-            gpMap.set(home, (gpMap.get(home) ?? 0) + 1);
-            gpMap.set(away, (gpMap.get(away) ?? 0) + 1);
-          }
-        }
-      }
-      const enriched = statsResult.data.map((entry) => ({
-        ...entry,
-        gamesPlayed: gpMap.get(normaliseTeamName(entry.team)) ?? entry.gamesPlayed
-      }));
-      if (summaryType === "averages") {
-        return ok(
-          enriched.map((entry) => ({
-            ...entry,
-            stats: Object.fromEntries(
-              Object.entries(entry.stats).map(([k, v]) => [
-                k,
-                entry.gamesPlayed > 0 ? +(v / entry.gamesPlayed).toFixed(1) : 0
-              ])
-            )
-          }))
-        );
-      }
-      return ok(enriched);
-    }
-    case "afl-api":
-    case "squiggle":
-      return err(
-        new UnsupportedSourceError(
-          `Team stats are not available from ${query.source}. Use "footywire" or "afl-tables".`,
-          query.source
-        )
-      );
-    default:
-      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+// src/api/ladder.ts
+async function fetchLadder(query) {
+  const adapterR = dispatch(ladderRegistry, "ladder", query);
+  return Result.flatMapAsync(adapterR, (a) => a.fetchLadder(query));
+}
+
+// src/api/lineup.ts
+async function fetchLineup(query) {
+  const adapterR = dispatch(lineupRegistry, "lineup", query);
+  return Result.flatMapAsync(adapterR, (a) => a.fetchLineup(query));
+}
+
+// src/transforms/match.ts
+function filterMatches(matches, query) {
+  let filtered = matches;
+  if (query.matchId !== void 0) {
+    filtered = filtered.filter((m) => m.matchId === query.matchId);
+  }
+  if (query.team !== void 0) {
+    const target = normaliseTeamName(query.team);
+    filtered = filtered.filter((m) => m.homeTeam === target || m.awayTeam === target);
   }
+  if (query.status !== void 0) {
+    filtered = filtered.filter((m) => m.status === query.status);
+  }
+  return [...filtered];
 }
 
-// src/api/teams.ts
-function teamTypeForComp(comp) {
-  return comp === "AFLW" ? "WOMEN" : "MEN";
+// src/api/match.ts
+async function fetchMatches(query) {
+  const adapterR = dispatch(matchRegistry, "match", query);
+  const fetchedR = await Result.flatMapAsync(adapterR, (a) => a.fetchMatches(query));
+  return Result.map(fetchedR, (matches) => filterMatches(matches, query));
+}
+
+// src/transforms/player-details.ts
+function squadToPlayerDetails(squad, source) {
+  return squad.players.map((p) => ({
+    playerId: p.playerId,
+    givenName: p.givenName,
+    surname: p.surname,
+    displayName: p.displayName,
+    team: squad.teamName,
+    jumperNumber: p.jumperNumber,
+    position: p.position,
+    dateOfBirth: p.dateOfBirth ? p.dateOfBirth.toISOString().slice(0, 10) : null,
+    heightCm: p.heightCm,
+    weightKg: p.weightKg,
+    gamesPlayed: p.gamesPlayed ?? null,
+    goals: p.goals ?? null,
+    draftYear: p.draftYear,
+    draftPosition: p.draftPosition,
+    draftType: p.draftType,
+    debutYear: p.debutYear,
+    recruitedFrom: p.recruitedFrom,
+    source,
+    competition: squad.competition
+  }));
 }
+
+// src/api/teams.ts
 function toTeams(data, competition) {
   return data.map((t) => ({
     teamId: String(t.id),
@@ -4123,55 +4447,65 @@ function toTeams(data, competition) {
 }
 async function fetchTeams(query) {
   const client = new AflApiClient();
-  if (!query?.competition && !query?.teamType) {
+  if (!query?.competition) {
     const [menResult, womenResult] = await Promise.all([
-      client.fetchTeams("MEN"),
-      client.fetchTeams("WOMEN")
+      client.fetchTeams("AFLM"),
+      client.fetchTeams("AFLW")
     ]);
     if (!menResult.success) return menResult;
     if (!womenResult.success) return womenResult;
     return ok([...toTeams(menResult.data, "AFLM"), ...toTeams(womenResult.data, "AFLW")]);
   }
-  const competition = query?.competition ?? "AFLM";
-  const teamType = query?.teamType ?? teamTypeForComp(competition);
-  const result = await client.fetchTeams(teamType);
+  const result = await client.fetchTeams(query.competition);
   if (!result.success) return result;
-  return ok(toTeams(result.data, competition));
+  return ok(toTeams(result.data, query.competition));
 }
 async function fetchSquad(query) {
-  const client = new AflApiClient();
-  const competition = query.competition ?? "AFLM";
-  const seasonResult = await client.resolveCompSeason(competition, query.season);
-  if (!seasonResult.success) return seasonResult;
-  const teamId = Number.parseInt(query.teamId, 10);
-  if (Number.isNaN(teamId)) {
-    return err(new ValidationError(`Invalid team ID: ${query.teamId}`));
-  }
-  const squadResult = await client.fetchSquad(teamId, seasonResult.data);
-  if (!squadResult.success) return squadResult;
-  const players = squadResult.data.squad.players.map((p) => ({
-    playerId: p.player.providerId ?? String(p.player.id),
-    givenName: p.player.firstName,
-    surname: p.player.surname,
-    displayName: `${p.player.firstName} ${p.player.surname}`,
-    jumperNumber: p.jumperNumber ?? null,
-    position: p.position ?? null,
-    dateOfBirth: p.player.dateOfBirth ? parseDate(p.player.dateOfBirth) : null,
-    heightCm: p.player.heightInCm || null,
-    weightKg: p.player.weightInKg || null,
-    draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
-    draftPosition: p.player.draftPosition ? Number.parseInt(p.player.draftPosition, 10) || null : null,
-    draftType: p.player.draftType ?? null,
-    debutYear: p.player.debutYear ? Number.parseInt(p.player.debutYear, 10) || null : null,
-    recruitedFrom: p.player.recruitedFrom ?? null
-  }));
-  return ok({
-    teamId: query.teamId,
-    teamName: normaliseTeamName(squadResult.data.squad.team?.name ?? query.teamId),
-    season: query.season,
-    players,
-    competition
+  const source = query.source ?? squadRegistry.defaultSource;
+  const adapterR = dispatch(squadRegistry, "squad", {
+    source,
+    competition: query.competition,
+    season: query.season
   });
+  return Result.flatMapAsync(adapterR, (a) => a.fetchSquad({ ...query, source }));
+}
+
+// src/api/player-details.ts
+async function fetchPlayerDetails(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.team) {
+    const squadR = await fetchSquad({
+      team: query.team,
+      season: query.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      source: query.source,
+      competition
+    });
+    if (!squadR.success) return squadR;
+    return ok(squadToPlayerDetails(squadR.data, query.source));
+  }
+  const teamNames = [...AFL_SENIOR_TEAMS];
+  const results = await batchedMap(
+    teamNames,
+    (team) => fetchSquad({
+      team,
+      season: query.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      source: query.source,
+      competition
+    })
+  );
+  const allPlayers = [];
+  for (const result of results) {
+    if (result.success) {
+      allPlayers.push(...squadToPlayerDetails(result.data, query.source));
+    }
+  }
+  return ok(allPlayers);
+}
+
+// src/api/team-stats.ts
+async function fetchTeamStats(query) {
+  const adapterR = dispatch(teamStatsRegistry, "team stats", { ...query, competition: "AFLM" });
+  return Result.flatMapAsync(adapterR, (a) => a.fetchTeamStats(query));
 }
 export {
   AflApiClient,
@@ -4221,11 +4555,9 @@ export {
   computeLadder,
   err,
   fetchAwards,
-  fetchCoachesVotes,
-  fetchFixture,
   fetchLadder,
   fetchLineup,
-  fetchMatchResults,
+  fetchMatches,
   fetchPlayerDetails,
   fetchPlayerStats,
   fetchSquad,