fitzroy 1.1.1 → 1.3.0

package/dist/cli.js

@@ -10,6 +10,12 @@ var __export = (target, all) => {
 };
 
 // src/lib/errors.ts
+function aflwUnsupportedError(source) {
+  return new UnsupportedSourceError(
+    `AFLW data is not available from ${source}. Use --source afl-api for AFLW data.`,
+    source
+  );
+}
 var AflApiError, ScrapeError, UnsupportedSourceError, ValidationError;
 var init_errors = __esm({
   "src/lib/errors.ts"() {
@@ -45,6 +51,47 @@ var init_errors = __esm({
   }
 });
 
+// src/cli/error-boundary.ts
+import pc from "picocolors";
+function formatError(error) {
+  if (error instanceof ValidationError && error.issues) {
+    const issueLines = error.issues.map((i) => `  ${pc.yellow(i.path)}: ${i.message}`);
+    return `${pc.red("Validation error:")}
+${issueLines.join("\n")}`;
+  }
+  if (error instanceof AflApiError) {
+    const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
+    return `${pc.red("AFL API error:")} ${error.message}${status}`;
+  }
+  if (error instanceof ScrapeError) {
+    const source = error.source ? ` [${error.source}]` : "";
+    return `${pc.red("Scrape error:")} ${error.message}${source}`;
+  }
+  if (error instanceof UnsupportedSourceError) {
+    return `${pc.red("Unsupported source:")} ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return `${pc.red("Error:")} ${error.message}`;
+  }
+  return `${pc.red("Error:")} ${String(error)}`;
+}
+function withErrorBoundary(fn) {
+  return async (ctx) => {
+    try {
+      await fn(ctx);
+    } catch (error) {
+      console.error(formatError(error));
+      process.exit(1);
+    }
+  };
+}
+var init_error_boundary = __esm({
+  "src/cli/error-boundary.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
 // src/lib/result.ts
 function ok(data) {
   return { success: true, data };
@@ -117,6 +164,10 @@ function parseAflTablesDate(dateStr) {
   }
   return null;
 }
+function resolveDefaultSeason(competition = "AFLM") {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  return competition === "AFLW" ? year - 1 : year;
+}
 function buildUtcDate(year, monthStr, day) {
   const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
   if (monthIndex === void 0) {
@@ -168,7 +219,7 @@ function normaliseTeamName(raw) {
   const trimmed = raw.trim();
   return ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
 }
-var TEAM_ALIASES, AFL_SENIOR_TEAMS, ALIAS_MAP;
+var TEAM_ALIASES, AFL_SENIOR_TEAMS, ALIAS_MAP, AFL_API_TEAM_IDS;
 var init_team_mapping = __esm({
   "src/lib/team-mapping.ts"() {
     "use strict";
@@ -241,6 +292,26 @@ var init_team_mapping = __esm({
       }
       return map;
     })();
+    AFL_API_TEAM_IDS = /* @__PURE__ */ new Map([
+      ["CD_T10", "Adelaide Crows"],
+      ["CD_T20", "Brisbane Lions"],
+      ["CD_T30", "Carlton"],
+      ["CD_T40", "Collingwood"],
+      ["CD_T50", "Essendon"],
+      ["CD_T60", "Fremantle"],
+      ["CD_T70", "Geelong Cats"],
+      ["CD_T1000", "Gold Coast Suns"],
+      ["CD_T1010", "GWS Giants"],
+      ["CD_T80", "Hawthorn"],
+      ["CD_T90", "Melbourne"],
+      ["CD_T100", "North Melbourne"],
+      ["CD_T110", "Port Adelaide"],
+      ["CD_T120", "Richmond"],
+      ["CD_T130", "St Kilda"],
+      ["CD_T160", "Sydney Swans"],
+      ["CD_T150", "West Coast Eagles"],
+      ["CD_T140", "Western Bulldogs"]
+    ]);
   }
 });
 
@@ -506,6 +577,14 @@ var init_footywire_player_stats = __esm({
 function inferRoundType(roundName) {
   return FINALS_PATTERN.test(roundName) ? "Finals" : "HomeAndAway";
 }
+function finalsRoundNumber(headerText, lastHARound) {
+  const lower = headerText.toLowerCase();
+  if (lower.includes("qualifying") || lower.includes("elimination")) return lastHARound + 1;
+  if (lower.includes("semi")) return lastHARound + 2;
+  if (lower.includes("preliminary")) return lastHARound + 3;
+  if (lower.includes("grand")) return lastHARound + 4;
+  return lastHARound + 1;
+}
 function toMatchStatus(raw) {
   switch (raw) {
     case "CONCLUDED":
@@ -595,6 +674,7 @@ function parseMatchList(html, year) {
   const $ = cheerio2.load(html);
   const results = [];
   let currentRound = 0;
+  let lastHARound = 0;
   let currentRoundType = "HomeAndAway";
   $("tr").each((_i, row) => {
     const roundHeader = $(row).find("td[colspan='7']");
@@ -604,6 +684,11 @@ function parseMatchList(html, year) {
       const roundMatch = /Round\s+(\d+)/i.exec(text);
       if (roundMatch?.[1]) {
         currentRound = Number.parseInt(roundMatch[1], 10);
+        if (currentRoundType === "HomeAndAway") {
+          lastHARound = currentRound;
+        }
+      } else if (currentRoundType === "Finals") {
+        currentRound = finalsRoundNumber(text, lastHARound);
       }
       return;
     }
@@ -674,6 +759,7 @@ function parseFixtureList(html, year) {
   const $ = cheerio2.load(html);
   const fixtures = [];
   let currentRound = 0;
+  let lastHARound = 0;
   let currentRoundType = "HomeAndAway";
   let gameNumber = 0;
   $("tr").each((_i, row) => {
@@ -684,6 +770,11 @@ function parseFixtureList(html, year) {
       const roundMatch = /Round\s+(\d+)/i.exec(text);
       if (roundMatch?.[1]) {
         currentRound = Number.parseInt(roundMatch[1], 10);
+        if (currentRoundType === "HomeAndAway") {
+          lastHARound = currentRound;
+        }
+      } else if (currentRoundType === "Finals") {
+        currentRound = finalsRoundNumber(text, lastHARound);
       }
       return;
     }
@@ -1301,6 +1392,27 @@ var init_coaches_votes = __esm({
   }
 });
 
+// src/lib/concurrency.ts
+async function batchedMap(items, fn, options) {
+  const batchSize = options?.batchSize ?? 5;
+  const delayMs = options?.delayMs ?? 0;
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(fn));
+    results.push(...batchResults);
+    if (delayMs > 0 && i + batchSize < items.length) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return results;
+}
+var init_concurrency = __esm({
+  "src/lib/concurrency.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/validation.ts
 import { z } from "zod/v4";
 var AflApiTokenSchema, CompetitionSchema, CompetitionListSchema, CompseasonSchema, CompseasonListSchema, RoundSchema, RoundListSchema, ScoreSchema, PeriodScoreSchema, TeamScoreSchema, CfsMatchTeamSchema, CfsMatchSchema, CfsScoreSchema, CfsVenueSchema, MatchItemSchema, MatchItemListSchema, CfsPlayerInnerSchema, statNum, PlayerGameStatsSchema, PlayerStatsItemSchema, PlayerStatsListSchema, RosterPlayerSchema, TeamPlayersSchema, MatchRosterSchema, TeamItemSchema, TeamListSchema, SquadPlayerInnerSchema, SquadPlayerItemSchema, SquadSchema, SquadListSchema, WinLossRecordSchema, LadderEntryRawSchema, LadderResponseSchema;
@@ -1410,7 +1522,14 @@ var init_validation = __esm({
       captain: z.boolean().optional(),
       playerJumperNumber: z.number().optional()
     }).passthrough();
-    statNum = z.number().nullable().optional();
+    statNum = z.union([
+      z.number(),
+      z.string().transform((s) => {
+        if (s === "" || s === "-") return null;
+        const n = Number(s);
+        return Number.isNaN(n) ? null : n;
+      })
+    ]).nullable().optional();
     PlayerGameStatsSchema = z.object({
       goals: statNum,
       behinds: statNum,
@@ -1488,8 +1607,8 @@ var init_validation = __esm({
       teamId: z.string(),
       playerStats: z.object({
         stats: PlayerGameStatsSchema,
-        timeOnGroundPercentage: z.number().nullable().optional()
-      }).passthrough()
+        timeOnGroundPercentage: statNum
+      }).passthrough().nullable().optional()
     }).passthrough();
     PlayerStatsListSchema = z.object({
       homeTeamPlayerStats: z.array(PlayerStatsItemSchema),
@@ -1589,6 +1708,7 @@ var TOKEN_URL, API_BASE, CFS_BASE, AflApiClient;
 var init_afl_api = __esm({
   "src/sources/afl-api.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_validation();
@@ -1599,6 +1719,7 @@ var init_afl_api = __esm({
       fetchFn;
       tokenUrl;
       cachedToken = null;
+      pendingAuth = null;
       constructor(options) {
         this.fetchFn = options?.fetchFn ?? globalThis.fetch;
         this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
@@ -1606,9 +1727,21 @@ var init_afl_api = __esm({
       /**
        * Authenticate with the WMCTok token endpoint and cache the token.
        *
+       * Concurrent callers share the same in-flight request to avoid
+       * redundant token fetches (thundering herd prevention).
+       *
        * @returns The access token on success, or an error Result.
        */
       async authenticate() {
+        if (this.pendingAuth) {
+          return this.pendingAuth;
+        }
+        this.pendingAuth = this.doAuthenticate().finally(() => {
+          this.pendingAuth = null;
+        });
+        return this.pendingAuth;
+      }
+      async doAuthenticate() {
         try {
           const response = await this.fetchFn(this.tokenUrl, {
             method: "POST",
@@ -1863,7 +1996,7 @@ var init_afl_api = __esm({
           return roundsResult;
         }
         const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
-        const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+        const results = await batchedMap(providerIds, (id) => this.fetchRoundMatchItems(id));
         const allItems = [];
         for (const result of results) {
           if (!result.success) {
@@ -2186,12 +2319,14 @@ function toFixture(item, season, fallbackRoundNumber, competition) {
 async function fetchFixture(query) {
   const competition = query.competition ?? "AFLM";
   if (query.source === "squiggle") {
+    if (competition === "AFLW") return err(aflwUnsupportedError("squiggle"));
     const client2 = new SquiggleClient();
     const result = await client2.fetchGames(query.season, query.round ?? void 0);
     if (!result.success) return result;
     return ok(transformSquiggleGamesToFixture(result.data.games, query.season));
   }
   if (query.source === "footywire") {
+    if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
     const fwClient = new FootyWireClient();
     const result = await fwClient.fetchSeasonFixture(query.season);
     if (!result.success) return result;
@@ -2221,8 +2356,9 @@ async function fetchFixture(query) {
   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 roundResults = await batchedMap(
+    roundProviderIds,
+    (r) => client.fetchRoundMatchItems(r.providerId)
   );
   const fixtures = [];
   for (let i = 0; i < roundResults.length; i++) {
@@ -2238,6 +2374,7 @@ async function fetchFixture(query) {
 var init_fixture = __esm({
   "src/api/fixture.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_team_mapping();
@@ -2380,6 +2517,7 @@ function parseSeasonPage(html, year) {
   const results = [];
   let currentRound = 0;
   let currentRoundType = "HomeAndAway";
+  let lastHARound = 0;
   let matchCounter = 0;
   $("table").each((_i, table) => {
     const $table = $(table);
@@ -2389,10 +2527,14 @@ function parseSeasonPage(html, year) {
     if (roundMatch?.[1] && border !== "1") {
       currentRound = Number.parseInt(roundMatch[1], 10);
       currentRoundType = inferRoundType(text);
+      if (currentRoundType === "HomeAndAway") {
+        lastHARound = currentRound;
+      }
       return;
     }
     if (border !== "1" && inferRoundType(text) === "Finals") {
       currentRoundType = "Finals";
+      currentRound = finalsRoundNumber(text, lastHARound);
       return;
     }
     if (border !== "1") return;
@@ -2902,6 +3044,7 @@ var init_ladder = __esm({
 async function fetchLadder(query) {
   const competition = query.competition ?? "AFLM";
   if (query.source === "squiggle") {
+    if (competition === "AFLW") return err(aflwUnsupportedError("squiggle"));
     const client2 = new SquiggleClient();
     const result = await client2.fetchStandings(query.season, query.round ?? void 0);
     if (!result.success) return result;
@@ -2913,6 +3056,7 @@ async function fetchLadder(query) {
     });
   }
   if (query.source === "afl-tables") {
+    if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
     const atClient = new AflTablesClient();
     const resultsResult = await atClient.fetchSeasonResults(query.season);
     if (!resultsResult.success) return resultsResult;
@@ -3034,8 +3178,9 @@ async function fetchLineup(query) {
   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 rosterResults = await batchedMap(
+    matchItems.data,
+    (item) => client.fetchMatchRoster(item.match.matchId)
   );
   const lineups = [];
   for (const rosterResult of rosterResults) {
@@ -3047,6 +3192,7 @@ async function fetchLineup(query) {
 var init_lineup2 = __esm({
   "src/api/lineup.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_afl_api();
@@ -3075,6 +3221,7 @@ async function fetchMatchResults(query) {
       return ok(transformMatchItems(itemsResult.data, query.season, competition));
     }
     case "footywire": {
+      if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
       const client = new FootyWireClient();
       const result = await client.fetchSeasonResults(query.season);
       if (!result.success) return result;
@@ -3084,6 +3231,7 @@ async function fetchMatchResults(query) {
       return result;
     }
     case "afl-tables": {
+      if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
       const client = new AflTablesClient();
       const result = await client.fetchSeasonResults(query.season);
       if (!result.success) return result;
@@ -3093,6 +3241,7 @@ async function fetchMatchResults(query) {
       return result;
     }
     case "squiggle": {
+      if (competition === "AFLW") return err(aflwUnsupportedError("squiggle"));
       const client = new SquiggleClient();
       const result = await client.fetchGames(query.season, query.round ?? void 0, 100);
       if (!result.success) return result;
@@ -3131,7 +3280,7 @@ async function resolveTeamId(client, teamName, competition) {
 async function fetchFromAflApi(query) {
   const client = new AflApiClient();
   const competition = query.competition ?? "AFLM";
-  const season = query.season ?? (/* @__PURE__ */ new Date()).getFullYear();
+  const season = query.season ?? resolveDefaultSeason(competition);
   const [teamIdResult, seasonResult] = await Promise.all([
     resolveTeamId(client, query.team, competition),
     client.resolveCompSeason(competition, season)
@@ -3154,8 +3303,8 @@ async function fetchFromAflApi(query) {
     jumperNumber: p.jumperNumber ?? null,
     position: p.position ?? null,
     dateOfBirth: p.player.dateOfBirth ?? null,
-    heightCm: p.player.heightInCm ?? null,
-    weightKg: p.player.weightInKg ?? null,
+    heightCm: p.player.heightInCm || null,
+    weightKg: p.player.weightInKg || null,
     gamesPlayed: null,
     goals: null,
     draftYear: p.player.draftYear ? Number.parseInt(p.player.draftYear, 10) || null : null,
@@ -3169,8 +3318,9 @@ async function fetchFromAflApi(query) {
   return ok(players);
 }
 async function fetchFromFootyWire(query) {
-  const client = new FootyWireClient();
   const competition = query.competition ?? "AFLM";
+  if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
+  const client = new FootyWireClient();
   const teamName = normaliseTeamName(query.team);
   const result = await client.fetchPlayerList(teamName);
   if (!result.success) return result;
@@ -3182,8 +3332,9 @@ async function fetchFromFootyWire(query) {
   return ok(players);
 }
 async function fetchFromAflTables(query) {
-  const client = new AflTablesClient();
   const competition = query.competition ?? "AFLM";
+  if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
+  const client = new AflTablesClient();
   const teamName = normaliseTeamName(query.team);
   const result = await client.fetchPlayerList(teamName);
   if (!result.success) return result;
@@ -3214,6 +3365,7 @@ async function fetchPlayerDetails(query) {
 var init_player_details = __esm({
   "src/api/player-details.ts"() {
     "use strict";
+    init_date_utils();
     init_errors();
     init_result();
     init_team_mapping();
@@ -3229,80 +3381,82 @@ function toNullable(value) {
 }
 function transformOne(item, matchId, season, roundNumber, competition, source, teamIdMap) {
   const inner = item.player.player.player;
-  const stats = item.playerStats.stats;
-  const clearances = stats.clearances;
+  const stats = item.playerStats?.stats;
+  const clearances = stats?.clearances;
   return {
     matchId,
     season,
     roundNumber,
-    team: normaliseTeamName(teamIdMap?.get(item.teamId) ?? item.teamId),
+    team: normaliseTeamName(
+      teamIdMap?.get(item.teamId) ?? AFL_API_TEAM_IDS.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),
+    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),
+    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
   };
 }
@@ -3365,8 +3519,9 @@ async function fetchPlayerStats(query) {
         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 statsResults = await batchedMap(
+        matchItemsResult.data,
+        (item) => client.fetchPlayerStats(item.match.matchId)
       );
       const allStats = [];
       for (let i = 0; i < statsResults.length; i++) {
@@ -3390,6 +3545,7 @@ async function fetchPlayerStats(query) {
       return ok(allStats);
     }
     case "footywire": {
+      if (competition === "AFLW") return err(aflwUnsupportedError("footywire"));
       const fwClient = new FootyWireClient();
       const idsResult = await fwClient.fetchSeasonMatchIds(query.season);
       if (!idsResult.success) return idsResult;
@@ -3419,6 +3575,7 @@ async function fetchPlayerStats(query) {
       return ok(allStats);
     }
     case "afl-tables": {
+      if (competition === "AFLW") return err(aflwUnsupportedError("afl-tables"));
       const atClient = new AflTablesClient();
       const atResult = await atClient.fetchSeasonPlayerStats(query.season);
       if (!atResult.success) return atResult;
@@ -3434,6 +3591,7 @@ async function fetchPlayerStats(query) {
 var init_player_stats2 = __esm({
   "src/api/player-stats.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_afl_api();
@@ -3453,7 +3611,37 @@ async function fetchTeamStats(query) {
     }
     case "afl-tables": {
       const client = new AflTablesClient();
-      return client.fetchTeamStats(query.season);
+      const statsResult = await client.fetchTeamStats(query.season);
+      if (!statsResult.success) return statsResult;
+      const needsGp = statsResult.data.some((e) => e.gamesPlayed === 0);
+      const gpMap = /* @__PURE__ */ new Map();
+      if (needsGp) {
+        const resultsResult = await client.fetchSeasonResults(query.season);
+        if (resultsResult.success) {
+          for (const m of resultsResult.data) {
+            gpMap.set(m.homeTeam, (gpMap.get(m.homeTeam) ?? 0) + 1);
+            gpMap.set(m.awayTeam, (gpMap.get(m.awayTeam) ?? 0) + 1);
+          }
+        }
+      }
+      const enriched = statsResult.data.map((entry) => ({
+        ...entry,
+        gamesPlayed: gpMap.get(entry.team) ?? entry.gamesPlayed
+      }));
+      if (summaryType === "averages") {
+        return ok(
+          enriched.map((entry) => ({
+            ...entry,
+            stats: Object.fromEntries(
+              Object.entries(entry.stats).map(([k, v]) => [
+                k,
+                entry.gamesPlayed > 0 ? +(v / entry.gamesPlayed).toFixed(1) : 0
+              ])
+            )
+          }))
+        );
+      }
+      return ok(enriched);
     }
     case "afl-api":
     case "squiggle":
@@ -3481,19 +3669,30 @@ var init_team_stats = __esm({
 function teamTypeForComp(comp) {
   return comp === "AFLW" ? "WOMEN" : "MEN";
 }
-async function fetchTeams(query) {
-  const client = new AflApiClient();
-  const teamType = query?.teamType ?? teamTypeForComp(query?.competition ?? "AFLM");
-  const result = await client.fetchTeams(teamType);
-  if (!result.success) return result;
-  const competition = query?.competition ?? "AFLM";
-  const teams = result.data.map((t) => ({
+function toTeams(data, competition) {
+  return data.map((t) => ({
     teamId: String(t.id),
     name: normaliseTeamName(t.name),
     abbreviation: t.abbreviation ?? "",
     competition
   })).filter((t) => AFL_SENIOR_TEAMS.has(t.name));
-  return ok(teams);
+}
+async function fetchTeams(query) {
+  const client = new AflApiClient();
+  if (!query?.competition && !query?.teamType) {
+    const [menResult, womenResult] = await Promise.all([
+      client.fetchTeams("MEN"),
+      client.fetchTeams("WOMEN")
+    ]);
+    if (!menResult.success) return menResult;
+    if (!womenResult.success) return womenResult;
+    return ok([...toTeams(menResult.data, "AFLM"), ...toTeams(womenResult.data, "AFLW")]);
+  }
+  const competition = query?.competition ?? "AFLM";
+  const teamType = query?.teamType ?? teamTypeForComp(competition);
+  const result = await client.fetchTeams(teamType);
+  if (!result.success) return result;
+  return ok(toTeams(result.data, competition));
 }
 async function fetchSquad(query) {
   const client = new AflApiClient();
@@ -3514,8 +3713,8 @@ async function fetchSquad(query) {
     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,
+    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,
@@ -3556,6 +3755,94 @@ var init_index = __esm({
   }
 });
 
+// src/cli/flags.ts
+var SEASON_FLAG, OPTIONAL_SEASON_FLAG, ROUND_FLAG, REQUIRED_ROUND_FLAG, SOURCE_FLAG, COMPETITION_FLAG, OPTIONAL_COMPETITION_FLAG, OUTPUT_FLAGS, REQUIRED_TEAM_FLAG, TEAM_FLAG, PLAYER_FLAG;
+var init_flags = __esm({
+  "src/cli/flags.ts"() {
+    "use strict";
+    SEASON_FLAG = {
+      season: {
+        type: "string",
+        description: "Season year (e.g. 2025)",
+        required: true,
+        alias: "s"
+      }
+    };
+    OPTIONAL_SEASON_FLAG = {
+      season: {
+        type: "string",
+        description: "Season year (e.g. 2025)",
+        alias: "s"
+      }
+    };
+    ROUND_FLAG = {
+      round: {
+        type: "string",
+        description: "Round number",
+        alias: "r"
+      }
+    };
+    REQUIRED_ROUND_FLAG = {
+      round: {
+        type: "string",
+        description: "Round number",
+        required: true,
+        alias: "r"
+      }
+    };
+    SOURCE_FLAG = {
+      source: {
+        type: "string",
+        description: "Data source",
+        default: "afl-api"
+      }
+    };
+    COMPETITION_FLAG = {
+      competition: {
+        type: "string",
+        description: "Competition code (AFLM or AFLW)",
+        default: "AFLM",
+        alias: "c"
+      }
+    };
+    OPTIONAL_COMPETITION_FLAG = {
+      competition: {
+        type: "string",
+        description: "Competition code (AFLM or AFLW)",
+        alias: "c"
+      }
+    };
+    OUTPUT_FLAGS = {
+      json: { type: "boolean", description: "Output as JSON", alias: "j" },
+      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" }
+    };
+    REQUIRED_TEAM_FLAG = {
+      team: {
+        type: "string",
+        description: "Team name, abbreviation, or ID (e.g. Carlton, CARL, 5)",
+        required: true,
+        alias: "t"
+      }
+    };
+    TEAM_FLAG = {
+      team: {
+        type: "string",
+        description: "Filter by team name",
+        alias: "t"
+      }
+    };
+    PLAYER_FLAG = {
+      player: {
+        type: "string",
+        description: "Filter by player name",
+        alias: "p"
+      }
+    };
+  }
+});
+
 // src/cli/formatters/csv.ts
 function escapeField(value) {
   if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
@@ -3768,10 +4055,6 @@ function validateOptionalSeason(raw) {
   if (raw != null) return validateSeason(raw);
   return void 0;
 }
-function resolveDefaultSeason(competition = "AFLM") {
-  const year = (/* @__PURE__ */ new Date()).getFullYear();
-  return competition === "AFLW" ? year - 1 : year;
-}
 function validateRound(raw) {
   const round = Number(raw);
   if (Number.isNaN(round) || !Number.isInteger(round) || round < 0) {
@@ -3822,11 +4105,35 @@ function resolveTeamIdentifier(raw, teams) {
   const validNames = teams.map((t) => `${t.name} (${t.abbreviation})`).join(", ");
   throw new Error(`Unknown team: "${raw}" \u2014 valid teams are: ${validNames}`);
 }
+function resolveMatchByTeam(teamSearch, matchItems) {
+  const normalised = normaliseTeamName(teamSearch);
+  const lower = teamSearch.toLowerCase();
+  const matches = matchItems.filter((item) => {
+    const home = item.match.homeTeam.name;
+    const away = item.match.awayTeam.name;
+    return normaliseTeamName(home) === normalised || normaliseTeamName(away) === normalised || home.toLowerCase().includes(lower) || away.toLowerCase().includes(lower);
+  });
+  const singleMatch = matches[0];
+  if (matches.length === 1 && singleMatch) {
+    return singleMatch.match.matchId;
+  }
+  if (matches.length === 0) {
+    const available = matchItems.map((item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`).join(", ");
+    throw new Error(
+      `No match found for "${teamSearch}" in this round. Available matches: ${available}`
+    );
+  }
+  const ambiguous = matches.map((item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`).join(", ");
+  throw new Error(
+    `Multiple matches found for "${teamSearch}": ${ambiguous}. Please be more specific.`
+  );
+}
 var VALID_SOURCES, VALID_COMPETITIONS, VALID_FORMATS;
 var init_validation2 = __esm({
   "src/cli/validation.ts"() {
     "use strict";
     init_team_mapping();
+    init_date_utils();
     VALID_SOURCES = ["afl-api", "footywire", "afl-tables", "squiggle"];
     VALID_COMPETITIONS = ["AFLM", "AFLW"];
     VALID_FORMATS = ["table", "json", "csv"];
@@ -3844,6 +4151,8 @@ var init_matches = __esm({
   "src/cli/commands/matches.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
     init_ui();
     init_validation2();
@@ -3862,20 +4171,13 @@ var init_matches = __esm({
         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"
-        },
-        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" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = args.round ? validateRound(args.round) : void 0;
         const source = validateSource(args.source);
@@ -3898,8 +4200,205 @@ var init_matches = __esm({
           columns: DEFAULT_COLUMNS
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
+    });
+  }
+});
+
+// src/lib/fuzzy.ts
+function levenshteinDistance(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  if (la === 0) return lb;
+  if (lb === 0) return la;
+  if (la < lb) return levenshteinDistance(b, a);
+  const row = Array.from({ length: lb + 1 }, (_, i) => i);
+  for (let i = 1; i <= la; i++) {
+    let prev = i;
+    for (let j = 1; j <= lb; j++) {
+      const current = row[j - 1];
+      const rowJ = row[j];
+      if (current === void 0 || rowJ === void 0) continue;
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const val = Math.min(rowJ + 1, prev + 1, current + cost);
+      row[j - 1] = prev;
+      prev = val;
+    }
+    row[lb] = prev;
+  }
+  return row[lb] ?? 0;
+}
+function fuzzySearch(query, candidates, keySelector, options) {
+  const maxResults = options?.maxResults ?? 10;
+  const threshold = options?.threshold ?? 0.4;
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const item of candidates) {
+    const key = keySelector(item).toLowerCase();
+    if (key === lowerQuery) {
+      results.push({ item, score: 0 });
+      continue;
+    }
+    if (key.startsWith(lowerQuery)) {
+      results.push({ item, score: 0.1 });
+      continue;
+    }
+    if (key.includes(lowerQuery)) {
+      results.push({ item, score: 0.3 });
+      continue;
+    }
+    const maxLen = Math.max(lowerQuery.length, key.length);
+    if (maxLen === 0) continue;
+    const distance = levenshteinDistance(lowerQuery, key);
+    const normalised = distance / maxLen;
+    if (normalised <= threshold) {
+      const score = 0.4 + normalised / threshold * 0.6;
+      results.push({ item, score });
+    }
+  }
+  results.sort((a, b) => {
+    if (a.score !== b.score) return a.score - b.score;
+    return keySelector(a.item).localeCompare(keySelector(b.item));
+  });
+  return results.slice(0, maxResults);
+}
+var init_fuzzy = __esm({
+  "src/lib/fuzzy.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/resolvers.ts
+import { isCancel, select } from "@clack/prompts";
+async function resolveTeamOrPrompt(query, teams) {
+  try {
+    return resolveTeamIdentifier(query, teams);
+  } catch {
+  }
+  const matches = fuzzySearch(query.trim(), teams, (t) => t.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const abbrevMatches = fuzzySearch(query.trim(), teams, (t) => t.abbreviation, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const seen = new Set(matches.map((m) => m.item.teamId));
+  for (const m of abbrevMatches) {
+    if (!seen.has(m.item.teamId)) {
+      matches.push(m);
+      seen.add(m.item.teamId);
+    }
+  }
+  matches.sort((a, b) => a.score - b.score);
+  return disambiguate(
+    query.trim(),
+    matches.map((m) => ({ value: m.item.teamId, label: m.item.name, score: m.score })),
+    teams.map((t) => `${t.name} (${t.abbreviation})`),
+    "team"
+  );
+}
+async function resolveTeamNameOrPrompt(query, teamNames) {
+  const trimmed = query.trim();
+  const canonical = normaliseTeamName(trimmed);
+  const candidates = teamNames ?? [...AFL_SENIOR_TEAMS];
+  if (candidates.includes(canonical)) {
+    return canonical;
+  }
+  const items = candidates.map((name) => ({ name }));
+  const matches = fuzzySearch(trimmed, items, (t) => t.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  return disambiguate(
+    trimmed,
+    matches.map((m) => ({ value: m.item.name, label: m.item.name, score: m.score })),
+    candidates,
+    "team"
+  );
+}
+async function resolveMatchOrPrompt(query, matchItems) {
+  try {
+    return resolveMatchByTeam(query, matchItems);
+  } catch {
+  }
+  const labelledItems = matchItems.map((item) => ({
+    item,
+    label: `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`
+  }));
+  const matches = fuzzySearch(query, labelledItems, (l) => l.label, {
+    maxResults: 5,
+    threshold: 0.5
+  });
+  const homeMatches = fuzzySearch(query, matchItems, (i) => i.match.homeTeam.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const awayMatches = fuzzySearch(query, matchItems, (i) => i.match.awayTeam.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const seen = new Set(matches.map((m) => m.item.item.match.matchId));
+  for (const m of homeMatches) {
+    if (!seen.has(m.item.match.matchId)) {
+      const label = `${m.item.match.homeTeam.name} vs ${m.item.match.awayTeam.name}`;
+      matches.push({ item: { item: m.item, label }, score: m.score });
+      seen.add(m.item.match.matchId);
+    }
+  }
+  for (const m of awayMatches) {
+    if (!seen.has(m.item.match.matchId)) {
+      const label = `${m.item.match.homeTeam.name} vs ${m.item.match.awayTeam.name}`;
+      matches.push({ item: { item: m.item, label }, score: m.score });
+      seen.add(m.item.match.matchId);
+    }
+  }
+  matches.sort((a, b) => a.score - b.score);
+  const available = matchItems.map(
+    (item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`
+  );
+  return disambiguate(
+    query,
+    matches.map((m) => ({
+      value: m.item.item.match.matchId,
+      label: m.item.label,
+      score: m.score
+    })),
+    available,
+    "match"
+  );
+}
+async function disambiguate(query, options, allLabels, entityName) {
+  const best = options[0];
+  if (!best) {
+    throw new Error(
+      `No ${entityName} found for "${query}". Valid options: ${allLabels.join(", ")}`
+    );
+  }
+  if (best.score < 0.2 || options.length === 1) {
+    return best.value;
+  }
+  if (isTTY2) {
+    const choice = await select({
+      message: `Multiple ${entityName}s matched "${query}". Which did you mean?`,
+      options: options.map((o) => ({ value: o.value, label: o.label }))
     });
+    if (isCancel(choice)) {
+      process.exit(0);
+    }
+    return choice;
+  }
+  console.error(`Matched "${query}" \u2192 ${best.label}`);
+  return best.value;
+}
+var isTTY2;
+var init_resolvers = __esm({
+  "src/cli/resolvers.ts"() {
+    "use strict";
+    init_fuzzy();
+    init_team_mapping();
+    init_validation2();
+    isTTY2 = process.stdout.isTTY === true;
   }
 });
 
@@ -3914,7 +4413,12 @@ var init_stats = __esm({
   "src/cli/commands/stats.ts"() {
     "use strict";
     init_index();
+    init_fuzzy();
+    init_afl_api();
+    init_error_boundary();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
     init_validation2();
     DEFAULT_COLUMNS2 = [
@@ -3932,27 +4436,32 @@ var init_stats = __esm({
         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"
-        },
-        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" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        match: { type: "string", description: "Filter by team name to find a specific match" },
+        "match-id": { type: "string", description: "Specific match provider ID (advanced)" },
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...PLAYER_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = args.round ? validateRound(args.round) : void 0;
-        const matchId = args["match-id"];
         const source = validateSource(args.source);
         const competition = validateCompetition(args.competition);
         const format = validateFormat(args.format);
+        let matchId = args["match-id"];
+        if (!matchId && args.match && round != null) {
+          const client = new AflApiClient();
+          const seasonResult = await client.resolveCompSeason(competition, season);
+          if (!seasonResult.success) throw seasonResult.error;
+          const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, round);
+          if (!itemsResult.success) throw itemsResult.error;
+          matchId = await resolveMatchOrPrompt(args.match, itemsResult.data);
+        } else if (args.match && round == null) {
+          throw new Error("--match requires --round (-r) to identify which round to search.");
+        }
         const result = await withSpinner(
           "Fetching player stats\u2026",
           () => fetchPlayerStats({ source, season, round, matchId, competition })
@@ -3960,7 +4469,14 @@ var init_stats = __esm({
         if (!result.success) {
           throw result.error;
         }
-        const data = result.data;
+        let data = result.data;
+        if (args.player) {
+          const playerMatches = fuzzySearch(args.player, data, (p) => p.displayName, {
+            maxResults: 50,
+            threshold: 0.4
+          });
+          data = playerMatches.map((m) => m.item);
+        }
         showSummary(
           `Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`
         );
@@ -3972,7 +4488,7 @@ var init_stats = __esm({
           columns: DEFAULT_COLUMNS2
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
     });
   }
 });
@@ -3988,6 +4504,8 @@ var init_fixture2 = __esm({
   "src/cli/commands/fixture.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
     init_ui();
     init_validation2();
@@ -4004,20 +4522,13 @@ var init_fixture2 = __esm({
         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"
-        },
-        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" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = args.round ? validateRound(args.round) : void 0;
         const source = validateSource(args.source);
@@ -4040,7 +4551,7 @@ var init_fixture2 = __esm({
           columns: DEFAULT_COLUMNS3
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4056,6 +4567,8 @@ var init_ladder3 = __esm({
   "src/cli/commands/ladder.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
     init_ui();
     init_validation2();
@@ -4074,20 +4587,13 @@ var init_ladder3 = __esm({
         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"
-        },
-        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" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = args.round ? validateRound(args.round) : void 0;
         const source = validateSource(args.source);
@@ -4112,7 +4618,7 @@ var init_ladder3 = __esm({
           columns: DEFAULT_COLUMNS4
         };
         console.log(formatOutput(data.entries, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4150,7 +4656,11 @@ var init_lineup3 = __esm({
   "src/cli/commands/lineup.ts"() {
     "use strict";
     init_index();
+    init_afl_api();
+    init_error_boundary();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
     init_validation2();
     DEFAULT_COLUMNS5 = [
@@ -4166,27 +4676,29 @@ var init_lineup3 = __esm({
         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"
-        },
-        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" }
+        ...SEASON_FLAG,
+        ...REQUIRED_ROUND_FLAG,
+        match: { type: "string", description: "Filter by team name to find a specific match" },
+        "match-id": { type: "string", description: "Specific match provider ID (advanced)" },
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = validateRound(args.round);
-        const matchId = args["match-id"];
         const source = validateSource(args.source);
         const competition = validateCompetition(args.competition);
         const format = validateFormat(args.format);
+        let matchId = args["match-id"];
+        if (!matchId && args.match) {
+          const client = new AflApiClient();
+          const seasonResult = await client.resolveCompSeason(competition, season);
+          if (!seasonResult.success) throw seasonResult.error;
+          const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, round);
+          if (!itemsResult.success) throw itemsResult.error;
+          matchId = await resolveMatchOrPrompt(args.match, itemsResult.data);
+        }
         const result = await withSpinner(
           "Fetching lineups\u2026",
           () => fetchLineup({ source, season, round, matchId, competition })
@@ -4209,7 +4721,7 @@ var init_lineup3 = __esm({
         } else {
           console.log(formatOutput(flattenLineups(data), formatOptions));
         }
-      }
+      })
     });
   }
 });
@@ -4225,7 +4737,10 @@ var init_squad = __esm({
   "src/cli/commands/squad.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
     init_validation2();
     DEFAULT_COLUMNS6 = [
@@ -4241,34 +4756,22 @@ var init_squad = __esm({
         description: "Fetch team squad for a season"
       },
       args: {
-        "team-id": {
-          type: "string",
-          description: "Team ID, abbreviation, or name (e.g. 5, CARL, Carlton)",
-          required: true
-        },
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        competition: {
-          type: "string",
-          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" }
+        ...REQUIRED_TEAM_FLAG,
+        ...SEASON_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const competition = validateCompetition(args.competition);
         const format = validateFormat(args.format);
-        let teamId = args["team-id"].trim();
-        const isNumeric = /^\d+$/.test(teamId);
-        if (!isNumeric) {
+        let teamId = args.team.trim();
+        if (!/^\d+$/.test(teamId)) {
           const teamsResult = await withSpinner("Resolving team\u2026", () => fetchTeams({ competition }));
           if (!teamsResult.success) {
             throw teamsResult.error;
           }
-          teamId = resolveTeamIdentifier(args["team-id"], teamsResult.data);
+          teamId = await resolveTeamOrPrompt(args.team, teamsResult.data);
         }
         const result = await withSpinner(
           "Fetching squad\u2026",
@@ -4287,7 +4790,7 @@ var init_squad = __esm({
           columns: DEFAULT_COLUMNS6
         };
         console.log(formatOutput(data.players, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4303,6 +4806,8 @@ var init_teams2 = __esm({
   "src/cli/commands/teams.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
     init_ui();
     init_validation2();
@@ -4318,14 +4823,11 @@ var init_teams2 = __esm({
         description: "Fetch team list"
       },
       args: {
-        competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
+        ...OPTIONAL_COMPETITION_FLAG,
         "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" }
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const competition = validateOptionalCompetition(args.competition);
         const format = validateFormat(args.format);
         const result = await withSpinner(
@@ -4350,7 +4852,7 @@ var init_teams2 = __esm({
           columns: DEFAULT_COLUMNS7
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4364,14 +4866,20 @@ import { defineCommand as defineCommand8 } from "citty";
 function flattenEntries(data) {
   return data.map((entry) => {
     const { stats, ...rest } = entry;
-    return { ...rest, ...stats };
+    const normalised = {};
+    for (const [key, value] of Object.entries(stats)) {
+      normalised[AFL_TABLES_KEY_MAP[key] ?? key] = value;
+    }
+    return { ...rest, ...normalised };
   });
 }
-var DEFAULT_COLUMNS8, teamStatsCommand;
+var DEFAULT_COLUMNS8, AFL_TABLES_KEY_MAP, teamStatsCommand;
 var init_team_stats2 = __esm({
   "src/cli/commands/team-stats.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
     init_ui();
     init_validation2();
@@ -4387,25 +4895,69 @@ var init_team_stats2 = __esm({
       { key: "T", label: "T", maxWidth: 6 },
       { key: "I50", label: "I50", maxWidth: 6 }
     ];
+    AFL_TABLES_KEY_MAP = {
+      KI_for: "K",
+      MK_for: "M",
+      HB_for: "HB",
+      DI_for: "D",
+      GL_for: "G",
+      BH_for: "B",
+      HO_for: "HO",
+      TK_for: "T",
+      RB_for: "RB",
+      IF_for: "IF",
+      CL_for: "CL",
+      CG_for: "CG",
+      FF_for: "FF",
+      BR_for: "BR",
+      CP_for: "CP",
+      UP_for: "UP",
+      CM_for: "CM",
+      MI_for: "MI",
+      "1%_for": "1%",
+      BO_for: "BO",
+      GA_for: "GA",
+      I50_for: "I50",
+      // "against" variants
+      KI_against: "K_against",
+      MK_against: "M_against",
+      HB_against: "HB_against",
+      DI_against: "D_against",
+      GL_against: "G_against",
+      BH_against: "B_against",
+      HO_against: "HO_against",
+      TK_against: "T_against",
+      RB_against: "RB_against",
+      IF_against: "IF_against",
+      CL_against: "CL_against",
+      CG_against: "CG_against",
+      FF_against: "FF_against",
+      BR_against: "BR_against",
+      CP_against: "CP_against",
+      UP_against: "UP_against",
+      CM_against: "CM_against",
+      MI_against: "MI_against",
+      "1%_against": "1%_against",
+      BO_against: "BO_against",
+      GA_against: "GA_against",
+      I50_against: "I50_against"
+    };
     teamStatsCommand = defineCommand8({
       meta: {
         name: "team-stats",
         description: "Fetch team aggregate statistics for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
+        ...SEASON_FLAG,
         source: {
           type: "string",
           description: "Data source (footywire, afl-tables)",
           default: "footywire"
         },
         summary: { type: "string", description: "Summary type: totals or averages", default: "totals" },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const source = validateSource(args.source);
         const format = validateFormat(args.format);
@@ -4428,7 +4980,7 @@ var init_team_stats2 = __esm({
           columns: DEFAULT_COLUMNS8
         };
         console.log(formatOutput(flat, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4444,7 +4996,10 @@ var init_player_details2 = __esm({
   "src/cli/commands/player-details.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
     init_validation2();
     DEFAULT_COLUMNS9 = [
@@ -4462,37 +5017,31 @@ var init_player_details2 = __esm({
         description: "Fetch player biographical details for a team"
       },
       args: {
-        team: { type: "positional", description: "Team name (e.g. Carlton, Hawthorn)", required: true },
+        ...REQUIRED_TEAM_FLAG,
         source: {
           type: "string",
           description: "Data source: afl-api, footywire, afl-tables",
           default: "afl-api"
         },
-        season: { type: "string", description: "Season year (for AFL API source, e.g. 2025)" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...OPTIONAL_SEASON_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const source = validateSource(args.source);
         const competition = validateCompetition(args.competition);
         const format = validateFormat(args.format);
         const season = validateOptionalSeason(args.season) ?? resolveDefaultSeason(competition);
+        const team = await resolveTeamNameOrPrompt(args.team);
         const result = await withSpinner(
           "Fetching player details\u2026",
-          () => fetchPlayerDetails({ source, team: args.team, season, competition })
+          () => fetchPlayerDetails({ source, team, season, competition })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
-        showSummary(`Loaded ${data.length} players for ${args.team} (${source})`);
+        showSummary(`Loaded ${data.length} players for ${team} (${source})`);
         const formatOptions = {
           json: args.json,
           csv: args.csv,
@@ -4501,7 +5050,7 @@ var init_player_details2 = __esm({
           columns: DEFAULT_COLUMNS9
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4517,7 +5066,10 @@ var init_coaches_votes2 = __esm({
   "src/cli/commands/coaches-votes.ts"() {
     "use strict";
     init_index();
+    init_error_boundary();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
     init_validation2();
     DEFAULT_COLUMNS10 = [
@@ -4534,33 +5086,27 @@ var init_coaches_votes2 = __esm({
         description: "Fetch AFLCA coaches votes for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
-        round: { type: "string", description: "Round number" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        team: { type: "string", description: "Filter by team name" },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...COMPETITION_FLAG,
+        ...TEAM_FLAG,
+        ...OUTPUT_FLAGS
       },
-      async run({ args }) {
+      run: withErrorBoundary(async ({ args }) => {
         const season = validateSeason(args.season);
         const round = args.round ? validateRound(args.round) : void 0;
         const competition = validateCompetition(args.competition);
         const format = validateFormat(args.format);
+        const team = args.team ? await resolveTeamNameOrPrompt(args.team) : void 0;
         const result = await withSpinner(
           "Fetching coaches votes\u2026",
-          () => fetchCoachesVotes({ season, round, competition, team: args.team })
+          () => fetchCoachesVotes({ season, round, competition, team })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
-        const teamSuffix = args.team ? ` for ${args.team}` : "";
+        const teamSuffix = team ? ` for ${team}` : "";
         const roundSuffix = round ? ` round ${round}` : "";
         showSummary(`Loaded ${data.length} vote records for ${season}${roundSuffix}${teamSuffix}`);
         const formatOptions = {
@@ -4571,7 +5117,7 @@ var init_coaches_votes2 = __esm({
           columns: DEFAULT_COLUMNS10
         };
         console.log(formatOutput(data, formatOptions));
-      }
+      })
     });
   }
 });
@@ -4579,37 +5125,34 @@ var init_coaches_votes2 = __esm({
 // src/cli.ts
 import { defineCommand as defineCommand11, runMain } from "citty";
 
-// src/cli/error-boundary.ts
-init_errors();
-import pc from "picocolors";
-function formatError(error) {
-  if (error instanceof ValidationError && error.issues) {
-    const issueLines = error.issues.map((i) => `  ${pc.yellow(i.path)}: ${i.message}`);
-    return `${pc.red("Validation error:")}
-${issueLines.join("\n")}`;
-  }
-  if (error instanceof AflApiError) {
-    const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
-    return `${pc.red("AFL API error:")} ${error.message}${status}`;
-  }
-  if (error instanceof ScrapeError) {
-    const source = error.source ? ` [${error.source}]` : "";
-    return `${pc.red("Scrape error:")} ${error.message}${source}`;
-  }
-  if (error instanceof UnsupportedSourceError) {
-    return `${pc.red("Unsupported source:")} ${error.message}`;
-  }
-  if (error instanceof Error) {
-    return `${pc.red("Error:")} ${error.message}`;
+// src/cli/alias-resolution.ts
+var SHORT_TO_LONG = {
+  "-s": "--season",
+  "-r": "--round",
+  "-c": "--competition",
+  "-j": "--json",
+  "-t": "--team",
+  "-p": "--player"
+};
+function resolveAliases() {
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg != null) {
+      const long = SHORT_TO_LONG[arg];
+      if (long) {
+        process.argv[i] = long;
+      }
+    }
   }
-  return `${pc.red("Error:")} ${String(error)}`;
 }
 
 // src/cli.ts
+init_error_boundary();
+resolveAliases();
 var main = defineCommand11({
   meta: {
     name: "fitzroy",
-    version: "1.1.1",
+    version: "1.3.0",
     description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
   },
   subCommands: {