@claudinho/core 0.9.3 → 0.10.0

package/dist/index.js

@@ -149,10 +149,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",
@@ -213,7 +214,7 @@ var BY_CODE = {
   HON: "HN",
   COD: "CD",
   MLI: "ML"
-};
+});
 function nationToFlag(nameOrCode) {
   const region = nationToRegion(nameOrCode);
   return region ? flagEmoji(region) : NEUTRAL;
@@ -221,7 +222,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++) {
@@ -246,11 +247,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)]);
 }
 
 // src/i18n.ts
@@ -272,6 +270,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",
@@ -301,6 +300,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",
@@ -330,6 +330,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",
@@ -359,6 +360,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",
@@ -447,7 +449,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, {
@@ -457,18 +466,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, {
@@ -476,10 +489,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);
@@ -490,75 +505,58 @@ 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);
 }
 
-// src/sanitize.ts
-var FEED_TEXT_MAX = 100;
-function sanitizeFeedText(value, max = FEED_TEXT_MAX) {
-  let out = "";
-  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;
-    out += isWhitespaceControl ? " " : ch;
-    count++;
-  }
-  return out;
-}
-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)
-  };
-}
-
 // src/text.ts
 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 out = "";
+  let w = 0;
+  for (const { segment } of segmenter.segment(s)) {
+    const cw = clusterWidth(segment);
+    if (w + cw > budget) break;
+    out += segment;
+    w += cw;
+  }
+  return out + 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);
@@ -3094,48 +3092,318 @@ function rosterAtZero(matches) {
   return [...teams.values()].sort((a, b) => a.name.localeCompare(b.name)).map(blankRow);
 }
 
-// src/adapters/espn.ts
-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.3"} (+https://github.com/arturogarrido/claudinho)`;
-var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-function competitionBase(slug) {
-  return `${ESPN_SOCCER}/${slug}`;
+// src/trust/bounded.ts
+function bounded(items, max, complete = true) {
+  const kept = items.length > max ? items.slice(0, max) : items;
+  return {
+    items: kept,
+    total: items.length,
+    shown: kept.length,
+    truncated: items.length > kept.length,
+    complete
+  };
 }
-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;
+function takeBounded(value, max) {
+  if (!Array.isArray(value)) return [];
+  return value.length > max ? value.slice(0, max) : value;
+}
+
+// src/trust/result.ts
+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";
+}
+
+// src/trust/roles.ts
+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 out = first;
+  for (let pass = 0; pass < 3; pass++) {
+    const again = sealLabelOnce(out, maxColumns);
+    if (again === out) return out;
+    out = again;
   }
-  /** 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);
+  return sealLabelOnce(out, maxColumns) === out ? out : "";
+}
+var lastPassDropped = false;
+function sealLabelOnce(value, maxColumns) {
+  lastPassDropped = false;
+  let normalized;
+  try {
+    normalized = value.normalize("NFC");
+  } catch {
+    return "";
   }
-};
+  const maxCodePoints = Math.max(16, maxColumns * 4);
+  let out = "";
+  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;
+    out += piece;
+    width += w;
+    points += cps;
+  }
+  try {
+    return out.normalize("NFC").trim();
+  } catch {
+    return out.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 out = new Date(t2).toISOString();
+  return ISO_CANONICAL.test(out) ? out : 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;
+}
+
+// src/trust/match.ts
+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 out = { type, minute, teamCode: humanLabel(e.teamCode, TEAM_CODE_COLUMNS) };
+  const player = humanLabel(e.player);
+  if (player) out.player = player;
+  return out;
+}
+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 out = { id, stage };
+  if (group) out.group = group;
+  out.kickoff = kickoff;
+  out.venue = humanLabel(parts.venue);
+  if (city) out.city = city;
+  if (country) out.country = country;
+  out.home = home;
+  out.away = away;
+  if (score) out.score = score;
+  if (shootout) out.shootout = shootout;
+  const minute = count(parts.minute, MAX_MINUTE);
+  if (minute !== void 0) out.minute = minute;
+  out.status = status;
+  if (events.length) out.events = events;
+  if (winnerCode) out.winnerCode = winnerCode;
+  out.updatedAt = canonicalTimestamp(parts.updatedAt) ?? "";
+  return valid(out);
+}
+function parseCachedMatch(raw, opts = {}) {
+  if (!raw || typeof raw !== "object") return definitiveNone("cache entry is not an object");
+  return sealMatch(raw, opts);
+}
+function parseCachedMatches(raw, max, opts = {}) {
+  const total = Array.isArray(raw) ? raw.length : 0;
+  const considered = takeBounded(raw, max);
+  const items = considered.map((m) => parseCachedMatch(m, opts)).flatMap((r) => r.kind === "valid" ? [r.value] : []);
+  return {
+    items,
+    total,
+    shown: items.length,
+    truncated: total > considered.length,
+    // Some record in the window was unreadable, or the window did not cover the
+    // file — either way we are not reporting on all of it.
+    complete: items.length === total
+  };
+}
+
+// src/trust/espn.ts
+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;
 }
@@ -3149,58 +3417,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,
@@ -3208,57 +3492,232 @@ 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 out = [];
-  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 seenCodes = /* @__PURE__ */ new Map();
+    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 { providerId, providerRank } = r.value;
+      const code = r.value.team.code;
+      const priorHadId = seenCodes.get(code);
+      const codeCollision = priorHadId !== void 0 && (providerId === void 0 || priorHadId === false);
+      if (codeCollision || seenRanks.has(providerRank) || providerId !== void 0 && seenProviderIds.has(providerId)) {
+        complete = false;
+        continue;
+      }
+      seenCodes.set(code, providerId !== void 0);
+      seenRanks.add(providerRank);
+      if (providerId !== void 0) seenProviderIds.add(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;
+    }
     out.push({ group: letter, rows: ranked.map((x) => x.row) });
   }
-  out.sort((a, b) => a.group.localeCompare(b.group));
-  return out;
+  return {
+    items: out,
+    total: seenGroups.size,
+    shown: out.length,
+    // We stopped early if the child list or any single group's rows were cut.
+    truncated: !sawAllChildren || rowsTruncated,
+    complete: complete && !rowsTruncated
+  };
+}
+
+// src/adapters/espn.ts
+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.10.0"} (+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 mapEspnEvent(ev, ctx = {}) {
+  return parsedValue(parseEspnEvent(ev, ctx));
+}
+function parseStandings(data) {
+  return [...parseEspnStandings(data).items];
+}
+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
@@ -3301,38 +3760,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 {};
@@ -3347,7 +3816,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;
@@ -3539,17 +4009,17 @@ function validateWinnerChain(nodes, problems) {
     { from: "QF", to: "SF", count: 4 },
     { from: "SF", to: "F", count: 2 }
   ];
-  for (const { from, to, count } of chains) {
+  for (const { from, to, count: count2 } of chains) {
     const refs = nodes.filter((n) => n.stage === to).flatMap((n) => [n.home, n.away]).filter((r) => r.kind === "winner" && r.stage === from);
     const indices = refs.map((r) => r.index);
-    if (indices.length !== count) {
-      problems.push(`${to}: expected ${count} ${from} winner refs, got ${indices.length}`);
+    if (indices.length !== count2) {
+      problems.push(`${to}: expected ${count2} ${from} winner refs, got ${indices.length}`);
     }
     const unique = new Set(indices);
-    if (unique.size !== count) {
-      problems.push(`${to}: ${from} winner indices must be unique 1..${count}`);
+    if (unique.size !== count2) {
+      problems.push(`${to}: ${from} winner indices must be unique 1..${count2}`);
     }
-    for (let i = 1; i <= count; i++) {
+    for (let i = 1; i <= count2; i++) {
       if (!unique.has(i)) problems.push(`${to}: missing ${from} winner index ${i}`);
       if (!indexMap.has(matchKey(from, i))) problems.push(`missing ${from} match index ${i}`);
     }
@@ -4284,7 +4754,7 @@ function loadBracketTopology() {
   return TOPOLOGY;
 }
 
-// src/live.ts
+// src/competition.ts
 function resolveCompetition(explicit) {
   if (explicit) return explicit;
   if (typeof process !== "undefined" && process.env?.CLAUDINHO_COMPETITION) {
@@ -4292,13 +4762,15 @@ function resolveCompetition(explicit) {
   }
   return DEFAULT_COMPETITION;
 }
+
+// src/live.ts
 var KNOWN_SOURCES = ["espn"];
-function makeAdapter(source = "espn") {
+function makeAdapter(source = "espn", opts = {}) {
   switch (source) {
     case "espn": {
       const competition = resolveCompetition();
       const baseUrl = competition === DEFAULT_COMPETITION ? void 0 : competitionBase(competition);
-      return new EspnAdapter({ baseUrl });
+      return new EspnAdapter({ baseUrl, enrichGroups: opts.enrichGroups });
     }
     default:
       throw new Error(
@@ -4327,17 +4799,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 };
 }
@@ -4394,7 +4875,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;
@@ -4458,15 +4942,149 @@ 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 };
   }
 }
 
+// src/markets/format.ts
+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;
+}
+
+// src/trust/market.ts
+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 out = { kind };
+  if (o.teamCode !== void 0) {
+    if (typeof o.teamCode !== "string") return void 0;
+    out.teamCode = humanLabel(o.teamCode, TEAM_CODE_COLUMNS2);
+  }
+  out.label = humanLabel(o.label);
+  out.probability = p;
+  if ((out.kind === "home" || out.kind === "away") && !out.teamCode) return void 0;
+  return out;
+}
+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 out = {
+    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) out.sourceMarketId = sourceMarketId;
+  out.asOf = canonicalTimestamp(s.asOf) ?? "";
+  out.fetchedAt = canonicalTimestamp(s.fetchedAt) ?? "";
+  out.outcomes = outcomes;
+  const isAmbiguous = s.ambiguous !== false;
+  const favorite = isAmbiguous ? void 0 : deriveFavorite(outcomes);
+  if (favorite) out.favorite = favorite;
+  if (liquidity !== void 0) out.liquidity = liquidity;
+  if (volume24h !== void 0) out.volume24h = volume24h;
+  out.stale = s.stale !== false;
+  out.ambiguous = isAmbiguous || out.source === "";
+  out.stale = out.stale || isStaleSignal(out, { now: options.now, maxAgeMs: options.maxAgeMs });
+  return valid(out);
+}
+function parseCachedMarketSignal(raw, options = {}) {
+  return sealMarketSignal(raw, options);
+}
+
 // src/markets/normalize.ts
 var DEFAULT_MAX_AGE_MS = 15 * 6e4;
 function marketRelevant(match, now = /* @__PURE__ */ new Date()) {
@@ -4486,9 +5104,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) {
@@ -4507,14 +5125,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;
@@ -4529,11 +5149,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 = {}) {
@@ -4549,8 +5171,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,
@@ -4562,68 +5184,35 @@ 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;
-}
-
-// src/markets/format.ts
-function pct(p) {
-  return Math.round(p * 100);
-}
-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)}%`);
+  const sealed = sealMarketSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
+  if (sealed.kind !== "valid") {
+    return { ...signal, outcomes: [], favorite: void 0, stale: true, ambiguous: true };
   }
-  for (const o of signal.outcomes) {
-    if (o.kind === "other") parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
-  }
-  return parts.join(" \xB7 ");
+  return { ...sealed.value, ambiguous: sealed.value.ambiguous || ambiguous2 };
 }
-function marketAttributionText(signal) {
-  const time = utcHhmm(signal.asOf);
-  const src = `Source: ${marketSourceLabel(signal.source)}`;
-  return time ? `${src} \xB7 updated ${time}` : src;
+
+// src/trust/batch.ts
+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 resolvedValues(batch) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, r] of batch.results) if (r.kind === "valid") out.set(key, r.value);
+  return out;
 }
-function marketLine(signal, match) {
-  return `Market: ${marketProbabilityText(signal, match)} \xB7 ${marketSourceLabel(
-    signal.source
-  )} \xB7 informational only`;
+function cacheableKeys(batch) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [key, r] of batch.results) if (isCacheable(r)) out.add(key);
+  return out;
 }
-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;
+function emptyBatch() {
+  return { results: /* @__PURE__ */ new Map(), complete: false };
 }
 
 // src/markets/fake.ts
@@ -4640,14 +5229,12 @@ var FakeMarketProvider = class {
     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}`);
@@ -4664,7 +5251,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,
@@ -4692,6 +5281,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;
@@ -4704,49 +5295,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),
@@ -4755,7 +5378,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}`);
     }
@@ -4764,63 +5387,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.seriesSlug !== WC_SERIES_SLUG && event.sport?.sport !== WC_SPORT) {
+      return definitiveNone("event is not in this competition");
     }
-    if (event.slug != null && event.slug !== eventSlug) return void 0;
-    const start = event.startTime ? Date.parse(event.startTime) : Number.NaN;
+    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");
+    }
+    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 moneyline = (event.markets ?? []).filter(
-      (m) => (m.sportsMarketType ?? "moneyline") === "moneyline"
+    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
@@ -4834,8 +5542,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();
@@ -4866,18 +5582,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;
@@ -4891,20 +5610,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 [];
     }
@@ -4912,15 +5640,19 @@ 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;
 }
 
 // src/markets/provider.ts
+var MARKET_COMPETITIONS = /* @__PURE__ */ new Set([DEFAULT_COMPETITION]);
+function marketsCoverCompetition(competition = resolveCompetition()) {
+  return MARKET_COMPETITIONS.has(competition);
+}
 function resolveMarketSource(explicit) {
   if (explicit) return explicit;
   if (typeof process !== "undefined" && process.env?.CLAUDINHO_MARKETS_SOURCE) {
@@ -4937,6 +5669,7 @@ function makeMarketProvider(source) {
       return new FakeMarketProvider();
     // no synth → yields no signals, no network
     default:
+      if (!marketsCoverCompetition()) return new FakeMarketProvider();
       return new PolymarketProvider();
   }
 }
@@ -4951,7 +5684,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();
   }
 }
 
@@ -5034,6 +5767,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,
@@ -5064,7 +5800,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(
@@ -5215,29 +5953,35 @@ export {
   DEFAULT_FLAVOR,
   DEFAULT_MAX_AGE_MS,
   EspnAdapter,
-  FEED_TEXT_MAX,
   FLAVOR_LEVELS,
   FakeMarketProvider,
   KNOCKOUT_EXTRA_TIME_MS,
   KNOWN_SOURCES,
   LIVE_WINDOW_MS,
+  MARKET_COMPETITIONS,
+  MAX_LABEL_COLUMNS,
   PolymarketProvider,
   ProviderError,
   SHARE_DISCLAIMER,
   SHARE_HASHTAG,
   allFixtures,
   allTeams,
+  ambiguous,
   asFlavorLevel,
+  bounded,
   buildBracketTopology,
   buildBracketView,
   buildMarketSignal,
   byKickoff,
+  cacheableKeys,
   competitionBase,
   computeStandings,
   countdown,
   currentOrNextFixtureForTeam,
+  definitiveNone,
   deriveFavorite,
   displayWidth,
+  emptyBatch,
   favoriteStrength,
   fixturesByDate,
   fixturesByGroup,
@@ -5265,6 +6009,8 @@ export {
   getStandings,
   groups,
   hasSaneDistribution,
+  humanLabel,
+  isCacheable,
   isFinished,
   isFlavorLevel,
   isLive,
@@ -5282,6 +6028,7 @@ export {
   lookupTeam,
   makeAdapter,
   makeMarketProvider,
+  malformed,
   mapEspnEvent,
   mapsCleanly,
   marketAttributionText,
@@ -5293,6 +6040,7 @@ export {
   marketRelevant,
   marketSignalRendersFor,
   marketSourceLabel,
+  marketsCoverCompetition,
   matchFlavor,
   matchKey,
   matchLocation,
@@ -5304,16 +6052,26 @@ export {
   normalizeOutcomes,
   outcomeFromScore,
   padVisible,
+  parseCachedMarketSignal,
+  parseCachedMatch,
+  parseCachedMatches,
   parseStandings,
   parseTeamSlot,
+  parsedValue,
+  productFlag,
   resolveCompetition,
   resolveMarketSource,
   resolveTz,
+  resolvedValues,
   sanitizeBundledFixture,
-  sanitizeFeedText,
-  sanitizeMatchStrings,
   scoreline,
+  sealMarketSignal,
+  sealMatch,
+  selectOne,
   stageLabel,
   stageLabelI18n,
-  t
+  t,
+  truncateVisible,
+  unresolved,
+  valid
 };