@claudinho/mcp 0.9.3 → 0.10.0

package/dist/index.js

@@ -5,7 +5,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/server.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
+import { types as utilTypes } from "util";
+import { z } from "zod/v3";
 
 // ../core/dist/index.js
 var REGIONAL_INDICATOR_A = 127462;
@@ -158,10 +159,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",
@@ -222,7 +224,7 @@ var BY_CODE = {
   HON: "HN",
   COD: "CD",
   MLI: "ML"
-};
+});
 function nationToFlag(nameOrCode) {
   const region = nationToRegion(nameOrCode);
   return region ? flagEmoji(region) : NEUTRAL;
@@ -230,7 +232,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++) {
@@ -255,11 +257,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",
@@ -279,6 +278,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",
@@ -308,6 +308,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",
@@ -337,6 +338,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",
@@ -366,6 +368,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",
@@ -450,7 +453,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, {
@@ -460,18 +470,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, {
@@ -479,10 +493,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);
@@ -493,41 +509,43 @@ 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 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;
-}
 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* 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);
@@ -2906,47 +2924,291 @@ 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.3"} (+https://github.com/arturogarrido/claudinho)`;
-var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-function competitionBase(slug) {
-  return `${ESPN_SOCCER}/${slug}`;
+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;
+}
+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 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;
+}
+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);
+}
+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;
 }
@@ -2960,58 +3222,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,
@@ -3019,57 +3297,224 @@ 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
+  };
+}
+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 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
@@ -3112,38 +3557,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 {};
@@ -3158,7 +3613,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;
@@ -3934,12 +4390,12 @@ function resolveCompetition(explicit) {
   return DEFAULT_COMPETITION;
 }
 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(
@@ -3968,17 +4424,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 };
 }
@@ -4035,7 +4500,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;
@@ -4084,14 +4552,141 @@ 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 src2 = `Source: ${marketSourceLabel(signal.source)}`;
+  return time ? `${src2} \xB7 updated ${time}` : src2;
+}
+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 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);
+}
 var DEFAULT_MAX_AGE_MS = 15 * 6e4;
 function marketRelevant(match, now = /* @__PURE__ */ new Date()) {
   if (isLive(match.status)) return true;
@@ -4110,9 +4705,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) {
@@ -4131,14 +4726,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;
@@ -4153,11 +4750,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 = {}) {
@@ -4173,8 +4772,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,
@@ -4186,66 +4785,33 @@ 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);
-}
-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)}%`);
+  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 parts.join(" \xB7 ");
+  return { ...sealed.value, ambiguous: sealed.value.ambiguous || ambiguous2 };
 }
-function marketAttributionText(signal) {
-  const time = utcHhmm(signal.asOf);
-  const src2 = `Source: ${marketSourceLabel(signal.source)}`;
-  return time ? `${src2} \xB7 updated ${time}` : src2;
+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 marketLine(signal, match) {
-  return `Market: ${marketProbabilityText(signal, match)} \xB7 ${marketSourceLabel(
-    signal.source
-  )} \xB7 informational only`;
+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 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 cacheableKeys(batch) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [key, r] of batch.results) if (isCacheable(r)) out.add(key);
+  return out;
+}
+function emptyBatch() {
+  return { results: /* @__PURE__ */ new Map(), complete: false };
 }
 var FakeMarketProvider = class {
   constructor(opts = {}) {
@@ -4260,14 +4826,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}`);
@@ -4284,7 +4848,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,
@@ -4308,6 +4874,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;
@@ -4320,49 +4888,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),
@@ -4371,7 +4971,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}`);
     }
@@ -4380,63 +4980,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");
+    }
+    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
@@ -4450,8 +5135,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();
@@ -4482,18 +5175,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;
@@ -4507,20 +5203,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 [];
     }
@@ -4528,13 +5233,17 @@ 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;
 }
+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) {
@@ -4551,21 +5260,15 @@ function makeMarketProvider(source) {
       return new FakeMarketProvider();
     // no synth → yields no signals, no network
     default:
+      if (!marketsCoverCompetition()) return new FakeMarketProvider();
       return new PolymarketProvider();
   }
 }
-async function getMarketSignal(provider, match, options) {
-  try {
-    return await provider.findSignal(match, options);
-  } catch {
-    return void 0;
-  }
-}
 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";
@@ -4646,6 +5349,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,
@@ -4676,7 +5382,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(
@@ -4815,9 +5523,21 @@ function matchLine(m, opts = {}) {
   const base = `${head} \u2014 ${tail} \xB7 ${stage} \xB7 ${matchLocation(m)}`;
   return (flair ? `${base} \u2014 ${flair}` : base).trimEnd();
 }
+var MAX_LIST_MATCHES = 40;
+function boundedRecords(rows, max = MAX_LIST_MATCHES) {
+  return bounded(rows, max);
+}
+function truncationNote(list) {
+  return list.truncated ? `
+(showing ${list.shown} of ${list.total} \u2014 list truncated)` : "";
+}
 function matchList(matches, empty, opts = {}) {
   if (matches.length === 0) return empty;
-  return matches.map((m) => `\u2022 ${matchLine(m, opts)}`).join("\n");
+  const shown = matches.slice(0, MAX_LIST_MATCHES);
+  const lines = shown.map((m) => `\u2022 ${matchLine(m, opts)}`).join("\n");
+  const overflow = matches.length - shown.length;
+  return overflow > 0 ? `${lines}
+\u2022 (list truncated \u2014 ${overflow} more not shown)` : lines;
 }
 function standingsTable(group, rows) {
   const header = `Group ${group}`;
@@ -4837,6 +5557,14 @@ function standingsTable(group, rows) {
   return [header, cols, ...lines].join("\n");
 }
 var DISCLAIMER = "Claudinho is an independent fan project \u2014 not affiliated with or endorsed by FIFA or Anthropic.";
+function capSignals(signals, kept) {
+  const ids = new Set(kept.map((m) => m.id));
+  const out = {};
+  for (const [id, v] of Object.entries(signals)) {
+    if (ids.has(id)) out[id] = v;
+  }
+  return out;
+}
 
 // src/tools.ts
 var adapters = /* @__PURE__ */ new Map();
@@ -4864,7 +5592,9 @@ function marketText(m, sig, args) {
   return `${marketHeader(m, args)}
 ${marketBlock(sig, m).join("\n")}`;
 }
+var MARKETS_SCOPE_NOTE = "Market signals cover the World Cup only; none are read for this competition.";
 function noSignalText(m, args, now) {
+  if (!marketsCoverCompetition()) return `${marketHeader(m, args)} \u2014 ${MARKETS_SCOPE_NOTE}`;
   if (marketRelevant(m, now)) return `No reliable market signal for ${marketHeader(m, args)}.`;
   const verb = isFinished(m.status) ? "has finished" : "appears to have finished";
   return `${marketHeader(m, args)} ${verb} \u2014 market signals are pre-match and in-play reads.`;
@@ -4895,11 +5625,19 @@ var MARKETS_TOOL_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
 function memKey(competition, id) {
   return `polymarket:${competition}:${id}`;
 }
-async function cachedMarketSignals(args, matches) {
-  if (args.marketProvider) return (await getMarketSignals(args.marketProvider, matches)).signals;
+async function cachedMarketSignals(args, matches, providerFactory = makeMarketProvider) {
+  if (args.marketProvider) {
+    const batch = await getMarketSignals(args.marketProvider, matches);
+    return { signals: resolvedValues(batch), complete: batch.complete };
+  }
   const source = resolveMarketSource();
   if (source !== "polymarket") {
-    return (await getMarketSignals(makeMarketProvider(source), matches, DEFAULT_ON_MARKET_OPTS)).signals;
+    const batch = await getMarketSignals(
+      providerFactory(source),
+      matches,
+      DEFAULT_ON_MARKET_OPTS
+    );
+    return { signals: resolvedValues(batch), complete: batch.complete };
   }
   const competition = resolveCompetition();
   const now = Date.now();
@@ -4908,39 +5646,46 @@ async function cachedMarketSignals(args, matches) {
   for (const m of matches) {
     const e = marketMem.get(memKey(competition, m.id));
     const ttl = e?.signal ? MEM_POSITIVE_TTL : MEM_NEGATIVE_TTL;
-    if (e && now - e.at <= ttl) {
+    const fresh = e && now - e.at <= ttl;
+    if (fresh && (!e.signal || marketSignalRendersFor(m, e.signal))) {
       if (e.signal) result.set(m.id, e.signal);
     } else {
       miss.push(m);
     }
   }
+  let complete = true;
   if (miss.length > 0) {
-    const { signals: fetched, checked } = await getMarketSignals(
-      makeMarketProvider("polymarket"),
+    const batch = await getMarketSignals(
+      providerFactory("polymarket"),
       miss,
       DEFAULT_ON_MARKET_OPTS
     );
-    for (const id of checked) {
+    const fetched = resolvedValues(batch);
+    complete = batch.complete;
+    for (const id of cacheableKeys(batch)) {
       marketMem.set(memKey(competition, id), { at: now, signal: fetched.get(id) ?? null });
     }
     for (const [id, s] of fetched) result.set(id, s);
   }
-  return result;
+  return { signals: result, complete };
 }
 async function reliableMarketData(args, matches) {
-  if (!marketsEnabled()) return void 0;
+  if (!marketsEnabled()) return { data: void 0, complete: true };
   const now = args.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
-  if (relevant.length === 0) return void 0;
-  const signals = await cachedMarketSignals(args, relevant);
+  if (relevant.length === 0) return { data: void 0, complete: true };
+  const result = await cachedMarketSignals(args, relevant);
   const out = {};
   for (const m of relevant) {
-    const s = signals.get(m.id);
+    const s = result.signals.get(m.id);
     if (s && isReliableMarketSignal(s, { now }) && marketSignalRendersFor(m, s)) {
       out[m.id] = marketData(s);
     }
   }
-  return Object.keys(out).length > 0 ? out : void 0;
+  return {
+    data: Object.keys(out).length > 0 ? out : void 0,
+    complete: result.complete
+  };
 }
 function fmtOpts(args) {
   return {
@@ -4965,16 +5710,28 @@ async function toolGetToday(args) {
   let text = `Matches on ${date}:
 ${matchList(todays, "No matches scheduled.", opts)}`;
   if (degraded) text += "\n\n(Live scores unavailable \u2014 showing the bundled schedule.)";
-  const marketSignals = await reliableMarketData(args, todays);
+  const market = await reliableMarketData(args, todays);
+  if (!market.complete) {
+    text += "\n\n(Market data unavailable or incomplete \u2014 not all fixtures were checked.)";
+  }
+  const shownToday = boundedRecords(todays);
   return {
     text: withDisclaimer(text, source, args.lang),
     data: {
       date,
       degraded,
       source: source ?? null,
-      count: todays.length,
-      matches: todays,
-      ...marketSignals ? { marketSignals } : {}
+      // ONE bounded view, so `count`, `matches` and the signal set cannot
+      // disagree about the same payload. `count` is the TRUE total; bounding
+      // only the TEXT would leave structuredContent unbounded, and that is
+      // model context too — a repeated-record payload measured ~5 MB there.
+      count: shownToday.total,
+      truncated: shownToday.truncated,
+      matches: shownToday.items,
+      marketComplete: market.complete,
+      // Capped in step with `matches`: a signal keyed to a match that is no
+      // longer in the payload is dead weight in model context.
+      ...market.data ? { marketSignals: capSignals(market.data, shownToday.items) } : {}
     }
   };
 }
@@ -4984,9 +5741,16 @@ async function toolGetLive(args = {}) {
   const opts = fmtOpts(args);
   const text = degraded ? "Live scores unavailable right now \u2014 could not reach the data provider." : `Live now:
 ${matchList(matches, "No matches in play right now.", opts)}`;
+  const shownLive = boundedRecords(matches);
   return {
     text: withDisclaimer(text, source, args.lang),
-    data: { degraded, source: source ?? null, count: matches.length, matches }
+    data: {
+      degraded,
+      source: source ?? null,
+      count: shownLive.total,
+      truncated: shownLive.truncated,
+      matches: shownLive.items
+    }
   };
 }
 async function toolGetMatch(args) {
@@ -4997,36 +5761,45 @@ async function toolGetMatch(args) {
   const opts = fmtOpts(args);
   const now = args.now ?? /* @__PURE__ */ new Date();
   let marketSignal;
+  let marketComplete = true;
   if (marketsEnabled() && marketRelevant(match, now)) {
-    const s = (await cachedMarketSignals(args, [match])).get(match.id);
+    const market = await cachedMarketSignals(args, [match]);
+    marketComplete = market.complete;
+    const s = market.signals.get(match.id);
     if (s && isReliableMarketSignal(s, { now }) && marketSignalRendersFor(match, s)) marketSignal = s;
   }
   const base = matchLine(match, opts);
   let text = marketSignal ? `${base}
 ${marketBlock(marketSignal, match).join("\n")}` : base;
   if (degraded) text += "\n\n(Live state unavailable \u2014 showing the scheduled fixture.)";
+  if (!marketComplete) {
+    text += "\n\n(Market data unavailable or incomplete \u2014 this match was not checked.)";
+  }
   return {
     text: withDisclaimer(text, liveSource, args.lang),
     data: {
       degraded,
       source: liveSource ?? null,
       match,
+      marketComplete,
       marketSignal: marketSignal ? marketData(marketSignal) : null
     }
   };
 }
 async function toolGetStandings(args) {
   const { tables, degraded, source } = await getStandings(resolveAdapter(args), args.group);
-  const shaped = tables.map((tb) => ({ group: tb.group, standings: tb.rows }));
+  const boundedTables = boundedRecords(tables);
+  const shaped = boundedTables.items.map((tb) => ({ group: tb.group, standings: tb.rows }));
   if (shaped.length === 0) {
     const g = args.group?.toUpperCase();
-    const msg = g ? `No group "${g}". Groups are A\u2013L.` : "No standings available.";
+    const msg = degraded ? t(args.lang, "standings.unavailable") : g ? `No group "${g}".` : "No standings available.";
     return {
-      text: withDisclaimer(degraded ? `${msg} (Live standings unavailable.)` : msg, source, args.lang),
+      text: withDisclaimer(msg, source, args.lang),
       data: { degraded, source: source ?? null, tables: args.group ? null : [] }
     };
   }
   let text = shaped.map((t2) => standingsTable(t2.group, t2.standings)).join("\n\n");
+  text += truncationNote(boundedTables);
   if (degraded) text += "\n\n(Live standings unavailable \u2014 showing the group roster.)";
   return {
     text: withDisclaimer(text, source, args.lang),
@@ -5069,7 +5842,7 @@ async function standingsResourceText(group, adapter) {
   const g = group.toUpperCase();
   const { tables, degraded, source } = await getStandings(adapter, g);
   const tb = tables[0];
-  let text = tb ? standingsTable(tb.group, tb.rows) : `No group ${g}.`;
+  let text = tb ? standingsTable(tb.group, tb.rows) : degraded ? "Live standings unavailable." : `No group ${g}.`;
   if (degraded && tb) text += "\n\n(Live standings unavailable \u2014 showing the group roster.)";
   return withDisclaimer(text, source);
 }
@@ -5115,14 +5888,16 @@ async function toolGetMarketSignal(args) {
   if (args.matchId) {
     const { match } = await getMatchById(resolveAdapter(args), args.matchId);
     const relevant = match ? marketRelevant(match, now) : false;
-    const sig = match && relevant ? await getMarketSignal(provider, match) : void 0;
-    const shown2 = match && sig && marketDisplayable(match, sig) ? sig : void 0;
-    const text2 = !match ? `No match found with id ${args.matchId}.` : shown2 ? marketText(match, shown2, args) : noSignalText(match, args, now);
+    const batch2 = match && relevant ? await getMarketSignals(provider, [match], MARKETS_TOOL_OPTS) : { results: /* @__PURE__ */ new Map(), complete: true };
+    const sig = match ? resolvedValues(batch2).get(match.id) : void 0;
+    const shown2 = batch2.complete && match && sig && marketDisplayable(match, sig) ? sig : void 0;
+    const text2 = !match ? `No match found with id ${args.matchId}.` : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(match, args)} \u2014 this match could not be checked.` : shown2 ? marketText(match, shown2, args) : noSignalText(match, args, now);
     return {
       text: withDisclaimer(text2),
       data: {
         matchId: args.matchId,
         informationalOnly: true,
+        complete: batch2.complete,
         signal: shown2 ? marketData(shown2) : null
       }
     };
@@ -5131,9 +5906,10 @@ async function toolGetMarketSignal(args) {
     const code = args.team.toUpperCase();
     const { match: fixture, degraded } = await marketFixtureForTeam(resolveAdapter(args), code, now);
     const relevant = fixture ? marketRelevant(fixture, now) : false;
-    const sig = fixture && relevant ? await getMarketSignal(provider, fixture) : void 0;
-    const shown2 = fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
-    const text2 = !fixture ? degraded ? `Live feed unavailable \u2014 can't resolve ${code}'s next fixture right now.` : `No upcoming fixture found for ${code}.` : shown2 ? marketText(fixture, shown2, args) : noSignalText(fixture, args, now);
+    const batch2 = fixture && relevant ? await getMarketSignals(provider, [fixture], MARKETS_TOOL_OPTS) : { results: /* @__PURE__ */ new Map(), complete: true };
+    const sig = fixture ? resolvedValues(batch2).get(fixture.id) : void 0;
+    const shown2 = batch2.complete && fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
+    const text2 = !fixture ? degraded ? `Live feed unavailable \u2014 can't resolve ${code}'s next fixture right now.` : `No upcoming fixture found for ${code}.` : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(fixture, args)} \u2014 this match could not be checked.` : shown2 ? marketText(fixture, shown2, args) : noSignalText(fixture, args, now);
     return {
       text: withDisclaimer(text2),
       data: {
@@ -5141,6 +5917,7 @@ async function toolGetMarketSignal(args) {
         matchId: fixture?.id ?? null,
         degraded,
         informationalOnly: true,
+        complete: batch2.complete,
         signal: shown2 ? marketData(shown2) : null
       }
     };
@@ -5148,33 +5925,56 @@ async function toolGetMarketSignal(args) {
   const date = args.date ?? localDate(now.toISOString(), args.tz);
   const { matches } = await getMatchesForDate(resolveAdapter(args), date);
   const todays = fixturesByDate(date, matches, args.tz).filter((m) => marketRelevant(m, now));
-  const { signals } = await getMarketSignals(provider, todays, MARKETS_TOOL_OPTS);
-  const shown = todays.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
+  const batch = await getMarketSignals(provider, todays, MARKETS_TOOL_OPTS);
+  const signals = resolvedValues(batch);
+  const all = todays.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
     (r) => !!r.signal && marketDisplayable(r.match, r.signal)
   );
-  const text = shown.length ? `Market signals on ${date}:
-${shown.map(({ match, signal }) => marketText(match, signal, args)).join("\n\n")}` : `No reliable market signals on ${date}.`;
+  const shown = boundedRecords(all);
+  let text = shown.shown ? `Market signals on ${date}:${truncationNote(shown)}
+${shown.items.map(({ match, signal }) => marketText(match, signal, args)).join("\n\n")}` : (
+    // An empty result and an INCOMPLETE one are different answers. The batch
+    // knows which it was — a provider outage or an expired deadline leaves it
+    // `complete: false` — and collapsing to `resolvedValues` threw that away,
+    // so "we could not reach the market data" rendered as the confident
+    // "there is none", which is the failure this project refuses everywhere
+    // else.
+    !marketsCoverCompetition() ? `${MARKETS_SCOPE_NOTE} (${date})` : batch.complete ? `No reliable market signals on ${date}.` : `Market data unavailable or incomplete for ${date} \u2014 not all fixtures could be checked.`
+  );
+  if (shown.shown > 0 && !batch.complete) {
+    text += `
+
+Market data unavailable or incomplete for ${date} \u2014 not all fixtures could be checked.`;
+  }
   return {
     text: withDisclaimer(text),
     data: {
       date,
       informationalOnly: true,
-      signals: shown.map(({ signal }) => marketData(signal))
+      // Self-describing: the prose says it was truncated, and so does the
+      // structured payload — a consumer reading only `data` could not otherwise
+      // tell 40 signals from all of them.
+      count: shown.total,
+      truncated: shown.truncated,
+      // Stated, so a consumer reading only `data` can tell "none" from
+      // "we could not check them all".
+      complete: batch.complete,
+      signals: shown.items.map(({ signal }) => marketData(signal))
     }
   };
 }
 async function reliableSignalMap(args, matches) {
-  if (!marketsEnabled()) return /* @__PURE__ */ new Map();
+  if (!marketsEnabled()) return { signals: /* @__PURE__ */ new Map(), complete: true };
   const now = args.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
-  if (relevant.length === 0) return /* @__PURE__ */ new Map();
-  const signals = await cachedMarketSignals(args, relevant);
+  if (relevant.length === 0) return { signals: /* @__PURE__ */ new Map(), complete: true };
+  const result = await cachedMarketSignals(args, relevant);
   const out = /* @__PURE__ */ new Map();
   for (const m of relevant) {
-    const s = signals.get(m.id);
+    const s = result.signals.get(m.id);
     if (s && isReliableMarketSignal(s, { now }) && marketDisplayable(m, s)) out.set(m.id, s);
   }
-  return out;
+  return { signals: out, complete: result.complete };
 }
 function shareOptions(args) {
   return {
@@ -5184,7 +5984,7 @@ function shareOptions(args) {
     includeInstallLine: args.includeInstallLine !== false
   };
 }
-function shareResult(kind, target, team, input, options) {
+function shareResult(kind, target, team, input, options, total = input.matches.length) {
   const snippet = formatShareSnippet(input, options);
   return {
     // The snippet is self-contained: it carries its own non-affiliation
@@ -5201,28 +6001,34 @@ function shareResult(kind, target, team, input, options) {
       informationalOnly: true,
       style: options.style ?? "social",
       snippet,
+      count: total,
+      truncated: total > input.matches.length,
       matches: input.matches,
       marketSignals: Object.fromEntries(
         [...input.marketSignals ?? /* @__PURE__ */ new Map()].map(([id, s]) => [
           id,
           marketData(s)
         ])
-      )
+      ),
+      marketComplete: input.marketComplete ?? true
     }
   };
 }
 async function toolGetShareSnippet(args) {
   const options = shareOptions(args);
-  const signalsFor = (ms) => args.includeMarkets === false ? Promise.resolve(/* @__PURE__ */ new Map()) : reliableSignalMap(args, ms);
+  const signalsFor = (ms) => args.includeMarkets === false ? Promise.resolve({ signals: /* @__PURE__ */ new Map(), complete: true }) : reliableSignalMap(args, ms);
   if (args.live) {
     const { matches, degraded: degraded2, source: source2 } = await getLiveMatches(resolveAdapter(args));
+    const shownLive = boundedRecords(matches);
     return shareResult(
       "live",
       "live",
       void 0,
       {
-        title: "Live match pulse",
-        matches,
+        title: `Live match pulse${truncationNote(shownLive)}`,
+        // Bounded like the date branch: a share card is returned through MCP
+        // before a human ever sees it. The count is STATED, not silently lost.
+        matches: shownLive.items,
         source: source2,
         degraded: degraded2,
         // Feed down ⇒ don't let an empty card read as "nothing is on".
@@ -5231,7 +6037,8 @@ async function toolGetShareSnippet(args) {
         tz: args.tz,
         locale: args.lang
       },
-      { ...options, includeMarkets: false }
+      { ...options, includeMarkets: false },
+      matches.length
     );
   }
   if (args.group) {
@@ -5239,12 +6046,15 @@ async function toolGetShareSnippet(args) {
     const { tables, degraded: degraded2, source: source2 } = await getStandings(resolveAdapter(args), group);
     const snippet = formatShareTable(
       {
-        tables,
-        // Degraded ⇒ static roster, no live provider: don't attribute one, and
-        // surface the not-live notice (the card gets pasted publicly).
+        // Capped like the structured payload beside it. Bounding `data.tables`
+        // while the rendered SNIPPET came from the full list meant the surface a
+        // reader actually sees was the unbounded one.
+        tables: boundedRecords(tables).items,
+        // Degraded ⇒ no live provider: don't attribute one. An open-scope
+        // outage has no compatible bundled roster, so name that empty state.
         source: degraded2 ? void 0 : source2,
         installLine: `npx @claudinho/cli table ${group}`,
-        emptyNote: `No group ${group}.`,
+        emptyNote: degraded2 ? "Live standings unavailable." : `No group ${group}.`,
         degraded: degraded2
       },
       options
@@ -5259,7 +6069,7 @@ async function toolGetShareSnippet(args) {
         degraded: degraded2,
         informationalOnly: true,
         snippet,
-        tables: tables.map((tb) => ({ group: tb.group, standings: tb.rows }))
+        tables: boundedRecords(tables).items.map((tb) => ({ group: tb.group, standings: tb.rows }))
       }
     };
   }
@@ -5305,6 +6115,7 @@ async function toolGetShareSnippet(args) {
   if (args.matchId) {
     const { match, degraded: degraded2, source: source2 } = await getMatchById(resolveAdapter(args), args.matchId);
     const matches = match ? [match] : [];
+    const market2 = await signalsFor(matches);
     return shareResult(
       "match",
       args.matchId,
@@ -5312,7 +6123,8 @@ async function toolGetShareSnippet(args) {
       {
         title: "Match pulse",
         matches,
-        marketSignals: await signalsFor(matches),
+        marketSignals: market2.signals,
+        marketComplete: market2.complete,
         source: source2,
         degraded: degraded2,
         emptyNote: `No match found with id ${args.matchId}.`,
@@ -5332,6 +6144,7 @@ async function toolGetShareSnippet(args) {
     );
     const matches = fixture ? [fixture] : [];
     const teamName = fixture ? fixture.home.code === code ? fixture.home.name : fixture.away.name : code;
+    const market2 = await signalsFor(matches);
     return shareResult(
       "next",
       "next",
@@ -5339,7 +6152,8 @@ async function toolGetShareSnippet(args) {
       {
         title: `Next up for ${teamName}`,
         matches,
-        marketSignals: await signalsFor(matches),
+        marketSignals: market2.signals,
+        marketComplete: market2.complete,
         // Attribute the provider only when the overlay resolved the tie; parity
         // with get_next_fixture (a static group fixture carries no source).
         source: source2,
@@ -5356,14 +6170,19 @@ async function toolGetShareSnippet(args) {
   const { matches: all, degraded, source } = await getMatchesForDate(resolveAdapter(args), date);
   const todays = fixturesByDate(date, all, args.tz);
   const human = formatDate(`${date}T12:00:00.000Z`, { tz: args.tz, locale: args.lang });
+  const shownToday = boundedRecords(todays);
+  const market = await signalsFor(shownToday.items);
   return shareResult(
     "today",
     date,
     void 0,
     {
-      title: args.date ? `Matches \xB7 ${human}` : `Today's matches \xB7 ${human}`,
-      matches: todays,
-      marketSignals: await signalsFor(todays),
+      title: (args.date ? `Matches \xB7 ${human}` : `Today's matches \xB7 ${human}`) + truncationNote(shownToday),
+      // Bounded like every other model-facing payload — a share card is
+      // returned through MCP before a human ever sees it.
+      matches: shownToday.items,
+      marketSignals: market.signals,
+      marketComplete: market.complete,
       source,
       degraded,
       emptyNote: `No matches scheduled for ${human}.`,
@@ -5371,13 +6190,14 @@ async function toolGetShareSnippet(args) {
       tz: args.tz,
       locale: args.lang
     },
-    options
+    options,
+    todays.length
   );
 }
 
 // src/server.ts
 var SERVER_NAME = "claudinho";
-var SERVER_VERSION = "0.9.3";
+var SERVER_VERSION = "0.10.0";
 var VOICE = asFlavorLevel(process.env.CLAUDINHO_FLAVOR) === "off" ? "" : `
 Voice: when relaying scores, narrate with lively, regionally-appropriate football-commentary energy in the user's language. Each match line may end with a short exclamation ("\u2014 \xA1GOOOOL!") \u2014 use it as a tone cue. Keep every fact exact; never invent details and never impersonate or name a real commentator.`;
 var INSTRUCTIONS = `Claudinho serves live scores, fixtures, and group standings for the 2026 men's football tournament.
@@ -5415,37 +6235,59 @@ var matchOut = z.object({
 }).passthrough();
 var anyObj = z.object({}).passthrough();
 var src = z.string().nullable();
+var responseMeta = {
+  responseTruncated: z.boolean().optional(),
+  responseTruncation: z.string().optional()
+};
 var todayOut = {
   date: z.string(),
   degraded: z.boolean(),
   source: src,
+  // `count` is the TRUE total and `matches` may be a bounded view of it, so the
+  // payload states whether it was cut rather than leaving a consumer to infer
+  // it from two numbers.
   count: z.number(),
+  truncated: z.boolean(),
   matches: z.array(matchOut),
-  marketSignals: z.record(anyObj).optional()
+  marketSignals: z.record(anyObj).optional(),
+  marketComplete: z.boolean().optional().describe("False when optional market enrichment did not check every relevant fixture"),
+  ...responseMeta
+};
+var liveOut = {
+  degraded: z.boolean(),
+  source: src,
+  count: z.number(),
+  truncated: z.boolean(),
+  matches: z.array(matchOut),
+  ...responseMeta
 };
-var liveOut = { degraded: z.boolean(), source: src, count: z.number(), matches: z.array(matchOut) };
 var matchDetailOut = {
   match: matchOut.nullable(),
   degraded: z.boolean().optional(),
   source: src.optional(),
-  marketSignal: anyObj.nullable().optional()
+  marketSignal: anyObj.nullable().optional(),
+  marketComplete: z.boolean().optional().describe("False when optional market enrichment did not check this fixture"),
+  ...responseMeta
 };
 var standingsOut = {
   degraded: z.boolean(),
   source: src,
-  tables: z.union([anyObj, z.array(anyObj), z.null()])
+  tables: z.union([anyObj, z.array(anyObj), z.null()]),
+  ...responseMeta
 };
 var bracketOut = {
   view: anyObj.nullable(),
   degraded: z.boolean().optional(),
   standingsDegraded: z.boolean().optional(),
-  source: src.optional()
+  source: src.optional(),
+  ...responseMeta
 };
 var nextOut = {
   team: z.string(),
   fixture: matchOut.nullable(),
   degraded: z.boolean(),
-  source: src
+  source: src,
+  ...responseMeta
 };
 var marketOut = {
   matchId: z.string().nullable().optional(),
@@ -5454,7 +6296,14 @@ var marketOut = {
   degraded: z.boolean().optional(),
   informationalOnly: z.boolean(),
   signal: anyObj.nullable().optional(),
-  signals: z.array(anyObj).optional()
+  signals: z.array(anyObj).optional(),
+  // Present on the list-shaped branches: the TRUE total and whether the array
+  // beside it was capped, so a consumer reading only `structuredContent` can
+  // tell a complete list from a truncated one.
+  count: z.number().optional(),
+  truncated: z.boolean().optional(),
+  complete: z.boolean().optional().describe("False when the market provider did not complete every relevant read"),
+  ...responseMeta
 };
 var shareOut = {
   kind: z.string(),
@@ -5471,23 +6320,183 @@ var shareOut = {
   tables: z.union([anyObj, z.array(anyObj), z.null()]).optional(),
   view: anyObj.nullable().optional(),
   matches: z.array(matchOut).optional(),
-  marketSignals: z.record(anyObj).optional()
+  marketSignals: z.record(anyObj).optional(),
+  marketComplete: z.boolean().optional().describe("False when optional market enrichment did not check every relevant fixture"),
+  count: z.number().optional(),
+  truncated: z.boolean().optional(),
+  ...responseMeta
 };
 var teamInfo = z.object({ code: z.string(), name: z.string(), flag: z.string(), group: z.string() }).partial().passthrough();
 var teamOut = {
   query: z.string(),
   team: teamInfo.nullable(),
   matches: z.array(teamInfo),
-  count: z.number()
+  count: z.number(),
+  ...responseMeta
 };
+var MAX_RESPONSE_CHARS = 128e3;
+var RESPONSE_TRUNCATION = "Optional response detail was truncated to stay within the MCP context limit.";
+var SHRINK_FAILED = /* @__PURE__ */ Symbol("shrink-failed");
+var MAX_INSPECTION_DEPTH = 64;
+var MAX_INSPECTION_ARRAY_LENGTH = 4096;
+var MAX_INSPECTION_KEYS_PER_OBJECT = 1024;
+var MAX_INSPECTION_ENTRIES = 65536;
+var MAX_INSPECTION_CONTAINERS = 16384;
+var MAX_INSPECTION_CHARS = 2e6;
+function withinInspectionBudget(root) {
+  const stack = [{ value: root, depth: 0 }];
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  let containers = 0;
+  let entries = 0;
+  let chars = 0;
+  try {
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      if (frame.exit) {
+        ancestors.delete(frame.value);
+        continue;
+      }
+      const { value, depth } = frame;
+      if (typeof value === "string") {
+        chars += value.length;
+        if (chars > MAX_INSPECTION_CHARS) return false;
+        continue;
+      }
+      if (!value || typeof value !== "object") continue;
+      if (depth >= MAX_INSPECTION_DEPTH || ancestors.has(value)) return false;
+      if (utilTypes.isProxy(value)) return false;
+      containers += 1;
+      if (containers > MAX_INSPECTION_CONTAINERS) return false;
+      const proto = Object.getPrototypeOf(value);
+      const expectedProto = Array.isArray(value) ? Array.prototype : Object.prototype;
+      if (proto !== expectedProto && proto !== null) return false;
+      if (Object.getOwnPropertyDescriptor(value, "toJSON") || proto && Object.getOwnPropertyDescriptor(proto, "toJSON")) {
+        return false;
+      }
+      ancestors.add(value);
+      stack.push({ value, depth, exit: true });
+      if (Array.isArray(value)) {
+        if (value.length > MAX_INSPECTION_ARRAY_LENGTH) return false;
+        entries += value.length;
+        if (entries > MAX_INSPECTION_ENTRIES) return false;
+        for (let i = 0; i < value.length; i++) {
+          const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+          if (!descriptor) continue;
+          if (!("value" in descriptor)) return false;
+          stack.push({ value: descriptor.value, depth: depth + 1 });
+        }
+        continue;
+      }
+      let keys = 0;
+      for (const key in value) {
+        keys += 1;
+        if (keys > MAX_INSPECTION_KEYS_PER_OBJECT) return false;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor?.enumerable) continue;
+        if (!("value" in descriptor)) return false;
+        entries += 1;
+        chars += key.length;
+        if (entries > MAX_INSPECTION_ENTRIES || chars > MAX_INSPECTION_CHARS) return false;
+        stack.push({ value: descriptor.value, depth: depth + 1 });
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shrink(value, pass, depth = 0, ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (depth >= 64) return SHRINK_FAILED;
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) return SHRINK_FAILED;
+    ancestors.add(value);
+    const items = pass === 3 ? value.slice(0, 8) : value;
+    const out = [];
+    for (const item of items) {
+      const shrunk = shrink(item, pass, depth + 1, ancestors);
+      if (shrunk === SHRINK_FAILED) return SHRINK_FAILED;
+      out.push(shrunk);
+    }
+    ancestors.delete(value);
+    return out;
+  }
+  if (value && typeof value === "object") {
+    if (ancestors.has(value)) return SHRINK_FAILED;
+    ancestors.add(value);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k === "events") continue;
+      const shrunk = shrink(v, pass, depth + 1, ancestors);
+      if (shrunk === SHRINK_FAILED) return SHRINK_FAILED;
+      out[k] = shrunk;
+    }
+    ancestors.delete(value);
+    return out;
+  }
+  if (typeof value === "string") {
+    if (pass >= 2 && value.length > 2e3) return `${value.slice(0, 2e3)}\u2026`;
+  }
+  return value;
+}
+function size(v) {
+  try {
+    return JSON.stringify(v ?? null)?.length ?? Number.POSITIVE_INFINITY;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function boundResponse(data) {
+  if (!withinInspectionBudget(data)) return null;
+  if (size(data) <= MAX_RESPONSE_CHARS) return data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  for (const pass of [1, 2, 3]) {
+    const candidate = shrink(data, pass);
+    if (candidate === SHRINK_FAILED || !candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+      continue;
+    }
+    const marked = {
+      ...candidate,
+      responseTruncated: true,
+      responseTruncation: RESPONSE_TRUNCATION
+    };
+    if (size(marked) <= MAX_RESPONSE_CHARS) return marked;
+  }
+  return null;
+}
+var MAX_TEXT_CHARS = 32e3;
+var DUAL_EMIT_LIMIT = 16e3;
 function toContent(r) {
-  return {
-    content: [
-      { type: "text", text: r.text },
-      { type: "text", text: "```json\n" + JSON.stringify(r.data, null, 2) + "\n```" }
-    ],
-    structuredContent: r.data
-  };
+  const data = boundResponse(r.data);
+  const dataTruncated = !!data && typeof data === "object" && data.responseTruncated === true;
+  const marker = dataTruncated ? `
+
+(${RESPONSE_TRUNCATION})` : "";
+  const room = Math.max(0, MAX_TEXT_CHARS - marker.length - "\n(truncated)".length);
+  const text = r.text.length > room ? `${r.text.slice(0, room)}
+(truncated)${marker}` : r.text + marker;
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    const error = "Response data exceeded the MCP context limit and could not be reduced without violating its output schema.";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${text.slice(0, Math.max(0, MAX_TEXT_CHARS - error.length - 2))}
+
+${error}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const compact = JSON.stringify(data);
+  const content = [{ type: "text", text }];
+  if (compact.length <= DUAL_EMIT_LIMIT) {
+    content.push({
+      type: "text",
+      text: "```json\n" + JSON.stringify(data, null, 2) + "\n```"
+    });
+  }
+  return { content, structuredContent: data };
 }
 function buildServer() {
   const server = new McpServer(
@@ -5498,7 +6507,7 @@ function buildServer() {
     "get_today",
     {
       title: "Today's matches",
-      description: "All fixtures for a date (default: today), with live score and minute overlaid on any match in play. Use this for a whole day's card; for only in-play matches use get_live, for one team's match use get_next_fixture, for a single match's detail use get_match. Kickoffs render in tz; lang localizes dates, attribution, and commentary (en/es/pt/fr); flavor sets commentary tone.",
+      description: "All fixtures for a date (default: today), with live score and minute overlaid on any match in play. Optional prediction-market enrichment carries marketComplete; false means the read was incomplete, not that no signal exists. Use this for a whole day's card; for only in-play matches use get_live, for one team's match use get_next_fixture, for a single match's detail use get_match. Kickoffs render in tz; lang localizes dates, attribution, and commentary (en/es/pt/fr); flavor sets commentary tone.",
       inputSchema: {
         date: dateArg.optional().describe("Date as YYYY-MM-DD (default: today)"),
         ...commonArgs
@@ -5524,7 +6533,7 @@ function buildServer() {
     "get_match",
     {
       title: "Match detail",
-      description: "One match by its id, with live score/minute overlaid when it's in play. Get the id from get_today or get_live; to find a team's match without an id, use get_next_fixture. tz/lang/flavor affect formatting.",
+      description: "One match by its id, with live score/minute overlaid when it's in play. Optional prediction-market enrichment carries marketComplete; false means the read was incomplete, not that no signal exists. Get the id from get_today or get_live; to find a team's match without an id, use get_next_fixture. tz/lang/flavor affect formatting.",
       inputSchema: { id: z.string().describe("Match id"), ...commonArgs },
       annotations: { readOnlyHint: true, openWorldHint: true },
       outputSchema: matchDetailOut
@@ -5535,7 +6544,7 @@ function buildServer() {
     "get_standings",
     {
       title: "Group standings",
-      description: "Live cumulative group standings \u2014 pass a group letter A\u2013L, or omit for all 12. Returns ranked rows (team, played, W/D/L, goal difference, points). Use get_today for fixtures/scores and get_next_fixture for one team. Falls back to a roster at zero (flagged degraded) if live standings are unavailable.",
+      description: "Live cumulative group standings \u2014 pass a group letter A\u2013L, or omit for all 12. Returns ranked rows (team, played, W/D/L, goal difference, points). Use get_today for fixtures/scores and get_next_fixture for one team. If unavailable, the default World Cup scope returns a roster at zero; competitions without a compatible bundled roster return no tables. Both are flagged degraded.",
       inputSchema: {
         group: groupArg.optional().describe("Group letter A\u2013L (omit for all)"),
         ...commonArgs
@@ -5575,7 +6584,7 @@ function buildServer() {
     "get_market_signal",
     {
       title: "Prediction-market signal",
-      description: "Read-only prediction-market signals for a match (by id), a team's current-or-next fixture, or a date (default: today). Returns market-implied percentages with attribution. Shown only before and during a match \u2014 finished matches have no market read. Informational only \u2014 relay the numbers factually; do not add betting, trading, or 'value' advice, and do not invent links.",
+      description: "Read-only prediction-market signals for a match (by id), a team's current-or-next fixture, or a date (default: today). Returns market-implied percentages with attribution; complete:false means the provider read was incomplete, not that no signal exists. Shown only before and during a match \u2014 finished matches have no market read. Informational only \u2014 relay the numbers factually; do not add betting, trading, or 'value' advice, and do not invent links.",
       inputSchema: {
         matchId: z.string().optional().describe("Match id (most specific)"),
         team: teamArg.optional().describe(
@@ -5594,7 +6603,7 @@ function buildServer() {
     "get_share_snippet",
     {
       title: "Shareable match snippet",
-      description: `A polished, copy-pasteable card (plain text) for a match (matchId), a team's next fixture (team), a group's standings table (group, e.g. "A"), the knockout bracket (bracket: true), a date (default: today), or live matches (live: true). Returns the ready-to-paste snippet plus structured data \u2014 hand the snippet text to the user verbatim. No links; it carries a non-affiliation disclaimer, and any market line stays informational only.`,
+      description: `A polished, copy-pasteable card (plain text) for a match (matchId), a team's next fixture (team), a group's standings table (group, e.g. "A"), the knockout bracket (bracket: true), a date (default: today), or live matches (live: true). Returns the ready-to-paste snippet plus structured data \u2014 hand the snippet text to the user verbatim. marketComplete:false is stated inside the card as an incomplete optional read. No links; it carries a non-affiliation disclaimer, and any market line stays informational only.`,
       inputSchema: {
         matchId: z.string().optional().describe("Match id (most specific)"),
         team: teamArg.optional().describe("3-letter team code for that team's next fixture, e.g. MEX"),