fitzroy 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,4 +1,1661 @@
-import {
+// src/lib/errors.ts
+var AflApiError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+  name = "AflApiError";
+};
+var ScrapeError = class extends Error {
+  constructor(message, source) {
+    super(message);
+    this.source = source;
+  }
+  name = "ScrapeError";
+};
+var UnsupportedSourceError = class extends Error {
+  constructor(message, source) {
+    super(message);
+    this.source = source;
+  }
+  name = "UnsupportedSourceError";
+};
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+  name = "ValidationError";
+};
+
+// src/lib/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+
+// src/lib/team-mapping.ts
+var TEAM_ALIASES = [
+  ["Adelaide Crows", "Adelaide", "Crows", "ADEL", "AD"],
+  ["Brisbane Lions", "Brisbane", "Brisbane Bears", "Bears", "Fitzroy Lions", "BL", "BRIS"],
+  ["Carlton", "Carlton Blues", "Blues", "CARL", "CA"],
+  ["Collingwood", "Collingwood Magpies", "Magpies", "COLL", "CW"],
+  ["Essendon", "Essendon Bombers", "Bombers", "ESS", "ES"],
+  ["Fremantle", "Fremantle Dockers", "Dockers", "FRE", "FR"],
+  ["Geelong Cats", "Geelong", "Cats", "GEEL", "GE"],
+  [
+    "Gold Coast Suns",
+    "Gold Coast",
+    "Gold Coast SUNS",
+    "Gold Coast Football Club",
+    "Suns",
+    "GCFC",
+    "GC"
+  ],
+  [
+    "GWS Giants",
+    "GWS",
+    "GWS GIANTS",
+    "Greater Western Sydney",
+    "Giants",
+    "Greater Western Sydney Giants",
+    "GW"
+  ],
+  ["Hawthorn", "Hawthorn Hawks", "Hawks", "HAW", "HW"],
+  ["Melbourne", "Melbourne Demons", "Demons", "MELB", "ME"],
+  ["North Melbourne", "North Melbourne Kangaroos", "Kangaroos", "Kangas", "North", "NMFC", "NM"],
+  ["Port Adelaide", "Port Adelaide Power", "Power", "Port", "PA", "PAFC"],
+  ["Richmond", "Richmond Tigers", "Tigers", "RICH", "RI"],
+  ["St Kilda", "St Kilda Saints", "Saints", "Saint Kilda", "STK", "SK"],
+  ["Sydney Swans", "Sydney", "Swans", "South Melbourne", "South Melbourne Swans", "SYD", "SY"],
+  ["West Coast Eagles", "West Coast", "Eagles", "WCE", "WC"],
+  ["Western Bulldogs", "Bulldogs", "Footscray", "Footscray Bulldogs", "WB", "WBD"],
+  // Historical / defunct VFL teams
+  ["Fitzroy", "Fitzroy Reds", "Fitzroy Gorillas", "Fitzroy Maroons", "FI"],
+  ["University", "University Blacks"]
+];
+var ALIAS_MAP = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [canonical, ...aliases] of TEAM_ALIASES) {
+    map.set(canonical.toLowerCase(), canonical);
+    for (const alias of aliases) {
+      map.set(alias.toLowerCase(), canonical);
+    }
+  }
+  return map;
+})();
+function normaliseTeamName(raw) {
+  const trimmed = raw.trim();
+  return ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+
+// src/lib/validation.ts
+import { z } from "zod/v4";
+var AflApiTokenSchema = z.object({
+  token: z.string(),
+  disclaimer: z.string().optional()
+}).passthrough();
+var CompetitionSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  code: z.string().optional()
+}).passthrough();
+var CompetitionListSchema = z.object({
+  competitions: z.array(CompetitionSchema)
+}).passthrough();
+var CompseasonSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  shortName: z.string().optional(),
+  currentRoundNumber: z.number().optional()
+}).passthrough();
+var CompseasonListSchema = z.object({
+  compSeasons: z.array(CompseasonSchema)
+}).passthrough();
+var RoundSchema = z.object({
+  id: z.number(),
+  /** Provider ID used by /cfs/ endpoints (e.g. "CD_R202501401"). */
+  providerId: z.string().optional(),
+  name: z.string(),
+  abbreviation: z.string().optional(),
+  roundNumber: z.number(),
+  utcStartTime: z.string().optional(),
+  utcEndTime: z.string().optional()
+}).passthrough();
+var RoundListSchema = z.object({
+  rounds: z.array(RoundSchema)
+}).passthrough();
+var ScoreSchema = z.object({
+  totalScore: z.number(),
+  goals: z.number(),
+  behinds: z.number(),
+  superGoals: z.number().nullable().optional()
+}).passthrough();
+var PeriodScoreSchema = z.object({
+  periodNumber: z.number(),
+  score: ScoreSchema
+}).passthrough();
+var TeamScoreSchema = z.object({
+  matchScore: ScoreSchema,
+  periodScore: z.array(PeriodScoreSchema).optional(),
+  rushedBehinds: z.number().optional(),
+  minutesInFront: z.number().optional()
+}).passthrough();
+var CfsMatchTeamSchema = z.object({
+  name: z.string(),
+  teamId: z.string(),
+  abbr: z.string().optional(),
+  nickname: z.string().optional()
+}).passthrough();
+var CfsMatchSchema = z.object({
+  matchId: z.string(),
+  name: z.string().optional(),
+  status: z.string(),
+  utcStartTime: z.string(),
+  homeTeamId: z.string(),
+  awayTeamId: z.string(),
+  homeTeam: CfsMatchTeamSchema,
+  awayTeam: CfsMatchTeamSchema,
+  round: z.string().optional(),
+  abbr: z.string().optional()
+}).passthrough();
+var CfsScoreSchema = z.object({
+  status: z.string(),
+  matchId: z.string(),
+  homeTeamScore: TeamScoreSchema,
+  awayTeamScore: TeamScoreSchema
+}).passthrough();
+var CfsVenueSchema = z.object({
+  name: z.string(),
+  venueId: z.string().optional(),
+  state: z.string().optional(),
+  timeZone: z.string().optional()
+}).passthrough();
+var MatchItemSchema = z.object({
+  match: CfsMatchSchema,
+  score: CfsScoreSchema.optional(),
+  venue: CfsVenueSchema.optional(),
+  round: z.object({
+    name: z.string(),
+    roundId: z.string(),
+    roundNumber: z.number()
+  }).passthrough().optional()
+}).passthrough();
+var MatchItemListSchema = z.object({
+  roundId: z.string().optional(),
+  items: z.array(MatchItemSchema)
+}).passthrough();
+var CfsPlayerInnerSchema = z.object({
+  playerId: z.string(),
+  playerName: z.object({
+    givenName: z.string(),
+    surname: z.string()
+  }).passthrough(),
+  captain: z.boolean().optional(),
+  playerJumperNumber: z.number().optional()
+}).passthrough();
+var PlayerGameStatsSchema = z.object({
+  goals: z.number().optional(),
+  behinds: z.number().optional(),
+  kicks: z.number().optional(),
+  handballs: z.number().optional(),
+  disposals: z.number().optional(),
+  marks: z.number().optional(),
+  bounces: z.number().optional(),
+  tackles: z.number().optional(),
+  contestedPossessions: z.number().optional(),
+  uncontestedPossessions: z.number().optional(),
+  totalPossessions: z.number().optional(),
+  inside50s: z.number().optional(),
+  marksInside50: z.number().optional(),
+  contestedMarks: z.number().optional(),
+  hitouts: z.number().optional(),
+  onePercenters: z.number().optional(),
+  disposalEfficiency: z.number().optional(),
+  clangers: z.number().optional(),
+  freesFor: z.number().optional(),
+  freesAgainst: z.number().optional(),
+  dreamTeamPoints: z.number().optional(),
+  clearances: z.object({
+    centreClearances: z.number().optional(),
+    stoppageClearances: z.number().optional(),
+    totalClearances: z.number().optional()
+  }).passthrough().optional(),
+  rebound50s: z.number().optional(),
+  goalAssists: z.number().optional(),
+  goalAccuracy: z.number().optional(),
+  turnovers: z.number().optional(),
+  intercepts: z.number().optional(),
+  tacklesInside50: z.number().optional(),
+  shotsAtGoal: z.number().optional(),
+  metresGained: z.number().optional(),
+  scoreInvolvements: z.number().optional(),
+  ratingPoints: z.number().optional(),
+  extendedStats: z.object({
+    effectiveDisposals: z.number().optional(),
+    effectiveKicks: z.number().optional(),
+    kickEfficiency: z.number().optional(),
+    kickToHandballRatio: z.number().optional(),
+    pressureActs: z.number().optional(),
+    defHalfPressureActs: z.number().optional(),
+    spoils: z.number().optional(),
+    hitoutsToAdvantage: z.number().optional(),
+    hitoutWinPercentage: z.number().optional(),
+    hitoutToAdvantageRate: z.number().optional(),
+    groundBallGets: z.number().optional(),
+    f50GroundBallGets: z.number().optional(),
+    interceptMarks: z.number().optional(),
+    marksOnLead: z.number().optional(),
+    contestedPossessionRate: z.number().optional(),
+    contestOffOneOnOnes: z.number().optional(),
+    contestOffWins: z.number().optional(),
+    contestOffWinsPercentage: z.number().optional(),
+    contestDefOneOnOnes: z.number().optional(),
+    contestDefLosses: z.number().optional(),
+    contestDefLossPercentage: z.number().optional(),
+    centreBounceAttendances: z.number().optional(),
+    kickins: z.number().optional(),
+    kickinsPlayon: z.number().optional(),
+    ruckContests: z.number().optional(),
+    scoreLaunches: z.number().optional()
+  }).passthrough().optional()
+}).passthrough();
+var PlayerStatsItemSchema = z.object({
+  player: z.object({
+    player: z.object({
+      position: z.string().optional(),
+      player: CfsPlayerInnerSchema
+    }).passthrough(),
+    jumperNumber: z.number().optional()
+  }).passthrough(),
+  teamId: z.string(),
+  playerStats: z.object({
+    stats: PlayerGameStatsSchema,
+    timeOnGroundPercentage: z.number().optional()
+  }).passthrough()
+}).passthrough();
+var PlayerStatsListSchema = z.object({
+  homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
+  awayTeamPlayerStats: z.array(PlayerStatsItemSchema)
+}).passthrough();
+var RosterPlayerSchema = z.object({
+  player: z.object({
+    position: z.string().optional(),
+    player: CfsPlayerInnerSchema
+  }).passthrough(),
+  jumperNumber: z.number().optional()
+}).passthrough();
+var TeamPlayersSchema = z.object({
+  teamId: z.string(),
+  players: z.array(RosterPlayerSchema)
+}).passthrough();
+var MatchRosterSchema = z.object({
+  match: CfsMatchSchema,
+  teamPlayers: z.array(TeamPlayersSchema)
+}).passthrough();
+var TeamItemSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  abbreviation: z.string().optional(),
+  teamType: z.string().optional()
+}).passthrough();
+var TeamListSchema = z.object({
+  teams: z.array(TeamItemSchema)
+}).passthrough();
+var SquadPlayerInnerSchema = z.object({
+  id: z.number(),
+  providerId: z.string().optional(),
+  firstName: z.string(),
+  surname: z.string(),
+  dateOfBirth: z.string().optional(),
+  heightInCm: z.number().optional(),
+  weightInKg: z.number().optional(),
+  draftYear: z.string().optional(),
+  draftPosition: z.string().optional(),
+  draftType: z.string().optional(),
+  debutYear: z.string().optional(),
+  recruitedFrom: z.string().optional()
+}).passthrough();
+var SquadPlayerItemSchema = z.object({
+  player: SquadPlayerInnerSchema,
+  jumperNumber: z.number().optional(),
+  position: z.string().optional()
+}).passthrough();
+var SquadSchema = z.object({
+  team: z.object({
+    name: z.string()
+  }).passthrough().optional(),
+  players: z.array(SquadPlayerItemSchema)
+}).passthrough();
+var SquadListSchema = z.object({
+  squad: SquadSchema
+}).passthrough();
+var WinLossRecordSchema = z.object({
+  wins: z.number(),
+  losses: z.number(),
+  draws: z.number(),
+  played: z.number().optional()
+}).passthrough();
+var LadderEntryRawSchema = z.object({
+  position: z.number(),
+  team: z.object({
+    name: z.string(),
+    id: z.number().optional(),
+    abbreviation: z.string().optional()
+  }).passthrough(),
+  played: z.number().optional(),
+  pointsFor: z.number().optional(),
+  pointsAgainst: z.number().optional(),
+  thisSeasonRecord: z.object({
+    aggregatePoints: z.number().optional(),
+    percentage: z.number().optional(),
+    winLossRecord: WinLossRecordSchema.optional()
+  }).passthrough().optional(),
+  form: z.string().optional()
+}).passthrough();
+var LadderResponseSchema = z.object({
+  ladders: z.array(
+    z.object({
+      entries: z.array(LadderEntryRawSchema)
+    }).passthrough()
+  ),
+  round: z.object({
+    roundNumber: z.number(),
+    name: z.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+
+// src/sources/afl-api.ts
+var TOKEN_URL = "https://api.afl.com.au/cfs/afl/WMCTok";
+var API_BASE = "https://aflapi.afl.com.au/afl/v2";
+var CFS_BASE = "https://api.afl.com.au/cfs/afl";
+var AflApiClient = class {
+  fetchFn;
+  tokenUrl;
+  cachedToken = null;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+    this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
+  }
+  /**
+   * Authenticate with the WMCTok token endpoint and cache the token.
+   *
+   * @returns The access token on success, or an error Result.
+   */
+  async authenticate() {
+    try {
+      const response = await this.fetchFn(this.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Length": "0" }
+      });
+      if (!response.ok) {
+        return err(new AflApiError(`Token request failed: ${response.status}`, response.status));
+      }
+      const json = await response.json();
+      const parsed = AflApiTokenSchema.safeParse(json);
+      if (!parsed.success) {
+        return err(new AflApiError("Invalid token response format"));
+      }
+      const ttlMs = 30 * 60 * 1e3;
+      this.cachedToken = {
+        accessToken: parsed.data.token,
+        expiresAt: Date.now() + ttlMs
+      };
+      return ok(parsed.data.token);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `Token request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
+    }
+  }
+  /**
+   * Whether the cached token is still valid (not expired).
+   */
+  get isAuthenticated() {
+    return this.cachedToken !== null && Date.now() < this.cachedToken.expiresAt;
+  }
+  /**
+   * Perform an authenticated fetch, automatically adding the bearer token.
+   * Retries once on 401 by re-authenticating.
+   *
+   * @param url - The URL to fetch.
+   * @param init - Additional fetch options.
+   * @returns The Response on success, or an error Result.
+   */
+  async authedFetch(url, init) {
+    if (!this.isAuthenticated) {
+      const authResult = await this.authenticate();
+      if (!authResult.success) {
+        return authResult;
+      }
+    }
+    const doFetch = async () => {
+      const token = this.cachedToken;
+      if (!token) {
+        throw new AflApiError("No cached token available");
+      }
+      const headers = new Headers(init?.headers);
+      headers.set("x-media-mis-token", token.accessToken);
+      return this.fetchFn(url, { ...init, headers });
+    };
+    try {
+      let response = await doFetch();
+      if (response.status === 401) {
+        const authResult = await this.authenticate();
+        if (!authResult.success) {
+          return authResult;
+        }
+        response = await doFetch();
+      }
+      if (!response.ok) {
+        return err(
+          new AflApiError(
+            `Request failed: ${response.status} ${response.statusText}`,
+            response.status
+          )
+        );
+      }
+      return ok(response);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
+    }
+  }
+  /**
+   * Fetch JSON from a URL, validate with a Zod schema, and return a typed Result.
+   *
+   * @param url - The URL to fetch.
+   * @param schema - Zod schema to validate the response against.
+   * @returns Validated data on success, or an error Result.
+   */
+  async fetchJson(url, schema) {
+    const isPublic = url.startsWith(API_BASE);
+    let response;
+    if (isPublic) {
+      try {
+        response = await this.fetchFn(url);
+        if (!response.ok) {
+          return err(
+            new AflApiError(
+              `Request failed: ${response.status} ${response.statusText}`,
+              response.status
+            )
+          );
+        }
+      } catch (cause) {
+        return err(
+          new AflApiError(
+            `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+          )
+        );
+      }
+    } else {
+      const fetchResult = await this.authedFetch(url);
+      if (!fetchResult.success) {
+        return fetchResult;
+      }
+      response = fetchResult.data;
+    }
+    try {
+      const json = await response.json();
+      const parsed = schema.safeParse(json);
+      if (!parsed.success) {
+        return err(
+          new ValidationError("Response validation failed", [
+            { path: url, message: String(parsed.error) }
+          ])
+        );
+      }
+      return ok(parsed.data);
+    } catch (cause) {
+      return err(
+        new AflApiError(
+          `JSON parse failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        )
+      );
+    }
+  }
+  /**
+   * Resolve a competition code (e.g. "AFLM") to its API competition ID.
+   *
+   * @param code - The competition code to resolve.
+   * @returns The competition ID string on success.
+   */
+  async resolveCompetitionId(code) {
+    const result = await this.fetchJson(
+      `${API_BASE}/competitions?pageSize=50`,
+      CompetitionListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    const apiCode = code === "AFLM" ? "AFL" : code;
+    const competition = result.data.competitions.find((c) => c.code === apiCode);
+    if (!competition) {
+      return err(new AflApiError(`Competition not found for code: ${code}`));
+    }
+    return ok(competition.id);
+  }
+  /**
+   * Resolve a season (compseason) ID from a competition ID and year.
+   *
+   * @param competitionId - The competition ID (from {@link resolveCompetitionId}).
+   * @param year - The season year (e.g. 2024).
+   * @returns The compseason ID string on success.
+   */
+  async resolveSeasonId(competitionId, year) {
+    const result = await this.fetchJson(
+      `${API_BASE}/competitions/${competitionId}/compseasons?pageSize=100`,
+      CompseasonListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    const yearStr = String(year);
+    const season = result.data.compSeasons.find((cs) => cs.name.includes(yearStr));
+    if (!season) {
+      return err(new AflApiError(`Season not found for year: ${year}`));
+    }
+    return ok(season.id);
+  }
+  /**
+   * Resolve a season ID from a competition code and year in one step.
+   *
+   * @param code - The competition code (e.g. "AFLM").
+   * @param year - The season year (e.g. 2025).
+   * @returns The compseason ID on success.
+   */
+  async resolveCompSeason(code, year) {
+    const compResult = await this.resolveCompetitionId(code);
+    if (!compResult.success) return compResult;
+    return this.resolveSeasonId(compResult.data, year);
+  }
+  /**
+   * Fetch all rounds for a season with their metadata.
+   *
+   * @param seasonId - The compseason ID (from {@link resolveSeasonId}).
+   * @returns Array of round objects on success.
+   */
+  async resolveRounds(seasonId) {
+    const result = await this.fetchJson(
+      `${API_BASE}/compseasons/${seasonId}/rounds?pageSize=50`,
+      RoundListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data.rounds);
+  }
+  /**
+   * Fetch match items for a round using the /cfs/ endpoint.
+   *
+   * @param roundProviderId - The round provider ID (e.g. "CD_R202501401").
+   * @returns Array of match items on success.
+   */
+  async fetchRoundMatchItems(roundProviderId) {
+    const result = await this.fetchJson(
+      `${CFS_BASE}/matchItems/round/${roundProviderId}`,
+      MatchItemListSchema
+    );
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data.items);
+  }
+  /**
+   * Fetch match items for a round by resolving the round provider ID from season and round number.
+   *
+   * @param seasonId - The compseason ID.
+   * @param roundNumber - The round number.
+   * @returns Array of match items on success.
+   */
+  async fetchRoundMatchItemsByNumber(seasonId, roundNumber) {
+    const roundsResult = await this.resolveRounds(seasonId);
+    if (!roundsResult.success) {
+      return roundsResult;
+    }
+    const round = roundsResult.data.find((r) => r.roundNumber === roundNumber);
+    if (!round?.providerId) {
+      return err(new AflApiError(`Round not found or missing providerId: round ${roundNumber}`));
+    }
+    return this.fetchRoundMatchItems(round.providerId);
+  }
+  /**
+   * Fetch match items for all completed rounds in a season.
+   *
+   * @param seasonId - The compseason ID.
+   * @returns Aggregated array of match items from all completed rounds.
+   */
+  async fetchSeasonMatchItems(seasonId) {
+    const roundsResult = await this.resolveRounds(seasonId);
+    if (!roundsResult.success) {
+      return roundsResult;
+    }
+    const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
+    const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+    const allItems = [];
+    for (const result of results) {
+      if (!result.success) {
+        return result;
+      }
+      const concluded = result.data.filter(
+        (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
+      );
+      allItems.push(...concluded);
+    }
+    return ok(allItems);
+  }
+  /**
+   * Fetch per-player statistics for a match.
+   *
+   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+   * @returns Player stats list with home and away arrays.
+   */
+  async fetchPlayerStats(matchProviderId) {
+    return this.fetchJson(
+      `${CFS_BASE}/playerStats/match/${matchProviderId}`,
+      PlayerStatsListSchema
+    );
+  }
+  /**
+   * Fetch match roster (lineup) for a match.
+   *
+   * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+   * @returns Match roster with team players.
+   */
+  async fetchMatchRoster(matchProviderId) {
+    return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
+  }
+  /**
+   * Fetch team list, optionally filtered by team type.
+   *
+   * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
+   * @returns Array of team items.
+   */
+  async fetchTeams(teamType) {
+    const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
+    if (!result.success) {
+      return result;
+    }
+    if (teamType) {
+      return ok(result.data.teams.filter((t) => t.teamType === teamType));
+    }
+    return ok(result.data.teams);
+  }
+  /**
+   * Fetch squad (roster) for a team in a specific season.
+   *
+   * @param teamId - The numeric team ID.
+   * @param compSeasonId - The compseason ID.
+   * @returns Squad list response.
+   */
+  async fetchSquad(teamId, compSeasonId) {
+    return this.fetchJson(
+      `${API_BASE}/squads?teamId=${teamId}&compSeasonId=${compSeasonId}`,
+      SquadListSchema
+    );
+  }
+  /**
+   * Fetch ladder standings for a season (optionally for a specific round).
+   *
+   * @param seasonId - The compseason ID.
+   * @param roundId - Optional round ID (numeric `id`, not `providerId`).
+   * @returns Ladder response with entries.
+   */
+  async fetchLadder(seasonId, roundId) {
+    let url = `${API_BASE}/compseasons/${seasonId}/ladders`;
+    if (roundId != null) {
+      url += `?roundId=${roundId}`;
+    }
+    return this.fetchJson(url, LadderResponseSchema);
+  }
+};
+
+// src/transforms/match-results.ts
+var FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
+function inferRoundType(roundName) {
+  return FINALS_PATTERN.test(roundName) ? "Finals" : "HomeAndAway";
+}
+function toMatchStatus(raw) {
+  switch (raw) {
+    case "CONCLUDED":
+    case "COMPLETE":
+      return "Complete";
+    case "LIVE":
+    case "IN_PROGRESS":
+      return "Live";
+    case "UPCOMING":
+    case "SCHEDULED":
+      return "Upcoming";
+    case "POSTPONED":
+      return "Postponed";
+    case "CANCELLED":
+      return "Cancelled";
+    default:
+      return "Complete";
+  }
+}
+function toQuarterScore(period) {
+  return {
+    goals: period.score.goals,
+    behinds: period.score.behinds,
+    points: period.score.totalScore
+  };
+}
+function findPeriod(periods, quarter) {
+  if (!periods) return null;
+  const period = periods.find((p) => p.periodNumber === quarter);
+  return period ? toQuarterScore(period) : null;
+}
+function transformMatchItems(items, season, competition, source = "afl-api") {
+  return items.map((item) => {
+    const homeScore = item.score?.homeTeamScore;
+    const awayScore = item.score?.awayTeamScore;
+    const homePoints = homeScore?.matchScore.totalScore ?? 0;
+    const awayPoints = awayScore?.matchScore.totalScore ?? 0;
+    return {
+      matchId: item.match.matchId,
+      season,
+      roundNumber: item.round?.roundNumber ?? 0,
+      roundType: inferRoundType(item.round?.name ?? ""),
+      date: new Date(item.match.utcStartTime),
+      venue: item.venue?.name ?? "",
+      homeTeam: normaliseTeamName(item.match.homeTeam.name),
+      awayTeam: normaliseTeamName(item.match.awayTeam.name),
+      homeGoals: homeScore?.matchScore.goals ?? 0,
+      homeBehinds: homeScore?.matchScore.behinds ?? 0,
+      homePoints,
+      awayGoals: awayScore?.matchScore.goals ?? 0,
+      awayBehinds: awayScore?.matchScore.behinds ?? 0,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: findPeriod(homeScore?.periodScore, 1),
+      q2Home: findPeriod(homeScore?.periodScore, 2),
+      q3Home: findPeriod(homeScore?.periodScore, 3),
+      q4Home: findPeriod(homeScore?.periodScore, 4),
+      q1Away: findPeriod(awayScore?.periodScore, 1),
+      q2Away: findPeriod(awayScore?.periodScore, 2),
+      q3Away: findPeriod(awayScore?.periodScore, 3),
+      q4Away: findPeriod(awayScore?.periodScore, 4),
+      status: toMatchStatus(item.match.status),
+      attendance: null,
+      venueState: item.venue?.state ?? null,
+      venueTimezone: item.venue?.timeZone ?? null,
+      homeRushedBehinds: homeScore?.rushedBehinds ?? null,
+      awayRushedBehinds: awayScore?.rushedBehinds ?? null,
+      homeMinutesInFront: homeScore?.minutesInFront ?? null,
+      awayMinutesInFront: awayScore?.minutesInFront ?? null,
+      source,
+      competition
+    };
+  });
+}
+
+// src/api/fixture.ts
+function toFixture(item, season, fallbackRoundNumber, competition) {
+  return {
+    matchId: item.match.matchId,
+    season,
+    roundNumber: item.round?.roundNumber ?? fallbackRoundNumber,
+    roundType: inferRoundType(item.round?.name ?? ""),
+    date: new Date(item.match.utcStartTime),
+    venue: item.venue?.name ?? "",
+    homeTeam: normaliseTeamName(item.match.homeTeam.name),
+    awayTeam: normaliseTeamName(item.match.awayTeam.name),
+    status: toMatchStatus(item.match.status),
+    competition
+  };
+}
+async function fetchFixture(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Fixture data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  if (query.round != null) {
+    const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
+    if (!itemsResult.success) return itemsResult;
+    return ok(itemsResult.data.map((item) => toFixture(item, query.season, 0, competition)));
+  }
+  const roundsResult = await client.resolveRounds(seasonResult.data);
+  if (!roundsResult.success) return roundsResult;
+  const roundProviderIds = roundsResult.data.flatMap(
+    (r) => r.providerId ? [{ providerId: r.providerId, roundNumber: r.roundNumber }] : []
+  );
+  const roundResults = await Promise.all(
+    roundProviderIds.map((r) => client.fetchRoundMatchItems(r.providerId))
+  );
+  const fixtures = [];
+  for (let i = 0; i < roundResults.length; i++) {
+    const result = roundResults[i];
+    if (!result?.success) continue;
+    const roundNumber = roundProviderIds[i]?.roundNumber ?? 0;
+    for (const item of result.data) {
+      fixtures.push(toFixture(item, query.season, roundNumber, competition));
+    }
+  }
+  return ok(fixtures);
+}
+
+// src/transforms/ladder.ts
+function transformLadderEntries(entries) {
+  return entries.map((entry) => {
+    const record = entry.thisSeasonRecord;
+    const wl = record?.winLossRecord;
+    return {
+      position: entry.position,
+      team: normaliseTeamName(entry.team.name),
+      played: entry.played ?? wl?.played ?? 0,
+      wins: wl?.wins ?? 0,
+      losses: wl?.losses ?? 0,
+      draws: wl?.draws ?? 0,
+      pointsFor: entry.pointsFor ?? 0,
+      pointsAgainst: entry.pointsAgainst ?? 0,
+      percentage: record?.percentage ?? 0,
+      premiershipsPoints: record?.aggregatePoints ?? 0,
+      form: entry.form ?? null
+    };
+  });
+}
+
+// src/api/ladder.ts
+async function fetchLadder(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Ladder data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  let roundId;
+  if (query.round != null) {
+    const roundsResult = await client.resolveRounds(seasonResult.data);
+    if (!roundsResult.success) return roundsResult;
+    const round = roundsResult.data.find((r) => r.roundNumber === query.round);
+    if (round) {
+      roundId = round.id;
+    }
+  }
+  const ladderResult = await client.fetchLadder(seasonResult.data, roundId);
+  if (!ladderResult.success) return ladderResult;
+  const firstLadder = ladderResult.data.ladders[0];
+  const entries = firstLadder ? transformLadderEntries(firstLadder.entries) : [];
+  return ok({
+    season: query.season,
+    roundNumber: ladderResult.data.round?.roundNumber ?? null,
+    entries,
+    competition
+  });
+}
+
+// src/transforms/lineup.ts
+var EMERGENCY_POSITIONS = /* @__PURE__ */ new Set(["EMG", "EMERG"]);
+var SUBSTITUTE_POSITIONS = /* @__PURE__ */ new Set(["SUB", "INT"]);
+function transformMatchRoster(roster, season, roundNumber, competition) {
+  const homeTeamId = roster.match.homeTeamId;
+  const awayTeamId = roster.match.awayTeamId;
+  const homeTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === homeTeamId);
+  const awayTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === awayTeamId);
+  const mapPlayers = (players) => players.map((p) => {
+    const inner = p.player.player;
+    const position = p.player.position ?? null;
+    return {
+      playerId: inner.playerId,
+      givenName: inner.playerName.givenName,
+      surname: inner.playerName.surname,
+      displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+      jumperNumber: p.jumperNumber ?? null,
+      position,
+      isEmergency: position !== null && EMERGENCY_POSITIONS.has(position),
+      isSubstitute: position !== null && SUBSTITUTE_POSITIONS.has(position)
+    };
+  });
+  return {
+    matchId: roster.match.matchId,
+    season,
+    roundNumber,
+    homeTeam: normaliseTeamName(roster.match.homeTeam.name),
+    awayTeam: normaliseTeamName(roster.match.awayTeam.name),
+    homePlayers: homeTeamPlayers ? mapPlayers(homeTeamPlayers.players) : [],
+    awayPlayers: awayTeamPlayers ? mapPlayers(awayTeamPlayers.players) : [],
+    competition
+  };
+}
+
+// src/api/lineup.ts
+async function fetchLineup(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Lineup data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  if (query.matchId) {
+    const rosterResult = await client.fetchMatchRoster(query.matchId);
+    if (!rosterResult.success) return rosterResult;
+    return ok([transformMatchRoster(rosterResult.data, query.season, query.round, competition)]);
+  }
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  const matchItems = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
+  if (!matchItems.success) return matchItems;
+  if (matchItems.data.length === 0) {
+    return err(new AflApiError(`No matches found for round ${query.round}`));
+  }
+  const rosterResults = await Promise.all(
+    matchItems.data.map((item) => client.fetchMatchRoster(item.match.matchId))
+  );
+  const lineups = [];
+  for (const rosterResult of rosterResults) {
+    if (!rosterResult.success) return rosterResult;
+    lineups.push(transformMatchRoster(rosterResult.data, query.season, query.round, competition));
+  }
+  return ok(lineups);
+}
+
+// src/sources/afl-tables.ts
+import * as cheerio from "cheerio";
+
+// src/lib/date-utils.ts
+function parseAflApiDate(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  return date;
+}
+function parseFootyWireDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/-/g, " ");
+  const match = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (!match) {
+    return null;
+  }
+  const [, dayStr, monthStr, yearStr] = match;
+  if (!dayStr || !monthStr || !yearStr) {
+    return null;
+  }
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const year = Number.parseInt(yearStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function parseAflTablesDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/[-/]/g, " ");
+  const dmy = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (dmy) {
+    const [, dayStr, monthStr, yearStr] = dmy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const mdy = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
+  if (mdy) {
+    const [, monthStr, dayStr, yearStr] = mdy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  return null;
+}
+function toAestString(date) {
+  const formatter = new Intl.DateTimeFormat("en-AU", {
+    timeZone: "Australia/Melbourne",
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZoneName: "short"
+  });
+  return formatter.format(date);
+}
+var MONTH_ABBREV_TO_INDEX = /* @__PURE__ */ new Map([
+  ["jan", 0],
+  ["feb", 1],
+  ["mar", 2],
+  ["apr", 3],
+  ["may", 4],
+  ["jun", 5],
+  ["jul", 6],
+  ["aug", 7],
+  ["sep", 8],
+  ["oct", 9],
+  ["nov", 10],
+  ["dec", 11],
+  ["january", 0],
+  ["february", 1],
+  ["march", 2],
+  ["april", 3],
+  ["june", 5],
+  ["july", 6],
+  ["august", 7],
+  ["september", 8],
+  ["october", 9],
+  ["november", 10],
+  ["december", 11]
+]);
+function buildUtcDate(year, monthStr, day) {
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+
+// src/sources/afl-tables.ts
+var AFL_TABLES_BASE = "https://afltables.com/afl/seas";
+var AflTablesClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+  }
+  /**
+   * Fetch season match results from AFL Tables.
+   *
+   * @param year - The season year (1897 to present).
+   * @returns Array of match results.
+   */
+  async fetchSeasonResults(year) {
+    const url = `${AFL_TABLES_BASE}/${year}.html`;
+    try {
+      const response = await this.fetchFn(url, {
+        headers: { "User-Agent": "Mozilla/5.0" }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(`AFL Tables request failed: ${response.status} (${url})`, "afl-tables")
+        );
+      }
+      const html = await response.text();
+      const results = parseSeasonPage(html, year);
+      return ok(results);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `AFL Tables request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "afl-tables"
+        )
+      );
+    }
+  }
+};
+function parseSeasonPage(html, year) {
+  const $ = cheerio.load(html);
+  const results = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  let matchCounter = 0;
+  $("table").each((_i, table) => {
+    const $table = $(table);
+    const text = $table.text().trim();
+    const roundMatch = /^Round\s+(\d+)/i.exec(text);
+    if (roundMatch?.[1] && !$table.attr("border")) {
+      currentRound = Number.parseInt(roundMatch[1], 10);
+      currentRoundType = inferRoundType(text);
+      return;
+    }
+    if (!$table.attr("border") && inferRoundType(text) === "Finals") {
+      currentRoundType = "Finals";
+      return;
+    }
+    if ($table.attr("border") !== "1") return;
+    const rows = $table.find("tr");
+    if (rows.length !== 2) return;
+    const homeRow = $(rows[0]);
+    const awayRow = $(rows[1]);
+    const homeCells = homeRow.find("td");
+    const awayCells = awayRow.find("td");
+    if (homeCells.length < 4 || awayCells.length < 3) return;
+    const homeTeam = normaliseTeamName($(homeCells[0]).find("a").text().trim());
+    const awayTeam = normaliseTeamName($(awayCells[0]).find("a").text().trim());
+    if (!homeTeam || !awayTeam) return;
+    const homeQuarters = parseQuarterScores($(homeCells[1]).text());
+    const awayQuarters = parseQuarterScores($(awayCells[1]).text());
+    const homePoints = Number.parseInt($(homeCells[2]).text().trim(), 10) || 0;
+    const awayPoints = Number.parseInt($(awayCells[2]).text().trim(), 10) || 0;
+    const infoText = $(homeCells[3]).text().trim();
+    const date = parseDateFromInfo(infoText, year);
+    const venue = parseVenueFromInfo($(homeCells[3]).html() ?? "");
+    const attendance = parseAttendanceFromInfo(infoText);
+    const homeFinal = homeQuarters[3];
+    const awayFinal = awayQuarters[3];
+    matchCounter++;
+    results.push({
+      matchId: `AT_${year}_${matchCounter}`,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals: homeFinal?.goals ?? 0,
+      homeBehinds: homeFinal?.behinds ?? 0,
+      homePoints,
+      awayGoals: awayFinal?.goals ?? 0,
+      awayBehinds: awayFinal?.behinds ?? 0,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: homeQuarters[0] ?? null,
+      q2Home: homeQuarters[1] ?? null,
+      q3Home: homeQuarters[2] ?? null,
+      q4Home: homeQuarters[3] ?? null,
+      q1Away: awayQuarters[0] ?? null,
+      q2Away: awayQuarters[1] ?? null,
+      q3Away: awayQuarters[2] ?? null,
+      q4Away: awayQuarters[3] ?? null,
+      status: "Complete",
+      attendance,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "afl-tables",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+function parseQuarterScores(text) {
+  const clean = text.replace(/\u00a0/g, " ").trim();
+  const matches = [...clean.matchAll(/(\d+)\.(\d+)/g)];
+  return matches.map((m) => {
+    const goals = Number.parseInt(m[1] ?? "0", 10);
+    const behinds = Number.parseInt(m[2] ?? "0", 10);
+    return { goals, behinds, points: goals * 6 + behinds };
+  });
+}
+function parseDateFromInfo(text, year) {
+  const dateMatch = /(\d{1,2}-[A-Z][a-z]{2}-\d{4})/.exec(text);
+  if (dateMatch?.[1]) {
+    return parseAflTablesDate(dateMatch[1]) ?? new Date(year, 0, 1);
+  }
+  return parseAflTablesDate(text) ?? new Date(year, 0, 1);
+}
+function parseVenueFromInfo(html) {
+  const $ = cheerio.load(html);
+  const venueLink = $("a[href*='venues']");
+  if (venueLink.length > 0) {
+    return venueLink.text().trim();
+  }
+  const venueMatch = /Venue:\s*(.+?)(?:<|$)/i.exec(html);
+  return venueMatch?.[1]?.trim() ?? "";
+}
+function parseAttendanceFromInfo(text) {
+  const match = /Att:\s*([\d,]+)/i.exec(text);
+  if (!match?.[1]) return null;
+  return Number.parseInt(match[1].replace(/,/g, ""), 10) || null;
+}
+
+// src/sources/footywire.ts
+import * as cheerio2 from "cheerio";
+var FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
+var FootyWireClient = class {
+  fetchFn;
+  constructor(options) {
+    this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+  }
+  /**
+   * Fetch the HTML content of a FootyWire page.
+   */
+  async fetchHtml(url) {
+    try {
+      const response = await this.fetchFn(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+      });
+      if (!response.ok) {
+        return err(
+          new ScrapeError(`FootyWire request failed: ${response.status} (${url})`, "footywire")
+        );
+      }
+      const html = await response.text();
+      return ok(html);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `FootyWire request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "footywire"
+        )
+      );
+    }
+  }
+  /**
+   * Fetch season match results from FootyWire.
+   *
+   * @param year - The season year.
+   * @returns Array of match results.
+   */
+  async fetchSeasonResults(year) {
+    const url = `${FOOTYWIRE_BASE}/ft_match_list?year=${year}`;
+    const htmlResult = await this.fetchHtml(url);
+    if (!htmlResult.success) {
+      return htmlResult;
+    }
+    try {
+      const results = parseMatchList(htmlResult.data, year);
+      return ok(results);
+    } catch (cause) {
+      return err(
+        new ScrapeError(
+          `Failed to parse match list: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "footywire"
+        )
+      );
+    }
+  }
+};
+function parseMatchList(html, year) {
+  const $ = cheerio2.load(html);
+  const results = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  $("tr").each((_i, row) => {
+    const roundHeader = $(row).find("td[colspan='7']");
+    if (roundHeader.length > 0) {
+      const text = roundHeader.text().trim();
+      currentRoundType = inferRoundType(text);
+      const roundMatch = /Round\s+(\d+)/i.exec(text);
+      if (roundMatch?.[1]) {
+        currentRound = Number.parseInt(roundMatch[1], 10);
+      }
+      return;
+    }
+    const cells = $(row).find("td.data");
+    if (cells.length < 5) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    const attendance = $(cells[3]).text().trim();
+    const scoreCell = $(cells[4]);
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const scoreText = scoreCell.text().trim();
+    const scoreMatch = /(\d+)-(\d+)/.exec(scoreText);
+    if (!scoreMatch) return;
+    const homePoints = Number.parseInt(scoreMatch[1] ?? "0", 10);
+    const awayPoints = Number.parseInt(scoreMatch[2] ?? "0", 10);
+    const scoreLink = scoreCell.find("a").attr("href") ?? "";
+    const midMatch = /mid=(\d+)/.exec(scoreLink);
+    const matchId = midMatch?.[1] ? `FW_${midMatch[1]}` : `FW_${year}_R${currentRound}_${homeTeam}`;
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const homeGoals = Math.floor(homePoints / 6);
+    const homeBehinds = homePoints - homeGoals * 6;
+    const awayGoals = Math.floor(awayPoints / 6);
+    const awayBehinds = awayPoints - awayGoals * 6;
+    results.push({
+      matchId,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals,
+      homeBehinds,
+      homePoints,
+      awayGoals,
+      awayBehinds,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
+      status: "Complete",
+      attendance: attendance ? Number.parseInt(attendance, 10) || null : null,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "footywire",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+
+// src/api/match-results.ts
+async function fetchMatchResults(query) {
+  const competition = query.competition ?? "AFLM";
+  switch (query.source) {
+    case "afl-api": {
+      const client = new AflApiClient();
+      const seasonResult = await client.resolveCompSeason(competition, query.season);
+      if (!seasonResult.success) return seasonResult;
+      if (query.round != null) {
+        const itemsResult2 = await client.fetchRoundMatchItemsByNumber(
+          seasonResult.data,
+          query.round
+        );
+        if (!itemsResult2.success) return itemsResult2;
+        return ok(transformMatchItems(itemsResult2.data, query.season, competition));
+      }
+      const itemsResult = await client.fetchSeasonMatchItems(seasonResult.data);
+      if (!itemsResult.success) return itemsResult;
+      return ok(transformMatchItems(itemsResult.data, query.season, competition));
+    }
+    case "footywire": {
+      const client = new FootyWireClient();
+      const result = await client.fetchSeasonResults(query.season);
+      if (!result.success) return result;
+      if (query.round != null) {
+        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      }
+      return result;
+    }
+    case "afl-tables": {
+      const client = new AflTablesClient();
+      const result = await client.fetchSeasonResults(query.season);
+      if (!result.success) return result;
+      if (query.round != null) {
+        return ok(result.data.filter((m) => m.roundNumber === query.round));
+      }
+      return result;
+    }
+    default:
+      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+  }
+}
+
+// src/transforms/player-stats.ts
+function toNullable(value) {
+  return value ?? null;
+}
+function transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap) {
+  const inner = item.player.player.player;
+  const stats = item.playerStats.stats;
+  const clearances = stats.clearances;
+  return {
+    matchId,
+    season,
+    roundNumber,
+    team: normaliseTeamName(teamIdMap?.get(item.teamId) ?? item.teamId),
+    competition,
+    playerId: inner.playerId,
+    givenName: inner.playerName.givenName,
+    surname: inner.playerName.surname,
+    displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+    jumperNumber: item.player.jumperNumber ?? null,
+    kicks: toNullable(stats.kicks),
+    handballs: toNullable(stats.handballs),
+    disposals: toNullable(stats.disposals),
+    marks: toNullable(stats.marks),
+    goals: toNullable(stats.goals),
+    behinds: toNullable(stats.behinds),
+    tackles: toNullable(stats.tackles),
+    hitouts: toNullable(stats.hitouts),
+    freesFor: toNullable(stats.freesFor),
+    freesAgainst: toNullable(stats.freesAgainst),
+    contestedPossessions: toNullable(stats.contestedPossessions),
+    uncontestedPossessions: toNullable(stats.uncontestedPossessions),
+    contestedMarks: toNullable(stats.contestedMarks),
+    intercepts: toNullable(stats.intercepts),
+    centreClearances: toNullable(clearances?.centreClearances),
+    stoppageClearances: toNullable(clearances?.stoppageClearances),
+    totalClearances: toNullable(clearances?.totalClearances),
+    inside50s: toNullable(stats.inside50s),
+    rebound50s: toNullable(stats.rebound50s),
+    clangers: toNullable(stats.clangers),
+    turnovers: toNullable(stats.turnovers),
+    onePercenters: toNullable(stats.onePercenters),
+    bounces: toNullable(stats.bounces),
+    goalAssists: toNullable(stats.goalAssists),
+    disposalEfficiency: toNullable(stats.disposalEfficiency),
+    metresGained: toNullable(stats.metresGained),
+    goalAccuracy: toNullable(stats.goalAccuracy),
+    marksInside50: toNullable(stats.marksInside50),
+    tacklesInside50: toNullable(stats.tacklesInside50),
+    shotsAtGoal: toNullable(stats.shotsAtGoal),
+    scoreInvolvements: toNullable(stats.scoreInvolvements),
+    totalPossessions: toNullable(stats.totalPossessions),
+    timeOnGroundPercentage: toNullable(item.playerStats.timeOnGroundPercentage),
+    ratingPoints: toNullable(stats.ratingPoints),
+    dreamTeamPoints: toNullable(stats.dreamTeamPoints),
+    effectiveDisposals: toNullable(stats.extendedStats?.effectiveDisposals),
+    effectiveKicks: toNullable(stats.extendedStats?.effectiveKicks),
+    kickEfficiency: toNullable(stats.extendedStats?.kickEfficiency),
+    kickToHandballRatio: toNullable(stats.extendedStats?.kickToHandballRatio),
+    pressureActs: toNullable(stats.extendedStats?.pressureActs),
+    defHalfPressureActs: toNullable(stats.extendedStats?.defHalfPressureActs),
+    spoils: toNullable(stats.extendedStats?.spoils),
+    hitoutsToAdvantage: toNullable(stats.extendedStats?.hitoutsToAdvantage),
+    hitoutWinPercentage: toNullable(stats.extendedStats?.hitoutWinPercentage),
+    hitoutToAdvantageRate: toNullable(stats.extendedStats?.hitoutToAdvantageRate),
+    groundBallGets: toNullable(stats.extendedStats?.groundBallGets),
+    f50GroundBallGets: toNullable(stats.extendedStats?.f50GroundBallGets),
+    interceptMarks: toNullable(stats.extendedStats?.interceptMarks),
+    marksOnLead: toNullable(stats.extendedStats?.marksOnLead),
+    contestedPossessionRate: toNullable(stats.extendedStats?.contestedPossessionRate),
+    contestOffOneOnOnes: toNullable(stats.extendedStats?.contestOffOneOnOnes),
+    contestOffWins: toNullable(stats.extendedStats?.contestOffWins),
+    contestOffWinsPercentage: toNullable(stats.extendedStats?.contestOffWinsPercentage),
+    contestDefOneOnOnes: toNullable(stats.extendedStats?.contestDefOneOnOnes),
+    contestDefLosses: toNullable(stats.extendedStats?.contestDefLosses),
+    contestDefLossPercentage: toNullable(stats.extendedStats?.contestDefLossPercentage),
+    centreBounceAttendances: toNullable(stats.extendedStats?.centreBounceAttendances),
+    kickins: toNullable(stats.extendedStats?.kickins),
+    kickinsPlayon: toNullable(stats.extendedStats?.kickinsPlayon),
+    ruckContests: toNullable(stats.extendedStats?.ruckContests),
+    scoreLaunches: toNullable(stats.extendedStats?.scoreLaunches),
+    source
+  };
+}
+function transformPlayerStats(data, matchId, season, roundNumber, competition, source = "afl-api", teamIdMap) {
+  const home = data.homeTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  const away = data.awayTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  return [...home, ...away];
+}
+
+// src/api/player-stats.ts
+async function fetchPlayerStats(query) {
+  const competition = query.competition ?? "AFLM";
+  switch (query.source) {
+    case "afl-api": {
+      const client = new AflApiClient();
+      if (query.matchId) {
+        const result = await client.fetchPlayerStats(query.matchId);
+        if (!result.success) return result;
+        return ok(
+          transformPlayerStats(
+            result.data,
+            query.matchId,
+            query.season,
+            query.round ?? 0,
+            competition
+          )
+        );
+      }
+      const seasonResult = await client.resolveCompSeason(competition, query.season);
+      if (!seasonResult.success) return seasonResult;
+      const roundNumber = query.round ?? 1;
+      const matchItemsResult = await client.fetchRoundMatchItemsByNumber(
+        seasonResult.data,
+        roundNumber
+      );
+      if (!matchItemsResult.success) return matchItemsResult;
+      const teamIdMap = /* @__PURE__ */ new Map();
+      for (const item of matchItemsResult.data) {
+        teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
+        teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
+      }
+      const statsResults = await Promise.all(
+        matchItemsResult.data.map((item) => client.fetchPlayerStats(item.match.matchId))
+      );
+      const allStats = [];
+      for (let i = 0; i < statsResults.length; i++) {
+        const statsResult = statsResults[i];
+        if (!statsResult?.success)
+          return statsResult ?? err(new AflApiError("Missing stats result"));
+        const item = matchItemsResult.data[i];
+        if (!item) continue;
+        allStats.push(
+          ...transformPlayerStats(
+            statsResult.data,
+            item.match.matchId,
+            query.season,
+            roundNumber,
+            competition,
+            "afl-api",
+            teamIdMap
+          )
+        );
+      }
+      return ok(allStats);
+    }
+    case "footywire":
+      return err(
+        new UnsupportedSourceError(
+          "Player stats from FootyWire are not yet supported. Use source: 'afl-api'.",
+          "footywire"
+        )
+      );
+    case "afl-tables":
+      return err(
+        new UnsupportedSourceError(
+          "Player stats from AFL Tables are not yet supported. Use source: 'afl-api'.",
+          "afl-tables"
+        )
+      );
+    default:
+      return err(new UnsupportedSourceError(`Unsupported source: ${query.source}`, query.source));
+  }
+}
+
+// src/api/teams.ts
+function teamTypeForComp(comp) {
+  return comp === "AFLW" ? "WOMEN" : "MEN";
+}
+async function fetchTeams(query) {
+  const client = new AflApiClient();
+  const teamType = query?.teamType ?? (query?.competition ? teamTypeForComp(query.competition) : void 0);
+  const result = await client.fetchTeams(teamType);
+  if (!result.success) return result;
+  const competition = query?.competition ?? "AFLM";
+  return ok(
+    result.data.map((t) => ({
+      teamId: String(t.id),
+      name: normaliseTeamName(t.name),
+      abbreviation: t.abbreviation ?? "",
+      competition
+    }))
+  );
+}
+async function fetchSquad(query) {
+  const client = new AflApiClient();
+  const competition = query.competition ?? "AFLM";
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  const teamId = Number.parseInt(query.teamId, 10);
+  if (Number.isNaN(teamId)) {
+    return err(new ValidationError(`Invalid team ID: ${query.teamId}`));
+  }
+  const squadResult = await client.fetchSquad(teamId, seasonResult.data);
+  if (!squadResult.success) return squadResult;
+  const players = squadResult.data.squad.players.map((p) => ({
+    playerId: p.player.providerId ?? String(p.player.id),
+    givenName: p.player.firstName,
+    surname: p.player.surname,
+    displayName: `${p.player.firstName} ${p.player.surname}`,
+    jumperNumber: p.jumperNumber ?? null,
+    position: p.position ?? null,
+    dateOfBirth: p.player.dateOfBirth ? new Date(p.player.dateOfBirth) : null,
+    heightCm: p.player.heightInCm ?? null,
+    weightKg: p.player.weightInKg ?? null,
+    draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
+    draftPosition: p.player.draftPosition ? Number.parseInt(p.player.draftPosition, 10) || null : null,
+    draftType: p.player.draftType ?? null,
+    debutYear: p.player.debutYear ? Number.parseInt(p.player.debutYear, 10) || null : null,
+    recruitedFrom: p.player.recruitedFrom ?? null
+  }));
+  return ok({
+    teamId: query.teamId,
+    teamName: normaliseTeamName(squadResult.data.squad.team?.name ?? query.teamId),
+    season: query.season,
+    players,
+    competition
+  });
+}
+
+// src/sources/fryzigg.ts
+function fetchFryziggStats() {
+  return err(
+    new ScrapeError(
+      "Fryzigg data is only available in R-specific RDS binary format and cannot be consumed from TypeScript. Use the AFL API source for player statistics instead.",
+      "fryzigg"
+    )
+  );
+}
+export {
   AflApiClient,
   AflApiError,
   AflApiTokenSchema,
@@ -56,64 +1713,4 @@ import {
   transformMatchItems,
   transformMatchRoster,
   transformPlayerStats
-} from "./shared/chunk-eyrvakjt.js";
-import"./shared/chunk-xv8z2kms.js";
-export {
-  transformPlayerStats,
-  transformMatchRoster,
-  transformMatchItems,
-  transformLadderEntries,
-  toAestString,
-  parseFootyWireDate,
-  parseAflTablesDate,
-  parseAflApiDate,
-  ok,
-  normaliseTeamName,
-  inferRoundType,
-  fetchTeams,
-  fetchSquad,
-  fetchPlayerStats,
-  fetchMatchResults,
-  fetchLineup,
-  fetchLadder,
-  fetchFryziggStats,
-  fetchFixture,
-  err,
-  ValidationError,
-  UnsupportedSourceError,
-  TeamScoreSchema,
-  TeamPlayersSchema,
-  TeamListSchema,
-  TeamItemSchema,
-  SquadSchema,
-  SquadPlayerItemSchema,
-  SquadPlayerInnerSchema,
-  SquadListSchema,
-  ScrapeError,
-  ScoreSchema,
-  RoundSchema,
-  RoundListSchema,
-  RosterPlayerSchema,
-  PlayerStatsListSchema,
-  PlayerStatsItemSchema,
-  PlayerGameStatsSchema,
-  PeriodScoreSchema,
-  MatchRosterSchema,
-  MatchItemSchema,
-  MatchItemListSchema,
-  LadderResponseSchema,
-  LadderEntryRawSchema,
-  FootyWireClient,
-  CompseasonSchema,
-  CompseasonListSchema,
-  CompetitionSchema,
-  CompetitionListSchema,
-  CfsVenueSchema,
-  CfsScoreSchema,
-  CfsMatchTeamSchema,
-  CfsMatchSchema,
-  AflTablesClient,
-  AflApiTokenSchema,
-  AflApiError,
-  AflApiClient
 };