@claudinho/cli 0.9.2 → 0.9.4

package/dist/index.js

@@ -154,10 +154,11 @@ var ALIASES = [
   ["Burma", "MM"],
   ["Cape Verde", "CV"]
 ];
-var BY_NATION = Object.fromEntries(
-  [...NATIONS, ...ALIASES].map(([name, code]) => [norm(name), code])
+var BY_NATION = Object.assign(
+  /* @__PURE__ */ Object.create(null),
+  Object.fromEntries([...NATIONS, ...ALIASES].map(([name, code]) => [norm(name), code]))
 );
-var BY_CODE = {
+var BY_CODE = Object.assign(/* @__PURE__ */ Object.create(null), {
   MEX: "MX",
   RSA: "ZA",
   KOR: "KR",
@@ -218,7 +219,7 @@ var BY_CODE = {
   HON: "HN",
   COD: "CD",
   MLI: "ML"
-};
+});
 function nationToFlag(nameOrCode) {
   const region = nationToRegion(nameOrCode);
   return region ? flagEmoji(region) : NEUTRAL;
@@ -226,7 +227,7 @@ function nationToFlag(nameOrCode) {
 var INTL_BY_NAME;
 function intlNameMap() {
   if (INTL_BY_NAME) return INTL_BY_NAME;
-  const map = {};
+  const map = /* @__PURE__ */ Object.create(null);
   try {
     const dn = new Intl.DisplayNames(["en"], { type: "region" });
     for (let a = 65; a <= 90; a++) {
@@ -251,11 +252,8 @@ function intlNameMap() {
 }
 function nationToRegion(nameOrCode) {
   if (!nameOrCode) return void 0;
-  const byName = BY_NATION[norm(nameOrCode)];
-  if (byName) return byName;
-  const byCode = BY_CODE[nameOrCode.trim().toUpperCase()];
-  if (byCode) return byCode;
-  return intlNameMap()[norm(nameOrCode)];
+  const str = (v) => typeof v === "string" && v ? v : void 0;
+  return str(BY_NATION[norm(nameOrCode)]) ?? str(BY_CODE[nameOrCode.trim().toUpperCase()]) ?? str(intlNameMap()[norm(nameOrCode)]);
 }
 var EN = {
   "bracket.title": "Knockout bracket",
@@ -275,6 +273,7 @@ var EN = {
   "bracket.slot.loser": "{stage} {n} loser",
   "bracket.slot.tbd": "TBD",
   "live.data": "Live data: {source}",
+  "standings.unavailable": "Live standings unavailable.",
   "share.tryIt": "Try it: {line}",
   "stage.group": "Group {group}",
   "stage.groupStage": "Group stage",
@@ -304,6 +303,7 @@ var ES = {
   "bracket.slot.loser": "Perdedor {stage} {n}",
   "bracket.slot.tbd": "Por definir",
   "live.data": "Datos en vivo: {source}",
+  "standings.unavailable": "Tabla en vivo no disponible.",
   "share.tryIt": "Pru\xE9balo: {line}",
   "stage.group": "Grupo {group}",
   "stage.groupStage": "Fase de grupos",
@@ -333,6 +333,7 @@ var PT = {
   "bracket.slot.loser": "Perdedor {stage} {n}",
   "bracket.slot.tbd": "A definir",
   "live.data": "Dados ao vivo: {source}",
+  "standings.unavailable": "Classifica\xE7\xE3o ao vivo indispon\xEDvel.",
   "share.tryIt": "Experimente: {line}",
   "stage.group": "Grupo {group}",
   "stage.groupStage": "Fase de grupos",
@@ -362,6 +363,7 @@ var FR = {
   "bracket.slot.loser": "Perdant {stage} {n}",
   "bracket.slot.tbd": "\xC0 d\xE9finir",
   "live.data": "Donn\xE9es en direct : {source}",
+  "standings.unavailable": "Classement en direct indisponible.",
   "share.tryIt": "Essayez : {line}",
   "stage.group": "Groupe {group}",
   "stage.groupStage": "Phase de groupes",
@@ -446,7 +448,14 @@ function safeLocale(locale) {
     return "en";
   }
 }
+function parsedDate(iso) {
+  const t2 = Date.parse(iso);
+  return Number.isFinite(t2) ? new Date(t2) : void 0;
+}
+var UNKNOWN_TIME = "\u2014";
 function formatKickoff(iso, opts = {}) {
+  const when = parsedDate(iso);
+  if (!when) return UNKNOWN_TIME;
   const tz = resolveTz(opts.tz);
   const locale = safeLocale(opts.locale);
   return new Intl.DateTimeFormat(locale, {
@@ -456,18 +465,22 @@ function formatKickoff(iso, opts = {}) {
     minute: "2-digit",
     hour12: false,
     timeZone: tz
-  }).format(new Date(iso));
+  }).format(when);
 }
 function formatDate(iso, opts = {}) {
+  const when = parsedDate(iso);
+  if (!when) return UNKNOWN_TIME;
   const tz = resolveTz(opts.tz);
   const locale = safeLocale(opts.locale);
   return new Intl.DateTimeFormat(locale, {
     month: "short",
     day: "numeric",
     timeZone: tz
-  }).format(new Date(iso));
+  }).format(when);
 }
 function formatTime(iso, opts = {}) {
+  const when = parsedDate(iso);
+  if (!when) return UNKNOWN_TIME;
   const tz = resolveTz(opts.tz);
   const locale = safeLocale(opts.locale);
   return new Intl.DateTimeFormat(locale, {
@@ -475,10 +488,12 @@ function formatTime(iso, opts = {}) {
     minute: "2-digit",
     hour12: false,
     timeZone: tz
-  }).format(new Date(iso));
+  }).format(when);
 }
 function countdown(iso, from = /* @__PURE__ */ new Date()) {
-  const ms = new Date(iso).getTime() - from.getTime();
+  const when = parsedDate(iso);
+  if (!when) return UNKNOWN_TIME;
+  const ms = when.getTime() - from.getTime();
   if (ms <= 0) return "now";
   const totalMin = Math.floor(ms / 6e4);
   const days = Math.floor(totalMin / 1440);
@@ -489,71 +504,56 @@ function countdown(iso, from = /* @__PURE__ */ new Date()) {
   return `${mins}m`;
 }
 function localDate(iso, tz) {
+  const when = parsedDate(iso);
+  if (!when) return "";
   const zone = resolveTz(tz);
   return new Intl.DateTimeFormat("en-CA", {
     year: "numeric",
     month: "2-digit",
     day: "2-digit",
     timeZone: zone
-  }).format(new Date(iso));
+  }).format(when);
 }
 function shiftUtcDate(dateISO, days) {
   const [y, m, d] = dateISO.slice(0, 10).split("-").map(Number);
   return new Date(Date.UTC(y ?? 1970, (m ?? 1) - 1, (d ?? 1) + days)).toISOString().slice(0, 10);
 }
-var FEED_TEXT_MAX = 100;
-function sanitizeFeedText(value, max = FEED_TEXT_MAX) {
-  let out2 = "";
-  let count = 0;
-  for (const ch of String(value)) {
-    const cp = ch.codePointAt(0) ?? 0;
-    const isWhitespaceControl = cp === 9 || cp === 10 || cp === 13;
-    if ((cp <= 31 || cp >= 127 && cp <= 159) && !isWhitespaceControl) continue;
-    if (count >= max) break;
-    out2 += isWhitespaceControl ? " " : ch;
-    count++;
-  }
-  return out2;
-}
-function sanitizeTeam(t2) {
-  return {
-    ...t2 ?? {},
-    code: sanitizeFeedText(t2?.code ?? ""),
-    name: sanitizeFeedText(t2?.name ?? ""),
-    flag: sanitizeFeedText(t2?.flag ?? "")
-  };
-}
-function finiteOrUndefined(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function sanitizeScorePair(v) {
-  const home = finiteOrUndefined(v?.home);
-  const away = finiteOrUndefined(v?.away);
-  return home !== void 0 && away !== void 0 ? { home, away } : void 0;
-}
-function sanitizeMatchStrings(m) {
-  const score = sanitizeScorePair(m.score);
-  return {
-    ...m,
-    venue: sanitizeFeedText(m.venue ?? ""),
-    city: m.city == null ? m.city : sanitizeFeedText(m.city),
-    country: m.country == null ? m.country : sanitizeFeedText(m.country),
-    home: sanitizeTeam(m.home),
-    away: sanitizeTeam(m.away),
-    score,
-    shootout: score ? sanitizeScorePair(m.shootout) : void 0,
-    minute: finiteOrUndefined(m.minute)
-  };
-}
 var segmenter = new Intl.Segmenter();
 var WIDE_CLUSTER = new RegExp("^(?:\\p{Regional_Indicator}|\\p{Extended_Pictographic})", "u");
+var WIDE_BASE = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏ꥠ-꥿가-힣豈-﫿︐-︙︰-﹯＀-｠￠-￦\u{20000}-\u{2FFFD}\u{30000}-\u{3FFFD}]/u;
+var KEYCAP = /\u{20E3}/u;
+var ZERO_WIDTH_BASE = /[\p{Mn}\p{Me}\p{Cf}\p{Cc}]/u;
+function clusterWidth(segment) {
+  if (WIDE_CLUSTER.test(segment) || KEYCAP.test(segment)) return 2;
+  const first = segment.codePointAt(0);
+  if (first === void 0) return 0;
+  const base = String.fromCodePoint(first);
+  if (ZERO_WIDTH_BASE.test(base)) return 0;
+  return WIDE_BASE.test(base) ? 2 : 1;
+}
 function displayWidth(s) {
   let w = 0;
   for (const { segment } of segmenter.segment(s)) {
-    w += WIDE_CLUSTER.test(segment) ? 2 : 1;
+    w += clusterWidth(segment);
   }
   return w;
 }
+function truncateVisible(s, maxColumns, marker = "\u2026") {
+  if (displayWidth(s) <= maxColumns) return s;
+  const budget = Math.max(0, maxColumns - displayWidth(marker));
+  let out2 = "";
+  let w = 0;
+  for (const { segment } of segmenter.segment(s)) {
+    const cw = clusterWidth(segment);
+    if (w + cw > budget) break;
+    out2 += segment;
+    w += cw;
+  }
+  return out2 + marker;
+}
+function* graphemes(s) {
+  for (const { segment } of segmenter.segment(s)) yield segment;
+}
 function padVisible(s, width) {
   const w = displayWidth(s);
   return w >= width ? s : s + " ".repeat(width - w);
@@ -2859,6 +2859,14 @@ var KNOCKOUT_EXTRA_TIME_MS = 60 * 6e4;
 function liveWindowMsFor(m) {
   return m.stage === "GROUP" || m.stage === "FRIENDLY" ? LIVE_WINDOW_MS : LIVE_WINDOW_MS + KNOCKOUT_EXTRA_TIME_MS;
 }
+function isTournamentWindowOver(now = Date.now(), fixtures = SCHEDULE) {
+  if (fixtures.length === 0) return false;
+  return fixtures.every((m) => {
+    const k = Date.parse(m.kickoff);
+    if (Number.isNaN(k)) return false;
+    return now > k + liveWindowMsFor(m);
+  });
+}
 function fixturesInLiveWindow(now = Date.now(), fixtures = SCHEDULE) {
   return fixtures.filter((m) => {
     const k = Date.parse(m.kickoff);
@@ -2945,47 +2953,285 @@ function rosterAtZero(matches) {
   }
   return [...teams.values()].sort((a, b) => a.name.localeCompare(b.name)).map(blankRow);
 }
-var ESPN_SOCCER = "https://site.api.espn.com/apis/site/v2/sports/soccer";
-var DEFAULT_COMPETITION = "fifa.world";
-var DEFAULT_BASE = `${ESPN_SOCCER}/${DEFAULT_COMPETITION}`;
-var USER_AGENT = `claudinho/${"0.9.2"} (+https://github.com/arturogarrido/claudinho)`;
-var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-function competitionBase(slug) {
-  return `${ESPN_SOCCER}/${slug}`;
+function takeBounded(value, max) {
+  if (!Array.isArray(value)) return [];
+  return value.length > max ? value.slice(0, max) : value;
 }
-var DEFAULT_TIMEOUT_MS = 6e3;
-var STANDINGS_SHARE_MS = 3e4;
-var ProviderError = class extends Error {
-  kind;
-  status;
-  constructor(message, kind, status) {
-    super(message);
-    this.name = "ProviderError";
-    this.kind = kind;
-    this.status = status;
+var valid = (value) => ({ kind: "valid", value });
+var definitiveNone = (reason) => ({
+  kind: "definitive-none",
+  reason
+});
+var malformed = (reason) => ({ kind: "malformed", reason });
+var ambiguous = (reason) => ({ kind: "ambiguous", reason });
+var unresolved = (reason) => ({ kind: "unresolved", reason });
+function parsedValue(r) {
+  return r.kind === "valid" ? r.value : void 0;
+}
+function isCacheable(r) {
+  return r.kind === "valid" || r.kind === "definitive-none" || r.kind === "ambiguous";
+}
+var FORBIDDEN_IN_LABEL = new RegExp("[\\p{Cc}\\p{Cf}\\p{Zl}\\p{Zp}\\p{Cs}\\p{Co}\\p{Cn}]|\\p{Default_Ignorable_Code_Point}", "u");
+var EMOJI_IN_LABEL = new RegExp("\\p{Extended_Pictographic}|\\p{Regional_Indicator}|\\p{Emoji_Modifier}|\\u{20E3}", "u");
+var MAX_LABEL_INPUT_UNITS = 4096;
+var MAX_LABEL_COLUMNS = 100;
+function humanLabel(value, maxColumns = MAX_LABEL_COLUMNS) {
+  if (typeof value !== "string" || value === "") return "";
+  const capped = value.length > MAX_LABEL_INPUT_UNITS ? value.slice(0, MAX_LABEL_INPUT_UNITS) : value;
+  return visible(runToFixedPoint(capped, maxColumns));
+}
+function visible(label) {
+  return label !== "" && displayWidth(label) === 0 ? "" : label;
+}
+function runToFixedPoint(capped, maxColumns) {
+  const first = sealLabelOnce(capped, maxColumns);
+  if (!lastPassDropped) return first;
+  let out2 = first;
+  for (let pass = 0; pass < 3; pass++) {
+    const again = sealLabelOnce(out2, maxColumns);
+    if (again === out2) return out2;
+    out2 = again;
+  }
+  return sealLabelOnce(out2, maxColumns) === out2 ? out2 : "";
+}
+var lastPassDropped = false;
+function sealLabelOnce(value, maxColumns) {
+  lastPassDropped = false;
+  let normalized;
+  try {
+    normalized = value.normalize("NFC");
+  } catch {
+    return "";
   }
-  /** 429/403 — the upstream is refusing us; retrying at the live cadence makes it worse. */
-  get throttled() {
-    return this.kind === "http" && (this.status === 429 || this.status === 403);
+  const maxCodePoints = Math.max(16, maxColumns * 4);
+  let out2 = "";
+  let width = 0;
+  let points = 0;
+  for (const cluster of graphemes(normalized)) {
+    if ([...cluster].length > 8) {
+      lastPassDropped = true;
+      continue;
+    }
+    if (EMOJI_IN_LABEL.test(cluster)) {
+      lastPassDropped = true;
+      continue;
+    }
+    let piece = "";
+    for (const ch of cluster) {
+      const cp = ch.codePointAt(0) ?? 0;
+      if (cp === 9 || cp === 10 || cp === 13) {
+        piece += " ";
+        continue;
+      }
+      if (FORBIDDEN_IN_LABEL.test(ch)) {
+        lastPassDropped = true;
+        continue;
+      }
+      piece += ch;
+    }
+    if (!piece) {
+      lastPassDropped = true;
+      continue;
+    }
+    const w = displayWidth(piece);
+    const cps = [...piece].length;
+    if (width + w > maxColumns || points + cps > maxCodePoints) break;
+    out2 += piece;
+    width += w;
+    points += cps;
   }
-};
+  try {
+    return out2.normalize("NFC").trim();
+  } catch {
+    return out2.trim();
+  }
+}
+function opaqueId(value, grammar) {
+  return typeof value === "string" && grammar.test(value) ? value : void 0;
+}
+var ESPN_ID = /^[0-9]{1,20}$/;
+var ISO_INSTANT = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:[Zz]|[+-]\d{2}(?::?\d{2})?)$/;
+var ISO_CANONICAL = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function calendarValid(iso) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+  if (!m) return false;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  if (month < 1 || month > 12 || day < 1) return false;
+  return day <= new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function canonicalTimestamp(value) {
+  if (typeof value !== "string" || !ISO_INSTANT.test(value)) return void 0;
+  if (!calendarValid(value)) return void 0;
+  const t2 = Date.parse(value);
+  if (!Number.isFinite(t2)) return void 0;
+  const out2 = new Date(t2).toISOString();
+  return ISO_CANONICAL.test(out2) ? out2 : void 0;
+}
+function productFlag(nameOrCode) {
+  return nationToFlag(nameOrCode);
+}
+function count(value, max) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= max ? value : void 0;
+}
+function quantity(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function probability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : void 0;
+}
+function member(value, allowed) {
+  return typeof value === "string" && allowed.has(value) ? value : void 0;
+}
+function flag(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+var MAX_GOALS = 99;
+var MAX_MINUTE = 200;
+var MAX_MATCH_EVENTS = 128;
+var TEAM_CODE_COLUMNS = 8;
+var STAGES = /* @__PURE__ */ new Set(["GROUP", "R32", "R16", "QF", "SF", "3P", "F", "FRIENDLY"]);
+var STATUSES = /* @__PURE__ */ new Set(["SCHEDULED", "LIVE", "HT", "FT", "POSTPONED", "CANCELLED"]);
+var EVENT_TYPES = /* @__PURE__ */ new Set(["GOAL", "OWN_GOAL", "PEN", "YELLOW", "RED", "SUB"]);
+function teamCode(raw, fallbackName) {
+  const upper = typeof raw === "string" ? raw.toUpperCase() : raw;
+  const stated = humanLabel(upper, TEAM_CODE_COLUMNS);
+  if (stated) return stated;
+  return humanLabel([...fallbackName].slice(0, 3).join("").toUpperCase(), TEAM_CODE_COLUMNS);
+}
+function sealTeam(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const t2 = raw;
+  const name = humanLabel(t2.name);
+  if (!name) return void 0;
+  const code = teamCode(t2.code, name);
+  return { code, name, flag: productFlag(name) };
+}
+function sealScorePair(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const v = raw;
+  const home = count(v.home, MAX_GOALS);
+  const away = count(v.away, MAX_GOALS);
+  return home !== void 0 && away !== void 0 ? { home, away } : void 0;
+}
+function sealEvent(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const e = raw;
+  const type = member(e.type, EVENT_TYPES);
+  if (!type) return void 0;
+  const minute = count(e.minute, MAX_MINUTE);
+  if (minute === void 0) return void 0;
+  const out2 = { type, minute, teamCode: humanLabel(e.teamCode, TEAM_CODE_COLUMNS) };
+  const player = humanLabel(e.player);
+  if (player) out2.player = player;
+  return out2;
+}
+function sealMatch(parts, opts = {}) {
+  if (!parts || typeof parts !== "object") return malformed("match is not an object");
+  const id = opaqueId(parts.id, ESPN_ID);
+  if (!id) return malformed("match id is absent or not an identifier");
+  const kickoff = canonicalTimestamp(parts.kickoff);
+  if (!kickoff) return malformed("match kickoff is absent or not one instant");
+  const stage = member(parts.stage, STAGES);
+  if (!stage) return malformed("match stage is not a known stage");
+  const status = member(parts.status, STATUSES);
+  if (!status) return malformed("match status is not a known status");
+  const home = sealTeam(parts.home);
+  const away = sealTeam(parts.away);
+  if (!home || !away) return malformed("match does not name both teams");
+  if (home.code === away.code && home.name === away.name) {
+    return definitiveNone("both competitors are the same team");
+  }
+  const group = humanLabel(parts.group) || void 0;
+  const city = humanLabel(parts.city) || void 0;
+  const country = humanLabel(parts.country) || void 0;
+  const score = status === "SCHEDULED" ? void 0 : sealScorePair(parts.score);
+  if ((status === "LIVE" || status === "HT" || status === "FT") && !score) {
+    return malformed("match claims an unreadable score");
+  }
+  const finished = status === "FT";
+  const canGoToPenalties = stage !== "GROUP";
+  const shootoutPresent = parts.shootout !== void 0 && parts.shootout !== null;
+  const parsedShootout = shootoutPresent ? sealScorePair(parts.shootout) : void 0;
+  const shootoutStatus = status === "LIVE" || status === "FT";
+  const shootout = parsedShootout && score && canGoToPenalties && shootoutStatus && !(finished && parsedShootout.home === parsedShootout.away) ? parsedShootout : void 0;
+  const claimedWinner = teamCode(parts.winnerCode, "");
+  const claimedSide = claimedWinner === home.code ? "home" : claimedWinner === away.code ? "away" : void 0;
+  let winnerCode;
+  const unusableShootoutCouldDecide = canGoToPenalties && shootoutPresent && !shootout;
+  if (claimedSide && score && finished && !unusableShootoutCouldDecide) {
+    const level = score.home === score.away;
+    const decider = shootout ?? score;
+    if (decider && decider.home !== decider.away) {
+      if ((decider.home > decider.away ? "home" : "away") === claimedSide) winnerCode = claimedWinner;
+    } else if (level && !shootoutPresent && canGoToPenalties) {
+      winnerCode = claimedWinner;
+    }
+  }
+  const events = opts.events === false ? [] : takeBounded(parts.events, MAX_MATCH_EVENTS).map(sealEvent).filter((e) => !!e);
+  const out2 = { id, stage };
+  if (group) out2.group = group;
+  out2.kickoff = kickoff;
+  out2.venue = humanLabel(parts.venue);
+  if (city) out2.city = city;
+  if (country) out2.country = country;
+  out2.home = home;
+  out2.away = away;
+  if (score) out2.score = score;
+  if (shootout) out2.shootout = shootout;
+  const minute = count(parts.minute, MAX_MINUTE);
+  if (minute !== void 0) out2.minute = minute;
+  out2.status = status;
+  if (events.length) out2.events = events;
+  if (winnerCode) out2.winnerCode = winnerCode;
+  out2.updatedAt = canonicalTimestamp(parts.updatedAt) ?? "";
+  return valid(out2);
+}
+function parseCachedMatch(raw, opts = {}) {
+  if (!raw || typeof raw !== "object") return definitiveNone("cache entry is not an object");
+  return sealMatch(raw, opts);
+}
+var MAX_EVENTS = 300;
+var MAX_GROUPS = 16;
+var MAX_GROUP_ROWS = 32;
+var STAGES2 = /* @__PURE__ */ new Set(["GROUP", "R32", "R16", "QF", "SF", "3P", "F", "FRIENDLY"]);
+function teamNames(t2) {
+  return [t2?.displayName, t2?.name, t2?.location, t2?.shortDisplayName, t2?.abbreviation].map((v) => humanLabel(v)).filter((v) => v !== "");
+}
+function toParticipant(raw) {
+  if (!raw || typeof raw !== "object") return malformed("competitor is not an object");
+  const names = teamNames(raw.team);
+  if (names.length === 0) return malformed("competitor names no team");
+  const name = names[0];
+  const code = teamCode(raw.team?.abbreviation, name);
+  const team = { code, name, flag: productFlag(name) };
+  const providerId = opaqueId(raw.team?.id, ESPN_ID);
+  const known = productFlag(name) !== nationToFlag("");
+  return valid(
+    providerId && known ? { kind: "team", providerId, team } : { kind: "slot", team }
+  );
+}
 function mapStatus(st) {
-  const name = (st?.type?.name ?? "").toUpperCase();
-  const state = st?.type?.state ?? "";
+  const type = st?.type;
+  const name = typeof type?.name === "string" ? type.name.toUpperCase() : "";
+  const state = typeof type?.state === "string" ? type.state : "";
   if (name.includes("HALFTIME")) return "HT";
   if (name.includes("POSTPONED")) return "POSTPONED";
   if (name.includes("CANCEL")) return "CANCELLED";
   if (state === "pre") return "SCHEDULED";
   if (state === "post") return "FT";
   if (state === "in") return "LIVE";
-  return "SCHEDULED";
+  return void 0;
 }
 function parseMinute(st) {
-  if (st?.type?.state !== "in") return void 0;
-  const dc = st.displayClock?.match(/(\d+)/);
-  if (dc) return parseInt(dc[1], 10);
-  if (typeof st.clock === "number" && st.clock > 0) {
-    return Math.floor(st.clock / 60) || void 0;
+  const s = st;
+  if (s?.type?.state !== "in") return void 0;
+  const dc = typeof s.displayClock === "string" ? s.displayClock.match(/(\d+)/) : null;
+  if (dc) return count(Number.parseInt(dc[1], 10), MAX_MINUTE);
+  if (typeof s.clock === "number" && s.clock > 0) {
+    const n = Math.floor(s.clock / 60);
+    return n > 0 ? count(n, MAX_MINUTE) : void 0;
   }
   return void 0;
 }
@@ -2999,58 +3245,74 @@ var SLUG_TO_STAGE = {
   final: "F"
 };
 function stageFromSlug(slug) {
-  if (slug && SLUG_TO_STAGE[slug]) return SLUG_TO_STAGE[slug];
-  if (!slug) return "GROUP";
+  if (slug == null || slug === "") return "GROUP";
+  if (typeof slug === "string" && Object.hasOwn(SLUG_TO_STAGE, slug)) {
+    const mapped = SLUG_TO_STAGE[slug];
+    if (mapped) return mapped;
+  }
   return "FRIENDLY";
 }
-function toInt(s) {
-  if (s == null || s === "") return void 0;
-  const n = parseInt(String(s), 10);
-  return Number.isFinite(n) ? n : void 0;
-}
-function toTeam(t2) {
-  const name = sanitizeFeedText(
-    t2?.displayName ?? t2?.name ?? t2?.location ?? t2?.shortDisplayName ?? "TBD"
-  );
-  const code = sanitizeFeedText(t2?.abbreviation ?? name.slice(0, 3)).toUpperCase();
-  return {
-    code,
-    name,
-    flag: nationToFlag(sanitizeFeedText(t2?.displayName ?? t2?.abbreviation ?? name))
-  };
-}
-function mapEspnEvent(ev, ctx = {}) {
-  const comp = ev.competitions?.[0];
-  const competitors = comp?.competitors ?? [];
-  const homeC = competitors.find((c) => c.homeAway === "home") ?? competitors[0];
-  const awayC = competitors.find((c) => c.homeAway === "away") ?? competitors[1];
+function toGoals(v) {
+  if (typeof v === "number") return count(v, MAX_GOALS);
+  if (typeof v !== "string" || v.trim() === "") return void 0;
+  return /^-?\d{1,9}$/.test(v.trim()) ? count(Number(v.trim()), MAX_GOALS) : void 0;
+}
+function parseEspnEvent(raw, ctx = {}) {
+  if (!raw || typeof raw !== "object") return malformed("event is not an object");
+  const ev = raw;
+  const id = opaqueId(ev.id, ESPN_ID);
+  if (!id) return malformed("event id is absent or not an identifier");
+  const kickoff = canonicalTimestamp(ev.date);
+  if (!kickoff) return malformed("event date is absent or not one instant");
+  const comp = Array.isArray(ev.competitions) ? ev.competitions[0] : void 0;
+  const rawCompetitors = takeBounded(comp?.competitors, 4);
+  if (rawCompetitors.length !== 2) {
+    return definitiveNone(`expected 2 competitors, found ${rawCompetitors.length}`);
+  }
+  const homeRaw = rawCompetitors.find((c) => c?.homeAway === "home");
+  const awayRaw = rawCompetitors.find((c) => c?.homeAway === "away");
+  if (!homeRaw || !awayRaw) return definitiveNone("competitors do not state home and away");
+  const homeP = toParticipant(homeRaw);
+  const awayP = toParticipant(awayRaw);
+  if (homeP.kind !== "valid") return homeP;
+  if (awayP.kind !== "valid") return awayP;
+  const h = homeP.value;
+  const a = awayP.value;
+  if (h.kind === "team" && a.kind === "team" && h.providerId === a.providerId) {
+    return definitiveNone("both competitors are the same team");
+  }
+  const home = homeP.value.team;
+  const away = awayP.value.team;
   const status = mapStatus(ev.status ?? comp?.status);
-  const stage = stageFromSlug(ev.season?.slug);
-  const home = toTeam(homeC?.team);
-  const away = toTeam(awayC?.team);
+  if (!status) return malformed("event status is not a status we recognize");
+  const stage = member(stageFromSlug(ev.season?.slug), STAGES2) ?? "FRIENDLY";
   let group;
   if (stage === "GROUP" && ctx.groupByTeam) {
     group = ctx.groupByTeam[home.code] ?? ctx.groupByTeam[away.code];
   }
-  const hs = toInt(homeC?.score);
-  const as = toInt(awayC?.score);
-  const hasScore = status !== "SCHEDULED" && hs !== void 0 && as !== void 0;
+  const hs = toGoals(homeRaw.score);
+  const as = toGoals(awayRaw.score);
+  const scoreExpected = status === "LIVE" || status === "HT" || status === "FT";
+  const hasScore = scoreExpected && hs !== void 0 && as !== void 0;
+  if (scoreExpected && !hasScore) return malformed("event score is absent or unreadable");
+  const hShoot = toGoals(homeRaw.shootoutScore);
+  const aShoot = toGoals(awayRaw.shootoutScore);
+  const shootoutPresent = homeRaw.shootoutScore !== void 0 || awayRaw.shootoutScore !== void 0;
+  const shootout = shootoutPresent ? { home: hShoot, away: aShoot } : void 0;
   let winnerCode;
   if (isFinished(status)) {
-    if (homeC?.winner) winnerCode = home.code;
-    else if (awayC?.winner) winnerCode = away.code;
+    const winners = [homeRaw, awayRaw].filter((c) => flag(c.winner) === true);
+    if (winners.length === 1) winnerCode = winners[0] === homeRaw ? home.code : away.code;
   }
-  const hShoot = toInt(homeC?.shootoutScore);
-  const aShoot = toInt(awayC?.shootoutScore);
-  const shootout = hasScore && hShoot !== void 0 && aShoot !== void 0 ? { home: hShoot, away: aShoot } : void 0;
-  return {
-    id: ev.id,
+  const venue = comp?.venue;
+  return sealMatch({
+    id,
     stage,
     group,
-    kickoff: ev.date,
-    venue: sanitizeFeedText(comp?.venue?.fullName ?? ""),
-    city: sanitizeFeedText(comp?.venue?.address?.city ?? "") || void 0,
-    country: sanitizeFeedText(comp?.venue?.address?.country ?? "") || void 0,
+    kickoff,
+    venue: venue?.fullName,
+    city: venue?.address?.city,
+    country: venue?.address?.country,
     home,
     away,
     score: hasScore ? { home: hs, away: as } : void 0,
@@ -3058,57 +3320,221 @@ function mapEspnEvent(ev, ctx = {}) {
     minute: parseMinute(ev.status ?? comp?.status),
     status,
     winnerCode,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    events: ev.events
+  });
 }
-function toEspnDate(d) {
-  return d.replace(/\D/g, "").slice(0, 8);
+function parseEspnEvents(raw, ctx = {}) {
+  const all = raw?.events;
+  const readable = Array.isArray(all);
+  const total = readable ? all.length : 0;
+  const considered = takeBounded(all, MAX_EVENTS);
+  const items = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  let complete = readable && considered.length === total;
+  for (const event of considered) {
+    const parsed = parseEspnEvent(event, ctx);
+    if (parsed.kind !== "valid") {
+      if (parsed.kind !== "definitive-none") complete = false;
+      continue;
+    }
+    if (seenIds.has(parsed.value.id)) {
+      complete = false;
+      continue;
+    }
+    seenIds.add(parsed.value.id);
+    items.push(parsed.value);
+  }
+  return {
+    items,
+    total,
+    shown: items.length,
+    truncated: total > considered.length,
+    // Some record was unreadable, or the window did not cover the payload, or
+    // the envelope itself was not a list — none of those is a complete account
+    // of what the provider sent.
+    complete
+  };
 }
-function statVal(stats, name) {
-  const v = stats?.find((s) => s.name === name)?.value;
-  return typeof v === "number" && Number.isFinite(v) ? Math.round(v) : 0;
+function statVal(stats, name, signed = false) {
+  if (!Array.isArray(stats) || stats.length > 64) return void 0;
+  const matches = takeBounded(stats, 64).filter(
+    (s) => s?.name === name
+  );
+  if (matches.length !== 1) return void 0;
+  const v = matches[0]?.value;
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) return void 0;
+  const limit = 1e3;
+  return v > limit || v < (signed ? -limit : 0) ? void 0 : v;
+}
+function optionalStatVal(stats, name) {
+  if (!Array.isArray(stats) || stats.length > 64) return void 0;
+  const matches = takeBounded(stats, 64).filter(
+    (s) => s?.name === name
+  );
+  if (matches.length === 0) return 0;
+  if (matches.length !== 1) return void 0;
+  const v = matches[0]?.value;
+  return typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 1e3 ? v : void 0;
 }
 function entryToRow(e) {
-  return {
-    team: toTeam(e.team),
-    played: statVal(e.stats, "gamesPlayed"),
-    won: statVal(e.stats, "wins"),
-    drawn: statVal(e.stats, "ties"),
-    lost: statVal(e.stats, "losses"),
-    goalsFor: statVal(e.stats, "pointsFor"),
-    goalsAgainst: statVal(e.stats, "pointsAgainst"),
-    goalDiff: statVal(e.stats, "pointDifferential"),
-    points: statVal(e.stats, "points")
-  };
+  const names = teamNames(e?.team);
+  if (names.length === 0) return definitiveNone("standings entry names no team");
+  const name = names[0];
+  const code = teamCode(e?.team?.abbreviation, name);
+  const played = statVal(e.stats, "gamesPlayed");
+  const won = statVal(e.stats, "wins");
+  const drawn = statVal(e.stats, "ties");
+  const lost = statVal(e.stats, "losses");
+  const goalsFor = statVal(e.stats, "pointsFor");
+  const goalsAgainst = statVal(e.stats, "pointsAgainst");
+  const goalDiff = statVal(e.stats, "pointDifferential", true);
+  const points = statVal(e.stats, "points", true);
+  const deductions = optionalStatVal(e.stats, "deductions");
+  const providerRank = statVal(e.stats, "rank");
+  if (played === void 0 || won === void 0 || drawn === void 0 || lost === void 0 || goalsFor === void 0 || goalsAgainst === void 0 || goalDiff === void 0 || points === void 0 || deductions === void 0 || providerRank === void 0 || providerRank < 1) {
+    return malformed("standings entry has missing or invalid statistics");
+  }
+  if (played !== won + drawn + lost) {
+    return malformed("standings entry games do not add up");
+  }
+  if (goalDiff !== goalsFor - goalsAgainst) {
+    return malformed("standings entry goal difference does not add up");
+  }
+  if (points !== won * 3 + drawn - deductions) {
+    return malformed("standings entry points do not add up");
+  }
+  return valid({
+    team: { code, name, flag: productFlag(name) },
+    played,
+    won,
+    drawn,
+    lost,
+    goalsFor,
+    goalsAgainst,
+    goalDiff,
+    points,
+    providerId: opaqueId(e?.team?.id, ESPN_ID),
+    providerRank
+  });
 }
-function parseStandings(data) {
+function parseEspnStandings(raw) {
+  const rawChildren = raw?.children;
+  const readable = Array.isArray(rawChildren);
+  const rawCount = readable ? rawChildren.length : 0;
+  const children = takeBounded(rawChildren, MAX_GROUPS * 4);
+  const sawAllChildren = rawCount === children.length;
+  let rowsTruncated = false;
+  let complete = readable && sawAllChildren;
   const out2 = [];
-  for (const child of data.children ?? []) {
-    const letter = (child.name ?? child.abbreviation ?? "").match(/Group\s+([A-L])/i)?.[1]?.toUpperCase();
+  const seenGroups = /* @__PURE__ */ new Set();
+  const seenProviderIds = /* @__PURE__ */ new Set();
+  for (const child of children) {
+    const label = humanLabel(child?.name ?? child?.abbreviation);
+    const letter = label.match(/Group\s+([A-L])/i)?.[1]?.toUpperCase();
     if (!letter) continue;
-    const ranked = (child.standings?.entries ?? []).map((e) => ({
-      row: entryToRow(e),
-      rank: statVal(e.stats, "rank")
-    }));
+    if (seenGroups.has(letter)) {
+      complete = false;
+      continue;
+    }
+    seenGroups.add(letter);
+    const rawEntries = child?.standings?.entries;
+    if (!Array.isArray(rawEntries) || rawEntries.length === 0) {
+      complete = false;
+      continue;
+    }
+    if (rawEntries.length > MAX_GROUP_ROWS) {
+      rowsTruncated = true;
+      complete = false;
+    }
+    const entries = takeBounded(rawEntries, MAX_GROUP_ROWS);
+    const seenTeams = /* @__PURE__ */ new Set();
+    const seenRanks = /* @__PURE__ */ new Set();
+    const ranked = [];
+    for (const e of entries) {
+      const r = entryToRow(e);
+      if (r.kind !== "valid") {
+        if (r.kind !== "definitive-none") complete = false;
+        continue;
+      }
+      const key = r.value.providerId ?? r.value.team.code;
+      if (seenTeams.has(key) || seenRanks.has(r.value.providerRank) || r.value.providerId !== void 0 && seenProviderIds.has(r.value.providerId)) {
+        complete = false;
+        continue;
+      }
+      seenTeams.add(key);
+      seenRanks.add(r.value.providerRank);
+      if (r.value.providerId !== void 0) seenProviderIds.add(r.value.providerId);
+      const { providerId: _dropId, providerRank: rank, ...row } = r.value;
+      ranked.push({ row, rank });
+    }
     ranked.sort((a, b) => {
       if (a.rank && b.rank && a.rank !== b.rank) return a.rank - b.rank;
-      const r = a.row;
-      const s = b.row;
-      return s.points - r.points || s.goalDiff - r.goalDiff || s.goalsFor - r.goalsFor || r.team.code.localeCompare(s.team.code);
+      if (b.row.points !== a.row.points) return b.row.points - a.row.points;
+      if (b.row.goalDiff !== a.row.goalDiff) return b.row.goalDiff - a.row.goalDiff;
+      return b.row.goalsFor - a.row.goalsFor;
     });
+    if (ranked.length === 0) {
+      complete = false;
+      continue;
+    }
     out2.push({ group: letter, rows: ranked.map((x) => x.row) });
   }
-  out2.sort((a, b) => a.group.localeCompare(b.group));
-  return out2;
+  return {
+    items: out2,
+    total: seenGroups.size,
+    shown: out2.length,
+    // We stopped early if the child list or any single group's rows were cut.
+    truncated: !sawAllChildren || rowsTruncated,
+    complete: complete && !rowsTruncated
+  };
+}
+var ESPN_SOCCER = "https://site.api.espn.com/apis/site/v2/sports/soccer";
+var DEFAULT_COMPETITION = "fifa.world";
+var DEFAULT_BASE = `${ESPN_SOCCER}/${DEFAULT_COMPETITION}`;
+var USER_AGENT = `claudinho/${"0.9.4"} (+https://github.com/arturogarrido/claudinho)`;
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+function competitionBase(slug) {
+  return `${ESPN_SOCCER}/${slug}`;
+}
+var DEFAULT_TIMEOUT_MS = 6e3;
+var STANDINGS_SHARE_MS = 3e4;
+var ProviderError = class extends Error {
+  kind;
+  status;
+  constructor(message, kind, status) {
+    super(message);
+    this.name = "ProviderError";
+    this.kind = kind;
+    this.status = status;
+  }
+  /** 429/403 — the upstream is refusing us; retrying at the live cadence makes it worse. */
+  get throttled() {
+    return this.kind === "http" && (this.status === 429 || this.status === 403);
+  }
+};
+function toEspnDate(d) {
+  return d.replace(/\D/g, "").slice(0, 8);
+}
+function usableProviderItems(kind, parsed, hasUsableRecord = parsed.items.length > 0) {
+  if (!hasUsableRecord && (!parsed.complete || parsed.total > 0)) {
+    throw new ProviderError(`ESPN ${kind} payload had no readable records`, "parse");
+  }
+  return [...parsed.items];
 }
 var EspnAdapter = class {
   constructor(opts = {}) {
     this.opts = opts;
+    const expected = opts.expectedStandingsGroups ?? (opts.baseUrl === void 0 ? groups() : void 0);
+    this.expectedStandingsGroups = expected ? [...expected] : void 0;
+    this.standingsFallbackGroups = opts.baseUrl === void 0 && expected ? [...expected] : void 0;
   }
   opts;
   name = "espn";
   capabilities = { push: false, latencyHintSec: 45 };
-  /** Cached team-code -> group-letter map (built lazily from standings). */
+  expectedStandingsGroups;
+  standingsFallbackGroups;
+  /** Short-lived team-code -> group-letter map (built lazily from standings). */
   groupMap;
   /**
    * One in-flight/recent standings fetch shared by fetchStandings and
@@ -3151,38 +3577,48 @@ var EspnAdapter = class {
     if (this.standingsShared && now - this.standingsShared.at < STANDINGS_SHARE_MS) {
       return this.standingsShared.promise;
     }
-    const promise = this.get(this.standingsUrl()).then(
-      (d) => parseStandings(d)
-    );
+    const promise = this.get(this.standingsUrl()).then((d) => {
+      const parsed = parseEspnStandings(d);
+      return usableProviderItems(
+        "standings",
+        parsed,
+        parsed.items.some((table) => table.rows.length > 0)
+      );
+    });
     this.standingsShared = { at: now, promise };
-    promise.catch(() => {
+    void promise.catch(() => {
       if (this.standingsShared?.promise === promise) this.standingsShared = void 0;
     });
     return promise;
   }
   /**
    * Authoritative, cumulative group tables from the standings endpoint. Throws
-   * on fetch/parse failure (the caller decides the fallback). Group-stage only:
-   * non-group `children` are filtered out by {@link parseStandings}.
+   * on fetch failure. Group-stage only: non-group `children` are filtered out
+   * by {@link parseStandings}; malformed rows are omitted without hiding their
+   * readable siblings.
    */
   async fetchStandings() {
     return this.sharedStandings();
   }
   /**
-   * Build (and cache) a team-code -> group-letter map from the standings
+   * Build (and briefly cache) a team-code -> group-letter map from the standings
    * endpoint. Best-effort: returns {} if standings are unavailable — but a
-   * transient failure is NOT cached (only a successful parse pins the map), so
-   * one blip can't silently drop group letters for the adapter's lifetime.
+   * transient failure is NOT cached, and a partial successful parse expires at
+   * the standings TTL, so neither can silently drop group letters for the
+   * adapter's lifetime.
    * Reuses the same parse/fetch as {@link fetchStandings}, so the two never
    * drift and one command never fetches standings twice.
    */
   async fetchGroupMap(force = false) {
-    if (this.groupMap && !force) return this.groupMap;
+    const now = Date.now();
+    if (!force && this.groupMap && now - this.groupMap.at < STANDINGS_SHARE_MS) {
+      return this.groupMap.value;
+    }
     try {
       const tables = await this.sharedStandings();
       const map = {};
       for (const t2 of tables) for (const r of t2.rows) map[r.team.code] = t2.group;
-      this.groupMap = map;
+      this.groupMap = { at: Date.now(), value: map };
       return map;
     } catch {
       return {};
@@ -3197,7 +3633,8 @@ var EspnAdapter = class {
       this.opts.enrichGroups === false ? Promise.resolve({}) : this.fetchGroupMap(),
       this.get(url.toString())
     ]);
-    return (data.events ?? []).map((ev) => mapEspnEvent(ev, { groupByTeam }));
+    const parsed = parseEspnEvents(data, { groupByTeam });
+    return usableProviderItems("scoreboard", parsed);
   }
   async get(url) {
     const doFetch = this.opts.fetchImpl ?? fetch;
@@ -4007,17 +4444,26 @@ async function getMatchesForDate(adapter, dateISO) {
 }
 async function getStandings(adapter, group) {
   const want = group?.toUpperCase();
+  const expected = adapter.expectedStandingsGroups;
+  if (want && expected && !expected.includes(want)) {
+    return { tables: [], degraded: false };
+  }
   if (adapter.fetchStandings) {
     try {
       const all = await adapter.fetchStandings();
       const tables2 = (want ? all.filter((t2) => t2.group === want) : all).sort(
         (a, b) => a.group.localeCompare(b.group)
       );
-      return { tables: tables2, degraded: false, source: adapter.name };
+      const availableGroups = new Set(tables2.map((table) => table.group));
+      const expectedGroupWasOmitted = want ? (expected?.includes(want) ?? false) && tables2.length === 0 : expected?.some((group2) => !availableGroups.has(group2)) ?? false;
+      if (!expectedGroupWasOmitted) {
+        return { tables: tables2, degraded: false, source: adapter.name };
+      }
     } catch {
     }
   }
-  const letters = want ? [want] : groups();
+  const fallbackGroups = adapter.standingsFallbackGroups;
+  const letters = fallbackGroups ? want ? fallbackGroups.includes(want) ? [want] : [] : [...new Set(fallbackGroups)].sort((a, b) => a.localeCompare(b)) : [];
   const tables = letters.map((g) => ({ group: g, rows: rosterAtZero(fixturesByGroup(g)) })).filter((t2) => t2.rows.length > 0);
   return { tables, degraded: true };
 }
@@ -4074,7 +4520,10 @@ async function marketFixtureForTeam(adapter, code, now = /* @__PURE__ */ new Dat
   try {
     const win = knockoutWindow();
     if (adapter.fetchWindow && win) {
-      fixtures = mergeLive(fixtures, await adapter.fetchWindow(win.start, win.end));
+      fixtures = mergeLive(
+        fixtures,
+        await adapter.fetchWindow(win.start, win.end)
+      );
     }
   } catch {
     overlayFailed = true;
@@ -4138,14 +4587,144 @@ async function getMatchById(adapter, id) {
 async function getLiveMatches(adapter, now = /* @__PURE__ */ new Date()) {
   try {
     const day = now.toISOString().slice(0, 10);
-    const matches = adapter.fetchWindow ? (await adapter.fetchWindow(shiftUtcDate(day, -1), shiftUtcDate(day, 1))).filter(
-      (m) => isLive(m.status)
-    ) : await adapter.fetchLive();
+    const matches = (adapter.fetchWindow ? await adapter.fetchWindow(shiftUtcDate(day, -1), shiftUtcDate(day, 1)) : await adapter.fetchLive()).filter((m) => isLive(m.status));
     return { matches, degraded: false, source: adapter.name };
   } catch {
     return { matches: [], degraded: true };
   }
 }
+function pct(p) {
+  return Math.round(p * 100);
+}
+var KNOWN_MARKET_SOURCES = ["polymarket", "fake"];
+function marketSourceLabel(source) {
+  if (source === "polymarket") return "Polymarket";
+  if (source === "fake") return "demo data";
+  return source.charAt(0).toUpperCase() + source.slice(1);
+}
+function outcomeLabel(o, match) {
+  if (o.kind === "home") return match.home.name;
+  if (o.kind === "away") return match.away.name;
+  if (o.kind === "draw") return "Draw";
+  return o.label;
+}
+function utcHhmm(iso) {
+  const t2 = Date.parse(iso);
+  if (!Number.isFinite(t2)) return "";
+  return `${new Date(t2).toISOString().slice(11, 16)} UTC`;
+}
+function marketFavoriteText(signal, match) {
+  const fav = signal.favorite;
+  if (!fav || fav.strength === "close") return "Prediction markets see this match as close.";
+  if (fav.kind === "draw") return "Prediction markets see a draw as the top outcome.";
+  const name = fav.kind === "home" ? match.home.name : match.away.name;
+  return fav.strength === "clear" ? `Prediction markets favor ${name}.` : `Prediction markets slightly favor ${name}.`;
+}
+function marketProbabilityText(signal, match) {
+  const order = ["home", "draw", "away"];
+  const parts = [];
+  for (const kind of order) {
+    const o = signal.outcomes.find((x) => x.kind === kind);
+    if (o) parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
+  }
+  for (const o of signal.outcomes) {
+    if (o.kind === "other") parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
+  }
+  return parts.join(" \xB7 ");
+}
+function marketAttributionText(signal) {
+  const time = utcHhmm(signal.asOf);
+  const src = `Source: ${marketSourceLabel(signal.source)}`;
+  return time ? `${src} \xB7 updated ${time}` : src;
+}
+function marketLine(signal, match) {
+  return `Market: ${marketProbabilityText(signal, match)} \xB7 ${marketSourceLabel(
+    signal.source
+  )} \xB7 informational only`;
+}
+function marketBlock(signal, match) {
+  const lines = [];
+  if (signal.stale) lines.push("Market signal is stale; the reading may be out of date.");
+  lines.push(marketFavoriteText(signal, match));
+  lines.push(marketProbabilityText(signal, match));
+  lines.push(`${marketAttributionText(signal)} \xB7 informational only`);
+  return lines;
+}
+var MAX_OUTCOMES = 128;
+var MATCH_ID = /^[0-9]{1,20}$/;
+var MARKET_ID = /^(?:[0-9]{1,32}|fifwc-[a-z]{2,3}-[a-z]{2,3}-\d{4}-\d{2}-\d{2})$/;
+var OUTCOME_KINDS = /* @__PURE__ */ new Set(["home", "draw", "away", "other"]);
+var TEAM_CODE_COLUMNS2 = 8;
+function sealOutcome(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const o = raw;
+  const kind = member(o.kind, OUTCOME_KINDS);
+  const p = probability(o.probability);
+  if (!kind || p === void 0) return void 0;
+  const out2 = { kind };
+  if (o.teamCode !== void 0) {
+    if (typeof o.teamCode !== "string") return void 0;
+    out2.teamCode = humanLabel(o.teamCode, TEAM_CODE_COLUMNS2);
+  }
+  out2.label = humanLabel(o.label);
+  out2.probability = p;
+  if ((out2.kind === "home" || out2.kind === "away") && !out2.teamCode) return void 0;
+  return out2;
+}
+function hasDuplicateKind(outcomes) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const o of outcomes) {
+    if (o.kind === "other") continue;
+    if (seen.has(o.kind)) return true;
+    seen.add(o.kind);
+  }
+  return false;
+}
+function sealMarketSignal(raw, options = {}) {
+  if (!raw || typeof raw !== "object") return malformed("signal is not an object");
+  const s = raw;
+  const matchId = opaqueId(s.matchId, MATCH_ID);
+  if (!matchId) return malformed("signal names no fixture");
+  if (!Array.isArray(s.outcomes) || s.outcomes.length > MAX_OUTCOMES) {
+    return malformed("signal outcomes are absent or exceed the cap");
+  }
+  const outcomes = [];
+  for (const rawOutcome of takeBounded(s.outcomes, MAX_OUTCOMES)) {
+    const outcome = sealOutcome(rawOutcome);
+    if (!outcome) return malformed("signal carries an unreadable outcome");
+    outcomes.push(outcome);
+  }
+  if (hasDuplicateKind(outcomes)) {
+    return ambiguous("two outcomes claim the same result");
+  }
+  const sourceMarketId = opaqueId(s.sourceMarketId, MARKET_ID);
+  const liquidity = quantity(s.liquidity);
+  const volume24h = quantity(s.volume24h);
+  const out2 = {
+    matchId,
+    // Allow-listed, not merely stripped: this lands in the provider-attribution
+    // slot, where `marketSourceLabel` falls through to the raw string for an
+    // unrecognized provider — attacker prose where the reader expects
+    // "Polymarket".
+    source: member(s.source, new Set(KNOWN_MARKET_SOURCES)) ?? ""
+  };
+  if (sourceMarketId) out2.sourceMarketId = sourceMarketId;
+  out2.asOf = canonicalTimestamp(s.asOf) ?? "";
+  out2.fetchedAt = canonicalTimestamp(s.fetchedAt) ?? "";
+  out2.outcomes = outcomes;
+  const isAmbiguous = s.ambiguous !== false;
+  const favorite = isAmbiguous ? void 0 : deriveFavorite(outcomes);
+  if (favorite) out2.favorite = favorite;
+  if (liquidity !== void 0) out2.liquidity = liquidity;
+  if (volume24h !== void 0) out2.volume24h = volume24h;
+  out2.stale = s.stale !== false;
+  out2.ambiguous = isAmbiguous || out2.source === "";
+  out2.stale = out2.stale || isStaleSignal(out2, { now: options.now, maxAgeMs: options.maxAgeMs });
+  return valid(out2);
+}
+function parseCachedMarketSignal(raw, options = {}) {
+  return sealMarketSignal(raw, options);
+}
 var DEFAULT_MAX_AGE_MS = 15 * 6e4;
 function marketRelevant(match, now = /* @__PURE__ */ new Date()) {
   if (isLive(match.status)) return true;
@@ -4164,9 +4743,9 @@ function normalizeOutcomes(outcomes) {
     probability: Number.isFinite(o.probability) && o.probability > 0 ? o.probability / sum : 0
   }));
 }
-function favoriteStrength(probability) {
-  if (probability >= 0.65) return "clear";
-  if (probability >= 0.52) return "slight";
+function favoriteStrength(probability2) {
+  if (probability2 >= 0.65) return "clear";
+  if (probability2 >= 0.52) return "slight";
   return "close";
 }
 function deriveFavorite(outcomes) {
@@ -4185,14 +4764,16 @@ function deriveFavorite(outcomes) {
 }
 function mapsCleanly(match, outcomes) {
   if (outcomes.some((o) => o.kind === "other")) return false;
+  const kinds = outcomes.map((o) => o.kind);
+  if (new Set(kinds).size !== kinds.length) return false;
   const home = outcomes.find((o) => o.kind === "home");
   const away = outcomes.find((o) => o.kind === "away");
   const draw = outcomes.find((o) => o.kind === "draw");
   if (!home || !away) return false;
-  if (home.teamCode && home.teamCode.toUpperCase() !== match.home.code.toUpperCase()) {
+  if (!home.teamCode || home.teamCode.toUpperCase() !== match.home.code.toUpperCase()) {
     return false;
   }
-  if (away.teamCode && away.teamCode.toUpperCase() !== match.away.code.toUpperCase()) {
+  if (!away.teamCode || away.teamCode.toUpperCase() !== match.away.code.toUpperCase()) {
     return false;
   }
   if (match.stage === "GROUP" && !draw) return false;
@@ -4207,11 +4788,13 @@ function hasSaneDistribution(outcomes) {
   const sum = priced.reduce((s, o) => s + o.probability, 0);
   return sum > 0.97 && sum < 1.03;
 }
+var FUTURE_SKEW_MS = 6e4;
 function isStaleSignal(signal, options = {}) {
   const maxAge = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
   const asOf = Date.parse(signal.asOf);
   if (!Number.isFinite(asOf)) return true;
   const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  if (asOf - now > FUTURE_SKEW_MS) return true;
   return now - asOf > maxAge;
 }
 function isReliableMarketSignal(signal, options = {}) {
@@ -4227,8 +4810,8 @@ function isReliableMarketSignal(signal, options = {}) {
 }
 function buildMarketSignal(input) {
   const outcomes = normalizeOutcomes(input.outcomes);
-  const ambiguous = input.ambiguous === true || !mapsCleanly(input.match, outcomes);
-  const favorite = ambiguous ? void 0 : deriveFavorite(outcomes);
+  const ambiguous2 = input.ambiguous === true || !mapsCleanly(input.match, outcomes);
+  const favorite = ambiguous2 ? void 0 : deriveFavorite(outcomes);
   const signal = {
     matchId: input.match.id,
     source: input.source,
@@ -4240,88 +4823,53 @@ function buildMarketSignal(input) {
     liquidity: input.liquidity,
     volume24h: input.volume24h,
     stale: false,
-    ambiguous
+    ambiguous: ambiguous2
   };
   signal.stale = isStaleSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
-  return signal;
-}
-function pct(p) {
-  return Math.round(p * 100);
+  const sealed = sealMarketSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
+  if (sealed.kind !== "valid") {
+    return { ...signal, outcomes: [], favorite: void 0, stale: true, ambiguous: true };
+  }
+  return { ...sealed.value, ambiguous: sealed.value.ambiguous || ambiguous2 };
 }
-function marketSourceLabel(source) {
-  if (source === "polymarket") return "Polymarket";
-  if (source === "fake") return "demo data";
-  return source.charAt(0).toUpperCase() + source.slice(1);
+var NONE = { kind: "none" };
+function selectOne(candidates) {
+  if (candidates.length === 1) return { kind: "one", value: candidates[0] };
+  if (candidates.length === 0) return NONE;
+  return { kind: "ambiguous", count: candidates.length };
 }
-function outcomeLabel(o, match) {
-  if (o.kind === "home") return match.home.name;
-  if (o.kind === "away") return match.away.name;
-  if (o.kind === "draw") return "Draw";
-  return o.label;
+function resolvedValues(batch) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const [key, r] of batch.results) if (r.kind === "valid") out2.set(key, r.value);
+  return out2;
 }
-function utcHhmm(iso) {
-  const t2 = Date.parse(iso);
-  if (!Number.isFinite(t2)) return "";
-  return `${new Date(t2).toISOString().slice(11, 16)} UTC`;
+function cacheableKeys(batch) {
+  const out2 = /* @__PURE__ */ new Set();
+  for (const [key, r] of batch.results) if (isCacheable(r)) out2.add(key);
+  return out2;
 }
-function marketFavoriteText(signal, match) {
-  const fav = signal.favorite;
-  if (!fav || fav.strength === "close") return "Prediction markets see this match as close.";
-  if (fav.kind === "draw") return "Prediction markets see a draw as the top outcome.";
-  const name = fav.kind === "home" ? match.home.name : match.away.name;
-  return fav.strength === "clear" ? `Prediction markets favor ${name}.` : `Prediction markets slightly favor ${name}.`;
+function emptyBatch() {
+  return { results: /* @__PURE__ */ new Map(), complete: false };
 }
-function marketProbabilityText(signal, match) {
-  const order = ["home", "draw", "away"];
-  const parts = [];
-  for (const kind of order) {
-    const o = signal.outcomes.find((x) => x.kind === kind);
-    if (o) parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
+var FakeMarketProvider = class {
+  constructor(opts = {}) {
+    this.opts = opts;
   }
-  for (const o of signal.outcomes) {
-    if (o.kind === "other") parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
-  }
-  return parts.join(" \xB7 ");
-}
-function marketAttributionText(signal) {
-  const time = utcHhmm(signal.asOf);
-  const src = `Source: ${marketSourceLabel(signal.source)}`;
-  return time ? `${src} \xB7 updated ${time}` : src;
-}
-function marketLine(signal, match) {
-  return `Market: ${marketProbabilityText(signal, match)} \xB7 ${marketSourceLabel(
-    signal.source
-  )} \xB7 informational only`;
-}
-function marketBlock(signal, match) {
-  const lines = [];
-  if (signal.stale) lines.push("Market signal is stale; the reading may be out of date.");
-  lines.push(marketFavoriteText(signal, match));
-  lines.push(marketProbabilityText(signal, match));
-  lines.push(`${marketAttributionText(signal)} \xB7 informational only`);
-  return lines;
-}
-var FakeMarketProvider = class {
-  constructor(opts = {}) {
-    this.opts = opts;
-  }
-  opts;
-  name = "fake";
-  async findSignal(match, options) {
-    const preset = this.opts.signals?.[match.id];
-    if (preset) return preset;
-    if (this.opts.synthesize) return this.synthesize(match, options);
-    return void 0;
+  opts;
+  name = "fake";
+  async findSignal(match, options) {
+    const preset = this.opts.signals?.[match.id];
+    if (preset) return preset;
+    if (this.opts.synthesize) return this.synthesize(match, options);
+    return void 0;
   }
   async findSignals(matches, options) {
-    const signals = /* @__PURE__ */ new Map();
-    const checked = /* @__PURE__ */ new Set();
+    const results = /* @__PURE__ */ new Map();
     for (const m of matches) {
-      checked.add(m.id);
       const s = await this.findSignal(m, options);
-      if (s) signals.set(m.id, s);
+      results.set(m.id, s ? valid(s) : definitiveNone("fake provider has no signal"));
     }
-    return { signals, checked };
+    return { results, complete: true };
   }
   synthesize(match, options) {
     const seed = hash(`${match.home.code}-${match.away.code}`);
@@ -4338,7 +4886,9 @@ var FakeMarketProvider = class {
     return buildMarketSignal({
       match,
       source: "fake",
-      sourceMarketId: `fake-${match.id}`,
+      // Must satisfy the boundary's opaque-id grammar, like a real one:
+      // a source id that only the live path accepts is the asymmetry itself.
+      sourceMarketId: match.id,
       asOf,
       fetchedAt: now.toISOString(),
       outcomes,
@@ -4362,6 +4912,8 @@ var DEFAULT_BASE2 = "https://gamma-api.polymarket.com";
 var ALLOWED_HOSTS = /* @__PURE__ */ new Set(["gamma-api.polymarket.com"]);
 var USER_AGENT2 = "claudinho/0.0 (+https://github.com/arturogarrido/claudinho)";
 var DEFAULT_TIMEOUT_MS2 = 8e3;
+var MAX_EVENT_MARKETS = 256;
+var DEFAULT_DEADLINE_MS = 15e3;
 var WC_SERIES_SLUG = "soccer-fifwc";
 var WC_SPORT = "fifwc";
 var KICKOFF_TOLERANCE_MS = 6 * 60 * 6e4;
@@ -4374,49 +4926,81 @@ var PolymarketProvider = class {
   opts;
   name = "polymarket";
   async findSignal(match, options) {
-    const deadline = options?.deadlineMs != null ? Date.now() + options.deadlineMs : Number.POSITIVE_INFINITY;
-    return (await this.resolveOne(match, options, deadline)).signal;
+    const deadline = Date.now() + (options?.deadlineMs ?? DEFAULT_DEADLINE_MS);
+    return parsedValue(await this.resolveOne(match, options, deadline));
   }
   async findSignals(matches, options) {
-    const signals = /* @__PURE__ */ new Map();
-    const checked = /* @__PURE__ */ new Set();
-    const deadline = options?.deadlineMs != null ? Date.now() + options.deadlineMs : Number.POSITIVE_INFINITY;
+    const results = /* @__PURE__ */ new Map();
+    const deadline = Date.now() + (options?.deadlineMs ?? DEFAULT_DEADLINE_MS);
+    let complete = true;
     for (const m of matches) {
-      if (Date.now() >= deadline) break;
+      if (Date.now() >= deadline) {
+        results.set(m.id, unresolved("enrichment deadline expired"));
+        complete = false;
+        continue;
+      }
       const r = await this.resolveOne(m, options, deadline);
-      if (r.checked) checked.add(m.id);
-      if (r.signal) signals.set(m.id, r.signal);
+      if (r.kind === "unresolved" || r.kind === "malformed") complete = false;
+      results.set(m.id, r);
     }
-    return { signals, checked };
+    return { results, complete };
   }
   /**
-   * Resolve one match. `checked` distinguishes a DEFINITIVE result (reached the
-   * source and found no usable market, or the fixture is unmappable) from a
-   * provider/network error — so transient failures are retried, not
-   * negative-cached.
+   * Resolve one match into a verdict.
+   *
+   * Every exit says which KIND of non-answer it is, because that decides
+   * whether it may be remembered — see `isCacheable`: a conclusion we drew from
+   * a payload we READ is cacheable (including an ambiguity, which is stable),
+   * while a shape we could not read is not. Previously a single
+   * `checked: boolean` collapsed five distinct situations into two, and the
+   * ones that landed on the wrong side of it — an ambiguous payload, a
+   * two-legged market, an incoherent 1X2 — were negative-cached as the fact
+   * that this fixture has no market.
    */
   async resolveOne(match, options, deadline = Number.POSITIVE_INFINITY) {
-    const entry = (this.opts.mapping ?? BUNDLED_MAPPING)[match.id];
-    const slugs = entry?.eventSlug ? [entry.eventSlug] : deriveEventSlugs(match);
-    if (slugs.length === 0) return { checked: true };
     const configured = options?.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
     try {
+      const entry = (this.opts.mapping ?? BUNDLED_MAPPING)[match.id];
+      const slugs = entry?.eventSlug ? [entry.eventSlug] : deriveEventSlugs(match);
+      if (slugs.length === 0) return definitiveNone("fixture has no derivable event slug");
+      const RANK = {
+        "definitive-none": 0,
+        ambiguous: 1,
+        unresolved: 2,
+        malformed: 3
+      };
+      let worst;
+      const keepWorst = (r) => {
+        if (r.kind === "definitive-none" || r.kind === "valid") return;
+        if (!worst || (RANK[r.kind] ?? 0) > (RANK[worst.kind] ?? 0)) worst = r;
+      };
       for (const slug of slugs) {
         const remaining = deadline - Date.now();
-        if (remaining <= 0) return { checked: false };
-        const event = await this.fetchEvent(slug, Math.min(configured, remaining));
-        const signal = event ? this.toSignal(match, slug, event, options) : void 0;
-        if (signal) return { signal, checked: true };
+        if (remaining <= 0) return unresolved("deadline expired between candidate slugs");
+        let found;
+        try {
+          found = await this.fetchEvent(slug, Math.min(configured, remaining));
+        } catch {
+          keepWorst(malformed("candidate request failed"));
+          continue;
+        }
+        if (found.kind !== "valid") {
+          keepWorst(found);
+          continue;
+        }
+        const r = this.toSignal(match, slug, found.value, options);
+        if (r.kind === "valid") return r;
+        keepWorst(r);
       }
-      return { checked: true };
+      return worst ?? definitiveNone("no candidate slug yielded a usable market");
     } catch {
-      return { checked: false };
+      return malformed("provider request failed");
     }
   }
   async fetchEvent(slug, timeoutMs) {
     const base = this.opts.baseUrl ?? DEFAULT_BASE2;
     assertAllowedHost(base);
-    const url = `${base}/events?slug=${encodeURIComponent(slug)}`;
+    const url = `${base}/events/slug/${encodeURIComponent(slug)}`;
     const doFetch = this.opts.fetchImpl ?? fetch;
     const res = await doFetch(url, {
       signal: AbortSignal.timeout(timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2),
@@ -4425,7 +5009,7 @@ var PolymarketProvider = class {
       redirect: "error",
       headers: { Accept: "application/json", "User-Agent": USER_AGENT2 }
     });
-    if (res.status === 404) return void 0;
+    if (res.status === 404) return definitiveNone("slug returns 404");
     if (!res.ok) {
       throw new Error(`Polymarket request failed: ${res.status} ${res.statusText}`);
     }
@@ -4434,63 +5018,148 @@ var PolymarketProvider = class {
       throw new Error(`Polymarket response too large: ${length} bytes`);
     }
     const data = await res.json();
+    if (Array.isArray(data) && data.length > 1) {
+      return ambiguous("slug returned more than one event");
+    }
+    if (Array.isArray(data) && data.length === 0) return definitiveNone("slug returns no event");
     const event = Array.isArray(data) ? data[0] : data;
-    return event && typeof event === "object" ? event : void 0;
+    if (!event || typeof event !== "object") return malformed("event body is not an object");
+    return valid(event);
   }
   toSignal(match, eventSlug, event, options) {
-    if (event.active === false || event.closed === true) return void 0;
-    if (event.seriesSlug != null && event.seriesSlug !== WC_SERIES_SLUG && event.sport?.sport !== WC_SPORT) {
-      return void 0;
+    if (typeof event.active !== "boolean" || typeof event.closed !== "boolean") {
+      return malformed("event active/closed is not a boolean");
+    }
+    if (event.active === false || event.closed === true) {
+      return definitiveNone("event is closed or inactive");
     }
-    if (event.slug != null && event.slug !== eventSlug) return void 0;
-    const start = event.startTime ? Date.parse(event.startTime) : Number.NaN;
+    if (event.seriesSlug !== WC_SERIES_SLUG && event.sport?.sport !== WC_SPORT) {
+      return definitiveNone("event is not in this competition");
+    }
+    if (typeof event.slug !== "string") {
+      return malformed("event states no slug");
+    }
+    if (event.slug !== eventSlug) return definitiveNone("event is not the one requested");
+    if (typeof event.startTime !== "string" || !canonicalTimestamp(event.startTime)) {
+      return malformed("event startTime missing or unparseable");
+    }
+    const start = Date.parse(event.startTime);
     const kick = Date.parse(match.kickoff);
-    if (Number.isFinite(start) && Number.isFinite(kick) && Math.abs(start - kick) > KICKOFF_TOLERANCE_MS) {
-      return void 0;
+    if (!Number.isFinite(start) || !Number.isFinite(kick)) {
+      return malformed("event or fixture kickoff is unreadable");
     }
-    const moneyline = (event.markets ?? []).filter(
-      (m) => (m.sportsMarketType ?? "moneyline") === "moneyline"
+    if (Math.abs(start - kick) > KICKOFF_TOLERANCE_MS) {
+      return definitiveNone("event kickoff does not match the fixture");
+    }
+    if (!Array.isArray(event.markets)) {
+      return malformed("event markets is not an array");
+    }
+    const marketsTruncated = Array.isArray(event.markets) && event.markets.length > MAX_EVENT_MARKETS;
+    if (marketsTruncated) {
+      return malformed("event market list exceeded the cap");
+    }
+    const marketList = takeBounded(event.markets, MAX_EVENT_MARKETS);
+    if (marketList.some(
+      (market) => !market || typeof market !== "object" || typeof market.sportsMarketType !== "string"
+    )) {
+      return malformed("event market is missing its market-type discriminator");
+    }
+    const moneyline = marketList.filter(
+      (m) => m?.sportsMarketType === "moneyline"
     );
-    const homeMarket = pickMarket(moneyline, match.home.code, match.home.name);
-    const awayMarket = pickMarket(moneyline, match.away.code, match.away.name);
-    const drawMarket = pickDraw(moneyline);
-    if (!homeMarket || !awayMarket) return void 0;
+    const homeSel = pickMarket(moneyline, match.home.code, match.home.name);
+    const awaySel = pickMarket(moneyline, match.away.code, match.away.name);
+    const drawSel = pickDraw(moneyline);
+    for (const [side, sel] of [
+      ["home", homeSel],
+      ["away", awaySel],
+      ["draw", drawSel]
+    ]) {
+      if (sel.kind === "ambiguous") {
+        return ambiguous(`${sel.count} markets claim the ${side} outcome`);
+      }
+    }
+    if (homeSel.kind !== "one" || awaySel.kind !== "one" || drawSel.kind !== "one") {
+      return definitiveNone("event does not carry all three 1X2 legs");
+    }
+    const homeMarket = homeSel.value;
+    const awayMarket = awaySel.value;
+    const drawMarket = drawSel.value;
     const legIds = [homeMarket, awayMarket, drawMarket].filter((m) => m != null).map((m) => m.id ?? m.slug ?? "");
-    if (new Set(legIds).size !== legIds.length) return void 0;
+    if (new Set(legIds).size !== legIds.length) {
+      return ambiguous("two outcome legs are the same market");
+    }
     const legs = [
       ["home", homeMarket, match.home.code, match.home.name],
       ["draw", drawMarket, void 0, "Draw"],
       ["away", awayMarket, match.away.code, match.away.name]
     ];
     const outcomes = [];
-    let asOf = event.updatedAt;
+    let asOf = canonicalTimestamp(event.updatedAt);
     let liquidity;
-    for (const [kind, market, teamCode, label] of legs) {
+    for (const [kind, market, teamCode2, label] of legs) {
       if (!market) continue;
-      if (market.closed === true || market.active === false) return void 0;
-      if (market.description && NON_REGULAR_TIME.test(market.description)) return void 0;
+      if (typeof market.closed !== "boolean" || typeof market.active !== "boolean") {
+        return malformed("market active/closed is not a boolean");
+      }
+      if (market.closed === true || market.active === false) {
+        return definitiveNone("an outcome leg is closed or inactive");
+      }
+      if (market.description && NON_REGULAR_TIME.test(market.description)) {
+        return definitiveNone("an outcome leg is not a regular-time market");
+      }
       const yes = yesPrice(market);
-      if (yes == null) return void 0;
-      outcomes.push({ kind, teamCode, label, probability: yes });
-      if (market.updatedAt && (!asOf || market.updatedAt < asOf)) asOf = market.updatedAt;
-      const liq = numberish(market.liquidityNum ?? market.liquidity);
+      if (yes == null) return malformed("market is not a readable Yes/No binary");
+      outcomes.push({ kind, teamCode: teamCode2, label, probability: yes });
+      const marketAsOf = canonicalTimestamp(market.updatedAt);
+      if (!marketAsOf) {
+        return malformed("market updatedAt missing or unparseable");
+      }
+      const nowMs = (options?.now ?? this.opts.now ?? /* @__PURE__ */ new Date()).getTime();
+      if (Date.parse(marketAsOf) - nowMs > FUTURE_SKEW_MS) {
+        return malformed("market updatedAt is dated forward");
+      }
+      if (!asOf || Date.parse(marketAsOf) < Date.parse(asOf)) asOf = marketAsOf;
+      const rawLiq = market.liquidityNum ?? market.liquidity;
+      const liq = numberish(rawLiq);
+      if (rawLiq != null && liq == null) {
+        return malformed("market liquidity is unreadable");
+      }
       if (liq != null) liquidity = liquidity == null ? liq : Math.min(liquidity, liq);
     }
     const rawSum = outcomes.reduce((s, o) => s + o.probability, 0);
-    if (rawSum < 0.9 || rawSum > 1.15) return void 0;
+    if (rawSum < 0.9 || rawSum > 1.15) {
+      return ambiguous("outcome probabilities do not form a coherent 1X2");
+    }
+    if (!asOf) return malformed("no usable timestamp on the event or its markets");
     const signal = buildMarketSignal({
       match,
       source: "polymarket",
-      sourceMarketId: event.id ?? eventSlug,
-      asOf: asOf ?? (/* @__PURE__ */ new Date()).toISOString(),
+      // Echoed into MCP structured content (tools.ts `market.id`), i.e. straight
+      // into an agent's context. Stripping control characters is NOT sufficient
+      // there: printable prose ("IGNORE PREVIOUS INSTRUCTIONS") survives that and
+      // is precisely what matters for a model reading it. Gamma ids are short
+      // opaque tokens, so validate that GRAMMAR and otherwise fall back to the
+      // slug we derived ourselves.
+      // The fallback is grammar-checked too. It is normally a slug we derived
+      // ourselves, but `mapping.2026.json` can override it, so echoing it raw
+      // was the one path around the agent-facing filter this line exists for.
+      sourceMarketId: safeMarketId(event.id) ?? safeDerivedSlug(eventSlug),
+      asOf,
       outcomes,
       liquidity,
       now: options?.now ?? this.opts.now,
       maxAgeMs: options?.maxAgeMs ?? this.opts.maxAgeMs
     });
-    return signal.ambiguous ? void 0 : signal;
+    return signal.ambiguous ? ambiguous("signal does not map cleanly onto this fixture") : valid(signal);
   }
 };
+function safeMarketId(id) {
+  return typeof id === "string" && /^[0-9]{1,32}$/.test(id) ? id : void 0;
+}
+function safeDerivedSlug(slug) {
+  return typeof slug === "string" && /^fifwc-[a-z]{2,3}-[a-z]{2,3}-\d{4}-\d{2}-\d{2}$/.test(slug) ? slug : void 0;
+}
 var POLYMARKET_TOKEN = {
   SUI: "che",
   // Switzerland
@@ -4504,8 +5173,16 @@ var POLYMARKET_TOKEN = {
   // Croatia
   COD: "cdr",
   // DR Congo
-  CPV: "cvi"
+  CPV: "cvi",
   // Cabo Verde
+  // TWO letters, not three — the one entry that is not ISO alpha-3. Verified
+  // live: `fifwc-kor-cze-2026-06-11` is a 404, `fifwc-kr-cze-2026-06-11`
+  // resolves to "Korea Republic vs. Czechia". Korea's three group fixtures
+  // therefore had no market line at all. The `^[a-z]{3}$` guard in
+  // `deriveEventSlugs` validates the FIFA CODE, not the token, so a two-letter
+  // alias passes through it unharmed.
+  KOR: "kr"
+  // Korea Republic
 };
 function pmTokens(code) {
   const c = code.toLowerCase();
@@ -4536,18 +5213,21 @@ function slugToken(m) {
   return (m.slug ?? "").toLowerCase().split("-").pop() ?? "";
 }
 function isDrawMarket(m) {
-  return slugToken(m) === "draw" || (m.groupItemTitle ?? "").trim().toLowerCase().startsWith("draw");
+  const title = (m.groupItemTitle ?? "").trim().toLowerCase();
+  return slugToken(m) === "draw" || title === "draw" || /^draw\s*\(/.test(title);
 }
-function pickMarket(markets, teamCode, teamName) {
-  const tokens = pmTokens(teamCode);
+function pickMarket(markets, teamCode2, teamName) {
+  const tokens = pmTokens(teamCode2);
   const name = teamName.trim().toLowerCase();
   const teamMarkets = markets.filter((m) => !isDrawMarket(m));
-  const bySlug = teamMarkets.find((m) => tokens.includes(slugToken(m)));
-  if (bySlug) return bySlug;
-  return teamMarkets.find((m) => (m.groupItemTitle ?? "").trim().toLowerCase() === name);
+  const bySlug = teamMarkets.filter((m) => tokens.includes(slugToken(m)));
+  if (bySlug.length > 1) return { kind: "ambiguous", count: bySlug.length };
+  const byTitle = name ? teamMarkets.filter((m) => (m.groupItemTitle ?? "").trim().toLowerCase() === name) : [];
+  if (byTitle.length > 1) return { kind: "ambiguous", count: byTitle.length };
+  return selectOne([.../* @__PURE__ */ new Set([...bySlug, ...byTitle])]);
 }
 function pickDraw(markets) {
-  return markets.find(isDrawMarket);
+  return selectOne(markets.filter(isDrawMarket));
 }
 function assertAllowedHost(base) {
   let host;
@@ -4561,20 +5241,29 @@ function assertAllowedHost(base) {
   }
 }
 function yesPrice(market) {
-  const labels = parseJsonArray(market.outcomes);
-  const prices = parseJsonArray(market.outcomePrices).map((p2) => Number(p2));
-  if (labels.length === 0 || labels.length !== prices.length) return void 0;
-  const i = labels.findIndex((l) => l.trim().toLowerCase() === "yes");
-  if (i < 0) return void 0;
-  const p = prices[i];
-  return typeof p === "number" && Number.isFinite(p) && p > 0 && p <= 1 ? p : void 0;
+  const labels = parseJsonArray(market.outcomes).map((l) => l.trim().toLowerCase());
+  const raw = parseJsonArray(market.outcomePrices);
+  if (raw.some((v) => v.trim() === "" || !Number.isFinite(Number(v)))) return void 0;
+  const prices = raw.map((v) => Number(v));
+  if (labels.length !== 2 || prices.length !== 2) return void 0;
+  const i = labels.indexOf("yes");
+  const j = labels.indexOf("no");
+  if (i < 0 || j < 0) return void 0;
+  const yes = prices[i];
+  const no = prices[j];
+  if (![yes, no].every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1)) {
+    return void 0;
+  }
+  if (Math.abs(yes + no - 1) > 0.05) return void 0;
+  return yes > 0 ? yes : void 0;
 }
 function parseJsonArray(v) {
-  if (Array.isArray(v)) return v.map((x) => String(x));
+  const asText = (x) => typeof x === "string" || typeof x === "number" ? String(x) : "";
+  if (Array.isArray(v)) return v.map(asText);
   if (typeof v === "string") {
     try {
       const parsed = JSON.parse(v);
-      return Array.isArray(parsed) ? parsed.map((x) => String(x)) : [];
+      return Array.isArray(parsed) ? parsed.map(asText) : [];
     } catch {
       return [];
     }
@@ -4582,10 +5271,10 @@ function parseJsonArray(v) {
   return [];
 }
 function numberish(v) {
-  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+  if (typeof v === "number") return Number.isFinite(v) && v >= 0 ? v : void 0;
   if (typeof v === "string") {
     const n = Number(v);
-    return Number.isFinite(n) ? n : void 0;
+    return Number.isFinite(n) && n >= 0 ? n : void 0;
   }
   return void 0;
 }
@@ -4612,7 +5301,7 @@ async function getMarketSignals(provider, matches, options) {
   try {
     return await provider.findSignals(matches, options);
   } catch {
-    return { signals: /* @__PURE__ */ new Map(), checked: /* @__PURE__ */ new Set() };
+    return emptyBatch();
   }
 }
 var SHARE_HASHTAG = "#VibingLaVidaLoca";
@@ -4693,6 +5382,9 @@ function formatShareSnippet(input, options = {}) {
   if (input.degraded && input.matches.length > 0) {
     blocks.push("(Live data unavailable \u2014 showing the bundled schedule, not live scores.)");
   }
+  if (includeMarkets && input.marketComplete === false) {
+    blocks.push("(Market data unavailable or incomplete \u2014 not all fixtures were checked.)");
+  }
   blocks.push(
     shareFooter({
       source: input.source,
@@ -4723,7 +5415,9 @@ function formatShareTable(input, options = {}) {
   const includeInstall = options.includeInstallLine !== false;
   const blocks = [];
   if (input.tables.length === 0) {
-    blocks.push(input.emptyNote ?? "No standings available.");
+    blocks.push(
+      input.emptyNote ?? (input.degraded ? "Live standings unavailable." : "No standings available.")
+    );
   } else {
     for (const { group, rows } of input.tables) {
       blocks.push(
@@ -4993,6 +5687,8 @@ var EN2 = {
   "today.none": "No matches scheduled for this date.",
   "live.title": "Live now",
   "live.none": "No matches in play right now.",
+  "signoff.complete": "The World Cup is complete. Thanks for using Claudinho.",
+  "signoff.star": "Star the project:",
   "live.degraded": "Live scores unavailable right now \u2014 couldn't reach the data provider.",
   "feed.degraded": "Live scores unavailable \u2014 showing the bundled schedule.",
   "next.none": "No upcoming fixture found for {team}.",
@@ -5005,6 +5701,7 @@ var EN2 = {
   "table.title": "Group {group}",
   "table.none": "No group found for {group}.",
   "table.degraded": "Live standings unavailable \u2014 showing the group roster.",
+  "table.unavailable": "Live standings unavailable.",
   "table.empty": "No standings available.",
   "match.none": "No match found with id {id}.",
   "status.live": "LIVE",
@@ -5031,6 +5728,8 @@ var ES2 = {
   "today.none": "No hay partidos para esta fecha.",
   "live.title": "En vivo",
   "live.none": "No hay partidos en juego ahora mismo.",
+  "signoff.complete": "El Mundial ha terminado. Gracias por usar Claudinho.",
+  "signoff.star": "Dale una estrella al proyecto:",
   "live.degraded": "Marcadores en vivo no disponibles \u2014 no se pudo conectar con el proveedor de datos.",
   "feed.degraded": "Marcadores en vivo no disponibles \u2014 mostrando el calendario.",
   "next.none": "No se encontr\xF3 pr\xF3ximo partido para {team}.",
@@ -5043,6 +5742,7 @@ var ES2 = {
   "table.title": "Grupo {group}",
   "table.none": "No se encontr\xF3 el grupo {group}.",
   "table.degraded": "Tabla en vivo no disponible \u2014 mostrando la lista del grupo.",
+  "table.unavailable": "Tabla en vivo no disponible.",
   "table.empty": "No hay clasificaci\xF3n disponible.",
   "match.none": "No se encontr\xF3 partido con id {id}.",
   "status.live": "EN VIVO",
@@ -5069,6 +5769,8 @@ var PT2 = {
   "today.none": "Nenhum jogo para esta data.",
   "live.title": "Ao vivo",
   "live.none": "Nenhum jogo em andamento agora.",
+  "signoff.complete": "A Copa do Mundo terminou. Obrigado por usar o Claudinho.",
+  "signoff.star": "D\xEA uma estrela ao projeto:",
   "live.degraded": "Placar ao vivo indispon\xEDvel \u2014 n\xE3o foi poss\xEDvel conectar ao provedor de dados.",
   "feed.degraded": "Placar ao vivo indispon\xEDvel \u2014 mostrando a tabela de jogos.",
   "next.none": "Nenhum pr\xF3ximo jogo encontrado para {team}.",
@@ -5081,6 +5783,7 @@ var PT2 = {
   "table.title": "Grupo {group}",
   "table.none": "Grupo {group} n\xE3o encontrado.",
   "table.degraded": "Classifica\xE7\xE3o ao vivo indispon\xEDvel \u2014 mostrando os times do grupo.",
+  "table.unavailable": "Classifica\xE7\xE3o ao vivo indispon\xEDvel.",
   "table.empty": "Classifica\xE7\xE3o indispon\xEDvel.",
   "match.none": "Nenhum jogo encontrado com id {id}.",
   "status.live": "AO VIVO",
@@ -5107,6 +5810,8 @@ var FR2 = {
   "today.none": "Aucun match pr\xE9vu pour cette date.",
   "live.title": "En direct",
   "live.none": "Aucun match en cours pour l'instant.",
+  "signoff.complete": "La Coupe du Monde est termin\xE9e. Merci d'avoir utilis\xE9 Claudinho.",
+  "signoff.star": "Mettez une \xE9toile au projet :",
   "live.degraded": "Scores en direct indisponibles \u2014 impossible de joindre le fournisseur de donn\xE9es.",
   "feed.degraded": "Scores en direct indisponibles \u2014 affichage du calendrier.",
   "next.none": "Aucun prochain match trouv\xE9 pour {team}.",
@@ -5119,6 +5824,7 @@ var FR2 = {
   "table.title": "Groupe {group}",
   "table.none": "Groupe {group} introuvable.",
   "table.degraded": "Classement en direct indisponible \u2014 affichage de la composition du groupe.",
+  "table.unavailable": "Classement en direct indisponible.",
   "table.empty": "Aucun classement disponible.",
   "match.none": "Aucun match trouv\xE9 avec id {id}.",
   "status.live": "DIRECT",
@@ -5229,7 +5935,19 @@ function dataSource(source, lang, c) {
 }
 
 // src/marketCache.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/cache.ts
+import {
+  closeSync as closeSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync,
+  writeSync as writeSync2
+} from "fs";
 import { join as join2 } from "path";
 
 // src/paths.ts
@@ -5252,133 +5970,63 @@ function writeFileAtomic(path, data) {
   renameSync(tmp, path);
 }
 
-// src/marketCache.ts
-var POSITIVE_TTL_MS = 10 * 6e4;
-var NEGATIVE_TTL_MS = 3 * 6e4;
-function cachePath() {
-  return join2(cacheDir(), "market-signals.json");
-}
-function readFile() {
-  try {
-    return JSON.parse(readFileSync2(cachePath(), "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function readMarketCache(source, competition, now = Date.now()) {
-  const signals = /* @__PURE__ */ new Map();
-  const checked = /* @__PURE__ */ new Set();
-  const file = readFile();
-  if (!file || file.source !== source || file.competition !== competition) {
-    return { signals, checked };
-  }
-  for (const [id, entry] of Object.entries(file.entries ?? {})) {
-    const t2 = Date.parse(entry.fetchedAt);
-    if (!Number.isFinite(t2)) continue;
-    const ttl = entry.signal ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS;
-    if (now - t2 > ttl) continue;
-    checked.add(id);
-    if (entry.signal) signals.set(id, entry.signal);
-  }
-  return { signals, checked };
-}
-function writeMarketCache(source, competition, attempted, fetched, now = Date.now()) {
-  if (attempted.length === 0) return;
-  try {
-    const existing = readFile();
-    const base = existing && existing.source === source && existing.competition === competition ? existing : { source, competition, entries: {} };
-    const fetchedAt = new Date(now).toISOString();
-    for (const id of attempted) {
-      base.entries[id] = { fetchedAt, signal: fetched.get(id) ?? null };
-    }
-    writeFileAtomic(cachePath(), JSON.stringify(base));
-  } catch {
-  }
-}
-
-// src/starNudge.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
-var REPO_URL = "https://github.com/arturogarrido/claudinho";
-var NUDGE_EVERY = 5;
-function counterPath() {
-  return join3(cacheDir(), "runs.json");
-}
-function shouldNudge(runCount, every = NUDGE_EVERY) {
-  return runCount > 0 && runCount % every === 0;
-}
-function bumpRunCount(path = counterPath()) {
-  try {
-    let count = 0;
-    try {
-      const raw = JSON.parse(readFileSync3(path, "utf8"));
-      if (typeof raw.count === "number" && Number.isFinite(raw.count)) count = raw.count;
-    } catch {
-      count = 0;
-    }
-    count += 1;
-    writeFileAtomic(path, JSON.stringify({ count }));
-    return count;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/clipboard.ts
-import { spawnSync } from "child_process";
-function clipboardTools(platform) {
-  if (platform === "darwin") return [{ cmd: "pbcopy", args: [] }];
-  if (platform === "win32") return [{ cmd: "clip", args: [] }];
-  return [
-    { cmd: "wl-copy", args: [] },
-    { cmd: "xclip", args: ["-selection", "clipboard"] },
-    { cmd: "xsel", args: ["--clipboard", "--input"] }
-  ];
-}
-function copyToClipboard(text, platform = process.platform) {
-  for (const { cmd, args } of clipboardTools(platform)) {
-    try {
-      const res = spawnSync(cmd, args, {
-        input: text,
-        stdio: ["pipe", "ignore", "ignore"],
-        timeout: 1e3
-      });
-      if (!res.error && res.status === 0) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-
 // src/cache.ts
-import {
-  closeSync as closeSync2,
-  mkdirSync as mkdirSync2,
-  openSync as openSync2,
-  readFileSync as readFileSync4,
-  rmSync,
-  statSync,
-  writeSync as writeSync2
-} from "fs";
-import { join as join4 } from "path";
 var CACHE_VERSION = 2;
+var MAX_STATE_BYTES = 1024 * 1024;
+var MAX_STATE_RECORDS = 1024;
 var LOCK_STALE_MS = 6e4;
-function cachePath2(source = "espn", competition = DEFAULT_COMPETITION) {
+function cachePath(source = "espn", competition = DEFAULT_COMPETITION) {
   if (source === "espn" && competition === DEFAULT_COMPETITION) {
-    return join4(cacheDir(), "state.json");
+    return join2(cacheDir(), "state.json");
   }
   const slug = `${source}.${competition}`.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return join4(cacheDir(), `state.${slug}.json`);
+  return join2(cacheDir(), `state.${slug}.json`);
 }
 function lockPath() {
-  return join4(cacheDir(), "refresh.lock");
+  return join2(cacheDir(), "refresh.lock");
+}
+function validStamp(value) {
+  if (typeof value !== "string") return false;
+  const match = value.match(
+    /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,3}))?Z$/
+  );
+  if (!match) return false;
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) return false;
+  const canonical = `${match[1]}.${(match[2] ?? "").padEnd(3, "0")}Z`;
+  return new Date(parsed).toISOString() === canonical;
+}
+function validScope(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 128 && /^[a-zA-Z0-9._-]+$/.test(value);
+}
+function isCacheState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const s = value;
+  if (s.version !== CACHE_VERSION) return false;
+  if (!validStamp(s.updatedAt) || typeof s.degraded !== "boolean") return false;
+  if (!validScope(s.source) || !validScope(s.competition)) return false;
+  if (!Array.isArray(s.live) || s.live.length > MAX_STATE_RECORDS) return false;
+  if (s.fixtures !== void 0 && (!Array.isArray(s.fixtures) || s.fixtures.length > MAX_STATE_RECORDS)) {
+    return false;
+  }
+  for (const key of [
+    "fixturesUpdatedAt",
+    "fixturesAttemptedAt",
+    "backoffUntil"
+  ]) {
+    if (s[key] !== void 0 && !validStamp(s[key])) return false;
+  }
+  return true;
 }
 function readState(source = "espn", competition = DEFAULT_COMPETITION) {
   try {
-    const s = JSON.parse(
-      readFileSync4(cachePath2(source, competition), "utf8")
-    );
-    return s.version === CACHE_VERSION ? s : void 0;
+    const path = cachePath(source, competition);
+    const info = statSync(path);
+    if (!info.isFile() || info.size > MAX_STATE_BYTES) return void 0;
+    const bytes = readFileSync2(path);
+    if (bytes.byteLength > MAX_STATE_BYTES) return void 0;
+    const parsed = JSON.parse(bytes.toString("utf8"));
+    return isCacheState(parsed) ? parsed : void 0;
   } catch {
     return void 0;
   }
@@ -5389,41 +6037,45 @@ function readCurrentState(source, competition) {
 }
 function writeState(state) {
   writeFileAtomic(
-    cachePath2(state.source, state.competition),
+    cachePath(state.source, state.competition),
     JSON.stringify({ ...state, version: CACHE_VERSION })
   );
 }
+var MAX_BACKOFF_MS = 30 * 6e4;
 function backoffActive(state, now = Date.now()) {
   if (!state?.backoffUntil) return false;
   const t2 = Date.parse(state.backoffUntil);
-  return Number.isFinite(t2) && now < t2;
+  if (!Number.isFinite(t2)) return false;
+  return now < t2 && t2 - now <= MAX_BACKOFF_MS;
 }
 function fixturesAttemptAgeMs(state, now = Date.now()) {
-  if (!state?.fixturesAttemptedAt) return Infinity;
-  const t2 = Date.parse(state.fixturesAttemptedAt);
-  return Number.isFinite(t2) ? now - t2 : Infinity;
+  return stampAgeMs(state?.fixturesAttemptedAt, now);
+}
+var FUTURE_SKEW_MS2 = 6e4;
+function stampAgeMs(value, now) {
+  if (!value) return Infinity;
+  const t2 = Date.parse(value);
+  if (!Number.isFinite(t2)) return Infinity;
+  const age = now - t2;
+  return age < -FUTURE_SKEW_MS2 ? Infinity : age;
 }
 function ageMs(state, now = Date.now()) {
-  if (!state) return Infinity;
-  const t2 = Date.parse(state.updatedAt);
-  return Number.isFinite(t2) ? now - t2 : Infinity;
+  return stampAgeMs(state?.updatedAt, now);
 }
 function fixturesAgeMs(state, now = Date.now()) {
-  if (!state?.fixturesUpdatedAt) return Infinity;
-  const t2 = Date.parse(state.fixturesUpdatedAt);
-  return Number.isFinite(t2) ? now - t2 : Infinity;
+  return stampAgeMs(state?.fixturesUpdatedAt, now);
 }
 function lockAgeMs(now = Date.now()) {
   const lp = lockPath();
   try {
-    const contents = readFileSync4(lp, "utf8");
+    const contents = readFileSync2(lp, "utf8");
     const written = Number.parseInt(contents.split(/\s+/)[1] ?? "", 10);
-    if (Number.isFinite(written)) return now - written;
+    if (Number.isFinite(written)) return stampAgeMs(new Date(written).toISOString(), now);
   } catch {
     return Infinity;
   }
   try {
-    return now - statSync(lp).mtimeMs;
+    return stampAgeMs(new Date(statSync(lp).mtimeMs).toISOString(), now);
   } catch {
     return Infinity;
   }
@@ -5471,8 +6123,172 @@ function releaseLock() {
   }
 }
 
+// src/marketCache.ts
+var POSITIVE_TTL_MS = 10 * 6e4;
+var NEGATIVE_TTL_MS = 3 * 6e4;
+var MAX_MARKET_CACHE_BYTES = 1024 * 1024;
+var FUTURE_SKEW_MS3 = 6e4;
+function cachePath2() {
+  return join3(cacheDir(), "market-signals.json");
+}
+function readFile() {
+  try {
+    const path = cachePath2();
+    const info = statSync2(path);
+    if (!info.isFile() || info.size > MAX_MARKET_CACHE_BYTES) return void 0;
+    const bytes = readFileSync3(path);
+    if (bytes.byteLength > MAX_MARKET_CACHE_BYTES) return void 0;
+    const parsed = JSON.parse(bytes.toString("utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function isEntryShaped(e) {
+  if (!e || typeof e !== "object") return false;
+  const entry = e;
+  if (typeof entry.fetchedAt !== "string" || !Number.isFinite(Date.parse(entry.fetchedAt))) {
+    return false;
+  }
+  if (entry.signal === null) return true;
+  return !!entry.signal && typeof entry.signal === "object";
+}
+function isUsableSignal(s) {
+  if (!s) return false;
+  if (s.source === "" || s.asOf === "" || s.outcomes.length === 0) return false;
+  if (s.outcomes.some((o) => o.kind === "other")) return false;
+  if (s.ambiguous) return false;
+  if (!s.favorite) return false;
+  return hasSaneDistribution(s.outcomes);
+}
+function readMarketCache(source, competition, now = Date.now()) {
+  const signals = /* @__PURE__ */ new Map();
+  const checked = /* @__PURE__ */ new Set();
+  const file = readFile();
+  if (!file || file.source !== source || file.competition !== competition) {
+    return { signals, checked };
+  }
+  const entries = file.entries;
+  if (!entries || typeof entries !== "object" || Array.isArray(entries)) {
+    return { signals, checked };
+  }
+  let examined = 0;
+  for (const id in entries) {
+    if (!Object.hasOwn(entries, id)) continue;
+    if (examined >= 256) break;
+    examined += 1;
+    const raw = entries[id];
+    if (!isEntryShaped(raw)) continue;
+    const entry = raw;
+    const t2 = Date.parse(entry.fetchedAt);
+    const ttl = entry.signal ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS;
+    const age = now - t2;
+    if (age > ttl || age < -FUTURE_SKEW_MS3) continue;
+    if (entry.signal === null) {
+      checked.add(id);
+      continue;
+    }
+    const sealed = parseCachedMarketSignal(entry.signal, { now: new Date(now) });
+    if (sealed.kind !== "valid") continue;
+    const clean = sealed.value;
+    if (clean.matchId !== id || clean.source !== source) continue;
+    if (!isUsableSignal(clean)) continue;
+    checked.add(id);
+    signals.set(id, clean);
+  }
+  return { signals, checked };
+}
+function writeMarketCache(source, competition, attempted, fetched, now = Date.now()) {
+  if (attempted.length === 0) return;
+  try {
+    const existing = readFile();
+    const reuse = existing && existing.source === source && existing.competition === competition;
+    const carried = {};
+    if (reuse && existing.entries && typeof existing.entries === "object" && !Array.isArray(existing.entries)) {
+      let examined = 0;
+      for (const id in existing.entries) {
+        if (!Object.hasOwn(existing.entries, id)) continue;
+        if (examined >= 256) break;
+        examined += 1;
+        const raw = existing.entries[id];
+        if (!isEntryShaped(raw)) continue;
+        const age = stampAgeMs(raw.fetchedAt, now);
+        if (age > (raw.signal ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS)) continue;
+        if (age < -FUTURE_SKEW_MS3) continue;
+        if (raw.signal !== null && !isUsableSignal(parsedValue(parseCachedMarketSignal(raw.signal, { now: new Date(now) })))) {
+          continue;
+        }
+        carried[id] = raw;
+      }
+    }
+    const base = { source, competition, entries: carried };
+    const fetchedAt = new Date(now).toISOString();
+    for (const id of attempted.slice(0, 256)) {
+      base.entries[id] = { fetchedAt, signal: fetched.get(id) ?? null };
+    }
+    writeFileAtomic(cachePath2(), JSON.stringify(base));
+  } catch {
+  }
+}
+
+// src/starNudge.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+var REPO_URL = "https://github.com/arturogarrido/claudinho";
+var NUDGE_EVERY = 5;
+function counterPath() {
+  return join4(cacheDir(), "runs.json");
+}
+function shouldNudge(runCount, every = NUDGE_EVERY) {
+  return runCount > 0 && runCount % every === 0;
+}
+function bumpRunCount(path = counterPath()) {
+  try {
+    let count2 = 0;
+    try {
+      const raw = JSON.parse(readFileSync4(path, "utf8"));
+      if (typeof raw.count === "number" && Number.isFinite(raw.count)) count2 = raw.count;
+    } catch {
+      count2 = 0;
+    }
+    count2 += 1;
+    writeFileAtomic(path, JSON.stringify({ count: count2 }));
+    return count2;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/clipboard.ts
+import { spawnSync } from "child_process";
+function clipboardTools(platform) {
+  if (platform === "darwin") return [{ cmd: "pbcopy", args: [] }];
+  if (platform === "win32") return [{ cmd: "clip", args: [] }];
+  return [
+    { cmd: "wl-copy", args: [] },
+    { cmd: "xclip", args: ["-selection", "clipboard"] },
+    { cmd: "xsel", args: ["--clipboard", "--input"] }
+  ];
+}
+function copyToClipboard(text, platform = process.platform) {
+  for (const { cmd, args } of clipboardTools(platform)) {
+    try {
+      const res = spawnSync(cmd, args, {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"],
+        timeout: 1e3
+      });
+      if (!res.error && res.status === 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
 // src/statusline.ts
 var DISPLAY_STALE_MS = 5 * 6e4;
+var TOURNAMENT_COMPLETE_LINE = "\u26BD World Cup 2026 is complete \xB7 Thanks for vibing with Claudinho";
 var FLAGLESS_TERMINALS = /* @__PURE__ */ new Set(["WarpTerminal"]);
 function flagsEnabled(env = process.env) {
   const v = (env.CLAUDINHO_FLAGS ?? "").trim().toLowerCase();
@@ -5506,35 +6322,110 @@ function matchSegment(m, compact, flags) {
   const away = compact ? m.away.flag : `${m.away.code} ${m.away.flag}`;
   return `${home} ${scoreline(m)} ${away} ${minute}`;
 }
+var MAX_LIVE_CONSIDERED = 64;
+var MAX_LIVE_EXAMINED = 512;
+function sealFixtures(raw) {
+  if (raw === void 0) {
+    return { items: [], total: 0, shown: 0, truncated: false, complete: true };
+  }
+  if (!Array.isArray(raw)) {
+    return { items: [], total: 0, shown: 0, truncated: false, complete: false };
+  }
+  const out2 = [];
+  let inspected = 0;
+  let readable = true;
+  for (const rec of raw) {
+    if (out2.length >= MAX_LIVE_CONSIDERED || inspected >= MAX_LIVE_EXAMINED) break;
+    inspected++;
+    if (!isMatchShaped(rec)) {
+      readable = false;
+      continue;
+    }
+    const sealed = parsedValue(parseCachedMatch(rec, { events: false }));
+    if (sealed) out2.push(sealed);
+    else readable = false;
+  }
+  const exhausted = inspected === raw.length;
+  const complete = exhausted && readable;
+  return {
+    items: out2,
+    // Exact only when complete; otherwise this is the number actually sealed.
+    // Callers use a nonnumeric marker for an incomplete scan.
+    total: out2.length,
+    shown: out2.length,
+    truncated: !exhausted,
+    complete
+  };
+}
 function liveMatchesFromCache(state, nowMs = Date.now()) {
   const fresh = state && ageMs(state, nowMs) < DISPLAY_STALE_MS;
-  const liveArr = fresh && Array.isArray(state?.live) ? state.live : [];
-  return liveArr.filter(
-    (m) => !!m && typeof m === "object" && isLive(m.status) && !!m.home?.code && !!m.away?.code
-  ).map(sanitizeMatchStrings);
+  const rawLive = fresh ? state?.live : [];
+  if (!Array.isArray(rawLive)) {
+    return { items: [], total: 0, shown: 0, truncated: false, complete: false };
+  }
+  const liveArr = rawLive;
+  const out2 = [];
+  let inspected = 0;
+  let readable = true;
+  for (let i = 0; i < liveArr.length; i++) {
+    if (out2.length >= MAX_LIVE_CONSIDERED || inspected >= MAX_LIVE_EXAMINED) break;
+    inspected++;
+    const raw = liveArr[i];
+    if (!raw || typeof raw !== "object") {
+      readable = false;
+      continue;
+    }
+    const m = raw;
+    if (!isLive(m.status) || !m.home?.code || !m.away?.code) {
+      readable = false;
+      continue;
+    }
+    const sealed = parsedValue(parseCachedMatch(m, { events: false }));
+    if (sealed) out2.push(sealed);
+    else readable = false;
+  }
+  const exhausted = inspected === liveArr.length;
+  const complete = exhausted && readable;
+  return {
+    items: out2,
+    total: out2.length,
+    shown: out2.length,
+    truncated: !exhausted,
+    // False when we stopped early or a record was unreadable. In either case an
+    // empty list must not render as the authoritative "nothing is on".
+    complete
+  };
 }
+var DEFAULT_MAX_SEGMENTS = 8;
+var MAX_LINE_COLUMNS = 200;
 function renderPrompt(state, opts = {}) {
+  return truncateVisible(renderPromptLine(state, opts), MAX_LINE_COLUMNS);
+}
+function renderPromptLine(state, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
+  const defaultCompetition = opts.defaultCompetition ?? true;
   const compact = opts.compact ?? true;
   const flags = opts.flags ?? true;
   const team = opts.team?.toUpperCase();
-  const live = liveMatchesFromCache(state, nowMs);
-  const cachedFixtures = Array.isArray(state?.fixtures) ? state.fixtures.filter(isMatchShaped).map(sanitizeMatchStrings) : [];
+  const liveList = liveMatchesFromCache(state, nowMs);
+  const live = liveList.items;
+  const cachedFixtureList = sealFixtures(state?.fixtures);
+  const cachedFixtures = [...cachedFixtureList.items];
   const schedule = cachedFixtures.length ? mergeLive(allFixtures(), cachedFixtures) : void 0;
   if (team) {
     const mine = live.find((m) => m.home?.code === team || m.away?.code === team);
     if (mine) return `\u26BD ${matchSegment(mine, compact, flags)}`;
   } else if (live.length > 0) {
-    const max = opts.max && opts.max > 0 ? opts.max : live.length;
+    const max = opts.max && opts.max > 0 ? Math.min(opts.max, DEFAULT_MAX_SEGMENTS) : DEFAULT_MAX_SEGMENTS;
     const shown = live.slice(0, max);
-    let line2 = "\u26BD " + shown.map((m) => matchSegment(m, compact, flags)).join(" \xB7 ");
     const overflow = live.length - shown.length;
-    if (overflow > 0) line2 += ` +${overflow}`;
-    return line2;
+    const marker = !liveList.complete ? " +more" : overflow > 0 ? ` +${overflow}` : "";
+    const body = "\u26BD " + shown.map((m) => matchSegment(m, compact, flags)).join(" \xB7 ");
+    return truncateVisible(body, MAX_LINE_COLUMNS - displayWidth(marker)) + marker;
   }
   const cacheFresh = !!state && state.degraded !== true && ageMs(state, nowMs) < DISPLAY_STALE_MS;
-  if (!cacheFresh) {
+  if (!cacheFresh || !liveList.complete) {
     const win = fixturesInLiveWindow(nowMs, schedule).filter(
       (m) => !team || m.home.code === team || m.away.code === team
     );
@@ -5549,10 +6440,22 @@ function renderPrompt(state, opts = {}) {
   if (next && isResolvedFixture(next)) {
     return `${teamTok(next.home, flags)} vs ${teamTok(next.away, flags)} in ${countdown(next.kickoff, now)}`;
   }
+  if (defaultCompetition && isTournamentWindowOver(nowMs, schedule)) {
+    return TOURNAMENT_COMPLETE_LINE;
+  }
   return "\u26BD \u2014";
 }
 
 // src/hook.ts
+var MAX_HOOK_MATCHES = 12;
+var MAX_HOOK_CODE_POINTS = 4096;
+function boundContext(text, marker = "") {
+  const points = [...text];
+  if (points.length + [...marker].length <= MAX_HOOK_CODE_POINTS) return text + marker;
+  const room = Math.max(0, MAX_HOOK_CODE_POINTS - [...marker].length);
+  return `${points.slice(0, room).join("")}
+(context truncated)${marker}`;
+}
 function rosterPinned(t2) {
   const { team } = lookupTeam(t2.code);
   return team ? { ...t2, name: team.name, flag: team.flag } : t2;
@@ -5569,7 +6472,8 @@ function renderHook(state, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const team = opts.team?.toUpperCase();
   const flags = opts.flags ?? true;
-  let live = liveMatchesFromCache(state, now.getTime());
+  const liveList = liveMatchesFromCache(state, now.getTime());
+  let live = [...liveList.items];
   if (live.length === 0) return "";
   if (team) {
     live = [...live].sort((a, b) => {
@@ -5578,9 +6482,13 @@ function renderHook(state, opts = {}) {
       return aHas - bHas;
     });
   }
-  const lines = live.map((mm) => line(mm, flags)).join("\n");
-  return `[Claudinho \u2014 live football scores right now]
-${lines}`;
+  const shown = live.slice(0, MAX_HOOK_MATCHES);
+  const overflow = live.length - shown.length;
+  const lines = shown.map((mm) => line(mm, flags)).join("\n");
+  const more = !liveList.complete ? "\n(more live matches may not be shown)" : overflow > 0 ? `
+(+${overflow} more not shown)` : "";
+  return boundContext(`[Claudinho \u2014 live football scores right now]
+${lines}`, more);
 }
 
 // src/refresh.ts
@@ -5869,11 +6777,15 @@ function adapterFor({ cfg, adapter }) {
 }
 var DEFAULT_ON_MARKET_OPTS = { deadlineMs: 2e3, timeoutMs: 2500 };
 var MARKETS_CMD_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
-async function marketSignalsFor(ctx, matches, opts = {}) {
-  if (ctx.marketProvider) return (await getMarketSignals(ctx.marketProvider, matches, opts)).signals;
+async function marketSignalsFor(ctx, matches, opts = {}, providerFactory = makeMarketProvider) {
+  if (ctx.marketProvider) {
+    const b = await getMarketSignals(ctx.marketProvider, matches, opts);
+    return { signals: resolvedValues(b), complete: b.complete };
+  }
   const source = resolveMarketSource();
   if (source !== "polymarket") {
-    return (await getMarketSignals(makeMarketProvider(source), matches, opts)).signals;
+    const b = await getMarketSignals(providerFactory(source), matches, opts);
+    return { signals: resolvedValues(b), complete: b.complete };
   }
   const competition = resolveCompetition();
   const { signals: cached, checked: cachedIds } = readMarketCache("polymarket", competition);
@@ -5881,35 +6793,39 @@ async function marketSignalsFor(ctx, matches, opts = {}) {
   const miss = [];
   for (const m of matches) {
     const hit = cached.get(m.id);
-    if (hit) result.set(m.id, hit);
-    else if (!cachedIds.has(m.id)) miss.push(m);
+    if (hit && marketSignalRendersFor(m, hit)) {
+      result.set(m.id, hit);
+      continue;
+    }
+    if (!hit && cachedIds.has(m.id)) continue;
+    miss.push(m);
   }
+  let complete = true;
   if (miss.length > 0) {
-    const { signals: fetched, checked } = await getMarketSignals(
-      makeMarketProvider("polymarket"),
-      miss,
-      opts
-    );
-    writeMarketCache("polymarket", competition, [...checked], fetched);
+    const batch = await getMarketSignals(providerFactory("polymarket"), miss, opts);
+    const fetched = resolvedValues(batch);
+    complete = batch.complete;
+    writeMarketCache("polymarket", competition, [...cacheableKeys(batch)], fetched);
     for (const [id, s] of fetched) result.set(id, s);
   }
-  return result;
+  return { signals: result, complete };
 }
 async function reliableMarketSignals(ctx, matches) {
-  if (ctx.cfg.markets === false) return /* @__PURE__ */ new Map();
+  if (ctx.cfg.markets === false) return { signals: /* @__PURE__ */ new Map(), complete: true };
   const now = ctx.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
-  if (relevant.length === 0) return /* @__PURE__ */ new Map();
+  if (relevant.length === 0) return { signals: /* @__PURE__ */ new Map(), complete: true };
   const raw = await marketSignalsFor(ctx, relevant, DEFAULT_ON_MARKET_OPTS);
   const out2 = /* @__PURE__ */ new Map();
-  for (const [id, s] of raw) {
+  for (const [id, s] of raw.signals) {
     const m = relevant.find((x) => x.id === id);
     if (m && isReliableMarketSignal(s, { now }) && marketSignalRendersFor(m, s)) out2.set(id, s);
   }
-  return out2;
+  return { signals: out2, complete: raw.complete };
 }
 async function reliableMarketSignalFor(ctx, match) {
-  return (await reliableMarketSignals(ctx, [match])).get(match.id);
+  const result = await reliableMarketSignals(ctx, [match]);
+  return { signal: result.signals.get(match.id), complete: result.complete };
 }
 function out(line2 = "") {
   process.stdout.write(line2 + "\n");
@@ -5968,14 +6884,15 @@ async function cmdToday(date, ctx) {
   const targetDate = date ?? localDate((/* @__PURE__ */ new Date()).toISOString(), cfg.tz);
   const { matches, degraded, source } = await getMatchesForDate(adapter, targetDate);
   const todays = fixturesByDate(targetDate, matches, cfg.tz);
-  const signals = await reliableMarketSignals(ctx, todays);
+  const market = await reliableMarketSignals(ctx, todays);
   if (cfg.json) {
     emitJson({
       date: targetDate,
       degraded,
       source: source ?? null,
       matches: todays,
-      marketSignals: Object.fromEntries(signals)
+      marketComplete: market.complete,
+      marketSignals: Object.fromEntries(market.signals)
     });
     return;
   }
@@ -5990,16 +6907,19 @@ async function cmdToday(date, ctx) {
   } else {
     for (const m of todays) {
       out(matchLine(m, cfg, t2, c, flags));
-      const s = signals.get(m.id);
+      const s = market.signals.get(m.id);
       if (s) out("    " + c.dim(marketLine(s, m)));
     }
   }
+  if (!market.complete) {
+    out(c.dim("  Market data unavailable or incomplete \u2014 not all fixtures were checked."));
+  }
   out();
   if (degraded) out(c.dim("  " + t2("feed.degraded")));
   const src = dataSource(source, cfg.lang, c);
   if (src) out(src);
   out(disclaimer(t2, c));
-  maybeStarNudge(ctx);
+  endScoreCommand(ctx);
 }
 async function cmdLive(ctx) {
   const { cfg, t: t2 } = ctx;
@@ -6026,7 +6946,7 @@ async function cmdLive(ctx) {
   const src = dataSource(source, cfg.lang, c);
   if (src) out(src);
   out(disclaimer(t2, c));
-  maybeStarNudge(ctx);
+  endScoreCommand(ctx);
 }
 async function cmdNext(team, ctx) {
   const { cfg, t: t2, now } = ctx;
@@ -6048,6 +6968,7 @@ async function cmdNext(team, ctx) {
     out(c.dim("  " + (degraded ? t2("live.degraded") : t2("next.none", { team: code }))));
     out();
     out(disclaimer(t2, c));
+    endScoreCommand(ctx);
     return;
   }
   out(header(t2("next.label", { team: code }), c));
@@ -6063,7 +6984,7 @@ async function cmdNext(team, ctx) {
   const src = dataSource(source, cfg.lang, c);
   if (src) out(src);
   out(disclaimer(t2, c));
-  maybeStarNudge(ctx);
+  endScoreCommand(ctx);
 }
 function cmdTeam(query, ctx) {
   const { cfg, t: t2 } = ctx;
@@ -6077,9 +6998,9 @@ function cmdTeam(query, ctx) {
   const c = painterFor(cfg);
   const flags = flagsEnabled();
   const label = (tm) => {
-    const flag = flags ? `${tm.flag} ` : "";
+    const flag2 = flags ? `${tm.flag} ` : "";
     const grp = tm.group ? ` \xB7 ${t2("team.group", { group: tm.group })}` : "";
-    return `  ${flag}${c.bold(tm.name)}  ${c.dim(tm.code + grp)}`;
+    return `  ${flag2}${c.bold(tm.name)}  ${c.dim(tm.code + grp)}`;
   };
   out();
   if (!q) {
@@ -6115,11 +7036,12 @@ async function cmdTable(group, ctx) {
     out();
     out(
       c.dim(
-        "  " + (group ? t2("table.none", { group: group.toUpperCase() }) : t2("table.empty"))
+        "  " + (degraded ? t2("table.unavailable") : group ? t2("table.none", { group: group.toUpperCase() }) : t2("table.empty"))
       )
     );
     out();
-    if (degraded) out(c.dim("  " + t2("table.degraded")));
+    const src2 = dataSource(source, cfg.lang, c);
+    if (src2) out(src2);
     out(disclaimer(t2, c));
     return;
   }
@@ -6221,7 +7143,15 @@ function cmdPrompt({ cfg }, io = {}) {
     const maxRaw = Number.parseInt(process.env.CLAUDINHO_MAX ?? "", 10);
     const max = Number.isFinite(maxRaw) && maxRaw > 0 ? maxRaw : void 0;
     const state = readCurrentState(cfg.source, resolveCompetition());
-    const scoreLine = renderPrompt(state, { team, compact, max, flags: flagsEnabled() });
+    const scoreLine = renderPrompt(state, {
+      team,
+      compact,
+      max,
+      flags: flagsEnabled(),
+      // The bundled schedule describes the default competition only — see the
+      // sign-off gate in renderPrompt.
+      defaultCompetition: resolveCompetition() === DEFAULT_COMPETITION
+    });
     out(renderPromptOutput(scoreLine, payload));
     if (!state && !isLockFresh() || shouldRefresh(Date.now(), state) || shouldRefreshFixtures(Date.now(), state)) {
       spawnRefresh(cfg.source);
@@ -6322,13 +7252,14 @@ async function cmdMatch(id, ctx) {
   const { cfg, t: t2 } = ctx;
   precheck(cfg, t2);
   const { match, degraded, source: liveSource } = await getMatchById(adapterFor(ctx), id);
-  const marketSignal = match ? await reliableMarketSignalFor(ctx, match) : void 0;
+  const market = match ? await reliableMarketSignalFor(ctx, match) : { signal: void 0, complete: true };
   if (cfg.json) {
     emitJson({
       degraded,
       match: match ?? null,
       source: liveSource ?? null,
-      marketSignal: marketSignal ?? null
+      marketComplete: market.complete,
+      marketSignal: market.signal ?? null
     });
     return;
   }
@@ -6356,9 +7287,13 @@ async function cmdMatch(id, ctx) {
       out(`  ${e.minute}'  ${e.type}  ${e.teamCode}${e.player ? ` \u2014 ${e.player}` : ""}`);
     }
   }
-  if (marketSignal) {
+  if (market.signal) {
     out();
-    for (const mline of marketBlock(marketSignal, match)) out("  " + c.dim(mline));
+    for (const mline of marketBlock(market.signal, match)) out("  " + c.dim(mline));
+  }
+  if (!market.complete) {
+    out();
+    out(c.dim("  Market data unavailable or incomplete \u2014 this match could not be checked."));
   }
   out();
   if (degraded) out(c.dim("  " + t2("feed.degraded")));
@@ -6389,14 +7324,16 @@ async function cmdMarkets(target, team, ctx) {
     const code = resolveTeamArg(team, "Usage: claudinho markets next <team> (or set CLAUDINHO_TEAM)", t2);
     const now2 = ctx.now ?? /* @__PURE__ */ new Date();
     const { match: fixture, degraded } = await marketFixtureForTeam(adapterFor(ctx), code, now2);
-    const sig = fixture && marketRelevant(fixture, now2) ? (await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS)).get(fixture.id) : void 0;
-    const shown = fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
+    const market = fixture && marketRelevant(fixture, now2) ? await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS) : { signals: /* @__PURE__ */ new Map(), complete: true };
+    const sig = fixture ? market.signals.get(fixture.id) : void 0;
+    const shown = market.complete && fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
     if (cfg.json) {
       emitJson({
         team: code,
         matchId: fixture?.id ?? null,
         degraded,
         informationalOnly: true,
+        complete: market.complete,
         signal: shown ?? null
       });
       return;
@@ -6409,7 +7346,9 @@ async function cmdMarkets(target, team, ctx) {
       out(header(marketHeaderLine(fixture, cfg), c2));
       out();
       if (shown) printMarketBlock(fixture, shown, c2);
-      else out(c2.dim("    " + noSignalLine(fixture, now2)));
+      else if (!market.complete) {
+        out(c2.dim("    Market data unavailable or incomplete \u2014 this match could not be checked."));
+      } else out(c2.dim("    " + noSignalLine(fixture, now2)));
     }
     out();
     out(disclaimer(t2, c2));
@@ -6420,10 +7359,16 @@ async function cmdMarkets(target, team, ctx) {
     precheck(cfg, t2);
     const now2 = ctx.now ?? /* @__PURE__ */ new Date();
     const { match } = await getMatchById(adapterFor(ctx), target);
-    const sig = match && marketRelevant(match, now2) ? (await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS)).get(match.id) : void 0;
-    const shown = match && sig && marketDisplayable(match, sig) ? sig : void 0;
+    const market = match && marketRelevant(match, now2) ? await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS) : { signals: /* @__PURE__ */ new Map(), complete: true };
+    const sig = match ? market.signals.get(match.id) : void 0;
+    const shown = market.complete && match && sig && marketDisplayable(match, sig) ? sig : void 0;
     if (cfg.json) {
-      emitJson({ matchId: target, informationalOnly: true, signal: shown ?? null });
+      emitJson({
+        matchId: target,
+        informationalOnly: true,
+        complete: market.complete,
+        signal: shown ?? null
+      });
       return;
     }
     const c2 = painterFor(cfg);
@@ -6434,7 +7379,9 @@ async function cmdMarkets(target, team, ctx) {
       out(header(marketHeaderLine(match, cfg), c2));
       out();
       if (shown) printMarketBlock(match, shown, c2);
-      else out(c2.dim("    " + noSignalLine(match, now2)));
+      else if (!market.complete) {
+        out(c2.dim("    Market data unavailable or incomplete \u2014 this match could not be checked."));
+      } else out(c2.dim("    " + noSignalLine(match, now2)));
     }
     out();
     out(disclaimer(t2, c2));
@@ -6448,14 +7395,14 @@ async function cmdMarkets(target, team, ctx) {
   const { matches } = await getMatchesForDate(adapterFor(ctx), date);
   const todays = fixturesByDate(date, matches, cfg.tz);
   const relevant = todays.filter((m) => marketRelevant(m, now));
-  const signals = await marketSignalsFor(ctx, relevant, MARKETS_CMD_OPTS);
+  const { signals, complete } = await marketSignalsFor(ctx, relevant, MARKETS_CMD_OPTS);
   const rows = relevant.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
     (r) => !!r.signal && marketDisplayable(r.match, r.signal)
   );
   if (cfg.json) {
     const marketSignals = {};
     for (const r of rows) marketSignals[r.match.id] = r.signal;
-    emitJson({ date, informationalOnly: true, marketSignals });
+    emitJson({ date, informationalOnly: true, complete, marketSignals });
     return;
   }
   const c = painterFor(cfg);
@@ -6463,13 +7410,21 @@ async function cmdMarkets(target, team, ctx) {
   out(header(`Market signals \xB7 ${date}`, c));
   out();
   if (rows.length === 0) {
-    out(c.dim(`  No market signals available for ${date}.`));
+    out(
+      c.dim(
+        complete ? `  No market signals available for ${date}.` : `  Market data unavailable or incomplete for ${date} \u2014 not all fixtures could be checked.`
+      )
+    );
   } else {
     for (const { match, signal } of rows) {
       out("  " + c.bold(marketHeaderLine(match, cfg)));
       printMarketBlock(match, signal, c);
       out();
     }
+    if (!complete) {
+      out(c.dim(`  Market data unavailable or incomplete for ${date} \u2014 not all fixtures could be checked.`));
+      out();
+    }
   }
   out(disclaimer(t2, c));
   out(c.dim(MARKET_INFO));
@@ -6480,11 +7435,11 @@ function pickShareStyle(v) {
 async function reliableShareSignals(ctx, matches) {
   const raw = await reliableMarketSignals(ctx, matches);
   const out2 = /* @__PURE__ */ new Map();
-  for (const [id, s] of raw) {
+  for (const [id, s] of raw.signals) {
     const m = matches.find((x) => x.id === id);
     if (m && marketDisplayable(m, s)) out2.set(id, s);
   }
-  return out2;
+  return { signals: out2, complete: raw.complete };
 }
 function emitShare(ctx, e, copy) {
   const snippet = formatShareSnippet(e.input, e.options);
@@ -6499,6 +7454,7 @@ function emitShare(ctx, e, copy) {
       style: e.options.style ?? "social",
       snippet,
       matches: e.input.matches,
+      marketComplete: e.input.marketComplete ?? true,
       marketSignals: Object.fromEntries(e.input.marketSignals ?? /* @__PURE__ */ new Map())
     });
   } else {
@@ -6618,11 +7574,12 @@ async function cmdShare(target, team, opts, ctx) {
       {
         group,
         tables,
-        // Degraded ⇒ a static roster, served by no live provider: no attribution.
+        // Degraded ⇒ no live provider: no attribution. Open-scope outages
+        // have no compatible bundled roster, so name the outage in the empty card.
         source: degraded2 ? void 0 : source2,
         degraded: degraded2,
         installLine: group ? `npx @claudinho/cli table ${group}` : "npx @claudinho/cli table",
-        emptyNote: group ? `No group ${group}.` : "No standings available.",
+        emptyNote: degraded2 ? "Live standings unavailable." : group ? `No group ${group}.` : "No standings available.",
         options: baseOptions
       },
       copy
@@ -6669,7 +7626,7 @@ async function cmdShare(target, team, opts, ctx) {
       ctx.now ?? /* @__PURE__ */ new Date()
     );
     const matches = fixture ? [fixture] : [];
-    const signals2 = await reliableShareSignals(ctx, matches);
+    const market2 = await reliableShareSignals(ctx, matches);
     const teamName = fixture ? fixture.home.code === code ? fixture.home.name : fixture.away.name : code;
     emitShare(
       ctx,
@@ -6680,7 +7637,8 @@ async function cmdShare(target, team, opts, ctx) {
         input: {
           title: `Next up for ${teamName}`,
           matches,
-          marketSignals: signals2,
+          marketSignals: market2.signals,
+          marketComplete: market2.complete,
           // Attribute the provider when the overlay resolved the tie (knockout);
           // undefined for a static group fixture — parity with CLI `next`.
           source: source2,
@@ -6701,7 +7659,7 @@ async function cmdShare(target, team, opts, ctx) {
     precheck(cfg, t2);
     const { match, degraded: degraded2, source: source2 } = await getMatchById(adapterFor(ctx), target);
     const matches = match ? [match] : [];
-    const signals2 = await reliableShareSignals(ctx, matches);
+    const market2 = await reliableShareSignals(ctx, matches);
     emitShare(
       ctx,
       {
@@ -6710,7 +7668,8 @@ async function cmdShare(target, team, opts, ctx) {
         input: {
           title: "Match pulse",
           matches,
-          marketSignals: signals2,
+          marketSignals: market2.signals,
+          marketComplete: market2.complete,
           source: source2,
           degraded: degraded2,
           emptyNote: `No match found with id ${target}.`,
@@ -6729,7 +7688,7 @@ async function cmdShare(target, team, opts, ctx) {
   const date = explicitDate ?? localDate((/* @__PURE__ */ new Date()).toISOString(), cfg.tz);
   const { matches: all, degraded, source } = await getMatchesForDate(adapterFor(ctx), date);
   const todays = fixturesByDate(date, all, cfg.tz);
-  const signals = await reliableShareSignals(ctx, todays);
+  const market = await reliableShareSignals(ctx, todays);
   const human = formatDate(`${date}T12:00:00.000Z`, { tz: cfg.tz, locale: cfg.lang });
   const title = explicitDate ? `Matches \xB7 ${human}` : `Today's matches \xB7 ${human}`;
   emitShare(
@@ -6740,7 +7699,8 @@ async function cmdShare(target, team, opts, ctx) {
       input: {
         title,
         matches: todays,
-        marketSignals: signals,
+        marketSignals: market.signals,
+        marketComplete: market.complete,
         source,
         degraded,
         emptyNote: `No matches scheduled for ${human}.`,
@@ -6813,6 +7773,22 @@ function maybeStarNudge(ctx) {
   out();
   out(c.dim(`  \u2B50 Enjoying Claudinho? Star it \u2192 ${REPO_URL}   (claudinho star)`));
 }
+function endScoreCommand(ctx) {
+  const over = resolveCompetition() === DEFAULT_COMPETITION && isTournamentWindowOver(ctx.now?.getTime() ?? Date.now());
+  if (over) printTournamentSignOff(ctx);
+  else maybeStarNudge(ctx);
+}
+function printTournamentSignOff(ctx) {
+  const { cfg, t: t2 } = ctx;
+  if (cfg.json) return;
+  const c = painterFor(cfg);
+  out();
+  out(`${t2("signoff.complete")} ${SHARE_HASHTAG}`);
+  if (!process.stdout.isTTY || process.env.CLAUDINHO_NO_STAR) return;
+  out();
+  out(c.dim(`\u2B50 ${t2("signoff.star")}`));
+  out(c.cyan(REPO_URL));
+}
 function printInitStarCta(cfg) {
   if (cfg.json || !process.stdout.isTTY || process.env.CLAUDINHO_NO_STAR) return;
   const c = painterFor(cfg);
@@ -6827,7 +7803,7 @@ function cmdVibe(ctx) {
   try {
     const state = readCurrentState(cfg.source, resolveCompetition());
     liveSeg = vibeLiveSegment(
-      liveMatchesFromCache(state, (ctx.now ?? /* @__PURE__ */ new Date()).getTime()),
+      liveMatchesFromCache(state, (ctx.now ?? /* @__PURE__ */ new Date()).getTime()).items,
       // Name-or-code, matching the statusline/hook (offline lookup).
       resolveEnvTeam(process.env.CLAUDINHO_TEAM)
     );
@@ -6853,7 +7829,7 @@ function handlePipeError(stream) {
 }
 handlePipeError(process.stdout);
 handlePipeError(process.stderr);
-var VERSION = "0.9.2";
+var VERSION = "0.9.4";
 var DISCLAIMER = "Claudinho is an independent fan project. Not affiliated with or endorsed by FIFA or Anthropic.";
 function ctxFrom(cmd) {
   let root = cmd;