@claudinho/core 0.11.1 → 0.12.0

package/dist/index.d.ts

@@ -153,11 +153,27 @@ type Stage = 'GROUP' | 'R32' | 'R16' | 'QF' | 'SF' | '3P' | 'F' | 'FRIENDLY' | '
 type Status = 'SCHEDULED' | 'LIVE' | 'HT' | 'FT' | 'POSTPONED' | 'CANCELLED';
 /** Match outcome from the home team's perspective. */
 type Outcome = 'H' | 'D' | 'A';
-/** A discrete in-match event (provider-dependent; often absent on free tiers). */
+/**
+ * One of a match's goals or cards, as the provider listed it (ESPN's
+ * `competitions[0].details`, read by the grammar in `trust/espn.ts` and sealed
+ * by `sealEvent` in `trust/match.ts`, on the feed and the cache path alike).
+ * Key order is the serialized order.
+ */
 interface MatchEvent {
+    /** The kind. `SUB` stays in the type; ESPN's scoreboard never produces one. */
     type: 'GOAL' | 'OWN_GOAL' | 'PEN' | 'YELLOW' | 'RED' | 'SUB';
+    /** The minute the provider's clock showed: `90` for `90'+3'`. */
     minute: number;
+    /** Added time past `minute` (`3` for `90'+3'`), 1 to 30; absent when none. */
+    added?: number;
+    /**
+     * The side the event belongs to: the side a goal COUNTED for (an own goal
+     * included), the side a card was shown to. The identity; `teamCode` is a label.
+     */
+    side: 'home' | 'away';
+    /** That side's code, a display label. */
     teamCode: string;
+    /** The player, when the provider names exactly one of the expected team. */
     player?: string;
 }
 /** A single fixture/result — the central entity. */
@@ -201,7 +217,13 @@ interface Match {
     /** Live match minute when in progress. */
     minute?: number;
     status: Status;
-    /** Goals/cards when the provider supplies them. */
+    /**
+     * The provider's goals and cards that could be read, in time order (minute,
+     * then added time). Never a claim that the list is every goal: a detail the
+     * grammar cannot read is left out, and a live timeline lags its score by
+     * nature. None on a match with no score (scheduled, postponed, cancelled);
+     * the key is absent when none was read.
+     */
     events?: MatchEvent[];
     /**
      * Winner's team code when the provider marks one (e.g. ESPN `competitor.winner`
@@ -279,6 +301,27 @@ type Lang = 'en' | 'es' | 'pt' | 'fr';
 declare function normalizeLang(lang?: string): Lang;
 /** Translate a message key with optional `{placeholder}` interpolation. */
 declare function t(lang: string | undefined, key: string, vars?: Record<string, string>): string;
+/**
+ * The ten words of the plugin's moments, as `claudinho ambient --json` sends
+ * them (`words`), in this order: core's `moment.*` keys in one language.
+ * `goalFor` and `win` are templates holding `{team}` once, which the plugin
+ * fills with the record's own names; names, scores and minutes are never
+ * translated.
+ */
+interface MomentWords {
+    readonly goal: string;
+    readonly ownGoal: string;
+    readonly ownGoalDetail: string;
+    readonly goalFor: string;
+    readonly goals: string;
+    readonly scoreUpdated: string;
+    readonly penalties: string;
+    readonly fullTime: string;
+    readonly win: string;
+    readonly draw: string;
+}
+/** The moment words in `lang` (an unsupported one is English), the templates left unfilled. */
+declare function momentWords(lang: string | undefined): MomentWords;
 /**
  * Localized stage label, from the match (its stage, its group letter under the
  * group stage, and the words an OTHER stage carries). An `OTHER` stage prints
@@ -313,16 +356,21 @@ declare function formatDate(iso: string, opts?: FormatOpts): string;
 declare function formatTime(iso: string, opts?: FormatOpts): string;
 /** What {@link countdown} says of a kickoff that has passed (the statusline prints it as it is: English, by its rule). */
 declare const COUNTDOWN_NOW = "now";
-/** Compact human countdown until kickoff: "3d4h", "2h10m", "45m", or {@link COUNTDOWN_NOW}. */
-declare function countdown(iso: string, from?: Date): string;
+/**
+ * Compact human countdown until kickoff: "3d4h", "2h10m", "45m", or {@link COUNTDOWN_NOW}, from `from`: the clock of
+ * the request or render that says it, which every caller hands in (no default: the wall clock is never read here).
+ */
+declare function countdown(iso: string, from: Date): string;
 /**
  * The countdown as the reader's phrase, ONE rule for every localized line that
  * says it (CLI `next`, the MCP match line): "in 3d4h" (`next.in`), or, for a
  * kickoff that has passed (a stale record, the bundle's skeleton during an
  * outage), the language's own word for now (`countdown.now`), never the
- * English word inside a translated "in".
+ * English word inside a translated "in". Relative to the REQUEST's clock
+ * (`from`), the one every other read of the request takes and every caller
+ * passes: the wall clock is never read here.
  */
-declare function countdownPhrase(lang: string | undefined, iso: string, from?: Date): string;
+declare function countdownPhrase(lang: string | undefined, iso: string, from: Date): string;
 /**
  * The calendar date (YYYY-MM-DD) of a kickoff in the target timezone, or ''
  * when the input can't be parsed — an unfileable fixture matches no date rather
@@ -379,6 +427,42 @@ declare function padVisible(s: string, width: number): string;
  */
 declare function withFlag(text: string, flag: string | undefined, side: 'home' | 'away'): string;
 
+interface TimelineOptions {
+    /** The reader's language (en/es/pt/fr); English when absent. */
+    readonly lang?: string;
+    /** Whether a nation's flag is printed beside its code (a club has none either way). */
+    readonly flags: boolean;
+}
+/** One part of a timeline row: its text, and `strong` on the player. */
+interface TimelinePart {
+    readonly text: string;
+    readonly style?: 'strong';
+}
+/**
+ * The match's events as rows of parts; `[]` when it has none. Each row is
+ * the aligned columns as one plain part (two spaces, the minute, the marker,
+ * one space and the localized kind word, the side's label), then, when the
+ * provider named a player, two spaces and the player as one `strong` part.
+ * Joined, a row is its {@link timelineRows} line.
+ */
+declare function timelineParts(match: Match, opts: TimelineOptions): TimelinePart[][];
+/** The match's events as aligned text rows ({@link timelineParts} joined); `[]` when it has none. */
+declare function timelineRows(match: Match, opts: TimelineOptions): string[];
+/**
+ * The goal that made the record's score, PROVEN, or `null`. The record's
+ * scoring events, counted per side in their order (an own goal for the side
+ * it credited, which is the event's `side`), must equal its regulation score:
+ * then the timeline is whole and its last scoring event is the goal that made
+ * this score. Anything else proves nothing (a timeline that lags the score, a
+ * disallowed goal still listed, no score, no scoring event): the first scorer
+ * is never named for a second goal. Two scoring events identical in type,
+ * minute, added time, side and player prove nothing either: the same goal
+ * listed twice beside a timeline that lags would count as two. The ambient
+ * view's `lastGoal`, written by the refresher on each live record it
+ * publishes.
+ */
+declare function provenLastGoal(match: Match): MatchEvent | null;
+
 /** Outcome (home perspective) from a final/looking scoreline. */
 declare function outcomeFromScore(home: number, away: number): Outcome;
 /** Is the match currently in play (including halftime)? */
@@ -866,8 +950,9 @@ declare function fixturesByGroup(group: string, fixtures?: Match[]): Match[];
 /**
  * Eligible to be "the next match": the kickoff is still ahead AND the match is
  * still going to be played. ONE predicate for every selector (`next`, the
- * statusline countdown, the knockout-fixture cache, the market fixture, the
- * refresher cadence) — a cancelled or postponed fixture keeps its kickoff, so
+ * knockout-fixture cache, the market fixture, the refresher cadence; the
+ * statusline countdown asks it for a kickoff strictly ahead and also names a
+ * DUE fixture, the CLI's `isDue`) — a cancelled or postponed fixture keeps its kickoff, so
  * a time-only check advertised it as the next game (audit A07). Finished is
  * deliberately NOT a clause: under a real clock a finished match never has a
  * future kickoff, and excluding it only changed seeded-clock replays of an
@@ -1384,6 +1469,15 @@ interface LiveResult {
      */
     served?: readonly string[];
 }
+/**
+ * THE clock of a request: the one its caller gave (a test's, a command's
+ * context), else the adapter's read clock ({@link clockOf}: the clock the
+ * adapter's reads and its cooldown count by, the wall clock in production).
+ * A surface reads it ONCE per request, after resolving its adapter, and hands
+ * it to every read and every rendering of the request, so a lookup and a
+ * countdown in one answer agree on "now".
+ */
+declare function requestClock(adapter: ProviderAdapter, given?: Date): Date;
 /** Human label for a live-data provider name (attribution). Text only. */
 declare function liveSourceLabel(source: string): string;
 /**
@@ -1669,7 +1763,7 @@ interface KnockoutFixturesResult {
 /**
  * The RESOLVED upcoming knockout fixtures from the live overlay — the data the
  * hot-path statusline can't fetch itself but needs to show a real next-match
- * countdown (e.g. "🇲🇽 vs 🇪🇨 in 2d") instead of a 🏳️ placeholder. The cold-path
+ * countdown (e.g. "⚽ 🇲🇽 vs 🇪🇨 in 2d") instead of a 🏳️ placeholder. The cold-path
  * refresher calls this and caches the result; the statusline reads the cache.
  *
  * Returns only fixtures where BOTH sides are resolved (neither is the 🏳️ placeholder) and kickoff
@@ -1780,6 +1874,8 @@ declare function getScheduleAhead(adapter: ProviderAdapter, now?: Date): Promise
  * an adjacent bucket. Adapters without a window fetch fall back to `fetchLive()`.
  */
 declare function getLiveMatches(adapter: ProviderAdapter, now?: Date): Promise<LiveResult>;
+/** The finished records a live read returns, at most (the refresher's record of play keeps as many). */
+declare const MAX_LIVE_FINISHED = 64;
 /** A live read with the answer's own account of itself: what the refresher decides from. */
 interface LiveReadResult extends LiveResult {
     /**
@@ -1788,14 +1884,30 @@ interface LiveReadResult extends LiveResult {
      * whole and holds no match in play does not prove none is.
      */
     complete: boolean;
+    /**
+     * The window's records with status `FT` that hold a score, as the adapter
+     * sealed them, asked of the whole window before the in-play filter: the ids
+     * the caller passed as `seen` first, in the window's order, then the others,
+     * at most {@link MAX_LIVE_FINISHED}. `[]` for a failed read. The evidence of
+     * full time for a match the refresher saw in play; never on
+     * {@link getLiveMatches}' result.
+     */
+    finished: Match[];
+    /**
+     * The cap left finished records out: an id the caller saw that is absent
+     * from `finished` may then be one of them, so its absence decides nothing.
+     */
+    finishedTruncated: boolean;
 }
 /**
  * {@link getLiveMatches}, keeping the window's `complete` verdict (read from
- * the window's result BEFORE the in-play filter makes a new array). For the
- * cold-path refresher, which keeps polling after a match was seen in play
- * until a WHOLE read holds none.
+ * the window's result BEFORE the in-play filter makes a new array), and the
+ * window's finished records (`finished`, chosen ids-first by `seen`, the ids
+ * the refresher's record of play holds as seen in play). For the cold-path
+ * refresher, which keeps polling after a match was seen in play until a WHOLE
+ * read holds none.
  */
-declare function getLiveRead(adapter: ProviderAdapter, now?: Date): Promise<LiveReadResult>;
+declare function getLiveRead(adapter: ProviderAdapter, now?: Date, seen?: readonly string[]): Promise<LiveReadResult>;
 
 /** A roster team plus its group letter (A–L). */
 interface TeamInfo extends Team {
@@ -1937,6 +2049,15 @@ interface BoundedList<T> {
  * make an unbounded traversal safe. `takeBounded` is the one that bounds work.
  */
 declare function bounded<T>(items: readonly T[], max: number, complete?: boolean): BoundedList<T>;
+/**
+ * Take at most `max` items from something that may not be an array at all,
+ * BEFORE any per-item work happens.
+ *
+ * This is the work bound. Mapping, sorting or sanitizing first and slicing
+ * afterwards is what made a 4,000-row group cost 300ms to return 32, and a
+ * 100k-event record cost 5.3s on a 150ms surface.
+ */
+declare function takeBounded<T>(value: unknown, max: number): T[];
 
 /**
  * The vocabulary for "we could not use this".
@@ -2500,7 +2621,7 @@ declare const DEFAULT_MAX_AGE_MS: number;
  * "markets favor X 100%" after full time reads as a bug, not information.
  * An unparseable kickoff fails open (the reliability gate still applies).
  */
-declare function marketRelevant(match: Match, now?: Date): boolean;
+declare function marketRelevant(match: Match, now: Date): boolean;
 /**
  * Re-scale outcome probabilities so the positive ones sum to 1. This removes
  * market "vig" (raw prices sum to >1) and is scale-agnostic: inputs may be
@@ -2872,6 +2993,15 @@ declare function isPinnedSide(side: Team, pin: {
     readonly code: string;
     readonly name: string;
 }): boolean;
+/**
+ * THE constructor of a `MatchEvent`, on the feed path (the candidates the ESPN
+ * detail grammar built) and the cache path alike. An event with no side, a
+ * side that is neither, an unreadable minute or an added time outside 1..30 is
+ * refused (`null`); the match stands. Keys in the order `MatchEvent` declares
+ * them. Exported for the one other reader of an event, the ambient view, which
+ * re-seals the `lastGoal` the refresher stored on a cached live record.
+ */
+declare function sealEvent(raw: unknown): MatchEvent | null;
 /**
  * Validate candidate parts into a Match, or say why not.
  *
@@ -3054,6 +3184,411 @@ declare const FAN_PROJECT = "Independent fan project";
  */
 declare function disclaimerLine(host?: string): string;
 
+/**
+ * Where a selection came from: the command line's `--competition` or a tool's
+ * `competition` argument (`flag`), `CLAUDINHO_COMPETITION` (`env`), or the
+ * user's saved choice (`saved`: the config file `claudinho follow` writes).
+ * Nothing else chooses: with none of the three there is no competition
+ * (`{ kind: 'none' }`), never a default.
+ */
+type ChosenBy = 'flag' | 'env' | 'saved';
+/** A competition a request is for, and where that choice came from. */
+interface SelectedCompetition {
+    readonly kind: 'selected';
+    /** The provider's slug the request asks for. */
+    readonly slug: string;
+    /** The table's alias; absent for a raw slug. */
+    readonly alias?: string;
+    /** What a surface names it: the table's name, or a raw slug as it is. */
+    readonly name: string;
+    readonly chosenBy: ChosenBy;
+    /** A raw slug the table does not hold: the escape hatch, labelled. */
+    readonly experimental: boolean;
+}
+/**
+ * What the edge resolved: a competition; a value that is neither an alias nor
+ * a slug, REFUSED with the aliases (an unknown value is never a request); or
+ * `none`: nothing was chosen (no flag, no environment, no saved choice). The
+ * finished World Cup is not a default anyone falls into without choosing.
+ */
+type CompetitionSelection = SelectedCompetition | {
+    readonly kind: 'refused';
+    readonly value: string;
+    readonly aliases: string[];
+    /** The source that gave the refused value (a flag or the environment: the file's reader refuses its own). */
+    readonly chosenBy: ChosenBy;
+} | {
+    readonly kind: 'none';
+};
+/**
+ * The ONE constructor of a selected competition: a slug and where it was
+ * chosen, described by the table (its alias and name) or, for a slug the
+ * table does not hold, as itself and experimental. The resolver builds every
+ * selection through it; an edge that already holds a slug (a config built
+ * without the resolver) describes it through it too, never by hand.
+ */
+declare function selectedCompetition(slug: string, chosenBy: ChosenBy): SelectedCompetition;
+/**
+ * THE EDGE. The one function that decides which competition a request is for,
+ * from the values its edge hands in: the flag (`--competition`, a tool's
+ * `competition` argument), then the environment (`CLAUDINHO_COMPETITION`), then
+ * the saved choice (the config file's `competition`, read at the edge through
+ * core's one reader: `readUserConfig`). The FIRST present source decides (an
+ * empty string is absent): a present value that is refused is refused, even
+ * when a lower source holds a valid one (what was asked for is not answered
+ * with something else). With no source present, `none`: nothing is chosen,
+ * and every competition-answering surface says so instead of answering.
+ *
+ * Each value is an alias (`premier-league`), a slug in the table (`eng.1`), or
+ * a raw ESPN slug the table does not hold (`fifa.friendly`, `esp.copa_del_rey`:
+ * lower-case segments of letters, digits and underscores joined by dots, 64
+ * units at most; experimental);
+ * anything else (`foo`, `ENG.1`, a space) is refused with the aliases.
+ *
+ * Core reads NO environment and no file: the edges pass them. It is called
+ * where a request ENTERS (the CLI's option resolution, the MCP server's
+ * request) and nowhere else. From there the competition travels as a value
+ * (on the config, on the adapter), so nothing further down can answer for a
+ * different competition halfway through. `core/test/selection-identity.test.ts`
+ * fails if a call appears anywhere else.
+ */
+declare function resolveCompetition(explicit?: string, env?: string, saved?: string): CompetitionSelection;
+/**
+ * The line every competition-answering text answer prints after its header:
+ * the competition's name, then where the choice came from when it was the
+ * flag or the environment (`from the command line`; on MCP, `from the
+ * request`; `from the environment`), then `experimental` for a raw slug. A
+ * saved choice prints the name alone. The name is not localized; the rest is.
+ * Empty for a selection that is not a competition.
+ */
+declare function modeLine(selection: CompetitionSelection, lang?: string, 
+/** What a flag is on this surface: the command line's, or a tool request's argument. */
+flag?: 'command' | 'request'): string;
+/** The structured form of a selection: what `--json` and MCP `data` carry. */
+interface CompetitionKey {
+    readonly slug: string;
+    readonly alias?: string;
+    readonly name: string;
+    readonly chosenBy: ChosenBy;
+    readonly experimental?: true;
+}
+/**
+ * The selection as ONE structured key, `competition`, for every
+ * competition-answering structured answer (CLI `--json`, MCP `data`): the
+ * alias only when there is one, `experimental` only when true; `null` when
+ * nothing is chosen (beside the `noCompetition` verdict: see
+ * {@link selectionVerdict}). Nothing for a refused value (it is an error, never
+ * an answer). Every emit site spreads this; none builds the key by hand.
+ */
+declare function selectionExtras(selection: CompetitionSelection): {
+    competition?: CompetitionKey | null;
+};
+/**
+ * The verdict a selection states about every answer made under it: with
+ * nothing chosen, `noCompetition` (the first replacing verdict: its sentence
+ * stands instead of any answer, and its key goes beside `competition: null`);
+ * nothing otherwise. A surface hands THIS to `verdictNotice`/`verdictExtras`,
+ * never an object it builds itself.
+ */
+declare function selectionVerdict(selection: CompetitionSelection): VerdictSource;
+/**
+ * Why a selection is not a competition, in the reader's language; undefined
+ * for a competition. A refused value names the value (bounded) and the
+ * aliases; nothing chosen is the CLI's sentence (`claudinho follow <alias>`,
+ * `follow --list`): MCP answers nothing chosen with the `noCompetition`
+ * verdict's own sentence (`verdictNotice`), never this one. The CLI raises it
+ * as an input error, MCP a refused value as a tool error, before any request.
+ */
+declare function selectionRefusal(selection: CompetitionSelection, lang?: string): string | undefined;
+/** The competition whose schedule ships bundled in the clients: the World Cup. */
+declare const BUNDLE_COMPETITION = "fifa.world";
+/**
+ * The edition the bundled schedule describes, read from the schedule itself
+ * (the year of its first kickoff) rather than written down a second time.
+ */
+declare function bundleSeasonYear(): number;
+/**
+ * Does the bundled schedule describe what this request is about?
+ *
+ * The competition is an ARGUMENT — the caller's adapter states it — never a
+ * default. Off the bundle, every path built on the skeleton (date merge,
+ * `match <id>`, `next`, the bracket, the knockout-fixture cache, the market
+ * fixture) must not read it: an empty foreign day once showed 104 World Cup
+ * fixtures with foreign attribution (audit A03).
+ *
+ * The bundle is ONE EDITION of its competition. When the provider reported the
+ * season a response belongs to and it is a different one, the bundle does not
+ * describe that response. With no provider answer (offline, degraded) there is
+ * nothing to compare, and the bundle stays what it is: the 2026 edition.
+ */
+declare function bundleApplies(competition: string, season?: SeasonInfo): boolean;
+/**
+ * The competitions that HAVE NO BRACKET: league seasons with no knockout tie of
+ * their own, where "no bracket" is the answer, not a gap. Written down in the
+ * supported table (`bracket: 'not-applicable'`), one fact each, never inferred
+ * from the standings shape (`STANDINGS_SHAPE` says
+ * how a table is read, not whether a knockout follows it: `uefa.champions` and
+ * `mex.1` read as one league table and both have one).
+ *   - `eng.1`: the Premier League; a 38-round league, no play-off.
+ *   - `esp.1`: LaLiga; a 38-round league, no play-off.
+ * Deliberately NOT here: `ita.1` (championship and relegation play-offs since
+ * the FIGC's May 2026 decision), `ger.1` (the relegation play-off), `mex.1`
+ * (the Liguilla), `uefa.champions` (a knockout after the league phase). A
+ * competition joins by a written fact. A derived view, kept for its readers (it
+ * is exported); {@link bracketCapability} reads the row itself.
+ */
+declare const NO_BRACKET: ReadonlySet<string>;
+/**
+ * What `bracket` is for a competition, one of three values, read from its ROW
+ * (one row, one fact: a listing, the README matrix and the command cannot
+ * disagree):
+ *   - `offered`: the row offers it (only the bundled competition can:
+ *     `deriveTables` refuses any other row that does);
+ *   - `inapplicable`: the row says the competition has none (`not-applicable`);
+ *   - `unsupported`: it may have one, and it is not offered yet; also a slug
+ *     the table does not hold.
+ */
+declare function bracketCapability(competition: string, table?: readonly CompetitionEntry[]): 'offered' | 'inapplicable' | 'unsupported';
+
+/**
+ * The ambient view: what `claudinho ambient --json` prints, ONE JSON object on
+ * one line, for a program that shows the statusline and the hook itself (the
+ * Claude Code plugin's band, its toasts and its prompt context). A type and
+ * its documentation only: the CLI builds it from its local cache (the
+ * statusline's reader, in `packages/cli`), and core reads no cache and no
+ * environment for it.
+ *
+ * Three shapes reach a reader, and the command always exits 0:
+ *   - nothing chosen (no `--competition`, no `CLAUDINHO_COMPETITION`, no saved
+ *     choice): the selection's structured twin, `competition: null` beside the
+ *     verdict that says nothing is chosen, and `line` (the statusline's
+ *     first-run line); no cache is read and no refresher started;
+ *   - a value that is no competition, or a failure anywhere: `line` (the
+ *     statusline's empty line) and `empty: true` alone, no view;
+ *   - a selected competition: an {@link AmbientView}.
+ */
+
+/**
+ * One part of the band's line (`lineParts`): a run of its text, `strong` for a
+ * score token the fit kept whole. The parts' texts joined are the line.
+ */
+interface AmbientLinePart {
+    readonly text: string;
+    readonly style?: 'strong';
+}
+/** The two names the hook's line prints for a record (a nation's roster name on the bundled competition). */
+interface AmbientNames {
+    readonly home: string;
+    readonly away: string;
+}
+/**
+ * A finished match as the ambient view lists it (`finished`): the sealed
+ * record (status `FT`, its final score), as a live one is serialized, with:
+ */
+type AmbientFinishedMatch = Match & {
+    /**
+     * The side of the SAVED pin (`claudinho follow <alias> --team`, by core's
+     * `isPinnedSide`), or `null`: never `CLAUDINHO_TEAM`, which only orders.
+     */
+    readonly pinnedSide: 'home' | 'away' | null;
+    /** The names the hook's line prints for it. */
+    readonly names: AmbientNames;
+    /** The hook's own line for it, `(FT)` in the minute's place. */
+    readonly line: string;
+};
+/**
+ * A live match as the ambient view lists it: the sealed record, as the other
+ * `--json` twins serialize a `Match` (`status`, the `score` object, `shootout`
+ * after a shootout, `Team.id` where the cache holds it, a nation's generated
+ * `flag`, no `flag` key on a club), with no `events` key (the ambient reader
+ * never seals a timeline), and what it says about the reader's own team, the
+ * names and the last goal:
+ */
+type AmbientMatch = Match & {
+    /**
+     * A side of it is the ambient PREFERENCE's (`pick`): `CLAUDINHO_TEAM`'s
+     * code, else the saved pin. The picked matches come first in the list.
+     */
+    readonly picked: boolean;
+    /**
+     * A side of it is the SAVED pin's (`claudinho follow <alias> --team`), by
+     * the pin's id when it has one (a club), by its code when it has none (the
+     * World Cup's nations); whatever `CLAUDINHO_TEAM` prefers.
+     */
+    readonly pinned: boolean;
+    /** Which side is the SAVED pin's (by core's `isPinnedSide`), or `null`: never `CLAUDINHO_TEAM`'s. */
+    readonly pinnedSide: 'home' | 'away' | null;
+    /** The names the hook's line prints for it (a nation's roster name on the bundled competition). */
+    readonly names: AmbientNames;
+    /**
+     * The hook's own line for this record, as `claudinho hook` prints it (the
+     * names, pinned to the World Cup's roster on the bundle, each with its flag
+     * where flags are on and the side has one, the scoreline with a shootout's
+     * tally, the minute token: `67'`, `half-time`, `live`). A program says it,
+     * never composes one.
+     */
+    readonly line: string;
+    /**
+     * The goal that made the record's score, PROVEN by the refresher (its
+     * scoring events counted per side equal the score: core's
+     * `provenLastGoal`), stored on the cached record and re-sealed by the
+     * reader with core's `sealEvent` and kept only as a goal, an own goal or a
+     * penalty whose `teamCode` is the code of the side its `side` names, a side
+     * that has scored (its regulation score at least 1); `null`
+     * when nothing is proven or the stored value is anything else.
+     */
+    readonly lastGoal: MatchEvent | null;
+};
+/** The ambient view of a selected competition, its keys in this order. */
+interface AmbientView {
+    /**
+     * The statusline's line rendered in `lang` (the same reader and the same
+     * options as `claudinho prompt`, which prints it in English), fitted to
+     * `--columns N` when given: whole matches are kept while they fit and
+     * the rest counted in the `+N` (or `+more`) suffix, which is never cut
+     * while the width holds it; below the suffix's own width
+     * the line is the width's cut, never wider than asked. Its own tokens are in
+     * `lang` (the countdown, the syncing phrase, the live segment's half-time
+     * and live words); the overflow marker (`+N`, `+more`), the World Cup's
+     * sign-off and nothing known (`⚽ —`) are English in every language, so
+     * `idle` and `empty` say what they say in every language.
+     */
+    readonly line: string;
+    /**
+     * The line as parts, built by the fitter as it places each shown score
+     * token: their texts joined are `line` exactly, a score token the fit kept
+     * whole is `strong`, one it cut is not. One plain part, the line itself, on
+     * the countdown, the syncing line, nothing known and the sign-off, and
+     * whenever the parts would not join to the line.
+     */
+    readonly lineParts: readonly AmbientLinePart[];
+    /**
+     * The line is the one long-lived line, the edition's sign-off (the World
+     * Cup's, once every bundled window has closed): nothing changes until the
+     * user follows another competition, so a program reads it slowly. Said of
+     * the line before any fit: a program reads the pace from this, never from the
+     * text, which `--columns` may have cut.
+     */
+    readonly idle: boolean;
+    /**
+     * The line says nothing is known (`⚽ —`): no live match read, no window to
+     * sync in, nothing to count down to. A program shows nothing for it. Said
+     * of the line before any fit: a program reads the visibility from this,
+     * never from the text.
+     */
+    readonly empty: boolean;
+    /** The hook's block, as `claudinho hook` prints it while a match is live; `null` when it prints nothing. */
+    readonly context: string | null;
+    /**
+     * The live matches the statusline reads (a believed snapshot's, inside the
+     * display window), the preference's first. `complete` says the scan was
+     * whole and `total` is exact only then; an empty list with `complete: false`
+     * is "not known". An empty list is "nothing on" ONLY beside `current: true`:
+     * with `current: false` (no snapshot, a stale one, a stamp the reader does
+     * not believe, a degraded one, one whose read was not whole or that does
+     * not say, the syncing window) it says nothing about
+     * play, a match may be on (`line` is the authority: it prints
+     * `live · syncing…` in the window), and a program must never read
+     * `complete && items.length === 0` alone as "nothing on". A degraded
+     * snapshot (the last read failed) may still carry a live record: it is
+     * listed, best effort, as the line shows it, and is never current.
+     */
+    readonly live: BoundedList<AmbientMatch>;
+    /**
+     * The matches the refresher SAW in play that a whole read then returned
+     * finished (the snapshot's record of play), each for 10 minutes from the
+     * read that first saw it finished, judged by the reader's clock (a stamp in
+     * the future is not believed), whatever the snapshot's display window (the
+     * refresher stops polling once the last match ends, so the snapshot ages
+     * past it while an entry is still inside its own 10 minutes); never one the
+     * live list holds. Listed only from a snapshot whose live read was whole
+     * (`liveComplete: true`); otherwise `[]`, which then says nothing. At most
+     * 64. Absence from it never means a match is over.
+     */
+    readonly finished: readonly AmbientFinishedMatch[];
+    /**
+     * The live list is a believed snapshot's inside its display window (its
+     * stamp's age, by the reader's own rule, is finite and short of the window),
+     * the snapshot is not degraded (a degraded one means the fetch failed, not
+     * that the feed said nothing: it is never current, whatever it carries), the
+     * snapshot states that the read that filled its live slice was whole (a read
+     * that was not, an unreadable record left out beside readable ones, is never
+     * current; nor is a snapshot that does not say, written before 0.11.2, until
+     * one refresh cycle rewrites it), and the line is not syncing: then, and
+     * only then, an empty list means the feed said nothing is in play.
+     */
+    readonly current: boolean;
+    /**
+     * The fixture the statusline's countdown names (its resolved pairing; the
+     * preference's first), whether or not a match is in play now; `null` when
+     * there is none to count down to. A fixture ahead, or a DUE one (still
+     * scheduled, its kickoff passed by at most 30 minutes, not held by the
+     * snapshot's record of play: the line reads "now"); never one in play.
+     */
+    readonly next: Match | null;
+    /**
+     * The ambient preference as the CLI holds it: `{ code }` from
+     * `CLAUDINHO_TEAM`, the saved pin (`{ id?, code, name }`) when that is
+     * unset, or `null`.
+     */
+    readonly pick: {
+        readonly code: string;
+    } | Pin | null;
+    /**
+     * Present (and `true`) when `CLAUDINHO_TEAM` is set to a value the hot path
+     * cannot read offline (off the World Cup, anything but a three-letter code;
+     * on it, a name its roster does not hold): `pick` is then `null`, never the
+     * pin (the environment is the override).
+     */
+    readonly pickUnreadable?: true;
+    /** The selection, as every `--json` answer carries it (core `selectionExtras`). */
+    readonly competition: CompetitionKey;
+    /**
+     * The CLI's resolved language (`--lang`, `CLAUDINHO_LANG`, `LANG`'s language
+     * part, each only when it is one of the four, else `en`), the language of
+     * `line`, `lineParts` and `words`. `context`, `attribution`, `disclaimer`
+     * and each record's `line` stay English in every language.
+     */
+    readonly lang: Lang;
+    /**
+     * The plugin's moment words in `lang` (core's `moment.*` keys, `momentWords`):
+     * `goalFor` and `win` templates holding `{team}` once, for the plugin to
+     * fill with a record's own `names`.
+     */
+    readonly words: MomentWords;
+    /** The snapshot says its last refresh failed (`false` with no snapshot). */
+    readonly degraded: boolean;
+    /** The provider the snapshot was read from, whatever its stamp; `null` with no snapshot. */
+    readonly source: string | null;
+    /**
+     * When the snapshot was written (ISO 8601, re-emitted canonically), or
+     * `null` with no snapshot or a stamp the reader does not believe (further in
+     * the future than its clock-skew allowance: its live scores are not shown).
+     */
+    readonly updatedAt: string | null;
+    /**
+     * When the snapshot's live scores stop being shown (`updatedAt` plus the
+     * statusline's display window), or `null` whenever `updatedAt` is.
+     */
+    readonly staleAfter: string | null;
+    /** The non-affiliation sentence, core's `DISCLAIMER`. */
+    readonly disclaimer: string;
+    /**
+     * The provider's attribution sentence, in English as every ambient string:
+     * core's `live.data` copy with `liveSourceLabel(source)` (`Live data:
+     * ESPN`), when the snapshot names a provider (`source` is a string) AND
+     * the line is neither the sign-off (`idle`) nor nothing known (`empty`);
+     * `null` otherwise: no snapshot, the sign-off (made from the bundled clock),
+     * nothing known. `degraded` does not decide: a degraded snapshot still shows
+     * a live row an earlier read served, or a countdown to a fixture discovery
+     * read; nor does a read that was not whole. A limit: on the bundled
+     * competition, a countdown made from the bundled skeleton (before its
+     * knockout pairings resolve) would be attributed too; unreachable while that
+     * edition is over.
+     */
+    readonly attribution: string | null;
+}
+
 /** The two v1 snippet shapes. `social` is the rich card; `compact` is one terse line per match. */
 type ShareStyle = 'compact' | 'social';
 /** The project social tag — a distribution unit, default-on but removable. */
@@ -3544,172 +4079,6 @@ declare function isPlaceholderSide(team: Pick<Team, 'flag'>): boolean;
 /** The bundled knockout bracket topology (generated by gen:schedule). */
 declare function loadBracketTopology(): BracketTopology;
 
-/**
- * Where a selection came from: the command line's `--competition` or a tool's
- * `competition` argument (`flag`), `CLAUDINHO_COMPETITION` (`env`), or the
- * user's saved choice (`saved`: the config file `claudinho follow` writes).
- * Nothing else chooses: with none of the three there is no competition
- * (`{ kind: 'none' }`), never a default.
- */
-type ChosenBy = 'flag' | 'env' | 'saved';
-/** A competition a request is for, and where that choice came from. */
-interface SelectedCompetition {
-    readonly kind: 'selected';
-    /** The provider's slug the request asks for. */
-    readonly slug: string;
-    /** The table's alias; absent for a raw slug. */
-    readonly alias?: string;
-    /** What a surface names it: the table's name, or a raw slug as it is. */
-    readonly name: string;
-    readonly chosenBy: ChosenBy;
-    /** A raw slug the table does not hold: the escape hatch, labelled. */
-    readonly experimental: boolean;
-}
-/**
- * What the edge resolved: a competition; a value that is neither an alias nor
- * a slug, REFUSED with the aliases (an unknown value is never a request); or
- * `none`: nothing was chosen (no flag, no environment, no saved choice). The
- * finished World Cup is not a default anyone falls into without choosing.
- */
-type CompetitionSelection = SelectedCompetition | {
-    readonly kind: 'refused';
-    readonly value: string;
-    readonly aliases: string[];
-    /** The source that gave the refused value (a flag or the environment: the file's reader refuses its own). */
-    readonly chosenBy: ChosenBy;
-} | {
-    readonly kind: 'none';
-};
-/**
- * The ONE constructor of a selected competition: a slug and where it was
- * chosen, described by the table (its alias and name) or, for a slug the
- * table does not hold, as itself and experimental. The resolver builds every
- * selection through it; an edge that already holds a slug (a config built
- * without the resolver) describes it through it too, never by hand.
- */
-declare function selectedCompetition(slug: string, chosenBy: ChosenBy): SelectedCompetition;
-/**
- * THE EDGE. The one function that decides which competition a request is for,
- * from the values its edge hands in: the flag (`--competition`, a tool's
- * `competition` argument), then the environment (`CLAUDINHO_COMPETITION`), then
- * the saved choice (the config file's `competition`, read at the edge through
- * core's one reader: `readUserConfig`). The FIRST present source decides (an
- * empty string is absent): a present value that is refused is refused, even
- * when a lower source holds a valid one (what was asked for is not answered
- * with something else). With no source present, `none`: nothing is chosen,
- * and every competition-answering surface says so instead of answering.
- *
- * Each value is an alias (`premier-league`), a slug in the table (`eng.1`), or
- * a raw ESPN slug the table does not hold (`fifa.friendly`, `esp.copa_del_rey`:
- * lower-case segments of letters, digits and underscores joined by dots, 64
- * units at most; experimental);
- * anything else (`foo`, `ENG.1`, a space) is refused with the aliases.
- *
- * Core reads NO environment and no file: the edges pass them. It is called
- * where a request ENTERS (the CLI's option resolution, the MCP server's
- * request) and nowhere else. From there the competition travels as a value
- * (on the config, on the adapter), so nothing further down can answer for a
- * different competition halfway through. `core/test/selection-identity.test.ts`
- * fails if a call appears anywhere else.
- */
-declare function resolveCompetition(explicit?: string, env?: string, saved?: string): CompetitionSelection;
-/**
- * The line every competition-answering text answer prints after its header:
- * the competition's name, then where the choice came from when it was the
- * flag or the environment (`from the command line`; on MCP, `from the
- * request`; `from the environment`), then `experimental` for a raw slug. A
- * saved choice prints the name alone. The name is not localized; the rest is.
- * Empty for a selection that is not a competition.
- */
-declare function modeLine(selection: CompetitionSelection, lang?: string, 
-/** What a flag is on this surface: the command line's, or a tool request's argument. */
-flag?: 'command' | 'request'): string;
-/** The structured form of a selection: what `--json` and MCP `data` carry. */
-interface CompetitionKey {
-    readonly slug: string;
-    readonly alias?: string;
-    readonly name: string;
-    readonly chosenBy: ChosenBy;
-    readonly experimental?: true;
-}
-/**
- * The selection as ONE structured key, `competition`, for every
- * competition-answering structured answer (CLI `--json`, MCP `data`): the
- * alias only when there is one, `experimental` only when true; `null` when
- * nothing is chosen (beside the `noCompetition` verdict: see
- * {@link selectionVerdict}). Nothing for a refused value (it is an error, never
- * an answer). Every emit site spreads this; none builds the key by hand.
- */
-declare function selectionExtras(selection: CompetitionSelection): {
-    competition?: CompetitionKey | null;
-};
-/**
- * The verdict a selection states about every answer made under it: with
- * nothing chosen, `noCompetition` (the first replacing verdict: its sentence
- * stands instead of any answer, and its key goes beside `competition: null`);
- * nothing otherwise. A surface hands THIS to `verdictNotice`/`verdictExtras`,
- * never an object it builds itself.
- */
-declare function selectionVerdict(selection: CompetitionSelection): VerdictSource;
-/**
- * Why a selection is not a competition, in the reader's language; undefined
- * for a competition. A refused value names the value (bounded) and the
- * aliases; nothing chosen is the CLI's sentence (`claudinho follow <alias>`,
- * `follow --list`): MCP answers nothing chosen with the `noCompetition`
- * verdict's own sentence (`verdictNotice`), never this one. The CLI raises it
- * as an input error, MCP a refused value as a tool error, before any request.
- */
-declare function selectionRefusal(selection: CompetitionSelection, lang?: string): string | undefined;
-/** The competition whose schedule ships bundled in the clients: the World Cup. */
-declare const BUNDLE_COMPETITION = "fifa.world";
-/**
- * The edition the bundled schedule describes, read from the schedule itself
- * (the year of its first kickoff) rather than written down a second time.
- */
-declare function bundleSeasonYear(): number;
-/**
- * Does the bundled schedule describe what this request is about?
- *
- * The competition is an ARGUMENT — the caller's adapter states it — never a
- * default. Off the bundle, every path built on the skeleton (date merge,
- * `match <id>`, `next`, the bracket, the knockout-fixture cache, the market
- * fixture) must not read it: an empty foreign day once showed 104 World Cup
- * fixtures with foreign attribution (audit A03).
- *
- * The bundle is ONE EDITION of its competition. When the provider reported the
- * season a response belongs to and it is a different one, the bundle does not
- * describe that response. With no provider answer (offline, degraded) there is
- * nothing to compare, and the bundle stays what it is: the 2026 edition.
- */
-declare function bundleApplies(competition: string, season?: SeasonInfo): boolean;
-/**
- * The competitions that HAVE NO BRACKET: league seasons with no knockout tie of
- * their own, where "no bracket" is the answer, not a gap. Written down in the
- * supported table (`bracket: 'not-applicable'`), one fact each, never inferred
- * from the standings shape (`STANDINGS_SHAPE` says
- * how a table is read, not whether a knockout follows it: `uefa.champions` and
- * `mex.1` read as one league table and both have one).
- *   - `eng.1`: the Premier League; a 38-round league, no play-off.
- *   - `esp.1`: LaLiga; a 38-round league, no play-off.
- * Deliberately NOT here: `ita.1` (championship and relegation play-offs since
- * the FIGC's May 2026 decision), `ger.1` (the relegation play-off), `mex.1`
- * (the Liguilla), `uefa.champions` (a knockout after the league phase). A
- * competition joins by a written fact. A derived view, kept for its readers (it
- * is exported); {@link bracketCapability} reads the row itself.
- */
-declare const NO_BRACKET: ReadonlySet<string>;
-/**
- * What `bracket` is for a competition, one of three values, read from its ROW
- * (one row, one fact: a listing, the README matrix and the command cannot
- * disagree):
- *   - `offered`: the row offers it (only the bundled competition can:
- *     `deriveTables` refuses any other row that does);
- *   - `inapplicable`: the row says the competition has none (`not-applicable`);
- *   - `unsupported`: it may have one, and it is not offered yet; also a slug
- *     the table does not hold.
- */
-declare function bracketCapability(competition: string, table?: readonly CompetitionEntry[]): 'offered' | 'inapplicable' | 'unsupported';
-
 /**
  * Metadata that belongs to ONE fetch result.
  *
@@ -3911,4 +4280,4 @@ declare function lookAtEntry(path: string): FileEntry;
  */
 declare function lookAtOwnFile(path: string, maxBytes: number): OwnFile;
 
-export { BRACKET_STAGE_ORDER, BUNDLE_COMPETITION, type BatchResolution, type BetweenEditions, type BoundedList, type BracketFormatOpts, type BracketMatchNode, type BracketMatchView, type BracketResult, type BracketShareCard, type BracketTopology, type BracketView, type BuildSignalInput, COMPETITION_KIND, COUNTDOWN_NOW, type Capabilities, type Capability, type ChosenBy, type ClubResolution, type CompetitionEntry, type CompetitionKey, type CompetitionKind, type CompetitionSelection, DEFAULT_COMPETITION, DEFAULT_COOLDOWN_MS, DEFAULT_FLAVOR, DEFAULT_MAX_AGE_MS, DISCLAIMER, type DayAttribution, type DerivedTables, EARLIER_RECORD_NOTE, EspnAdapter, type EspnAdapterOptions, FAN_PROJECT, FLAVOR_BANKS, FLAVOR_LEVELS, FLAVOR_MOMENTS, FakeMarketProvider, type FakeMarketProviderOptions, type FavoriteStrength, type FetchMeta, type FetchWindowOptions, type FileEntry, type Flair, type FlairOpts, type FlavorBank, type FlavorLevel, type Moment as FlavorMoment, type FlavorOpts, type FormatOpts, type GroupStandings, KNOCKOUT_EXTRA_TIME_MS, KNOWN_SOURCES, type KnockoutFixturesResult, LIVE_WINDOW_MS, type Lang, type LedgerRow, type ListedCompetition, type LiveReadResult, type LiveResult, MARKETS_SCOPE_NOTE, MARKET_COMPETITIONS, MAX_CONFIG_BYTES, MAX_COOLDOWN_MS, MAX_LABEL_COLUMNS, MAX_RESPONSE_BYTES, MAX_SCHEDULE_INDEX, type MapContext, type MarketFavorite, type MarketMapping, type MarketMappingTable, type MarketOutcome, type MarketOutcomeKind, type MarketProvider, type MarketSignal, type MarketSignalOptions, type MarketSignalsResult, type Match, type MatchByIdResult, type MatchEvent, type MatchShareCard, NO_BRACKET, type NextFixtureResult, type NoConfigReason, type Outcome, type OwnFile, type ParseResult, type Pin, PolymarketProvider, type PolymarketProviderOptions, type ProviderAdapter, type ProviderCapabilities, ProviderError, type ProviderErrorKind, type PunditPick, RALLY_CRIES, type RallyCry, type RallyPin, type ReadAccount, type ResolvedParticipant, ResponseTooLargeError, type Roster, SCHEDULE_AHEAD_DAYS, SCHEDULE_LOOKBACK_DAYS, SEASON_SLUG, SHARE_DISCLAIMER, SHARE_HASHTAG, STANDINGS_SHAPE, SUPPORTED, type ScheduleAheadResult, type ScheduleEntry, type SeasonInfo, type SelectedCompetition, type Selection, type ShareBracketInput, type ShareBracketOptions, type ShareCardContext, type ShareCardMarket, type ShareCardView, type ShareSnippetInput, type ShareSnippetOptions, type ShareStyle, type ShareTableInput, type SlotRef, type SmallFile, type Stage, type StandingRow, type StandingsResult, type Status, TABLE_KEY_ARG, TEAM_KIND, type TableData, type TableShareCard, type Team, type TeamInfo, type TeamKind, type TeamLookup, type UserConfig, type UserConfigRead, type VerdictExtras, type VerdictSource, allFixtures, allTeams, ambiguous, asFlavorLevel, attachFetchMeta, bounded, bracketCapability, bracketShareCard, buildBracketTopology, buildBracketView, buildMarketSignal, bundleApplies, bundleSeasonYear, byKickoff, cacheDirFor, cacheableKeys, capabilitiesOf, competitionBase, competitionKind, competitionLabel, competitionValue, computeStandings, configPath, countdown, countdownPhrase, currentOrNextFixtureForTeam, dateNoneRead, dateNoneReadSentence, dateShareCard, dateUnreached, dateUnreachedSentence, dayAttribution, definitiveNone, deriveFavorite, deriveTables, disclaimerLine, displayWidth, emptyBatch, entryOf, favoriteStrength, fetchMeta, fixturesByDate, fixturesByGroup, fixturesByTeam, fixturesInLiveWindow, flagEmoji, flavorsFor, formatBracketCompactLine, formatBracketList, formatBracketMatchLine, formatBracketTree, formatDate, formatKickoff, formatShareBracket, formatShareSnippet, formatShareTable, formatTime, getBracket, getKnockoutFixtures, getLiveMatches, getLiveRead, getMarketSignal, getMarketSignals, getMatchById, getMatchesForDate, getNextFixtureForTeam, getScheduleAhead, getStandings, groups, hasLiveWindow, hasSaneDistribution, humanLabel, isCacheable, isFinished, isFlavorLevel, isHumanLabel, isKnockoutStage, isKnownSource, isLive, isMexicoNationalTeam, isPinnedSide, isPlaceholderSide, isReliableMarketSignal, isStaleSignal, isTeam, isTournamentWindowOver, isUpcoming, isValidDate, isValidTimeZone, joinSegments, knockoutWindow, listCompetitions, liveNoneRead, liveNoneReadSentence, liveShareCard, liveSourceLabel, liveWindowMsFor, loadBracketTopology, localDate, lookAtEntry, lookAtOwnFile, lookAtSmallFile, lookupTeam, makeAdapter, makeMarketProvider, malformed, mapEspnEvent, mapsCleanly, marketAttributionText, marketBlock, marketDisplayable, marketFavoriteText, marketFixtureForTeam, marketLine, marketProbabilityText, marketRelevant, marketScopeVerdict, marketSignalRendersFor, marketSourceLabel, marketsCoverCompetition, marketsNoneRead, marketsNoneReadNote, marketsNoneReadSentence, matchFlair, matchFlairs, matchFlavor, matchKey, matchLocation, matchNoneReadSentence, matchShareCard, matchWindowSentence, mergeLive, modeLine, nationArg, nationToFlag, nationToRegion, nextFixtureForPin, nextFixtureForTeam, nextHorizonSentence, nextNoneReadSentence, nextShareCard, normalizeLang, normalizeOutcomes, outcomeFromScore, padVisible, parseCachedMarketSignal, parseCachedMatch, parseCachedMatches, parseCachedScheduleIndex, parseStandings, parseTeamSlot, parsedValue, pinUnder, productFlag, rallyCryFor, rallyEntryFor, readJsonBounded, readSmallFile, readUserConfig, resolveClub, resolveCompetition, resolveMarketSource, resolveTz, resolvedValues, retryAfterMs, rosterFor, sanitizeBundledFixture, savedSlug, scheduleEntryOf, scheduleSpan, scoreline, sealMarketSignal, sealMatch, sealScheduleEntry, sealSeason, selectOne, selectedCompetition, selectionExtras, selectionRefusal, selectionVerdict, servedExtras, stageLabel, stageLabelI18n, standingsShapeOf, statesPartial, t, tableData, tableKeyArg, tableShareCard, tableTitle, teamKind, truncateVisible, unresolved, unservedSentence, valid, verdictExtras, verdictNotice, verdictQualifiers, withFlag };
+export { type AmbientFinishedMatch, type AmbientLinePart, type AmbientMatch, type AmbientNames, type AmbientView, BRACKET_STAGE_ORDER, BUNDLE_COMPETITION, type BatchResolution, type BetweenEditions, type BoundedList, type BracketFormatOpts, type BracketMatchNode, type BracketMatchView, type BracketResult, type BracketShareCard, type BracketTopology, type BracketView, type BuildSignalInput, COMPETITION_KIND, COUNTDOWN_NOW, type Capabilities, type Capability, type ChosenBy, type ClubResolution, type CompetitionEntry, type CompetitionKey, type CompetitionKind, type CompetitionSelection, DEFAULT_COMPETITION, DEFAULT_COOLDOWN_MS, DEFAULT_FLAVOR, DEFAULT_MAX_AGE_MS, DISCLAIMER, type DayAttribution, type DerivedTables, EARLIER_RECORD_NOTE, EspnAdapter, type EspnAdapterOptions, FAN_PROJECT, FLAVOR_BANKS, FLAVOR_LEVELS, FLAVOR_MOMENTS, FakeMarketProvider, type FakeMarketProviderOptions, type FavoriteStrength, type FetchMeta, type FetchWindowOptions, type FileEntry, type Flair, type FlairOpts, type FlavorBank, type FlavorLevel, type Moment as FlavorMoment, type FlavorOpts, type FormatOpts, type GroupStandings, KNOCKOUT_EXTRA_TIME_MS, KNOWN_SOURCES, type KnockoutFixturesResult, LIVE_WINDOW_MS, type Lang, type LedgerRow, type ListedCompetition, type LiveReadResult, type LiveResult, MARKETS_SCOPE_NOTE, MARKET_COMPETITIONS, MAX_CONFIG_BYTES, MAX_COOLDOWN_MS, MAX_LABEL_COLUMNS, MAX_LIVE_FINISHED, MAX_RESPONSE_BYTES, MAX_SCHEDULE_INDEX, type MapContext, type MarketFavorite, type MarketMapping, type MarketMappingTable, type MarketOutcome, type MarketOutcomeKind, type MarketProvider, type MarketSignal, type MarketSignalOptions, type MarketSignalsResult, type Match, type MatchByIdResult, type MatchEvent, type MatchShareCard, type MomentWords, NO_BRACKET, type NextFixtureResult, type NoConfigReason, type Outcome, type OwnFile, type ParseResult, type Pin, PolymarketProvider, type PolymarketProviderOptions, type ProviderAdapter, type ProviderCapabilities, ProviderError, type ProviderErrorKind, type PunditPick, RALLY_CRIES, type RallyCry, type RallyPin, type ReadAccount, type ResolvedParticipant, ResponseTooLargeError, type Roster, SCHEDULE_AHEAD_DAYS, SCHEDULE_LOOKBACK_DAYS, SEASON_SLUG, SHARE_DISCLAIMER, SHARE_HASHTAG, STANDINGS_SHAPE, SUPPORTED, type ScheduleAheadResult, type ScheduleEntry, type SeasonInfo, type SelectedCompetition, type Selection, type ShareBracketInput, type ShareBracketOptions, type ShareCardContext, type ShareCardMarket, type ShareCardView, type ShareSnippetInput, type ShareSnippetOptions, type ShareStyle, type ShareTableInput, type SlotRef, type SmallFile, type Stage, type StandingRow, type StandingsResult, type Status, TABLE_KEY_ARG, TEAM_KIND, type TableData, type TableShareCard, type Team, type TeamInfo, type TeamKind, type TeamLookup, type TimelineOptions, type TimelinePart, type UserConfig, type UserConfigRead, type VerdictExtras, type VerdictSource, allFixtures, allTeams, ambiguous, asFlavorLevel, attachFetchMeta, bounded, bracketCapability, bracketShareCard, buildBracketTopology, buildBracketView, buildMarketSignal, bundleApplies, bundleSeasonYear, byKickoff, cacheDirFor, cacheableKeys, capabilitiesOf, competitionBase, competitionKind, competitionLabel, competitionValue, computeStandings, configPath, countdown, countdownPhrase, currentOrNextFixtureForTeam, dateNoneRead, dateNoneReadSentence, dateShareCard, dateUnreached, dateUnreachedSentence, dayAttribution, definitiveNone, deriveFavorite, deriveTables, disclaimerLine, displayWidth, emptyBatch, entryOf, favoriteStrength, fetchMeta, fixturesByDate, fixturesByGroup, fixturesByTeam, fixturesInLiveWindow, flagEmoji, flavorsFor, formatBracketCompactLine, formatBracketList, formatBracketMatchLine, formatBracketTree, formatDate, formatKickoff, formatShareBracket, formatShareSnippet, formatShareTable, formatTime, getBracket, getKnockoutFixtures, getLiveMatches, getLiveRead, getMarketSignal, getMarketSignals, getMatchById, getMatchesForDate, getNextFixtureForTeam, getScheduleAhead, getStandings, groups, hasLiveWindow, hasSaneDistribution, humanLabel, isCacheable, isFinished, isFlavorLevel, isHumanLabel, isKnockoutStage, isKnownSource, isLive, isMexicoNationalTeam, isPinnedSide, isPlaceholderSide, isReliableMarketSignal, isStaleSignal, isTeam, isTournamentWindowOver, isUpcoming, isValidDate, isValidTimeZone, joinSegments, knockoutWindow, listCompetitions, liveNoneRead, liveNoneReadSentence, liveShareCard, liveSourceLabel, liveWindowMsFor, loadBracketTopology, localDate, lookAtEntry, lookAtOwnFile, lookAtSmallFile, lookupTeam, makeAdapter, makeMarketProvider, malformed, mapEspnEvent, mapsCleanly, marketAttributionText, marketBlock, marketDisplayable, marketFavoriteText, marketFixtureForTeam, marketLine, marketProbabilityText, marketRelevant, marketScopeVerdict, marketSignalRendersFor, marketSourceLabel, marketsCoverCompetition, marketsNoneRead, marketsNoneReadNote, marketsNoneReadSentence, matchFlair, matchFlairs, matchFlavor, matchKey, matchLocation, matchNoneReadSentence, matchShareCard, matchWindowSentence, mergeLive, modeLine, momentWords, nationArg, nationToFlag, nationToRegion, nextFixtureForPin, nextFixtureForTeam, nextHorizonSentence, nextNoneReadSentence, nextShareCard, normalizeLang, normalizeOutcomes, outcomeFromScore, padVisible, parseCachedMarketSignal, parseCachedMatch, parseCachedMatches, parseCachedScheduleIndex, parseStandings, parseTeamSlot, parsedValue, pinUnder, productFlag, provenLastGoal, rallyCryFor, rallyEntryFor, readJsonBounded, readSmallFile, readUserConfig, requestClock, resolveClub, resolveCompetition, resolveMarketSource, resolveTz, resolvedValues, retryAfterMs, rosterFor, sanitizeBundledFixture, savedSlug, scheduleEntryOf, scheduleSpan, scoreline, sealEvent, sealMarketSignal, sealMatch, sealScheduleEntry, sealSeason, selectOne, selectedCompetition, selectionExtras, selectionRefusal, selectionVerdict, servedExtras, stageLabel, stageLabelI18n, standingsShapeOf, statesPartial, t, tableData, tableKeyArg, tableShareCard, tableTitle, takeBounded, teamKind, timelineParts, timelineRows, truncateVisible, unresolved, unservedSentence, valid, verdictExtras, verdictNotice, verdictQualifiers, withFlag };