fifa-wc26 0.1.0

package/dist/cli.js

@@ -0,0 +1,1289 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/render/live-dashboard.tsx
+var live_dashboard_exports = {};
+__export(live_dashboard_exports, {
+  Dashboard: () => Dashboard
+});
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function scoreStr3(f) {
+  return f.score ? `${f.score.home}-${f.score.away}` : "\u2013";
+}
+function Dashboard({ live, upcoming, stale, reason, favoriteOnly }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "wc26 live" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      stale && /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "[STALE",
+        reason ? " " + reason : "",
+        "]"
+      ] }),
+      favoriteOnly && /* @__PURE__ */ jsx(Text, { color: "magenta", children: " [fav-only]" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "LIVE" }) }),
+    live.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "no live matches" }) : live.map((m) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+        String(m.minute).padStart(3),
+        "'"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        m.home.code,
+        " ",
+        scoreStr3(m),
+        " ",
+        m.away.code,
+        "  "
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        m.stage,
+        m.group ? " " + m.group : ""
+      ] })
+    ] }, m.id)),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Upcoming" }) }),
+    upcoming.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "none" }) : upcoming.map((f) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: f.utcKickoff.replace("T", " ").replace(".000Z", "") }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        f.home.code,
+        " vs ",
+        f.away.code,
+        "  "
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        f.stage,
+        f.group ? " " + f.group : ""
+      ] })
+    ] }, f.id)),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "q: quit  r: refresh  t: fav-only  ?: help" }) })
+  ] });
+}
+var init_live_dashboard = __esm({
+  "src/render/live-dashboard.tsx"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/fixtures.ts
+init_esm_shims();
+
+// src/commands/_shared.ts
+init_esm_shims();
+import { homedir } from "os";
+import { join as join3 } from "path";
+
+// src/config/store.ts
+init_esm_shims();
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
+var DEFAULTS = {
+  providers: ["espn", "thesportsdb"],
+  apiKeys: {},
+  defaults: { watchIntervalSec: 15, output: "pretty" }
+};
+var ENV_KEYS = {
+  "thesportsdb": "WC26_THESPORTSDB_KEY"
+};
+var ConfigStore = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  file() {
+    return join(this.root, "config.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.file(), "utf8");
+      const parsed = JSON.parse(raw);
+      return { ...DEFAULTS, ...parsed, defaults: { ...DEFAULTS.defaults, ...parsed.defaults } };
+    } catch (e) {
+      if (e.code === "ENOENT") return { ...DEFAULTS };
+      throw e;
+    }
+  }
+  async save(cfg) {
+    await mkdir(this.root, { recursive: true });
+    await writeFile(this.file(), JSON.stringify(cfg, null, 2), "utf8");
+    await chmod(this.file(), 384);
+  }
+  async set(key, value) {
+    const cfg = await this.load();
+    cfg[key] = value;
+    await this.save(cfg);
+  }
+  async setApiKey(provider, key) {
+    const cfg = await this.load();
+    cfg.apiKeys[provider] = key;
+    await this.save(cfg);
+  }
+  async apiKey(provider) {
+    const env2 = ENV_KEYS[provider];
+    if (env2 && process.env[env2]) return process.env[env2];
+    const cfg = await this.load();
+    return cfg.apiKeys[provider];
+  }
+};
+
+// src/cache/json-cache.ts
+init_esm_shims();
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, rm, readdir } from "fs/promises";
+import { dirname, join as join2 } from "path";
+function sanitize(key) {
+  return key.split("/").map((seg) => seg.replace(/[^A-Za-z0-9_-]/g, "_")).filter(Boolean).join("/");
+}
+var JsonCache = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  pathFor(key) {
+    return join2(this.root, `${sanitize(key)}.json`);
+  }
+  async read(key, opts = {}) {
+    try {
+      const raw = await readFile2(this.pathFor(key), "utf8");
+      const env2 = JSON.parse(raw);
+      const age = (Date.now() - new Date(env2.fetchedAt).getTime()) / 1e3;
+      const stale = age >= env2.ttlSec;
+      if (stale && !opts.allowStale) return null;
+      return { data: env2.data, stale, fetchedAt: env2.fetchedAt, provider: env2.provider };
+    } catch (e) {
+      if (e.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+  async write(key, data, ttlSec, provider) {
+    const file = this.pathFor(key);
+    await mkdir2(dirname(file), { recursive: true });
+    const env2 = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ttlSec, provider, data };
+    await writeFile2(file, JSON.stringify(env2), "utf8");
+  }
+  async clear(resource) {
+    if (!resource) {
+      await rm(this.root, { recursive: true, force: true });
+      return;
+    }
+    const target = join2(this.root, sanitize(resource));
+    try {
+      const entries = await readdir(target);
+      await Promise.all(entries.map((f) => rm(join2(target, f), { force: true })));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+};
+
+// src/providers/registry.ts
+init_esm_shims();
+
+// src/errors.ts
+init_esm_shims();
+var WC26Error = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "WC26Error";
+  }
+  code;
+  cause;
+};
+var EXIT = {
+  NO_PROVIDER_CONFIGURED: 3,
+  PROVIDER_UNREACHABLE: 4,
+  CACHE_MISS_OFFLINE: 4,
+  NOT_FOUND: 5,
+  RATE_LIMIT: 1,
+  SCHEMA_MISMATCH: 1,
+  CONFIG_INVALID: 1
+};
+function exitCodeFor(code) {
+  return EXIT[code];
+}
+
+// src/providers/registry.ts
+var FAIL_THRESHOLD = 3;
+var OPEN_MS = 5 * 60 * 1e3;
+var ProviderRegistry = class {
+  constructor(providers) {
+    this.providers = providers;
+  }
+  providers;
+  breakers = /* @__PURE__ */ new Map();
+  breaker(name) {
+    let b = this.breakers.get(name);
+    if (!b) {
+      b = { failures: 0, openedAt: null };
+      this.breakers.set(name, b);
+    }
+    return b;
+  }
+  isOpen(name) {
+    const b = this.breaker(name);
+    if (b.openedAt == null) return false;
+    if (Date.now() - b.openedAt < OPEN_MS) return true;
+    b.openedAt = null;
+    b.failures = 0;
+    return false;
+  }
+  recordFail(name) {
+    const b = this.breaker(name);
+    b.failures++;
+    if (b.failures >= FAIL_THRESHOLD) b.openedAt = Date.now();
+  }
+  recordOk(name) {
+    const b = this.breaker(name);
+    b.failures = 0;
+    b.openedAt = null;
+  }
+  async call(fn) {
+    const candidates = this.providers.filter((p) => p.isConfigured() && !this.isOpen(p.name));
+    if (candidates.length === 0) {
+      if (this.providers.length === 0 || !this.providers.some((p) => p.isConfigured())) {
+        throw new WC26Error("NO_PROVIDER_CONFIGURED", "no provider configured. defaults are keyless (espn, thesportsdb).");
+      }
+      throw new WC26Error("PROVIDER_UNREACHABLE", "all providers temporarily unavailable");
+    }
+    let lastErr;
+    for (const p of candidates) {
+      try {
+        const out = await fn(p);
+        this.recordOk(p.name);
+        return out;
+      } catch (e) {
+        if (e instanceof WC26Error && e.code === "NOT_FOUND") throw e;
+        this.recordFail(p.name);
+        lastErr = e instanceof WC26Error ? e : new WC26Error("PROVIDER_UNREACHABLE", String(e));
+      }
+    }
+    throw new WC26Error("PROVIDER_UNREACHABLE", lastErr?.message ?? "all providers failed");
+  }
+};
+
+// src/providers/espn.ts
+init_esm_shims();
+
+// src/http/client.ts
+init_esm_shims();
+import { fetch } from "undici";
+var TRANSIENT = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function httpJson(url, opts = {}) {
+  const retries = opts.retries ?? 3;
+  const base2 = opts.baseDelayMs ?? 1e3;
+  let attempt = 0;
+  let lastErr;
+  while (attempt <= retries) {
+    try {
+      const res = await fetch(url, {
+        headers: opts.headers,
+        signal: opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : void 0
+      });
+      if (res.ok) return await res.json();
+      if (res.status === 404) {
+        throw new WC26Error("NOT_FOUND", `not found: ${url}`);
+      }
+      if (!TRANSIENT.has(res.status)) {
+        throw new WC26Error("PROVIDER_UNREACHABLE", `http ${res.status}: ${url}`);
+      }
+      lastErr = res.status === 429 ? new WC26Error("RATE_LIMIT", `rate limited: ${url}`) : new WC26Error("PROVIDER_UNREACHABLE", `http ${res.status}: ${url}`);
+      if (attempt === retries) throw lastErr;
+      const retryAfter = res.headers.get("retry-after");
+      const delay = retryAfter ? Number(retryAfter) * 1e3 : base2 * 2 ** attempt;
+      await sleep(Math.max(0, delay));
+    } catch (e) {
+      if (e instanceof WC26Error && (e.code === "NOT_FOUND" || attempt === retries)) throw e;
+      if (!(e instanceof WC26Error)) {
+        lastErr = new WC26Error("PROVIDER_UNREACHABLE", `network error: ${url}`, e);
+        if (attempt === retries) throw lastErr;
+        await sleep(base2 * 2 ** attempt);
+      } else {
+        lastErr = e;
+      }
+    }
+    attempt++;
+  }
+  throw lastErr ?? new WC26Error("PROVIDER_UNREACHABLE", `exhausted retries: ${url}`);
+}
+
+// src/providers/espn.ts
+var BASE = "https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.worldcup";
+var STANDINGS_BASE = "https://site.api.espn.com/apis/v2/sports/soccer/fifa.worldcup";
+var SEASON = 2026;
+function mapStage(headline, typeName) {
+  const text = `${headline ?? ""} ${typeName ?? ""}`.toLowerCase();
+  if (/third[- ]place|3rd[- ]place/.test(text)) return { stage: "third" };
+  if (/\bfinal\b/.test(text) && !/semi|quarter|third|3rd/.test(text)) return { stage: "final" };
+  if (/semi/.test(text)) return { stage: "sf" };
+  if (/quarter|qf\b/.test(text)) return { stage: "qf" };
+  if (/round of 16|r16|last 16/.test(text)) return { stage: "r16" };
+  const g = text.match(/group\s+([a-l])\b/i);
+  return { stage: "group", group: g?.[1]?.toUpperCase() };
+}
+function mapStatus(name, state) {
+  if (name === "STATUS_POSTPONED") return "postponed";
+  if (name === "STATUS_CANCELED" || name === "STATUS_FORFEIT") return "cancelled";
+  if (state === "in") return "live";
+  if (state === "post") return "finished";
+  return "scheduled";
+}
+function clockMinute(displayClock, period) {
+  if (!displayClock) return 0;
+  const m = displayClock.match(/^(\d+)/);
+  const base2 = m ? Number(m[1]) : 0;
+  if (period === 2) return Math.max(base2, 45);
+  return base2;
+}
+function teamRef(c) {
+  const name = c.team.displayName ?? c.team.name ?? c.team.abbreviation ?? "?";
+  const code = (c.team.abbreviation ?? name.slice(0, 3)).toUpperCase().slice(0, 3);
+  return { code, name };
+}
+function fixtureFromEvent(ev) {
+  const comp = ev.competitions[0];
+  if (!comp) throw new WC26Error("PROVIDER_UNREACHABLE", `event ${ev.id} has no competition`);
+  const home = comp.competitors.find((c) => c.homeAway === "home") ?? comp.competitors[0];
+  const away = comp.competitors.find((c) => c.homeAway === "away") ?? comp.competitors[1];
+  if (!home || !away) throw new WC26Error("PROVIDER_UNREACHABLE", `event ${ev.id} missing competitors`);
+  const status = mapStatus(comp.status?.type?.name ?? ev.status?.type?.name, comp.status?.type?.state ?? ev.status?.type?.state);
+  const note = comp.notes?.[0]?.headline;
+  const { stage, group } = mapStage(note, comp.status?.type?.description);
+  const hs = Number(home.score);
+  const as = Number(away.score);
+  const score = Number.isFinite(hs) && Number.isFinite(as) && (status === "live" || status === "finished") ? { home: hs, away: as } : void 0;
+  return {
+    id: ev.id,
+    utcKickoff: new Date(ev.date).toISOString(),
+    stage,
+    group,
+    home: teamRef(home),
+    away: teamRef(away),
+    venue: comp.venue?.fullName ?? "",
+    status,
+    score
+  };
+}
+function eventToLive(ev) {
+  const base2 = fixtureFromEvent(ev);
+  const comp = ev.competitions[0];
+  const minute = clockMinute(comp.status?.displayClock, comp.status?.period);
+  const homeId = comp.competitors.find((c) => c.homeAway === "home")?.team.id;
+  const events = (comp.details ?? []).map((d) => {
+    const min = Number((d.clock?.displayValue ?? "0").match(/\d+/)?.[0] ?? 0);
+    let type = "var";
+    if (d.scoringPlay) type = d.ownGoal ? "own-goal" : d.penaltyKick ? "penalty" : "goal";
+    else if (d.redCard) type = "red";
+    else if (d.yellowCard) type = "yellow";
+    else if ((d.type?.text ?? "").toLowerCase().includes("substitution")) type = "sub";
+    return {
+      minute: min,
+      type,
+      team: d.team?.id === homeId ? "home" : "away",
+      player: d.athletesInvolved?.[0]?.displayName,
+      detail: d.text ?? d.type?.text
+    };
+  });
+  return { ...base2, minute, events };
+}
+function fmtDate(d) {
+  return d.replace(/-/g, "");
+}
+var EspnProvider = class {
+  name = "espn";
+  isConfigured() {
+    return true;
+  }
+  async scoreboard(dates) {
+    const qs = dates ? `?dates=${dates}` : `?dates=${SEASON}`;
+    const data = await httpJson(`${BASE}/scoreboard${qs}`);
+    return data.events ?? [];
+  }
+  async fixtures(q) {
+    let dates;
+    if (q.from && q.to) dates = `${fmtDate(q.from)}-${fmtDate(q.to)}`;
+    else if (q.from) dates = fmtDate(q.from);
+    const events = await this.scoreboard(dates);
+    let out = events.map(fixtureFromEvent);
+    if (q.teamCode) out = out.filter((f) => f.home.code === q.teamCode || f.away.code === q.teamCode);
+    if (q.stage) out = out.filter((f) => f.stage === q.stage);
+    return out;
+  }
+  async liveMatches() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
+    const events = await this.scoreboard(today);
+    return events.filter((e) => (e.competitions[0]?.status?.type?.state ?? e.status?.type?.state) === "in").map(eventToLive);
+  }
+  async match(id) {
+    const data = await httpJson(
+      `${BASE}/summary?event=${id}`
+    );
+    const comp = data.header?.competitions?.[0];
+    if (!comp || !data.header) throw new WC26Error("NOT_FOUND", `match ${id} not found`);
+    const ev = { id: data.header.id ?? id, date: comp.date, competitions: [comp] };
+    const live = eventToLive(ev);
+    const homeRoster = data.rosters?.find((r) => r.homeAway === "home")?.roster ?? [];
+    const awayRoster = data.rosters?.find((r) => r.homeAway === "away")?.roster ?? [];
+    const mapPlayer = (r) => ({
+      name: r.athlete?.displayName ?? "?",
+      position: r.athlete?.position?.abbreviation ?? "",
+      number: r.athlete?.jersey ? Number(r.athlete.jersey) : void 0
+    });
+    const ref = data.gameInfo?.officials?.find((o) => /referee/i.test(o.position?.name ?? ""))?.displayName;
+    return {
+      ...live,
+      lineups: { home: homeRoster.map(mapPlayer), away: awayRoster.map(mapPlayer) },
+      stats: {},
+      referee: ref
+    };
+  }
+  async standings(group) {
+    const data = await httpJson(`${STANDINGS_BASE}/standings?season=${SEASON}`);
+    const stat = (entry, names) => {
+      for (const n of names) {
+        const s = entry.stats.find((x) => x.name === n);
+        if (s && typeof s.value === "number") return s.value;
+      }
+      return 0;
+    };
+    const groups = [];
+    for (const child of data.children ?? []) {
+      const label = (child.abbreviation ?? child.name ?? "").match(/[A-Z]$/)?.[0] ?? (child.name ?? "").replace(/^Group\s+/i, "").trim();
+      if (!label) continue;
+      groups.push({
+        group: label.toUpperCase(),
+        rows: (child.standings?.entries ?? []).map((e) => ({
+          team: { code: (e.team.abbreviation ?? e.team.displayName.slice(0, 3)).toUpperCase(), name: e.team.displayName },
+          p: stat(e, ["gamesPlayed"]),
+          w: stat(e, ["wins"]),
+          d: stat(e, ["ties", "draws"]),
+          l: stat(e, ["losses"]),
+          gf: stat(e, ["pointsFor", "goalsFor"]),
+          ga: stat(e, ["pointsAgainst", "goalsAgainst"]),
+          gd: stat(e, ["pointDifferential", "goalDifferential", "differential"]),
+          pts: stat(e, ["points"])
+        }))
+      });
+    }
+    groups.sort((a, b) => a.group.localeCompare(b.group));
+    return group ? groups.filter((g) => g.group === group.toUpperCase()) : groups;
+  }
+  async knockoutBracket() {
+    const fixtures = await this.fixtures({});
+    const stages = ["r16", "qf", "sf", "third", "final"];
+    return fixtures.filter((f) => stages.includes(f.stage)).map((f) => ({
+      stage: f.stage,
+      matchId: f.id,
+      home: f.home,
+      away: f.away,
+      winner: f.status === "finished" && f.score ? f.score.home > f.score.away ? f.home : f.score.away > f.score.home ? f.away : void 0 : void 0
+    }));
+  }
+  async team(code) {
+    const data = await httpJson(`${BASE}/teams`);
+    const teams = data.sports?.[0]?.leagues?.[0]?.teams ?? [];
+    const match = teams.find((t2) => (t2.team.abbreviation ?? "").toUpperCase() === code.toUpperCase());
+    if (!match) throw new WC26Error("NOT_FOUND", `team ${code} not found`);
+    const t = match.team;
+    let squad = [];
+    try {
+      const roster = await httpJson(`${BASE}/teams/${t.id}/roster`);
+      squad = (roster.athletes ?? []).map((a) => ({
+        name: a.displayName ?? "?",
+        position: a.position?.abbreviation ?? "",
+        number: a.jersey ? Number(a.jersey) : void 0
+      }));
+    } catch {
+      squad = [];
+    }
+    const fixtures = await this.fixtures({ teamCode: code });
+    return {
+      code: (t.abbreviation ?? code).toUpperCase(),
+      name: t.displayName,
+      squad,
+      fixtures
+    };
+  }
+};
+
+// src/providers/thesportsdb.ts
+init_esm_shims();
+var LEAGUE_ID = "4429";
+var SEASON2 = "2026";
+function base(key) {
+  return `https://www.thesportsdb.com/api/v1/json/${encodeURIComponent(key || "3")}`;
+}
+function mapStage2(round) {
+  const r = (round ?? "").toLowerCase();
+  if (/final/.test(r) && !/semi|quarter|third|3rd/.test(r)) return { stage: "final" };
+  if (/third|3rd/.test(r)) return { stage: "third" };
+  if (/semi/.test(r)) return { stage: "sf" };
+  if (/quarter/.test(r)) return { stage: "qf" };
+  if (/round of 16|r16|last 16/.test(r)) return { stage: "r16" };
+  const g = r.match(/group\s+([a-l])/);
+  return { stage: "group", group: g?.[1]?.toUpperCase() };
+}
+function teamCode(name, fallback) {
+  const raw = (fallback ?? name ?? "?").toUpperCase().replace(/[^A-Z]/g, "");
+  return raw.slice(0, 3) || "???";
+}
+function mapStatus2(s) {
+  const status = (s.strStatus ?? "").toLowerCase();
+  if (s.strPostponed === "yes" || status.includes("postp")) return "postponed";
+  if (status.includes("cancel")) return "cancelled";
+  if (/ft|finished|full[- ]time|match finished/.test(status)) return "finished";
+  if (/1h|2h|ht|live|in progress|playing/.test(status)) return "live";
+  if (s.intHomeScore != null && s.intAwayScore != null) return "finished";
+  return "scheduled";
+}
+function fixtureFromTSDB(e) {
+  const ts = e.strTimestamp ? new Date(e.strTimestamp) : /* @__PURE__ */ new Date(`${e.dateEvent}T${e.strTime ?? "00:00:00"}Z`);
+  const status = mapStatus2(e);
+  const hs = e.intHomeScore != null ? Number(e.intHomeScore) : NaN;
+  const as = e.intAwayScore != null ? Number(e.intAwayScore) : NaN;
+  const score = Number.isFinite(hs) && Number.isFinite(as) ? { home: hs, away: as } : void 0;
+  const round = e.strRound ?? e.strGroup ?? "";
+  const { stage, group: gFromRound } = mapStage2(round);
+  const group = gFromRound ?? (e.strGroup ? e.strGroup.replace(/^Group\s+/i, "").trim().toUpperCase().slice(0, 1) : void 0);
+  return {
+    id: e.idEvent,
+    utcKickoff: ts.toISOString(),
+    stage,
+    group: group || void 0,
+    home: { code: teamCode(e.strHomeTeam, e.strHomeTeamShort), name: e.strHomeTeam ?? "?" },
+    away: { code: teamCode(e.strAwayTeam, e.strAwayTeamShort), name: e.strAwayTeam ?? "?" },
+    venue: e.strVenue ?? "",
+    status,
+    score
+  };
+}
+var TheSportsDbProvider = class {
+  constructor(apiKey = "3") {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  name = "thesportsdb";
+  isConfigured() {
+    return true;
+  }
+  async fixtures(q) {
+    const data = await httpJson(
+      `${base(this.apiKey)}/eventsseason.php?id=${LEAGUE_ID}&s=${SEASON2}`
+    );
+    let out = (data.events ?? []).map(fixtureFromTSDB);
+    if (q.from) out = out.filter((f) => f.utcKickoff.slice(0, 10) >= q.from);
+    if (q.to) out = out.filter((f) => f.utcKickoff.slice(0, 10) <= q.to);
+    if (q.teamCode) out = out.filter((f) => f.home.code === q.teamCode || f.away.code === q.teamCode);
+    if (q.stage) out = out.filter((f) => f.stage === q.stage);
+    return out;
+  }
+  async liveMatches() {
+    const data = await httpJson(
+      `${base(this.apiKey)}/livescore.php?l=Soccer`
+    ).catch(() => ({ events: [] }));
+    return (data.events ?? []).filter((e) => e.idLeague === LEAGUE_ID || (e.strEvent ?? "").includes("World Cup")).map((e) => ({ ...fixtureFromTSDB(e), minute: 0, events: [] }));
+  }
+  async match(id) {
+    const data = await httpJson(`${base(this.apiKey)}/lookupevent.php?id=${id}`);
+    const e = data.events?.[0];
+    if (!e) throw new WC26Error("NOT_FOUND", `match ${id} not found`);
+    const f = fixtureFromTSDB(e);
+    return { ...f, minute: 0, events: [], lineups: { home: [], away: [] }, stats: {} };
+  }
+  async standings(group) {
+    const data = await httpJson(`${base(this.apiKey)}/lookuptable.php?l=${LEAGUE_ID}&s=${SEASON2}`);
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of data.table ?? []) {
+      const label = (row.strGroup ?? "").replace(/^Group\s+/i, "").trim().toUpperCase().slice(0, 1) || "?";
+      if (!groups.has(label)) groups.set(label, { group: label, rows: [] });
+      groups.get(label).rows.push({
+        team: { code: teamCode(row.strTeam, row.strTeamShort), name: row.strTeam },
+        p: Number(row.intPlayed ?? 0),
+        w: Number(row.intWin ?? 0),
+        d: Number(row.intDraw ?? 0),
+        l: Number(row.intLoss ?? 0),
+        gf: Number(row.intGoalsFor ?? 0),
+        ga: Number(row.intGoalsAgainst ?? 0),
+        gd: Number(row.intGoalDifference ?? 0),
+        pts: Number(row.intPoints ?? 0)
+      });
+    }
+    const out = [...groups.values()].sort((a, b) => a.group.localeCompare(b.group));
+    return group ? out.filter((g) => g.group === group.toUpperCase()) : out;
+  }
+  async knockoutBracket() {
+    const fixtures = await this.fixtures({});
+    const stages = ["r16", "qf", "sf", "third", "final"];
+    return fixtures.filter((f) => stages.includes(f.stage)).map((f) => ({
+      stage: f.stage,
+      matchId: f.id,
+      home: f.home,
+      away: f.away,
+      winner: f.status === "finished" && f.score ? f.score.home > f.score.away ? f.home : f.score.away > f.score.home ? f.away : void 0 : void 0
+    }));
+  }
+  async team(code) {
+    const data = await httpJson(`${base(this.apiKey)}/search_all_teams.php?l=FIFA%20World%20Cup`).catch(() => ({ teams: [] }));
+    const list = data.teams ?? [];
+    const t = list.find((x) => teamCode(x.strTeam, x.strTeamShort) === code.toUpperCase());
+    if (!t) throw new WC26Error("NOT_FOUND", `team ${code} not found`);
+    const fixtures = await this.fixtures({ teamCode: code });
+    return {
+      code: teamCode(t.strTeam, t.strTeamShort),
+      name: t.strTeam,
+      squad: [],
+      fixtures
+    };
+  }
+};
+
+// src/commands/_shared.ts
+function homeDir() {
+  return process.env.WC26_HOME ?? join3(homedir(), ".wc26");
+}
+var env = {
+  get config() {
+    return new ConfigStore(homeDir());
+  },
+  get cache() {
+    return new JsonCache(join3(homeDir(), "cache"));
+  }
+};
+async function buildRegistry(opts) {
+  const cfg = await env.config.load();
+  const names = opts.provider ? [opts.provider] : cfg.providers;
+  const providers = [];
+  for (const name of names) {
+    const key = await env.config.apiKey(name) ?? "";
+    if (name === "espn") providers.push(new EspnProvider());
+    else if (name === "thesportsdb") providers.push(new TheSportsDbProvider(key || "3"));
+  }
+  return new ProviderRegistry(providers);
+}
+async function runCached(key, ttlSec, fetcher, opts) {
+  if (!opts.noCache) {
+    const hit = await env.cache.read(key, { allowStale: false });
+    if (hit) return { data: hit.data, stale: false };
+  }
+  try {
+    const { data, provider } = await fetcher();
+    await env.cache.write(key, data, ttlSec, provider);
+    return { data, stale: false };
+  } catch (e) {
+    const stale = await env.cache.read(key, { allowStale: true });
+    if (stale) {
+      const reason = e instanceof WC26Error ? e.code.toLowerCase() : "unreachable";
+      return { data: stale.data, stale: true, reason };
+    }
+    throw e;
+  }
+}
+function die(e, opts) {
+  if (e instanceof WC26Error) {
+    if (opts.json) {
+      process.stderr.write(JSON.stringify({ error: { code: e.code, message: e.message } }) + "\n");
+    } else {
+      process.stderr.write(`\u2717 ${e.message}
+`);
+    }
+    if (opts.verbose && e.cause) process.stderr.write(String(e.cause) + "\n");
+    process.exit(exitCodeFor(e.code));
+  }
+  process.stderr.write(String(e) + "\n");
+  if (opts.verbose && e instanceof Error && e.stack) process.stderr.write(e.stack + "\n");
+  process.exit(1);
+}
+
+// src/render/json.ts
+init_esm_shims();
+function renderJson(data, opts = {}) {
+  return JSON.stringify({ stale: !!opts.stale, ...opts.reason ? { reason: opts.reason } : {}, data });
+}
+
+// src/render/plain.ts
+init_esm_shims();
+var scoreStr = (f) => f.score ? `${f.score.home}-${f.score.away}` : "-";
+function renderFixturesPlain(items) {
+  const lines = ["id	kickoff	stage	group	home	away	venue	status	score"];
+  for (const f of items) {
+    lines.push([f.id, f.utcKickoff, f.stage, f.group ?? "-", f.home.code, f.away.code, f.venue, f.status, scoreStr(f)].join("	"));
+  }
+  return lines.join("\n") + "\n";
+}
+function renderLivePlain(items) {
+  const lines = ["id	minute	home	away	score	status"];
+  for (const m of items) {
+    lines.push([m.id, m.minute, m.home.code, m.away.code, scoreStr(m), m.status].join("	"));
+  }
+  return lines.join("\n") + "\n";
+}
+function renderStandingsPlain(groups) {
+  const lines = ["group	team	p	w	d	l	gf	ga	gd	pts"];
+  for (const g of groups) {
+    for (const r of g.rows) {
+      lines.push([g.group, r.team.code, r.p, r.w, r.d, r.l, r.gf, r.ga, r.gd, r.pts].join("	"));
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function renderBracketPlain(nodes) {
+  const lines = ["stage	home	away	winner"];
+  for (const n of nodes) {
+    lines.push([n.stage, n.home?.code ?? "?", n.away?.code ?? "?", n.winner?.code ?? "-"].join("	"));
+  }
+  return lines.join("\n") + "\n";
+}
+function renderTeamPlain(t) {
+  return [
+    `code	name	group`,
+    `${t.code}	${t.name}	${t.group ?? "-"}`
+  ].join("\n") + "\n";
+}
+
+// src/render/pretty.ts
+init_esm_shims();
+import Table from "cli-table3";
+import chalk from "chalk";
+var stageLabel = (s) => ({
+  group: "Group",
+  r16: "R16",
+  qf: "QF",
+  sf: "SF",
+  third: "3rd",
+  final: "Final"
+})[s] ?? s;
+var colorStatus = (s) => {
+  if (s === "live") return chalk.green(s);
+  if (s === "finished") return chalk.gray(s);
+  if (s === "cancelled" || s === "postponed") return chalk.red(s);
+  return chalk.cyan(s);
+};
+var scoreStr2 = (f) => f.score ? `${f.score.home}-${f.score.away}` : "\u2013";
+function renderFixturesPretty(fixtures) {
+  const t = new Table({
+    head: ["Kickoff (UTC)", "Stage", "Home", "Away", "Venue", "Score", "Status"],
+    style: { head: ["bold"] }
+  });
+  for (const f of fixtures) {
+    t.push([
+      f.utcKickoff.replace("T", " ").replace(".000Z", ""),
+      `${stageLabel(f.stage)}${f.group ? " " + f.group : ""}`,
+      `${f.home.code} ${chalk.dim(f.home.name)}`,
+      `${f.away.code} ${chalk.dim(f.away.name)}`,
+      f.venue,
+      scoreStr2(f),
+      colorStatus(f.status)
+    ]);
+  }
+  return t.toString();
+}
+function renderLivePretty(items) {
+  if (items.length === 0) return chalk.dim("no live matches");
+  const t = new Table({ head: ["Min", "Home", "Score", "Away", "Stage"], style: { head: ["bold"] } });
+  for (const m of items) {
+    t.push([
+      chalk.green(`${m.minute}'`),
+      `${m.home.code} ${chalk.dim(m.home.name)}`,
+      scoreStr2(m),
+      `${m.away.code} ${chalk.dim(m.away.name)}`,
+      stageLabel(m.stage)
+    ]);
+  }
+  return t.toString();
+}
+function renderStandingsPretty(groups) {
+  return groups.map((g) => {
+    const t = new Table({
+      head: ["Team", "P", "W", "D", "L", "GF", "GA", "GD", "Pts"],
+      style: { head: ["bold"] }
+    });
+    for (const r of g.rows) {
+      t.push([`${r.team.code} ${chalk.dim(r.team.name)}`, r.p, r.w, r.d, r.l, r.gf, r.ga, r.gd, chalk.bold(String(r.pts))]);
+    }
+    return chalk.bold(`Group ${g.group}`) + "\n" + t.toString();
+  }).join("\n\n");
+}
+function renderTeamPretty(t) {
+  const head = `${chalk.bold(t.name)} (${t.code})${t.group ? ` \u2014 Group ${t.group}` : ""}${t.coach ? ` \u2014 ${t.coach}` : ""}`;
+  const sq = new Table({ head: ["#", "Name", "Pos", "Club"], style: { head: ["bold"] } });
+  for (const p of t.squad) sq.push([p.number ?? "", p.name, p.position, p.club ?? ""]);
+  const fx = renderFixturesPretty(t.fixtures);
+  return [head, sq.toString(), chalk.bold("Fixtures"), fx].join("\n");
+}
+
+// src/commands/fixtures.ts
+function fixturesCmd(p) {
+  p.command("fixtures").description("List World Cup fixtures").option("--team <code>", "filter by FIFA 3-letter team code").option("--from <date>", 'ISO date (or "today")').option("--to <date>", "ISO date").option("--stage <s>", "group|r16|qf|sf|third|final").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      const q = {
+        teamCode: g.team,
+        from: g.from === "today" ? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) : g.from,
+        to: g.to,
+        stage: g.stage
+      };
+      const key = `fixtures/${g.team ? `team-${g.team}` : "all"}`;
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        key,
+        6 * 3600,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.fixtures(q);
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      const filtered = data.filter(
+        (f) => (!q.stage || f.stage === q.stage) && (!q.teamCode || f.home.code === q.teamCode || f.away.code === q.teamCode)
+      );
+      if (g.json) process.stdout.write(renderJson(filtered, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderFixturesPlain(filtered));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderFixturesPretty(filtered) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/next.ts
+init_esm_shims();
+function nextCmd(p) {
+  p.command("next").description("Show upcoming matches").option("--team <code>", "filter by team").option("-n, --count <n>", "number of matches", "5").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const n = Math.max(1, parseInt(g.count ?? "5", 10));
+    try {
+      const reg = await buildRegistry(g);
+      const key = `fixtures/${g.team ? `team-${g.team}` : "all"}`;
+      const { data, stale, reason } = await runCached(
+        key,
+        6 * 3600,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.fixtures({ teamCode: g.team });
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      const now = Date.now();
+      const out = data.filter((f) => f.status === "scheduled" && new Date(f.utcKickoff).getTime() > now).sort((a, b) => a.utcKickoff.localeCompare(b.utcKickoff)).slice(0, n);
+      if (g.json) process.stdout.write(renderJson(out, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderFixturesPlain(out));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderFixturesPretty(out) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/live.ts
+init_esm_shims();
+function liveCmd(p) {
+  p.command("live").description("Show live matches").option("--watch", "interactive dashboard").option("--interval <sec>", "refresh interval in seconds", "15").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      if (g.watch) {
+        const { render } = await import("ink");
+        const React = (await import("react")).default;
+        const { Dashboard: Dashboard2 } = await Promise.resolve().then(() => (init_live_dashboard(), live_dashboard_exports));
+        const cfg = await env.config.load();
+        const interval = Math.max(10, parseInt(g.interval ?? String(cfg.defaults.watchIntervalSec), 10)) * 1e3;
+        const fav = cfg.favoriteTeam;
+        let favoriteOnly = false;
+        const reg2 = await buildRegistry(g);
+        let state = { live: [], upcoming: [], stale: false };
+        const refresh = async () => {
+          try {
+            const { data: live, stale: stale2, reason: reason2 } = await runCached(
+              "live/all",
+              10,
+              async () => {
+                let provider = "";
+                const data2 = await reg2.call(async (p2) => {
+                  provider = p2.name;
+                  return p2.liveMatches();
+                });
+                return { data: data2, provider };
+              },
+              g
+            );
+            const { data: fx } = await runCached(
+              "fixtures/all",
+              6 * 3600,
+              async () => {
+                let provider = "";
+                const data2 = await reg2.call(async (p2) => {
+                  provider = p2.name;
+                  return p2.fixtures({});
+                });
+                return { data: data2, provider };
+              },
+              g
+            );
+            const now = Date.now();
+            const upcoming = fx.filter((f) => f.status === "scheduled" && new Date(f.utcKickoff).getTime() > now).sort((a, b) => a.utcKickoff.localeCompare(b.utcKickoff)).slice(0, 8);
+            const filterFav = (m) => !favoriteOnly || !fav || m.home.code === fav || m.away.code === fav;
+            state = { live: live.filter(filterFav), upcoming: upcoming.filter(filterFav), stale: stale2, reason: reason2 };
+            app.rerender(React.createElement(Dashboard2, { ...state, favoriteOnly }));
+          } catch (e) {
+            die(e, g);
+          }
+        };
+        const app = render(React.createElement(Dashboard2, { ...state, favoriteOnly }));
+        await refresh();
+        const timer = setInterval(refresh, interval);
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        const cleanup = () => {
+          clearInterval(timer);
+          process.stdin.setRawMode?.(false);
+          process.stdin.pause();
+          app.unmount();
+        };
+        process.on("SIGINT", () => {
+          cleanup();
+          process.exit(0);
+        });
+        process.on("exit", cleanup);
+        process.stdin.on("data", (buf) => {
+          const k = buf.toString();
+          if (k === "q" || k === "") {
+            cleanup();
+            process.exit(0);
+          }
+          if (k === "r") void refresh();
+          if (k === "t") {
+            favoriteOnly = !favoriteOnly;
+            void refresh();
+          }
+        });
+        return;
+      }
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        "live/all",
+        10,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.liveMatches();
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      if (g.json) process.stdout.write(renderJson(data, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderLivePlain(data));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderLivePretty(data) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/match.ts
+init_esm_shims();
+function renderMatchPretty(m) {
+  const head = `[${m.stage.toUpperCase()}${m.group ? " " + m.group : ""}] ${m.home.name} vs ${m.away.name}  ${m.score ? `${m.score.home}-${m.score.away}` : "\u2013"}  ${m.status === "live" ? `${m.minute}'` : m.status}`;
+  const events = m.events.map((e) => `  ${e.minute}'  ${e.type.padEnd(6)}  ${e.team.padEnd(4)}  ${e.player ?? ""}`).join("\n");
+  return [head, m.venue, "", "Events:", events || "  (none)"].join("\n");
+}
+function renderMatchPlain(m) {
+  const head = `match	${m.id}	${m.home.code}	${m.away.code}	${m.score ? `${m.score.home}-${m.score.away}` : "-"}	${m.status}	${m.minute}`;
+  const events = m.events.map((e) => `event	${e.minute}	${e.type}	${e.team}	${e.player ?? "-"}`).join("\n");
+  return events ? `${head}
+${events}
+` : `${head}
+`;
+}
+function matchCmd(p) {
+  p.command("match <id>").description("Show match detail").action(async (id, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        `match/${id}`,
+        10,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.match(id);
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      if (g.json) process.stdout.write(renderJson(data, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderMatchPlain(data));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderMatchPretty(data) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/groups.ts
+init_esm_shims();
+function groupsCmd(p) {
+  p.command("groups [group]").description("Show group standings").action(async (group, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        group ? `standings/group-${group.toUpperCase()}` : "standings/all",
+        3600,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.standings();
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      const filtered = group ? data.filter((x) => x.group === group.toUpperCase()) : data;
+      if (g.json) process.stdout.write(renderJson(filtered, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderStandingsPlain(filtered));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderStandingsPretty(filtered) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/bracket.ts
+init_esm_shims();
+
+// src/render/bracket.ts
+init_esm_shims();
+import chalk2 from "chalk";
+var STAGES = [
+  { key: "r16", label: "R16", slots: 8 },
+  { key: "qf", label: "QF", slots: 4 },
+  { key: "sf", label: "SF", slots: 2 },
+  { key: "final", label: "Final", slots: 1 },
+  { key: "third", label: "3rd", slots: 1 }
+];
+var COL_WIDTH = 18;
+function pad(s, w = COL_WIDTH) {
+  if (s.length >= w) return s.slice(0, w);
+  return s + " ".repeat(w - s.length);
+}
+function nodeLine(n) {
+  if (!n) return pad("TBD vs TBD");
+  const h = n.home?.code ?? "TBD";
+  const a = n.away?.code ?? "TBD";
+  const w = n.winner ? chalk2.bold(n.winner.code) : "";
+  return pad(`${h} vs ${a}${w ? " \u2192 " + w : ""}`);
+}
+function renderBracketAscii(nodes) {
+  const byStage = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (!byStage.has(n.stage)) byStage.set(n.stage, []);
+    byStage.get(n.stage).push(n);
+  }
+  const lines = [];
+  lines.push(STAGES.map((s) => pad(chalk2.bold(s.label))).join(" | "));
+  lines.push(STAGES.map(() => "-".repeat(COL_WIDTH)).join("-+-"));
+  const maxRows = Math.max(...STAGES.map((s) => s.slots));
+  for (let i = 0; i < maxRows; i++) {
+    const row = STAGES.map((s) => {
+      const list = byStage.get(s.key) ?? [];
+      if (i >= s.slots) return pad("");
+      return nodeLine(list[i]);
+    }).join(" | ");
+    lines.push(row);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/bracket.ts
+function bracketCmd(p) {
+  p.command("bracket").description("Show knockout bracket").option("--from <stage>", "r16|qf|sf|final").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        "bracket/all",
+        3600,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.knockoutBracket();
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      const order = ["r16", "qf", "sf", "final", "third"];
+      const fromIdx = g.from ? order.indexOf(g.from) : 0;
+      const filtered = fromIdx <= 0 ? data : data.filter((n) => order.indexOf(n.stage) >= fromIdx);
+      if (g.json) process.stdout.write(renderJson(filtered, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderBracketPlain(filtered));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderBracketAscii(filtered) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/team.ts
+init_esm_shims();
+function teamCmd(p) {
+  p.command("team <code>").description("Show team info, squad, and fixtures").action(async (code, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const upper = code.toUpperCase();
+    try {
+      const reg = await buildRegistry(g);
+      const { data, stale, reason } = await runCached(
+        `team/${upper}`,
+        24 * 3600,
+        async () => {
+          let provider = "";
+          const data2 = await reg.call(async (p2) => {
+            provider = p2.name;
+            return p2.team(upper);
+          });
+          return { data: data2, provider };
+        },
+        g
+      );
+      if (g.json) process.stdout.write(renderJson(data, { stale, reason }) + "\n");
+      else if (g.plain) process.stdout.write(renderTeamPlain(data));
+      else {
+        if (stale) process.stdout.write(`[STALE${reason ? ` ${reason}` : ""}]
+`);
+        process.stdout.write(renderTeamPretty(data) + "\n");
+      }
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/config.ts
+init_esm_shims();
+function configCmd(p) {
+  const root = p.command("config").description("Get/set config values");
+  root.command("set <key> [args...]").description("set favorite <code> | apiKey <provider> <key> | providers <a,b>").action(async (key, args, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      if (key === "favorite") {
+        if (!args[0]) throw new Error("favorite requires a team code");
+        await env.config.set("favoriteTeam", args[0]);
+      } else if (key === "apiKey") {
+        if (!args[0] || !args[1]) throw new Error("apiKey requires <provider> <key>");
+        await env.config.setApiKey(args[0], args[1]);
+      } else if (key === "providers") {
+        if (!args[0]) throw new Error("providers requires a comma-separated list");
+        await env.config.set("providers", args[0].split(","));
+      } else throw new Error(`unknown key: ${key}`);
+    } catch (e) {
+      die(e, g);
+    }
+  });
+  root.command("get <key> [args...]").description("get a config value").action(async (key, args, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      const cfg = await env.config.load();
+      if (key === "favorite") process.stdout.write((cfg.favoriteTeam ?? "") + "\n");
+      else if (key === "apiKey") {
+        if (!args[0]) throw new Error("apiKey requires <provider>");
+        process.stdout.write((await env.config.apiKey(args[0]) ?? "") + "\n");
+      } else if (key === "providers") process.stdout.write(cfg.providers.join(",") + "\n");
+      else throw new Error(`unknown key: ${key}`);
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/commands/cache.ts
+init_esm_shims();
+function cacheCmd(p) {
+  const root = p.command("cache").description("Manage local cache");
+  root.command("clear").description("drop cached files").option("--resource <name>", "only this resource directory").action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    try {
+      await env.cache.clear(opts.resource);
+    } catch (e) {
+      die(e, g);
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("wc26").description("FIFA World Cup 2026 CLI").version("0.1.0").option("--json", "emit JSON to stdout").option("--plain", "tab-separated, no color").option("--no-cache", "skip cache read").option("--provider <name>", "force a specific provider").option("--verbose", "include stack traces");
+fixturesCmd(program);
+nextCmd(program);
+liveCmd(program);
+matchCmd(program);
+groupsCmd(program);
+bracketCmd(program);
+teamCmd(program);
+configCmd(program);
+cacheCmd(program);
+program.parseAsync().catch((e) => {
+  process.stderr.write(String(e) + "\n");
+  process.exit(1);
+});