fitzroy 1.0.1 → 1.0.2

package/dist/cli.js

@@ -1,83 +1,1851 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/errors.ts
+var AflApiError, ScrapeError, UnsupportedSourceError, ValidationError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    AflApiError = class extends Error {
+      constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+      }
+      name = "AflApiError";
+    };
+    ScrapeError = class extends Error {
+      constructor(message, source) {
+        super(message);
+        this.source = source;
+      }
+      name = "ScrapeError";
+    };
+    UnsupportedSourceError = class extends Error {
+      constructor(message, source) {
+        super(message);
+        this.source = source;
+      }
+      name = "UnsupportedSourceError";
+    };
+    ValidationError = class extends Error {
+      constructor(message, issues) {
+        super(message);
+        this.issues = issues;
+      }
+      name = "ValidationError";
+    };
+  }
+});
+
+// src/lib/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+var init_result = __esm({
+  "src/lib/result.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/team-mapping.ts
+function normaliseTeamName(raw) {
+  const trimmed = raw.trim();
+  return ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+var TEAM_ALIASES, ALIAS_MAP;
+var init_team_mapping = __esm({
+  "src/lib/team-mapping.ts"() {
+    "use strict";
+    TEAM_ALIASES = [
+      ["Adelaide Crows", "Adelaide", "Crows", "ADEL", "AD"],
+      ["Brisbane Lions", "Brisbane", "Brisbane Bears", "Bears", "Fitzroy Lions", "BL", "BRIS"],
+      ["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"]
+    ];
+    ALIAS_MAP = (() => {
+      const map = /* @__PURE__ */ new Map();
+      for (const [canonical, ...aliases] of TEAM_ALIASES) {
+        map.set(canonical.toLowerCase(), canonical);
+        for (const alias of aliases) {
+          map.set(alias.toLowerCase(), canonical);
+        }
+      }
+      return map;
+    })();
+  }
+});
+
+// src/lib/validation.ts
+import { z } from "zod/v4";
+var AflApiTokenSchema, CompetitionSchema, CompetitionListSchema, CompseasonSchema, CompseasonListSchema, RoundSchema, RoundListSchema, ScoreSchema, PeriodScoreSchema, TeamScoreSchema, CfsMatchTeamSchema, CfsMatchSchema, CfsScoreSchema, CfsVenueSchema, MatchItemSchema, MatchItemListSchema, CfsPlayerInnerSchema, PlayerGameStatsSchema, PlayerStatsItemSchema, PlayerStatsListSchema, RosterPlayerSchema, TeamPlayersSchema, MatchRosterSchema, TeamItemSchema, TeamListSchema, SquadPlayerInnerSchema, SquadPlayerItemSchema, SquadSchema, SquadListSchema, WinLossRecordSchema, LadderEntryRawSchema, LadderResponseSchema;
+var init_validation = __esm({
+  "src/lib/validation.ts"() {
+    "use strict";
+    AflApiTokenSchema = z.object({
+      token: z.string(),
+      disclaimer: z.string().optional()
+    }).passthrough();
+    CompetitionSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      code: z.string().optional()
+    }).passthrough();
+    CompetitionListSchema = z.object({
+      competitions: z.array(CompetitionSchema)
+    }).passthrough();
+    CompseasonSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      shortName: z.string().optional(),
+      currentRoundNumber: z.number().optional()
+    }).passthrough();
+    CompseasonListSchema = z.object({
+      compSeasons: z.array(CompseasonSchema)
+    }).passthrough();
+    RoundSchema = z.object({
+      id: z.number(),
+      /** Provider ID used by /cfs/ endpoints (e.g. "CD_R202501401"). */
+      providerId: z.string().optional(),
+      name: z.string(),
+      abbreviation: z.string().optional(),
+      roundNumber: z.number(),
+      utcStartTime: z.string().optional(),
+      utcEndTime: z.string().optional()
+    }).passthrough();
+    RoundListSchema = z.object({
+      rounds: z.array(RoundSchema)
+    }).passthrough();
+    ScoreSchema = z.object({
+      totalScore: z.number(),
+      goals: z.number(),
+      behinds: z.number(),
+      superGoals: z.number().nullable().optional()
+    }).passthrough();
+    PeriodScoreSchema = z.object({
+      periodNumber: z.number(),
+      score: ScoreSchema
+    }).passthrough();
+    TeamScoreSchema = z.object({
+      matchScore: ScoreSchema,
+      periodScore: z.array(PeriodScoreSchema).optional(),
+      rushedBehinds: z.number().optional(),
+      minutesInFront: z.number().optional()
+    }).passthrough();
+    CfsMatchTeamSchema = z.object({
+      name: z.string(),
+      teamId: z.string(),
+      abbr: z.string().optional(),
+      nickname: z.string().optional()
+    }).passthrough();
+    CfsMatchSchema = z.object({
+      matchId: z.string(),
+      name: z.string().optional(),
+      status: z.string(),
+      utcStartTime: z.string(),
+      homeTeamId: z.string(),
+      awayTeamId: z.string(),
+      homeTeam: CfsMatchTeamSchema,
+      awayTeam: CfsMatchTeamSchema,
+      round: z.string().optional(),
+      abbr: z.string().optional()
+    }).passthrough();
+    CfsScoreSchema = z.object({
+      status: z.string(),
+      matchId: z.string(),
+      homeTeamScore: TeamScoreSchema,
+      awayTeamScore: TeamScoreSchema
+    }).passthrough();
+    CfsVenueSchema = z.object({
+      name: z.string(),
+      venueId: z.string().optional(),
+      state: z.string().optional(),
+      timeZone: z.string().optional()
+    }).passthrough();
+    MatchItemSchema = z.object({
+      match: CfsMatchSchema,
+      score: CfsScoreSchema.optional(),
+      venue: CfsVenueSchema.optional(),
+      round: z.object({
+        name: z.string(),
+        roundId: z.string(),
+        roundNumber: z.number()
+      }).passthrough().optional()
+    }).passthrough();
+    MatchItemListSchema = z.object({
+      roundId: z.string().optional(),
+      items: z.array(MatchItemSchema)
+    }).passthrough();
+    CfsPlayerInnerSchema = z.object({
+      playerId: z.string(),
+      playerName: z.object({
+        givenName: z.string(),
+        surname: z.string()
+      }).passthrough(),
+      captain: z.boolean().optional(),
+      playerJumperNumber: z.number().optional()
+    }).passthrough();
+    PlayerGameStatsSchema = z.object({
+      goals: z.number().optional(),
+      behinds: z.number().optional(),
+      kicks: z.number().optional(),
+      handballs: z.number().optional(),
+      disposals: z.number().optional(),
+      marks: z.number().optional(),
+      bounces: z.number().optional(),
+      tackles: z.number().optional(),
+      contestedPossessions: z.number().optional(),
+      uncontestedPossessions: z.number().optional(),
+      totalPossessions: z.number().optional(),
+      inside50s: z.number().optional(),
+      marksInside50: z.number().optional(),
+      contestedMarks: z.number().optional(),
+      hitouts: z.number().optional(),
+      onePercenters: z.number().optional(),
+      disposalEfficiency: z.number().optional(),
+      clangers: z.number().optional(),
+      freesFor: z.number().optional(),
+      freesAgainst: z.number().optional(),
+      dreamTeamPoints: z.number().optional(),
+      clearances: z.object({
+        centreClearances: z.number().optional(),
+        stoppageClearances: z.number().optional(),
+        totalClearances: z.number().optional()
+      }).passthrough().optional(),
+      rebound50s: z.number().optional(),
+      goalAssists: z.number().optional(),
+      goalAccuracy: z.number().optional(),
+      turnovers: z.number().optional(),
+      intercepts: z.number().optional(),
+      tacklesInside50: z.number().optional(),
+      shotsAtGoal: z.number().optional(),
+      metresGained: z.number().optional(),
+      scoreInvolvements: z.number().optional(),
+      ratingPoints: z.number().optional(),
+      extendedStats: z.object({
+        effectiveDisposals: z.number().optional(),
+        effectiveKicks: z.number().optional(),
+        kickEfficiency: z.number().optional(),
+        kickToHandballRatio: z.number().optional(),
+        pressureActs: z.number().optional(),
+        defHalfPressureActs: z.number().optional(),
+        spoils: z.number().optional(),
+        hitoutsToAdvantage: z.number().optional(),
+        hitoutWinPercentage: z.number().optional(),
+        hitoutToAdvantageRate: z.number().optional(),
+        groundBallGets: z.number().optional(),
+        f50GroundBallGets: z.number().optional(),
+        interceptMarks: z.number().optional(),
+        marksOnLead: z.number().optional(),
+        contestedPossessionRate: z.number().optional(),
+        contestOffOneOnOnes: z.number().optional(),
+        contestOffWins: z.number().optional(),
+        contestOffWinsPercentage: z.number().optional(),
+        contestDefOneOnOnes: z.number().optional(),
+        contestDefLosses: z.number().optional(),
+        contestDefLossPercentage: z.number().optional(),
+        centreBounceAttendances: z.number().optional(),
+        kickins: z.number().optional(),
+        kickinsPlayon: z.number().optional(),
+        ruckContests: z.number().optional(),
+        scoreLaunches: z.number().optional()
+      }).passthrough().optional()
+    }).passthrough();
+    PlayerStatsItemSchema = z.object({
+      player: z.object({
+        player: z.object({
+          position: z.string().optional(),
+          player: CfsPlayerInnerSchema
+        }).passthrough(),
+        jumperNumber: z.number().optional()
+      }).passthrough(),
+      teamId: z.string(),
+      playerStats: z.object({
+        stats: PlayerGameStatsSchema,
+        timeOnGroundPercentage: z.number().optional()
+      }).passthrough()
+    }).passthrough();
+    PlayerStatsListSchema = z.object({
+      homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
+      awayTeamPlayerStats: z.array(PlayerStatsItemSchema)
+    }).passthrough();
+    RosterPlayerSchema = z.object({
+      player: z.object({
+        position: z.string().optional(),
+        player: CfsPlayerInnerSchema
+      }).passthrough(),
+      jumperNumber: z.number().optional()
+    }).passthrough();
+    TeamPlayersSchema = z.object({
+      teamId: z.string(),
+      players: z.array(RosterPlayerSchema)
+    }).passthrough();
+    MatchRosterSchema = z.object({
+      match: CfsMatchSchema,
+      teamPlayers: z.array(TeamPlayersSchema)
+    }).passthrough();
+    TeamItemSchema = z.object({
+      id: z.number(),
+      name: z.string(),
+      abbreviation: z.string().optional(),
+      teamType: z.string().optional()
+    }).passthrough();
+    TeamListSchema = z.object({
+      teams: z.array(TeamItemSchema)
+    }).passthrough();
+    SquadPlayerInnerSchema = z.object({
+      id: z.number(),
+      providerId: z.string().optional(),
+      firstName: z.string(),
+      surname: z.string(),
+      dateOfBirth: z.string().optional(),
+      heightInCm: z.number().optional(),
+      weightInKg: z.number().optional(),
+      draftYear: z.string().optional(),
+      draftPosition: z.string().optional(),
+      draftType: z.string().optional(),
+      debutYear: z.string().optional(),
+      recruitedFrom: z.string().optional()
+    }).passthrough();
+    SquadPlayerItemSchema = z.object({
+      player: SquadPlayerInnerSchema,
+      jumperNumber: z.number().optional(),
+      position: z.string().optional()
+    }).passthrough();
+    SquadSchema = z.object({
+      team: z.object({
+        name: z.string()
+      }).passthrough().optional(),
+      players: z.array(SquadPlayerItemSchema)
+    }).passthrough();
+    SquadListSchema = z.object({
+      squad: SquadSchema
+    }).passthrough();
+    WinLossRecordSchema = z.object({
+      wins: z.number(),
+      losses: z.number(),
+      draws: z.number(),
+      played: z.number().optional()
+    }).passthrough();
+    LadderEntryRawSchema = z.object({
+      position: z.number(),
+      team: z.object({
+        name: z.string(),
+        id: z.number().optional(),
+        abbreviation: z.string().optional()
+      }).passthrough(),
+      played: z.number().optional(),
+      pointsFor: z.number().optional(),
+      pointsAgainst: z.number().optional(),
+      thisSeasonRecord: z.object({
+        aggregatePoints: z.number().optional(),
+        percentage: z.number().optional(),
+        winLossRecord: WinLossRecordSchema.optional()
+      }).passthrough().optional(),
+      form: z.string().optional()
+    }).passthrough();
+    LadderResponseSchema = z.object({
+      ladders: z.array(
+        z.object({
+          entries: z.array(LadderEntryRawSchema)
+        }).passthrough()
+      ),
+      round: z.object({
+        roundNumber: z.number(),
+        name: z.string().optional()
+      }).passthrough().optional()
+    }).passthrough();
+  }
+});
+
+// src/sources/afl-api.ts
+var TOKEN_URL, API_BASE, CFS_BASE, AflApiClient;
+var init_afl_api = __esm({
+  "src/sources/afl-api.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_validation();
+    TOKEN_URL = "https://api.afl.com.au/cfs/afl/WMCTok";
+    API_BASE = "https://aflapi.afl.com.au/afl/v2";
+    CFS_BASE = "https://api.afl.com.au/cfs/afl";
+    AflApiClient = class {
+      fetchFn;
+      tokenUrl;
+      cachedToken = null;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+        this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
+      }
+      /**
+       * Authenticate with the WMCTok token endpoint and cache the token.
+       *
+       * @returns The access token on success, or an error Result.
+       */
+      async authenticate() {
+        try {
+          const response = await this.fetchFn(this.tokenUrl, {
+            method: "POST",
+            headers: { "Content-Length": "0" }
+          });
+          if (!response.ok) {
+            return err(new AflApiError(`Token request failed: ${response.status}`, response.status));
+          }
+          const json = await response.json();
+          const parsed = AflApiTokenSchema.safeParse(json);
+          if (!parsed.success) {
+            return err(new AflApiError("Invalid token response format"));
+          }
+          const ttlMs = 30 * 60 * 1e3;
+          this.cachedToken = {
+            accessToken: parsed.data.token,
+            expiresAt: Date.now() + ttlMs
+          };
+          return ok(parsed.data.token);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `Token request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Whether the cached token is still valid (not expired).
+       */
+      get isAuthenticated() {
+        return this.cachedToken !== null && Date.now() < this.cachedToken.expiresAt;
+      }
+      /**
+       * Perform an authenticated fetch, automatically adding the bearer token.
+       * Retries once on 401 by re-authenticating.
+       *
+       * @param url - The URL to fetch.
+       * @param init - Additional fetch options.
+       * @returns The Response on success, or an error Result.
+       */
+      async authedFetch(url, init) {
+        if (!this.isAuthenticated) {
+          const authResult = await this.authenticate();
+          if (!authResult.success) {
+            return authResult;
+          }
+        }
+        const doFetch = async () => {
+          const token = this.cachedToken;
+          if (!token) {
+            throw new AflApiError("No cached token available");
+          }
+          const headers = new Headers(init?.headers);
+          headers.set("x-media-mis-token", token.accessToken);
+          return this.fetchFn(url, { ...init, headers });
+        };
+        try {
+          let response = await doFetch();
+          if (response.status === 401) {
+            const authResult = await this.authenticate();
+            if (!authResult.success) {
+              return authResult;
+            }
+            response = await doFetch();
+          }
+          if (!response.ok) {
+            return err(
+              new AflApiError(
+                `Request failed: ${response.status} ${response.statusText}`,
+                response.status
+              )
+            );
+          }
+          return ok(response);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Fetch JSON from a URL, validate with a Zod schema, and return a typed Result.
+       *
+       * @param url - The URL to fetch.
+       * @param schema - Zod schema to validate the response against.
+       * @returns Validated data on success, or an error Result.
+       */
+      async fetchJson(url, schema) {
+        const isPublic = url.startsWith(API_BASE);
+        let response;
+        if (isPublic) {
+          try {
+            response = await this.fetchFn(url);
+            if (!response.ok) {
+              return err(
+                new AflApiError(
+                  `Request failed: ${response.status} ${response.statusText}`,
+                  response.status
+                )
+              );
+            }
+          } catch (cause) {
+            return err(
+              new AflApiError(
+                `Request failed: ${cause instanceof Error ? cause.message : String(cause)}`
+              )
+            );
+          }
+        } else {
+          const fetchResult = await this.authedFetch(url);
+          if (!fetchResult.success) {
+            return fetchResult;
+          }
+          response = fetchResult.data;
+        }
+        try {
+          const json = await response.json();
+          const parsed = schema.safeParse(json);
+          if (!parsed.success) {
+            return err(
+              new ValidationError("Response validation failed", [
+                { path: url, message: String(parsed.error) }
+              ])
+            );
+          }
+          return ok(parsed.data);
+        } catch (cause) {
+          return err(
+            new AflApiError(
+              `JSON parse failed: ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
+        }
+      }
+      /**
+       * Resolve a competition code (e.g. "AFLM") to its API competition ID.
+       *
+       * @param code - The competition code to resolve.
+       * @returns The competition ID string on success.
+       */
+      async resolveCompetitionId(code) {
+        const result = await this.fetchJson(
+          `${API_BASE}/competitions?pageSize=50`,
+          CompetitionListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        const apiCode = code === "AFLM" ? "AFL" : code;
+        const competition = result.data.competitions.find((c) => c.code === apiCode);
+        if (!competition) {
+          return err(new AflApiError(`Competition not found for code: ${code}`));
+        }
+        return ok(competition.id);
+      }
+      /**
+       * Resolve a season (compseason) ID from a competition ID and year.
+       *
+       * @param competitionId - The competition ID (from {@link resolveCompetitionId}).
+       * @param year - The season year (e.g. 2024).
+       * @returns The compseason ID string on success.
+       */
+      async resolveSeasonId(competitionId, year) {
+        const result = await this.fetchJson(
+          `${API_BASE}/competitions/${competitionId}/compseasons?pageSize=100`,
+          CompseasonListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        const yearStr = String(year);
+        const season = result.data.compSeasons.find((cs) => cs.name.includes(yearStr));
+        if (!season) {
+          return err(new AflApiError(`Season not found for year: ${year}`));
+        }
+        return ok(season.id);
+      }
+      /**
+       * Resolve a season ID from a competition code and year in one step.
+       *
+       * @param code - The competition code (e.g. "AFLM").
+       * @param year - The season year (e.g. 2025).
+       * @returns The compseason ID on success.
+       */
+      async resolveCompSeason(code, year) {
+        const compResult = await this.resolveCompetitionId(code);
+        if (!compResult.success) return compResult;
+        return this.resolveSeasonId(compResult.data, year);
+      }
+      /**
+       * Fetch all rounds for a season with their metadata.
+       *
+       * @param seasonId - The compseason ID (from {@link resolveSeasonId}).
+       * @returns Array of round objects on success.
+       */
+      async resolveRounds(seasonId) {
+        const result = await this.fetchJson(
+          `${API_BASE}/compseasons/${seasonId}/rounds?pageSize=50`,
+          RoundListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        return ok(result.data.rounds);
+      }
+      /**
+       * Fetch match items for a round using the /cfs/ endpoint.
+       *
+       * @param roundProviderId - The round provider ID (e.g. "CD_R202501401").
+       * @returns Array of match items on success.
+       */
+      async fetchRoundMatchItems(roundProviderId) {
+        const result = await this.fetchJson(
+          `${CFS_BASE}/matchItems/round/${roundProviderId}`,
+          MatchItemListSchema
+        );
+        if (!result.success) {
+          return result;
+        }
+        return ok(result.data.items);
+      }
+      /**
+       * Fetch match items for a round by resolving the round provider ID from season and round number.
+       *
+       * @param seasonId - The compseason ID.
+       * @param roundNumber - The round number.
+       * @returns Array of match items on success.
+       */
+      async fetchRoundMatchItemsByNumber(seasonId, roundNumber) {
+        const roundsResult = await this.resolveRounds(seasonId);
+        if (!roundsResult.success) {
+          return roundsResult;
+        }
+        const round = roundsResult.data.find((r) => r.roundNumber === roundNumber);
+        if (!round?.providerId) {
+          return err(new AflApiError(`Round not found or missing providerId: round ${roundNumber}`));
+        }
+        return this.fetchRoundMatchItems(round.providerId);
+      }
+      /**
+       * Fetch match items for all completed rounds in a season.
+       *
+       * @param seasonId - The compseason ID.
+       * @returns Aggregated array of match items from all completed rounds.
+       */
+      async fetchSeasonMatchItems(seasonId) {
+        const roundsResult = await this.resolveRounds(seasonId);
+        if (!roundsResult.success) {
+          return roundsResult;
+        }
+        const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
+        const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+        const allItems = [];
+        for (const result of results) {
+          if (!result.success) {
+            return result;
+          }
+          const concluded = result.data.filter(
+            (item) => item.match.status === "CONCLUDED" || item.match.status === "COMPLETE"
+          );
+          allItems.push(...concluded);
+        }
+        return ok(allItems);
+      }
+      /**
+       * Fetch per-player statistics for a match.
+       *
+       * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+       * @returns Player stats list with home and away arrays.
+       */
+      async fetchPlayerStats(matchProviderId) {
+        return this.fetchJson(
+          `${CFS_BASE}/playerStats/match/${matchProviderId}`,
+          PlayerStatsListSchema
+        );
+      }
+      /**
+       * Fetch match roster (lineup) for a match.
+       *
+       * @param matchProviderId - The match provider ID (e.g. "CD_M20250140101").
+       * @returns Match roster with team players.
+       */
+      async fetchMatchRoster(matchProviderId) {
+        return this.fetchJson(`${CFS_BASE}/matchRoster/full/${matchProviderId}`, MatchRosterSchema);
+      }
+      /**
+       * Fetch team list, optionally filtered by team type.
+       *
+       * @param teamType - Optional filter (e.g. "MEN", "WOMEN").
+       * @returns Array of team items.
+       */
+      async fetchTeams(teamType) {
+        const result = await this.fetchJson(`${API_BASE}/teams?pageSize=100`, TeamListSchema);
+        if (!result.success) {
+          return result;
+        }
+        if (teamType) {
+          return ok(result.data.teams.filter((t) => t.teamType === teamType));
+        }
+        return ok(result.data.teams);
+      }
+      /**
+       * Fetch squad (roster) for a team in a specific season.
+       *
+       * @param teamId - The numeric team ID.
+       * @param compSeasonId - The compseason ID.
+       * @returns Squad list response.
+       */
+      async fetchSquad(teamId, compSeasonId) {
+        return this.fetchJson(
+          `${API_BASE}/squads?teamId=${teamId}&compSeasonId=${compSeasonId}`,
+          SquadListSchema
+        );
+      }
+      /**
+       * Fetch ladder standings for a season (optionally for a specific round).
+       *
+       * @param seasonId - The compseason ID.
+       * @param roundId - Optional round ID (numeric `id`, not `providerId`).
+       * @returns Ladder response with entries.
+       */
+      async fetchLadder(seasonId, roundId) {
+        let url = `${API_BASE}/compseasons/${seasonId}/ladders`;
+        if (roundId != null) {
+          url += `?roundId=${roundId}`;
+        }
+        return this.fetchJson(url, LadderResponseSchema);
+      }
+    };
+  }
+});
+
+// src/transforms/match-results.ts
+function inferRoundType(roundName) {
+  return FINALS_PATTERN.test(roundName) ? "Finals" : "HomeAndAway";
+}
+function toMatchStatus(raw) {
+  switch (raw) {
+    case "CONCLUDED":
+    case "COMPLETE":
+      return "Complete";
+    case "LIVE":
+    case "IN_PROGRESS":
+      return "Live";
+    case "UPCOMING":
+    case "SCHEDULED":
+      return "Upcoming";
+    case "POSTPONED":
+      return "Postponed";
+    case "CANCELLED":
+      return "Cancelled";
+    default:
+      return "Complete";
+  }
+}
+function toQuarterScore(period) {
+  return {
+    goals: period.score.goals,
+    behinds: period.score.behinds,
+    points: period.score.totalScore
+  };
+}
+function findPeriod(periods, quarter) {
+  if (!periods) return null;
+  const period = periods.find((p) => p.periodNumber === quarter);
+  return period ? toQuarterScore(period) : null;
+}
+function transformMatchItems(items, season, competition, source = "afl-api") {
+  return items.map((item) => {
+    const homeScore = item.score?.homeTeamScore;
+    const awayScore = item.score?.awayTeamScore;
+    const homePoints = homeScore?.matchScore.totalScore ?? 0;
+    const awayPoints = awayScore?.matchScore.totalScore ?? 0;
+    return {
+      matchId: item.match.matchId,
+      season,
+      roundNumber: item.round?.roundNumber ?? 0,
+      roundType: inferRoundType(item.round?.name ?? ""),
+      date: new Date(item.match.utcStartTime),
+      venue: item.venue?.name ?? "",
+      homeTeam: normaliseTeamName(item.match.homeTeam.name),
+      awayTeam: normaliseTeamName(item.match.awayTeam.name),
+      homeGoals: homeScore?.matchScore.goals ?? 0,
+      homeBehinds: homeScore?.matchScore.behinds ?? 0,
+      homePoints,
+      awayGoals: awayScore?.matchScore.goals ?? 0,
+      awayBehinds: awayScore?.matchScore.behinds ?? 0,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: findPeriod(homeScore?.periodScore, 1),
+      q2Home: findPeriod(homeScore?.periodScore, 2),
+      q3Home: findPeriod(homeScore?.periodScore, 3),
+      q4Home: findPeriod(homeScore?.periodScore, 4),
+      q1Away: findPeriod(awayScore?.periodScore, 1),
+      q2Away: findPeriod(awayScore?.periodScore, 2),
+      q3Away: findPeriod(awayScore?.periodScore, 3),
+      q4Away: findPeriod(awayScore?.periodScore, 4),
+      status: toMatchStatus(item.match.status),
+      attendance: null,
+      venueState: item.venue?.state ?? null,
+      venueTimezone: item.venue?.timeZone ?? null,
+      homeRushedBehinds: homeScore?.rushedBehinds ?? null,
+      awayRushedBehinds: awayScore?.rushedBehinds ?? null,
+      homeMinutesInFront: homeScore?.minutesInFront ?? null,
+      awayMinutesInFront: awayScore?.minutesInFront ?? null,
+      source,
+      competition
+    };
+  });
+}
+var FINALS_PATTERN;
+var init_match_results = __esm({
+  "src/transforms/match-results.ts"() {
+    "use strict";
+    init_team_mapping();
+    FINALS_PATTERN = /final|elimination|qualifying|preliminary|semi|grand/i;
+  }
+});
+
+// src/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);
+}
+var init_fixture = __esm({
+  "src/api/fixture.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_api();
+    init_match_results();
+  }
+});
+
+// src/transforms/ladder.ts
+function transformLadderEntries(entries) {
+  return entries.map((entry) => {
+    const record = entry.thisSeasonRecord;
+    const wl = record?.winLossRecord;
+    return {
+      position: entry.position,
+      team: normaliseTeamName(entry.team.name),
+      played: entry.played ?? wl?.played ?? 0,
+      wins: wl?.wins ?? 0,
+      losses: wl?.losses ?? 0,
+      draws: wl?.draws ?? 0,
+      pointsFor: entry.pointsFor ?? 0,
+      pointsAgainst: entry.pointsAgainst ?? 0,
+      percentage: record?.percentage ?? 0,
+      premiershipsPoints: record?.aggregatePoints ?? 0,
+      form: entry.form ?? null
+    };
+  });
+}
+var init_ladder = __esm({
+  "src/transforms/ladder.ts"() {
+    "use strict";
+    init_team_mapping();
+  }
+});
+
+// src/api/ladder.ts
+async function fetchLadder(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Ladder data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  let roundId;
+  if (query.round != null) {
+    const roundsResult = await client.resolveRounds(seasonResult.data);
+    if (!roundsResult.success) return roundsResult;
+    const round = roundsResult.data.find((r) => r.roundNumber === query.round);
+    if (round) {
+      roundId = round.id;
+    }
+  }
+  const ladderResult = await client.fetchLadder(seasonResult.data, roundId);
+  if (!ladderResult.success) return ladderResult;
+  const firstLadder = ladderResult.data.ladders[0];
+  const entries = firstLadder ? transformLadderEntries(firstLadder.entries) : [];
+  return ok({
+    season: query.season,
+    roundNumber: ladderResult.data.round?.roundNumber ?? null,
+    entries,
+    competition
+  });
+}
+var init_ladder2 = __esm({
+  "src/api/ladder.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_ladder();
+  }
+});
+
+// src/transforms/lineup.ts
+function transformMatchRoster(roster, season, roundNumber, competition) {
+  const homeTeamId = roster.match.homeTeamId;
+  const awayTeamId = roster.match.awayTeamId;
+  const homeTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === homeTeamId);
+  const awayTeamPlayers = roster.teamPlayers.find((tp) => tp.teamId === awayTeamId);
+  const mapPlayers = (players) => players.map((p) => {
+    const inner = p.player.player;
+    const position = p.player.position ?? null;
+    return {
+      playerId: inner.playerId,
+      givenName: inner.playerName.givenName,
+      surname: inner.playerName.surname,
+      displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+      jumperNumber: p.jumperNumber ?? null,
+      position,
+      isEmergency: position !== null && EMERGENCY_POSITIONS.has(position),
+      isSubstitute: position !== null && SUBSTITUTE_POSITIONS.has(position)
+    };
+  });
+  return {
+    matchId: roster.match.matchId,
+    season,
+    roundNumber,
+    homeTeam: normaliseTeamName(roster.match.homeTeam.name),
+    awayTeam: normaliseTeamName(roster.match.awayTeam.name),
+    homePlayers: homeTeamPlayers ? mapPlayers(homeTeamPlayers.players) : [],
+    awayPlayers: awayTeamPlayers ? mapPlayers(awayTeamPlayers.players) : [],
+    competition
+  };
+}
+var EMERGENCY_POSITIONS, SUBSTITUTE_POSITIONS;
+var init_lineup = __esm({
+  "src/transforms/lineup.ts"() {
+    "use strict";
+    init_team_mapping();
+    EMERGENCY_POSITIONS = /* @__PURE__ */ new Set(["EMG", "EMERG"]);
+    SUBSTITUTE_POSITIONS = /* @__PURE__ */ new Set(["SUB", "INT"]);
+  }
+});
+
+// src/api/lineup.ts
+async function fetchLineup(query) {
+  const competition = query.competition ?? "AFLM";
+  if (query.source !== "afl-api") {
+    return err(
+      new UnsupportedSourceError(
+        "Lineup data is only available from the AFL API source.",
+        query.source
+      )
+    );
+  }
+  const client = new AflApiClient();
+  if (query.matchId) {
+    const rosterResult = await client.fetchMatchRoster(query.matchId);
+    if (!rosterResult.success) return rosterResult;
+    return ok([transformMatchRoster(rosterResult.data, query.season, query.round, competition)]);
+  }
+  const seasonResult = await client.resolveCompSeason(competition, query.season);
+  if (!seasonResult.success) return seasonResult;
+  const matchItems = await client.fetchRoundMatchItemsByNumber(seasonResult.data, query.round);
+  if (!matchItems.success) return matchItems;
+  if (matchItems.data.length === 0) {
+    return err(new AflApiError(`No matches found for round ${query.round}`));
+  }
+  const rosterResults = await Promise.all(
+    matchItems.data.map((item) => client.fetchMatchRoster(item.match.matchId))
+  );
+  const lineups = [];
+  for (const rosterResult of rosterResults) {
+    if (!rosterResult.success) return rosterResult;
+    lineups.push(transformMatchRoster(rosterResult.data, query.season, query.round, competition));
+  }
+  return ok(lineups);
+}
+var init_lineup2 = __esm({
+  "src/api/lineup.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_lineup();
+  }
+});
+
+// src/lib/date-utils.ts
+function parseFootyWireDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/-/g, " ");
+  const match = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (!match) {
+    return null;
+  }
+  const [, dayStr, monthStr, yearStr] = match;
+  if (!dayStr || !monthStr || !yearStr) {
+    return null;
+  }
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const year = Number.parseInt(yearStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function parseAflTablesDate(dateStr) {
+  const trimmed = dateStr.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
+  const normalised = withoutDow.replace(/[-/]/g, " ");
+  const dmy = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (dmy) {
+    const [, dayStr, monthStr, yearStr] = dmy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  const mdy = /^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})$/.exec(normalised);
+  if (mdy) {
+    const [, monthStr, dayStr, yearStr] = mdy;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
+  }
+  return null;
+}
+function buildUtcDate(year, monthStr, day) {
+  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+var MONTH_ABBREV_TO_INDEX;
+var init_date_utils = __esm({
+  "src/lib/date-utils.ts"() {
+    "use strict";
+    MONTH_ABBREV_TO_INDEX = /* @__PURE__ */ new Map([
+      ["jan", 0],
+      ["feb", 1],
+      ["mar", 2],
+      ["apr", 3],
+      ["may", 4],
+      ["jun", 5],
+      ["jul", 6],
+      ["aug", 7],
+      ["sep", 8],
+      ["oct", 9],
+      ["nov", 10],
+      ["dec", 11],
+      ["january", 0],
+      ["february", 1],
+      ["march", 2],
+      ["april", 3],
+      ["june", 5],
+      ["july", 6],
+      ["august", 7],
+      ["september", 8],
+      ["october", 9],
+      ["november", 10],
+      ["december", 11]
+    ]);
+  }
+});
+
+// src/sources/afl-tables.ts
+import * as cheerio from "cheerio";
+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;
+}
+var AFL_TABLES_BASE, AflTablesClient;
+var init_afl_tables = __esm({
+  "src/sources/afl-tables.ts"() {
+    "use strict";
+    init_date_utils();
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_match_results();
+    AFL_TABLES_BASE = "https://afltables.com/afl/seas";
+    AflTablesClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch season match results from AFL Tables.
+       *
+       * @param year - The season year (1897 to present).
+       * @returns Array of match results.
+       */
+      async fetchSeasonResults(year) {
+        const url = `${AFL_TABLES_BASE}/${year}.html`;
+        try {
+          const response = await this.fetchFn(url, {
+            headers: { "User-Agent": "Mozilla/5.0" }
+          });
+          if (!response.ok) {
+            return err(
+              new ScrapeError(`AFL Tables request failed: ${response.status} (${url})`, "afl-tables")
+            );
+          }
+          const html = await response.text();
+          const results = parseSeasonPage(html, year);
+          return ok(results);
+        } catch (cause) {
+          return err(
+            new ScrapeError(
+              `AFL Tables request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+              "afl-tables"
+            )
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/sources/footywire.ts
+import * as cheerio2 from "cheerio";
+function parseMatchList(html, year) {
+  const $ = cheerio2.load(html);
+  const results = [];
+  let currentRound = 0;
+  let currentRoundType = "HomeAndAway";
+  $("tr").each((_i, row) => {
+    const roundHeader = $(row).find("td[colspan='7']");
+    if (roundHeader.length > 0) {
+      const text = roundHeader.text().trim();
+      currentRoundType = inferRoundType(text);
+      const roundMatch = /Round\s+(\d+)/i.exec(text);
+      if (roundMatch?.[1]) {
+        currentRound = Number.parseInt(roundMatch[1], 10);
+      }
+      return;
+    }
+    const cells = $(row).find("td.data");
+    if (cells.length < 5) return;
+    const dateText = $(cells[0]).text().trim();
+    const teamsCell = $(cells[1]);
+    const venue = $(cells[2]).text().trim();
+    const attendance = $(cells[3]).text().trim();
+    const scoreCell = $(cells[4]);
+    if (venue === "BYE") return;
+    const teamLinks = teamsCell.find("a");
+    if (teamLinks.length < 2) return;
+    const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
+    const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
+    const scoreText = scoreCell.text().trim();
+    const scoreMatch = /(\d+)-(\d+)/.exec(scoreText);
+    if (!scoreMatch) return;
+    const homePoints = Number.parseInt(scoreMatch[1] ?? "0", 10);
+    const awayPoints = Number.parseInt(scoreMatch[2] ?? "0", 10);
+    const scoreLink = scoreCell.find("a").attr("href") ?? "";
+    const midMatch = /mid=(\d+)/.exec(scoreLink);
+    const matchId = midMatch?.[1] ? `FW_${midMatch[1]}` : `FW_${year}_R${currentRound}_${homeTeam}`;
+    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const homeGoals = Math.floor(homePoints / 6);
+    const homeBehinds = homePoints - homeGoals * 6;
+    const awayGoals = Math.floor(awayPoints / 6);
+    const awayBehinds = awayPoints - awayGoals * 6;
+    results.push({
+      matchId,
+      season: year,
+      roundNumber: currentRound,
+      roundType: currentRoundType,
+      date,
+      venue,
+      homeTeam,
+      awayTeam,
+      homeGoals,
+      homeBehinds,
+      homePoints,
+      awayGoals,
+      awayBehinds,
+      awayPoints,
+      margin: homePoints - awayPoints,
+      q1Home: null,
+      q2Home: null,
+      q3Home: null,
+      q4Home: null,
+      q1Away: null,
+      q2Away: null,
+      q3Away: null,
+      q4Away: null,
+      status: "Complete",
+      attendance: attendance ? Number.parseInt(attendance, 10) || null : null,
+      venueState: null,
+      venueTimezone: null,
+      homeRushedBehinds: null,
+      awayRushedBehinds: null,
+      homeMinutesInFront: null,
+      awayMinutesInFront: null,
+      source: "footywire",
+      competition: "AFLM"
+    });
+  });
+  return results;
+}
+var FOOTYWIRE_BASE, FootyWireClient;
+var init_footywire = __esm({
+  "src/sources/footywire.ts"() {
+    "use strict";
+    init_date_utils();
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_match_results();
+    FOOTYWIRE_BASE = "https://www.footywire.com/afl/footy";
+    FootyWireClient = class {
+      fetchFn;
+      constructor(options) {
+        this.fetchFn = options?.fetchFn ?? globalThis.fetch;
+      }
+      /**
+       * Fetch 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"
+            )
+          );
+        }
+      }
+    };
+  }
+});
+
+// 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));
+  }
+}
+var init_match_results2 = __esm({
+  "src/api/match-results.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_afl_tables();
+    init_footywire();
+    init_match_results();
+  }
+});
+
+// src/transforms/player-stats.ts
+function toNullable(value) {
+  return value ?? null;
+}
+function transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap) {
+  const inner = item.player.player.player;
+  const stats = item.playerStats.stats;
+  const clearances = stats.clearances;
+  return {
+    matchId,
+    season,
+    roundNumber,
+    team: normaliseTeamName(teamIdMap?.get(item.teamId) ?? item.teamId),
+    competition,
+    playerId: inner.playerId,
+    givenName: inner.playerName.givenName,
+    surname: inner.playerName.surname,
+    displayName: `${inner.playerName.givenName} ${inner.playerName.surname}`,
+    jumperNumber: item.player.jumperNumber ?? null,
+    kicks: toNullable(stats.kicks),
+    handballs: toNullable(stats.handballs),
+    disposals: toNullable(stats.disposals),
+    marks: toNullable(stats.marks),
+    goals: toNullable(stats.goals),
+    behinds: toNullable(stats.behinds),
+    tackles: toNullable(stats.tackles),
+    hitouts: toNullable(stats.hitouts),
+    freesFor: toNullable(stats.freesFor),
+    freesAgainst: toNullable(stats.freesAgainst),
+    contestedPossessions: toNullable(stats.contestedPossessions),
+    uncontestedPossessions: toNullable(stats.uncontestedPossessions),
+    contestedMarks: toNullable(stats.contestedMarks),
+    intercepts: toNullable(stats.intercepts),
+    centreClearances: toNullable(clearances?.centreClearances),
+    stoppageClearances: toNullable(clearances?.stoppageClearances),
+    totalClearances: toNullable(clearances?.totalClearances),
+    inside50s: toNullable(stats.inside50s),
+    rebound50s: toNullable(stats.rebound50s),
+    clangers: toNullable(stats.clangers),
+    turnovers: toNullable(stats.turnovers),
+    onePercenters: toNullable(stats.onePercenters),
+    bounces: toNullable(stats.bounces),
+    goalAssists: toNullable(stats.goalAssists),
+    disposalEfficiency: toNullable(stats.disposalEfficiency),
+    metresGained: toNullable(stats.metresGained),
+    goalAccuracy: toNullable(stats.goalAccuracy),
+    marksInside50: toNullable(stats.marksInside50),
+    tacklesInside50: toNullable(stats.tacklesInside50),
+    shotsAtGoal: toNullable(stats.shotsAtGoal),
+    scoreInvolvements: toNullable(stats.scoreInvolvements),
+    totalPossessions: toNullable(stats.totalPossessions),
+    timeOnGroundPercentage: toNullable(item.playerStats.timeOnGroundPercentage),
+    ratingPoints: toNullable(stats.ratingPoints),
+    dreamTeamPoints: toNullable(stats.dreamTeamPoints),
+    effectiveDisposals: toNullable(stats.extendedStats?.effectiveDisposals),
+    effectiveKicks: toNullable(stats.extendedStats?.effectiveKicks),
+    kickEfficiency: toNullable(stats.extendedStats?.kickEfficiency),
+    kickToHandballRatio: toNullable(stats.extendedStats?.kickToHandballRatio),
+    pressureActs: toNullable(stats.extendedStats?.pressureActs),
+    defHalfPressureActs: toNullable(stats.extendedStats?.defHalfPressureActs),
+    spoils: toNullable(stats.extendedStats?.spoils),
+    hitoutsToAdvantage: toNullable(stats.extendedStats?.hitoutsToAdvantage),
+    hitoutWinPercentage: toNullable(stats.extendedStats?.hitoutWinPercentage),
+    hitoutToAdvantageRate: toNullable(stats.extendedStats?.hitoutToAdvantageRate),
+    groundBallGets: toNullable(stats.extendedStats?.groundBallGets),
+    f50GroundBallGets: toNullable(stats.extendedStats?.f50GroundBallGets),
+    interceptMarks: toNullable(stats.extendedStats?.interceptMarks),
+    marksOnLead: toNullable(stats.extendedStats?.marksOnLead),
+    contestedPossessionRate: toNullable(stats.extendedStats?.contestedPossessionRate),
+    contestOffOneOnOnes: toNullable(stats.extendedStats?.contestOffOneOnOnes),
+    contestOffWins: toNullable(stats.extendedStats?.contestOffWins),
+    contestOffWinsPercentage: toNullable(stats.extendedStats?.contestOffWinsPercentage),
+    contestDefOneOnOnes: toNullable(stats.extendedStats?.contestDefOneOnOnes),
+    contestDefLosses: toNullable(stats.extendedStats?.contestDefLosses),
+    contestDefLossPercentage: toNullable(stats.extendedStats?.contestDefLossPercentage),
+    centreBounceAttendances: toNullable(stats.extendedStats?.centreBounceAttendances),
+    kickins: toNullable(stats.extendedStats?.kickins),
+    kickinsPlayon: toNullable(stats.extendedStats?.kickinsPlayon),
+    ruckContests: toNullable(stats.extendedStats?.ruckContests),
+    scoreLaunches: toNullable(stats.extendedStats?.scoreLaunches),
+    source
+  };
+}
+function transformPlayerStats(data, matchId, season, roundNumber, competition, source = "afl-api", teamIdMap) {
+  const home = data.homeTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  const away = data.awayTeamPlayerStats.map(
+    (item) => transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap)
+  );
+  return [...home, ...away];
+}
+var init_player_stats = __esm({
+  "src/transforms/player-stats.ts"() {
+    "use strict";
+    init_team_mapping();
+  }
+});
+
+// src/api/player-stats.ts
+async function fetchPlayerStats(query) {
+  const competition = query.competition ?? "AFLM";
+  switch (query.source) {
+    case "afl-api": {
+      const client = new AflApiClient();
+      if (query.matchId) {
+        const result = await client.fetchPlayerStats(query.matchId);
+        if (!result.success) return result;
+        return ok(
+          transformPlayerStats(
+            result.data,
+            query.matchId,
+            query.season,
+            query.round ?? 0,
+            competition
+          )
+        );
+      }
+      const seasonResult = await client.resolveCompSeason(competition, query.season);
+      if (!seasonResult.success) return seasonResult;
+      const roundNumber = query.round ?? 1;
+      const matchItemsResult = await client.fetchRoundMatchItemsByNumber(
+        seasonResult.data,
+        roundNumber
+      );
+      if (!matchItemsResult.success) return matchItemsResult;
+      const teamIdMap = /* @__PURE__ */ new Map();
+      for (const item of matchItemsResult.data) {
+        teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
+        teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
+      }
+      const statsResults = await Promise.all(
+        matchItemsResult.data.map((item) => client.fetchPlayerStats(item.match.matchId))
+      );
+      const allStats = [];
+      for (let i = 0; i < statsResults.length; i++) {
+        const statsResult = statsResults[i];
+        if (!statsResult?.success)
+          return statsResult ?? err(new AflApiError("Missing stats result"));
+        const item = matchItemsResult.data[i];
+        if (!item) continue;
+        allStats.push(
+          ...transformPlayerStats(
+            statsResult.data,
+            item.match.matchId,
+            query.season,
+            roundNumber,
+            competition,
+            "afl-api",
+            teamIdMap
+          )
+        );
+      }
+      return ok(allStats);
+    }
+    case "footywire":
+      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));
+  }
+}
+var init_player_stats2 = __esm({
+  "src/api/player-stats.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_afl_api();
+    init_player_stats();
+  }
+});
+
+// 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
+  });
+}
+var init_teams = __esm({
+  "src/api/teams.ts"() {
+    "use strict";
+    init_errors();
+    init_result();
+    init_team_mapping();
+    init_afl_api();
+  }
+});
 
 // src/index.ts
-var init_src = () => {};
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_fixture();
+    init_ladder2();
+    init_lineup2();
+    init_match_results2();
+    init_player_stats2();
+    init_teams();
+  }
+});
 
 // src/cli/formatters/csv.ts
 function escapeField(value) {
-  if (value.includes(",") || value.includes('"') || value.includes(`
-`) || value.includes("\r")) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
     return `"${value.replace(/"/g, '""')}"`;
   }
   return value;
 }
 function toStringValue(value) {
-  if (value === null || value === undefined)
-    return "";
-  if (value instanceof Date)
-    return value.toISOString();
-  if (typeof value === "object")
-    return JSON.stringify(value);
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
 function formatCsv(data) {
-  if (data.length === 0)
-    return "";
+  if (data.length === 0) return "";
   const firstRow = data[0];
-  if (!firstRow)
-    return "";
+  if (!firstRow) return "";
   const headers = Object.keys(firstRow);
   const lines = [headers.map(escapeField).join(",")];
   for (const row of data) {
     const values = headers.map((h) => escapeField(toStringValue(row[h])));
     lines.push(values.join(","));
   }
-  return lines.join(`
-`);
+  return lines.join("\n");
 }
+var init_csv = __esm({
+  "src/cli/formatters/csv.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/json.ts
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
+var init_json = __esm({
+  "src/cli/formatters/json.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/table.ts
 function toDisplayValue(value) {
-  if (value === null || value === undefined)
-    return "-";
-  if (value instanceof Date)
-    return value.toISOString().slice(0, 16).replace("T", " ");
-  if (typeof value === "object")
-    return JSON.stringify(value);
+  if (value === null || value === void 0) return "-";
+  if (value instanceof Date) return value.toISOString().slice(0, 16).replace("T", " ");
+  if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
 function truncate(str, maxLen) {
-  if (str.length <= maxLen)
-    return str;
-  return `${str.slice(0, maxLen - 1)}…`;
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 1)}\u2026`;
 }
 function formatTable(data, options = {}) {
-  if (data.length === 0)
-    return "No data.";
+  if (data.length === 0) return "No data.";
   const firstRow = data[0];
-  if (!firstRow)
-    return "No data.";
+  if (!firstRow) return "No data.";
   const termWidth = options.terminalWidth ?? process.stdout.columns ?? 120;
   const allKeys = Object.keys(firstRow);
   let columns;
@@ -88,78 +1856,72 @@ function formatTable(data, options = {}) {
   }
   const colWidths = columns.map((col) => (col.label ?? col.key).length);
   for (const row of data) {
-    for (let i = 0;i < columns.length; i++) {
+    for (let i = 0; i < columns.length; i++) {
       const col = columns[i];
-      if (!col)
-        continue;
+      if (!col) continue;
       const len = toDisplayValue(row[col.key]).length;
       const current = colWidths[i];
-      if (current !== undefined && len > current) {
+      if (current !== void 0 && len > current) {
         colWidths[i] = len;
       }
     }
   }
-  for (let i = 0;i < columns.length; i++) {
+  for (let i = 0; i < columns.length; i++) {
     const col = columns[i];
     const width = colWidths[i];
-    if (!col || width === undefined)
-      continue;
+    if (!col || width === void 0) continue;
     colWidths[i] = Math.min(col.maxWidth ?? 30, width);
   }
   const gap = 2;
   const visibleCols = [];
   let usedWidth = 0;
-  for (let i = 0;i < columns.length; i++) {
+  for (let i = 0; i < columns.length; i++) {
     const colWidth = colWidths[i];
-    if (colWidth === undefined)
-      continue;
+    if (colWidth === void 0) continue;
     const needed = usedWidth > 0 ? colWidth + gap : colWidth;
-    if (usedWidth + needed > termWidth && visibleCols.length > 0)
-      break;
+    if (usedWidth + needed > termWidth && visibleCols.length > 0) break;
     visibleCols.push(i);
     usedWidth += needed;
   }
   const headerParts = visibleCols.map((i) => {
     const col = columns[i];
     const width = colWidths[i];
-    if (!col || width === undefined)
-      return "";
+    if (!col || width === void 0) return "";
     const label = (col.label ?? col.key).toUpperCase();
     return truncate(label, width).padEnd(width);
   });
   const header = headerParts.join("  ");
   const separator = visibleCols.map((i) => {
     const width = colWidths[i];
-    if (width === undefined)
-      return "";
-    return "─".repeat(width);
+    if (width === void 0) return "";
+    return "\u2500".repeat(width);
   }).join("  ");
   const rows = data.map((row) => {
     const parts = visibleCols.map((i) => {
       const col = columns[i];
       const width = colWidths[i];
-      if (!col || width === undefined)
-        return "";
+      if (!col || width === void 0) return "";
       const val = toDisplayValue(row[col.key]);
       return truncate(val, width).padEnd(width);
     });
     return parts.join("  ");
   });
-  return [header, separator, ...rows].join(`
-`);
+  return [header, separator, ...rows].join("\n");
 }
+var init_table = __esm({
+  "src/cli/formatters/table.ts"() {
+    "use strict";
+  }
+});
 
 // src/cli/formatters/index.ts
 function resolveFormat(options) {
-  if (options.json)
-    return "json";
-  if (options.csv)
-    return "csv";
+  if (options.json) return "json";
+  if (options.csv) return "csv";
   if (options.format === "json" || options.format === "csv" || options.format === "table") {
     return options.format;
   }
-  if (!process.stdout.isTTY)
-    return "json";
+  if (!process.stdout.isTTY) return "json";
   return "table";
 }
 function formatOutput(data, options) {
@@ -177,7 +1939,14 @@ function formatOutput(data, options) {
       });
   }
 }
-var init_formatters = () => {};
+var init_formatters = __esm({
+  "src/cli/formatters/index.ts"() {
+    "use strict";
+    init_csv();
+    init_json();
+    init_table();
+  }
+});
 
 // src/cli/ui.ts
 import { spinner } from "@clack/prompts";
@@ -198,517 +1967,526 @@ async function withSpinner(message, fn) {
   }
 }
 function showSummary(message) {
-  if (!isTTY)
-    return;
+  if (!isTTY) return;
   console.error(pc.dim(message));
 }
 var isTTY;
-var init_ui = __esm(() => {
-  isTTY = process.stdout.isTTY === true;
+var init_ui = __esm({
+  "src/cli/ui.ts"() {
+    "use strict";
+    isTTY = process.stdout.isTTY === true;
+  }
 });
 
 // src/cli/commands/matches.ts
-var exports_matches = {};
-__export(exports_matches, {
+var matches_exports = {};
+__export(matches_exports, {
   matchesCommand: () => matchesCommand
 });
 import { defineCommand } from "citty";
 var DEFAULT_COLUMNS, matchesCommand;
-var init_matches = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS = [
-    { key: "date", label: "Date", maxWidth: 16 },
-    { key: "roundNumber", label: "Round", maxWidth: 6 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 },
-    { key: "homePoints", label: "H.Pts", maxWidth: 6 },
-    { key: "awayPoints", label: "A.Pts", maxWidth: 6 },
-    { key: "venue", label: "Venue", maxWidth: 24 }
-  ];
-  matchesCommand = defineCommand({
-    meta: {
-      name: "matches",
-      description: "Fetch match results for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_matches = __esm({
+  "src/cli/commands/matches.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS = [
+      { key: "date", label: "Date", maxWidth: 16 },
+      { key: "roundNumber", label: "Round", maxWidth: 6 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 },
+      { key: "homePoints", label: "H.Pts", maxWidth: 6 },
+      { key: "awayPoints", label: "A.Pts", maxWidth: 6 },
+      { key: "venue", label: "Venue", maxWidth: 24 }
+    ];
+    matchesCommand = defineCommand({
+      meta: {
+        name: "matches",
+        description: "Fetch match results for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching match results…", () => fetchMatchResults({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} matches for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching match results\u2026",
+          () => fetchMatchResults({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} matches for ${season}${round ? ` round ${round}` : ""}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/stats.ts
-var exports_stats = {};
-__export(exports_stats, {
+var stats_exports = {};
+__export(stats_exports, {
   statsCommand: () => statsCommand
 });
 import { defineCommand as defineCommand2 } from "citty";
 var DEFAULT_COLUMNS2, statsCommand;
-var init_stats = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS2 = [
-    { key: "displayName", label: "Player", maxWidth: 22 },
-    { key: "team", label: "Team", maxWidth: 18 },
-    { key: "disposals", label: "Disp", maxWidth: 6 },
-    { key: "kicks", label: "Kicks", maxWidth: 6 },
-    { key: "handballs", label: "HB", maxWidth: 6 },
-    { key: "marks", label: "Marks", maxWidth: 6 },
-    { key: "goals", label: "Goals", maxWidth: 6 }
-  ];
-  statsCommand = defineCommand2({
-    meta: {
-      name: "stats",
-      description: "Fetch player statistics for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      "match-id": { type: "string", description: "Specific match ID" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_stats = __esm({
+  "src/cli/commands/stats.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS2 = [
+      { key: "displayName", label: "Player", maxWidth: 22 },
+      { key: "team", label: "Team", maxWidth: 18 },
+      { key: "disposals", label: "Disp", maxWidth: 6 },
+      { key: "kicks", label: "Kicks", maxWidth: 6 },
+      { key: "handballs", label: "HB", maxWidth: 6 },
+      { key: "marks", label: "Marks", maxWidth: 6 },
+      { key: "goals", label: "Goals", maxWidth: 6 }
+    ];
+    statsCommand = defineCommand2({
+      meta: {
+        name: "stats",
+        description: "Fetch player statistics for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const matchId = args["match-id"];
-      const result = await withSpinner("Fetching player stats…", () => fetchPlayerStats({
-        source: args.source,
-        season,
-        round,
-        matchId,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS2
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        "match-id": { type: "string", description: "Specific match ID" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const matchId = args["match-id"];
+        const result = await withSpinner(
+          "Fetching player stats\u2026",
+          () => fetchPlayerStats({
+            source: args.source,
+            season,
+            round,
+            matchId,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(
+          `Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`
+        );
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS2
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/fixture.ts
-var exports_fixture = {};
-__export(exports_fixture, {
+var fixture_exports = {};
+__export(fixture_exports, {
   fixtureCommand: () => fixtureCommand
 });
 import { defineCommand as defineCommand3 } from "citty";
 var DEFAULT_COLUMNS3, fixtureCommand;
-var init_fixture = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS3 = [
-    { key: "roundNumber", label: "Round", maxWidth: 6 },
-    { key: "date", label: "Date", maxWidth: 16 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 },
-    { key: "venue", label: "Venue", maxWidth: 24 }
-  ];
-  fixtureCommand = defineCommand3({
-    meta: {
-      name: "fixture",
-      description: "Fetch fixture/schedule for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_fixture2 = __esm({
+  "src/cli/commands/fixture.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS3 = [
+      { key: "roundNumber", label: "Round", maxWidth: 6 },
+      { key: "date", label: "Date", maxWidth: 16 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 },
+      { key: "venue", label: "Venue", maxWidth: 24 }
+    ];
+    fixtureCommand = defineCommand3({
+      meta: {
+        name: "fixture",
+        description: "Fetch fixture/schedule for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching fixture…", () => fetchFixture({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} fixtures for ${season}${round ? ` round ${round}` : ""}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS3
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching fixture\u2026",
+          () => fetchFixture({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} fixtures for ${season}${round ? ` round ${round}` : ""}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS3
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/ladder.ts
-var exports_ladder = {};
-__export(exports_ladder, {
+var ladder_exports = {};
+__export(ladder_exports, {
   ladderCommand: () => ladderCommand
 });
 import { defineCommand as defineCommand4 } from "citty";
 var DEFAULT_COLUMNS4, ladderCommand;
-var init_ladder = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS4 = [
-    { key: "position", label: "Pos", maxWidth: 4 },
-    { key: "team", label: "Team", maxWidth: 24 },
-    { key: "wins", label: "W", maxWidth: 4 },
-    { key: "losses", label: "L", maxWidth: 4 },
-    { key: "draws", label: "D", maxWidth: 4 },
-    { key: "percentage", label: "Pct", maxWidth: 8 },
-    { key: "premiershipsPoints", label: "Pts", maxWidth: 5 }
-  ];
-  ladderCommand = defineCommand4({
-    meta: {
-      name: "ladder",
-      description: "Fetch ladder standings for a season"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_ladder3 = __esm({
+  "src/cli/commands/ladder.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS4 = [
+      { key: "position", label: "Pos", maxWidth: 4 },
+      { key: "team", label: "Team", maxWidth: 24 },
+      { key: "wins", label: "W", maxWidth: 4 },
+      { key: "losses", label: "L", maxWidth: 4 },
+      { key: "draws", label: "D", maxWidth: 4 },
+      { key: "percentage", label: "Pct", maxWidth: 8 },
+      { key: "premiershipsPoints", label: "Pts", maxWidth: 5 }
+    ];
+    ladderCommand = defineCommand4({
+      meta: {
+        name: "ladder",
+        description: "Fetch ladder standings for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = args.round ? Number(args.round) : undefined;
-      const result = await withSpinner("Fetching ladder…", () => fetchLadder({
-        source: args.source,
-        season,
-        round,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ladder for ${season}${round ? ` round ${round}` : ""} (${data.entries.length} teams)`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS4
-      };
-      console.log(formatOutput(data.entries, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = args.round ? Number(args.round) : void 0;
+        const result = await withSpinner(
+          "Fetching ladder\u2026",
+          () => fetchLadder({
+            source: args.source,
+            season,
+            round,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(
+          `Loaded ladder for ${season}${round ? ` round ${round}` : ""} (${data.entries.length} teams)`
+        );
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS4
+        };
+        console.log(formatOutput(data.entries, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/lineup.ts
-var exports_lineup = {};
-__export(exports_lineup, {
+var lineup_exports = {};
+__export(lineup_exports, {
   lineupCommand: () => lineupCommand
 });
 import { defineCommand as defineCommand5 } from "citty";
 var DEFAULT_COLUMNS5, lineupCommand;
-var init_lineup = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS5 = [
-    { key: "matchId", label: "Match", maxWidth: 12 },
-    { key: "homeTeam", label: "Home", maxWidth: 20 },
-    { key: "awayTeam", label: "Away", maxWidth: 20 }
-  ];
-  lineupCommand = defineCommand5({
-    meta: {
-      name: "lineup",
-      description: "Fetch match lineups for a round"
-    },
-    args: {
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      round: { type: "string", description: "Round number", required: true },
-      "match-id": { type: "string", description: "Specific match ID" },
-      source: { type: "string", description: "Data source", default: "afl-api" },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_lineup3 = __esm({
+  "src/cli/commands/lineup.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS5 = [
+      { key: "matchId", label: "Match", maxWidth: 12 },
+      { key: "homeTeam", label: "Home", maxWidth: 20 },
+      { key: "awayTeam", label: "Away", maxWidth: 20 }
+    ];
+    lineupCommand = defineCommand5({
+      meta: {
+        name: "lineup",
+        description: "Fetch match lineups for a round"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const season = Number(args.season);
-      const round = Number(args.round);
-      const matchId = args["match-id"];
-      const result = await withSpinner("Fetching lineups…", () => fetchLineup({
-        source: args.source,
-        season,
-        round,
-        matchId,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} lineups for ${season} round ${round}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS5
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+      args: {
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        round: { type: "string", description: "Round number", required: true },
+        "match-id": { type: "string", description: "Specific match ID" },
+        source: { type: "string", description: "Data source", default: "afl-api" },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const season = Number(args.season);
+        const round = Number(args.round);
+        const matchId = args["match-id"];
+        const result = await withSpinner(
+          "Fetching lineups\u2026",
+          () => fetchLineup({
+            source: args.source,
+            season,
+            round,
+            matchId,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} lineups for ${season} round ${round}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS5
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/squad.ts
-var exports_squad = {};
-__export(exports_squad, {
+var squad_exports = {};
+__export(squad_exports, {
   squadCommand: () => squadCommand
 });
 import { defineCommand as defineCommand6 } from "citty";
 var DEFAULT_COLUMNS6, squadCommand;
-var init_squad = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS6 = [
-    { key: "displayName", label: "Player", maxWidth: 24 },
-    { key: "jumperNumber", label: "#", maxWidth: 4 },
-    { key: "position", label: "Pos", maxWidth: 12 },
-    { key: "heightCm", label: "Ht", maxWidth: 5 },
-    { key: "weightKg", label: "Wt", maxWidth: 5 }
-  ];
-  squadCommand = defineCommand6({
-    meta: {
-      name: "squad",
-      description: "Fetch team squad for a season"
-    },
-    args: {
-      "team-id": { type: "string", description: "Team ID", required: true },
-      season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-      competition: {
-        type: "string",
-        description: "Competition code (AFLM or AFLW)",
-        default: "AFLM"
+var init_squad = __esm({
+  "src/cli/commands/squad.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS6 = [
+      { key: "displayName", label: "Player", maxWidth: 24 },
+      { key: "jumperNumber", label: "#", maxWidth: 4 },
+      { key: "position", label: "Pos", maxWidth: 12 },
+      { key: "heightCm", label: "Ht", maxWidth: 5 },
+      { key: "weightKg", label: "Wt", maxWidth: 5 }
+    ];
+    squadCommand = defineCommand6({
+      meta: {
+        name: "squad",
+        description: "Fetch team squad for a season"
       },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const teamId = args["team-id"];
-      const season = Number(args.season);
-      const result = await withSpinner("Fetching squad…", () => fetchSquad({
-        teamId,
-        season,
-        competition: args.competition
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.players.length} players for ${data.teamName} ${season}`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS6
-      };
-      console.log(formatOutput(data.players, formatOptions));
-    }
-  });
+      args: {
+        "team-id": { type: "string", description: "Team ID", required: true },
+        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
+        competition: {
+          type: "string",
+          description: "Competition code (AFLM or AFLW)",
+          default: "AFLM"
+        },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const teamId = args["team-id"];
+        const season = Number(args.season);
+        const result = await withSpinner(
+          "Fetching squad\u2026",
+          () => fetchSquad({
+            teamId,
+            season,
+            competition: args.competition
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.players.length} players for ${data.teamName} ${season}`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS6
+        };
+        console.log(formatOutput(data.players, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli/commands/teams.ts
-var exports_teams = {};
-__export(exports_teams, {
+var teams_exports = {};
+__export(teams_exports, {
   teamsCommand: () => teamsCommand
 });
 import { defineCommand as defineCommand7 } from "citty";
 var DEFAULT_COLUMNS7, teamsCommand;
-var init_teams = __esm(() => {
-  init_src();
-  init_formatters();
-  init_ui();
-  DEFAULT_COLUMNS7 = [
-    { key: "teamId", label: "ID", maxWidth: 8 },
-    { key: "name", label: "Team", maxWidth: 24 },
-    { key: "abbreviation", label: "Abbr", maxWidth: 6 },
-    { key: "competition", label: "Comp", maxWidth: 6 }
-  ];
-  teamsCommand = defineCommand7({
-    meta: {
-      name: "teams",
-      description: "Fetch team list"
-    },
-    args: {
-      competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
-      "team-type": { type: "string", description: "Team type filter" },
-      json: { type: "boolean", description: "Output as JSON" },
-      csv: { type: "boolean", description: "Output as CSV" },
-      format: { type: "string", description: "Output format: table, json, csv" },
-      full: { type: "boolean", description: "Show all columns in table output" }
-    },
-    async run({ args }) {
-      const result = await withSpinner("Fetching teams…", () => fetchTeams({
-        competition: args.competition,
-        teamType: args["team-type"]
-      }));
-      if (!result.success) {
-        throw result.error;
-      }
-      const data = result.data;
-      showSummary(`Loaded ${data.length} teams`);
-      const formatOptions = {
-        json: args.json,
-        csv: args.csv,
-        format: args.format,
-        full: args.full,
-        columns: DEFAULT_COLUMNS7
-      };
-      console.log(formatOutput(data, formatOptions));
-    }
-  });
+var init_teams2 = __esm({
+  "src/cli/commands/teams.ts"() {
+    "use strict";
+    init_index();
+    init_formatters();
+    init_ui();
+    DEFAULT_COLUMNS7 = [
+      { key: "teamId", label: "ID", maxWidth: 8 },
+      { key: "name", label: "Team", maxWidth: 24 },
+      { key: "abbreviation", label: "Abbr", maxWidth: 6 },
+      { key: "competition", label: "Comp", maxWidth: 6 }
+    ];
+    teamsCommand = defineCommand7({
+      meta: {
+        name: "teams",
+        description: "Fetch team list"
+      },
+      args: {
+        competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
+        "team-type": { type: "string", description: "Team type filter" },
+        json: { type: "boolean", description: "Output as JSON" },
+        csv: { type: "boolean", description: "Output as CSV" },
+        format: { type: "string", description: "Output format: table, json, csv" },
+        full: { type: "boolean", description: "Show all columns in table output" }
+      },
+      async run({ args }) {
+        const result = await withSpinner(
+          "Fetching teams\u2026",
+          () => fetchTeams({
+            competition: args.competition,
+            teamType: args["team-type"]
+          })
+        );
+        if (!result.success) {
+          throw result.error;
+        }
+        const data = result.data;
+        showSummary(`Loaded ${data.length} teams`);
+        const formatOptions = {
+          json: args.json,
+          csv: args.csv,
+          format: args.format,
+          full: args.full,
+          columns: DEFAULT_COLUMNS7
+        };
+        console.log(formatOutput(data, formatOptions));
+      }
+    });
+  }
 });
 
 // src/cli.ts
+init_errors();
 import { defineCommand as defineCommand8, runMain } from "citty";
 import pc2 from "picocolors";
-
-// src/lib/errors.ts
-class AflApiError extends Error {
-  statusCode;
-  name = "AflApiError";
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-  }
-}
-
-class ScrapeError extends Error {
-  source;
-  name = "ScrapeError";
-  constructor(message, source) {
-    super(message);
-    this.source = source;
-  }
-}
-
-class UnsupportedSourceError extends Error {
-  source;
-  name = "UnsupportedSourceError";
-  constructor(message, source) {
-    super(message);
-    this.source = source;
-  }
-}
-
-class ValidationError extends Error {
-  issues;
-  name = "ValidationError";
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
-  }
-}
-
-// src/cli.ts
 var main = defineCommand8({
   meta: {
     name: "fitzroy",
-    version: "1.0.1",
-    description: "CLI for fetching AFL data — match results, player stats, fixtures, ladders, and more"
+    version: "1.0.2",
+    description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
   },
   subCommands: {
-    matches: () => Promise.resolve().then(() => (init_matches(), exports_matches)).then((m) => m.matchesCommand),
-    stats: () => Promise.resolve().then(() => (init_stats(), exports_stats)).then((m) => m.statsCommand),
-    fixture: () => Promise.resolve().then(() => (init_fixture(), exports_fixture)).then((m) => m.fixtureCommand),
-    ladder: () => Promise.resolve().then(() => (init_ladder(), exports_ladder)).then((m) => m.ladderCommand),
-    lineup: () => Promise.resolve().then(() => (init_lineup(), exports_lineup)).then((m) => m.lineupCommand),
-    squad: () => Promise.resolve().then(() => (init_squad(), exports_squad)).then((m) => m.squadCommand),
-    teams: () => Promise.resolve().then(() => (init_teams(), exports_teams)).then((m) => m.teamsCommand)
+    matches: () => Promise.resolve().then(() => (init_matches(), matches_exports)).then((m) => m.matchesCommand),
+    stats: () => Promise.resolve().then(() => (init_stats(), stats_exports)).then((m) => m.statsCommand),
+    fixture: () => Promise.resolve().then(() => (init_fixture2(), fixture_exports)).then((m) => m.fixtureCommand),
+    ladder: () => Promise.resolve().then(() => (init_ladder3(), ladder_exports)).then((m) => m.ladderCommand),
+    lineup: () => Promise.resolve().then(() => (init_lineup3(), lineup_exports)).then((m) => m.lineupCommand),
+    squad: () => Promise.resolve().then(() => (init_squad(), squad_exports)).then((m) => m.squadCommand),
+    teams: () => Promise.resolve().then(() => (init_teams2(), teams_exports)).then((m) => m.teamsCommand)
   }
 });
 function formatError(error) {
   if (error instanceof ValidationError && error.issues) {
     const issueLines = error.issues.map((i) => `  ${pc2.yellow(i.path)}: ${i.message}`);
     return `${pc2.red("Validation error:")}
-${issueLines.join(`
-`)}`;
+${issueLines.join("\n")}`;
   }
   if (error instanceof AflApiError) {
     const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";