claudial 0.6.3 → 0.7.0

package/dist/ui/picker/Picker.js

@@ -0,0 +1,152 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useReducer, useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { ACCENT, RED } from '../Header.js';
+import { getSettings, listLeagues, listTeams, putSettings, } from '../../api/backend.js';
+import { followedIn, initialPickerState, pickerReducer, rows, settingsOf, stillLoading, teamName, } from './state.js';
+const defaultApi = { listLeagues, listTeams, getSettings, putSettings };
+export function Picker({ onDone, api = defaultApi, intro }) {
+    const [s, dispatch] = useReducer(pickerReducer, initialPickerState);
+    const [phase, setPhase] = useState({ kind: 'loading' });
+    const { stdout } = useStdout();
+    // Every line of chrome counted (padding 2, title 2, intro 2, search 1, list margins 2,
+    // more-arrows 2, summary 1, status 1, help 1), plus one spare: a frame taller than the
+    // terminal cannot be cleared by Ink and leaves stale lines behind.
+    const height = Math.max(3, (stdout?.rows ?? 24) - (intro ? 16 : 14));
+    // Load leagues and current settings, then every league's teams in parallel,
+    // so search works across all of them.
+    useEffect(() => {
+        let alive = true;
+        (async () => {
+            try {
+                const [leagues, settings] = await Promise.all([api.listLeagues(), api.getSettings()]);
+                if (!alive)
+                    return;
+                dispatch({ type: 'loaded', leagues, settings });
+                setPhase({ kind: 'ready' });
+                for (const l of leagues) {
+                    dispatch({ type: 'teamsLoaded', slug: l.slug, teams: 'loading' });
+                    api.listTeams(l.slug).then((teams) => alive && dispatch({ type: 'teamsLoaded', slug: l.slug, teams }), () => alive && dispatch({ type: 'teamsLoaded', slug: l.slug, teams: 'error' }));
+                }
+            }
+            catch (e) {
+                if (alive)
+                    setPhase({ kind: 'error', message: `could not reach the claudial server (${e instanceof Error ? e.message : String(e)})` });
+            }
+        })();
+        return () => { alive = false; };
+    }, [api]);
+    // Esc on the home screen: save if anything changed, then hand back.
+    useEffect(() => {
+        if (!s.finished)
+            return;
+        const settings = settingsOf(s);
+        if (!s.dirty) {
+            onDone({ saved: false, settings });
+            return;
+        }
+        setPhase({ kind: 'saving' });
+        api.putSettings(settings)
+            .then((stored) => {
+            setPhase({ kind: 'saved', settings: stored });
+            setTimeout(() => onDone({ saved: true, settings: stored }), 900);
+        })
+            .catch((e) => {
+            setPhase({ kind: 'error', message: `not saved: ${e instanceof Error ? e.message : String(e)}. Press esc to try again.` });
+            dispatch({ type: 'resume' });
+        });
+    }, [s.finished]); // eslint-disable-line react-hooks/exhaustive-deps
+    useInput((input, key) => {
+        if (phase.kind === 'saving' || phase.kind === 'saved')
+            return;
+        if (phase.kind === 'loading') {
+            if (key.escape)
+                onDone({ saved: false, settings: settingsOf(s) });
+            return;
+        }
+        if (phase.kind === 'error' && s.leagues.length === 0) {
+            if (key.escape)
+                onDone({ saved: false, settings: settingsOf(s) });
+            return;
+        }
+        if (key.upArrow)
+            dispatch({ type: 'up' });
+        else if (key.downArrow)
+            dispatch({ type: 'down' });
+        else if (key.pageUp)
+            dispatch({ type: 'pageUp', by: height });
+        else if (key.pageDown)
+            dispatch({ type: 'pageDown', by: height });
+        else if (key.escape)
+            dispatch({ type: 'escape' });
+        else if (key.leftArrow)
+            dispatch({ type: 'back' });
+        else if (key.return || key.rightArrow)
+            dispatch({ type: 'open' });
+        else if (key.backspace || key.delete)
+            dispatch({ type: 'backspace' });
+        else if (input === ' ')
+            dispatch({ type: 'toggle' });
+        else if (input && !key.ctrl && !key.meta && !key.tab)
+            dispatch({ type: 'type', text: input });
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: ACCENT, children: "claudial" }), _jsx(Text, { dimColor: true, children: " \u00B7 what do you follow?" })] }), intro && _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: intro }) }), _jsx(Body, { s: s, phase: phase, height: height })] }));
+}
+function Body({ s, phase, height }) {
+    if (phase.kind === 'loading')
+        return _jsx(Text, { dimColor: true, children: "loading leagues\u2026" });
+    if (phase.kind === 'error' && s.leagues.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: RED, children: phase.message }), _jsx(Text, { dimColor: true, children: "Is the server reachable? Set CLAUDIAL_API_URL if you run your own. esc to close" })] }));
+    }
+    if (phase.kind === 'saved') {
+        const names = [
+            ...phase.settings.leagues.map((slug) => s.leagues.find((l) => l.slug === slug)?.name ?? slug),
+            ...phase.settings.teams.map((id) => teamName(s, id)),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: "\u2713 Saved." }), ' ', names.length ? _jsxs(_Fragment, { children: ["You follow ", _jsx(Text, { bold: true, children: names.join(' · ') }), "."] }) : 'You follow nothing for now.'] }), _jsx(Text, { dimColor: true, children: "Your Claude Code status bar picks it up on its next refresh. Change it any time: claudial follow" })] }));
+    }
+    const list = rows(s);
+    const start = Math.max(0, Math.min(s.cursor - Math.floor(height / 2), list.length - height));
+    const shown = list.slice(start, start + height);
+    const leagueName = (slug) => s.leagues.find((l) => l.slug === slug)?.name ?? slug;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SearchLine, { s: s, leagueName: leagueName }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [start > 0 && _jsxs(Text, { dimColor: true, children: ["   \u2191 ", start, " more"] }), shown.map((row, i) => (_jsx(RowLine, { row: row, s: s, active: start + i === s.cursor, showLeague: s.view.kind === 'home', leagueName: leagueName }, row.kind === 'league' ? `l-${row.slug}` : `t-${row.id}`))), list.length === 0 && _jsx(Empty, { s: s }), start + height < list.length && _jsxs(Text, { dimColor: true, children: ["   \u2193 ", list.length - start - height, " more"] })] }), _jsx(Summary, { s: s, leagueName: leagueName }), phase.kind === 'saving' && _jsx(Text, { dimColor: true, children: "saving\u2026" }), phase.kind === 'error' && _jsx(Text, { color: RED, children: phase.message }), _jsx(Help, { s: s })] }));
+}
+function SearchLine({ s, leagueName }) {
+    const where = s.view.kind === 'league' ? `${leagueName(s.view.slug)} › ` : '';
+    return (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [where, "search \u203A "] }), s.query
+                ? _jsxs(Text, { bold: true, children: [s.query, _jsx(Text, { color: ACCENT, children: "\u258F" })] })
+                : _jsxs(Text, { dimColor: true, children: [s.view.kind === 'league' ? 'type to filter teams' : 'type a team name, e.g. "arsenal"', _jsx(Text, { color: ACCENT, children: "\u258F" })] })] }));
+}
+function RowLine({ row, s, active, showLeague, leagueName }) {
+    const on = row.kind === 'league' ? s.followLeagues.includes(row.slug) : s.followTeams.includes(row.id);
+    const mark = on ? _jsx(Text, { color: ACCENT, children: "\u25C9" }) : _jsx(Text, { dimColor: true, children: "\u25CB" });
+    const pointer = active ? _jsx(Text, { color: ACCENT, children: "\u203A" }) : ' ';
+    if (row.kind === 'league') {
+        const teams = followedIn(s, row.slug);
+        return (_jsxs(Text, { wrap: "truncate", children: [pointer, " ", mark, " ", _jsx(Text, { bold: active, children: row.name }), teams.length > 0 && _jsxs(Text, { color: ACCENT, children: ['  ', teams.join(', ')] }), active && _jsxs(Text, { dimColor: true, children: ['  ', "enter: teams"] })] }));
+    }
+    return (_jsxs(Text, { wrap: "truncate", children: [pointer, " ", mark, " ", _jsx(Text, { bold: active, children: row.name }), _jsxs(Text, { dimColor: true, children: ['  ', row.code, showLeague ? ` · ${leagueName(row.league)}` : ''] })] }));
+}
+function Empty({ s }) {
+    if (s.view.kind === 'league') {
+        const list = s.teams[s.view.slug];
+        if (list === 'loading' || list === undefined)
+            return _jsx(Text, { dimColor: true, children: "   loading teams\u2026" });
+        if (list === 'error')
+            return _jsx(Text, { dimColor: true, children: "   this league's teams are not available yet, try again in a minute" });
+    }
+    if (s.query && stillLoading(s))
+        return _jsx(Text, { dimColor: true, children: "   searching\u2026 (team lists still loading)" });
+    return _jsxs(Text, { dimColor: true, children: ["   no team matches \"", s.query, "\""] });
+}
+function Summary({ s, leagueName }) {
+    const parts = [...s.followLeagues.map(leagueName), ...s.followTeams.map((id) => teamName(s, id))];
+    if (parts.length === 0)
+        return _jsx(Text, { dimColor: true, children: "You follow nothing yet: tick a league or a team." });
+    return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { dimColor: true, children: "Following " }), _jsx(Text, { color: ACCENT, children: parts.join(' · ') })] }));
+}
+function Help({ s }) {
+    const exit = s.query ? 'esc clear search' : s.view.kind === 'league' ? 'esc back' : 'esc save & close';
+    const enter = s.view.kind === 'home' && !s.query ? ' · enter open league' : '';
+    return _jsxs(Text, { dimColor: true, wrap: "truncate", children: ["\u2191\u2193 move \u00B7 space follow", enter, " \u00B7 type to search \u00B7 ", exit, " \u00B7 ctrl+c cancel"] });
+}

package/dist/ui/picker/run.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { render } from 'ink';
+import { Picker } from './Picker.js';
+/** Open the picker full-screen and resolve when it closes (esc saves, ctrl+c cancels). */
+export async function runPicker(intro) {
+    let result = null;
+    const app = render(React.createElement(Picker, {
+        intro,
+        onDone: (r) => { result = r; app.unmount(); },
+    }));
+    await app.waitUntilExit();
+    return result;
+}

package/dist/ui/picker/state.js

@@ -0,0 +1,120 @@
+export const initialPickerState = {
+    leagues: [], teams: {}, followLeagues: [], followTeams: [],
+    view: { kind: 'home' }, query: '', cursor: 0, dirty: false, finished: false,
+};
+const fold = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+function matches(t, query) {
+    const q = fold(query.trim());
+    return q === '' || fold(t.name).includes(q) || fold(t.code).includes(q);
+}
+/** International competitions (European cups, World Cup): a club's "home" is its league. */
+const isCup = (slug) => slug.startsWith('uefa.') || slug.startsWith('fifa.');
+/** What the list shows right now, in order. */
+export function rows(s) {
+    if (s.view.kind === 'league') {
+        const slug = s.view.slug;
+        const list = s.teams[slug];
+        if (!Array.isArray(list))
+            return [];
+        return list.filter((t) => matches(t, s.query)).map((t) => ({ kind: 'team', ...t, league: slug }));
+    }
+    if (s.query.trim() === '') {
+        return s.leagues.map((l) => ({ kind: 'league', slug: l.slug, name: l.name }));
+    }
+    // Search across every league. A club in two competitions (league and a
+    // European cup) has one id: list it once, under its domestic league.
+    const seen = new Set();
+    const out = [];
+    const domesticFirst = [...s.leagues].sort((a, b) => Number(isCup(a.slug)) - Number(isCup(b.slug)));
+    for (const l of domesticFirst) {
+        const list = s.teams[l.slug];
+        if (!Array.isArray(list))
+            continue;
+        for (const t of list) {
+            if (!seen.has(t.id) && matches(t, s.query)) {
+                seen.add(t.id);
+                out.push({ kind: 'team', ...t, league: l.slug });
+            }
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Leagues whose team lists are still loading (so search results may be partial). */
+export function stillLoading(s) {
+    return s.leagues.some((l) => s.teams[l.slug] === 'loading' || s.teams[l.slug] === undefined);
+}
+/** A followed team's display name, from any loaded league; falls back to its id. */
+export function teamName(s, id) {
+    for (const list of Object.values(s.teams)) {
+        if (Array.isArray(list)) {
+            const t = list.find((x) => x.id === id);
+            if (t)
+                return t.name;
+        }
+    }
+    return `team ${id}`;
+}
+/** Names of followed teams that play in `slug`. */
+export function followedIn(s, slug) {
+    const list = s.teams[slug];
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((t) => s.followTeams.includes(t.id)).map((t) => t.name);
+}
+export function settingsOf(s) {
+    return { leagues: [...s.followLeagues], teams: [...s.followTeams] };
+}
+const clamp = (n, len) => (len === 0 ? 0 : Math.max(0, Math.min(n, len - 1)));
+const toggled = (list, x) => (list.includes(x) ? list.filter((y) => y !== x) : [...list, x]);
+export function pickerReducer(s, a) {
+    switch (a.type) {
+        case 'loaded':
+            return { ...s, leagues: a.leagues, followLeagues: a.settings.leagues, followTeams: a.settings.teams };
+        case 'teamsLoaded':
+            return { ...s, teams: { ...s.teams, [a.slug]: a.teams } };
+        case 'type':
+            return { ...s, query: s.query + a.text, cursor: 0 };
+        case 'backspace':
+            return { ...s, query: s.query.slice(0, -1), cursor: 0 };
+        case 'up':
+            return { ...s, cursor: clamp(s.cursor - 1, rows(s).length) };
+        case 'down':
+            return { ...s, cursor: clamp(s.cursor + 1, rows(s).length) };
+        case 'pageUp':
+            return { ...s, cursor: clamp(s.cursor - a.by, rows(s).length) };
+        case 'pageDown':
+            return { ...s, cursor: clamp(s.cursor + a.by, rows(s).length) };
+        case 'toggle': {
+            const row = rows(s)[s.cursor];
+            if (!row)
+                return s;
+            if (row.kind === 'league')
+                return { ...s, followLeagues: toggled(s.followLeagues, row.slug), dirty: true };
+            return { ...s, followTeams: toggled(s.followTeams, row.id), dirty: true };
+        }
+        case 'open': {
+            const row = rows(s)[s.cursor];
+            if (!row)
+                return s;
+            if (row.kind === 'league')
+                return { ...s, view: { kind: 'league', slug: row.slug }, query: '', cursor: 0 };
+            return pickerReducer(s, { type: 'toggle' }); // enter on a team ticks it
+        }
+        case 'back': {
+            if (s.view.kind !== 'league')
+                return s;
+            const at = s.leagues.findIndex((l) => l.slug === s.view.slug);
+            return { ...s, view: { kind: 'home' }, query: '', cursor: Math.max(0, at) };
+        }
+        case 'escape':
+            // Peel one layer at a time: search text, then the league view, then done.
+            if (s.query !== '')
+                return { ...s, query: '', cursor: 0 };
+            if (s.view.kind === 'league')
+                return pickerReducer(s, { type: 'back' });
+            return { ...s, finished: true };
+        case 'resume':
+            // Saving failed: stay open so the user can retry.
+            return { ...s, finished: false };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claudial",
-  "version": "0.6.3",
-  "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
+  "version": "0.7.0",
+  "description": "Live football scores for your leagues and teams, in your terminal and Claude Code's status bar — goal and red-card takeovers included",
   "type": "module",
   "bin": {
     "claudial": "dist/index.js"
@@ -16,7 +16,7 @@
     "build": "rm -rf dist && tsc && chmod +x dist/index.js",
     "dev": "tsx src/index.tsx",
     "test": "vitest run",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "node scripts/check-release.mjs && npm run build"
   },
   "dependencies": {
     "ink": "^5.2.0",
@@ -30,8 +30,9 @@
     "vitest": "^2.1.0"
   },
   "keywords": [
+    "football",
+    "premier-league",
     "worldcup",
-    "world-cup-2026",
     "tui",
     "cli",
     "football",

package/dist/api/espn.js

@@ -1,130 +0,0 @@
-import { parseEvent, parseIncidents } from './parse.js';
-// ESPN's public soccer scoreboard for the FIFA World Cup (league fifa.world).
-// Keyless, served openly to ESPN's own web/apps, facts-only. One call returns
-// every match for a date (or date range) with goals and cards inline.
-const BASE = 'https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world';
-async function get(path) {
-    const res = await fetch(`${BASE}${path}`, { headers: { Accept: 'application/json' } });
-    if (!res.ok)
-        throw new Error(`espn ${res.status} ${path}`);
-    const text = await res.text();
-    if (!text)
-        throw new Error(`espn empty body ${path}`);
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new Error(`espn: malformed JSON from ${path}: ${text.slice(0, 120)}`);
-    }
-}
-function yyyymmdd(d) {
-    return `${d.getUTCFullYear()}${String(d.getUTCMonth() + 1).padStart(2, '0')}${String(d.getUTCDate()).padStart(2, '0')}`;
-}
-// Brief cache so one live tick (live + per-match incidents) is a single fetch.
-const cache = new Map();
-const CACHE_MS = 5_000;
-async function scoreboard(dates) {
-    const hit = cache.get(dates);
-    if (hit && Date.now() - hit.at < CACHE_MS)
-        return hit.events;
-    const data = await get(`/scoreboard?dates=${dates}`);
-    const events = data.events ?? [];
-    cache.set(dates, { at: Date.now(), events });
-    return events;
-}
-function todayRange(daysAhead) {
-    const now = new Date();
-    const start = yyyymmdd(now);
-    if (daysAhead <= 0)
-        return start;
-    const end = new Date(now.getTime() + daysAhead * 86_400_000);
-    return `${start}-${yyyymmdd(end)}`;
-}
-// Past date range "YYYYMMDD-YYYYMMDD" from (today - daysBack) through today (UTC).
-export function pastRange(daysBack, now = Date.now()) {
-    const end = new Date(now);
-    const start = new Date(now - daysBack * 86_400_000);
-    return `${yyyymmdd(start)}-${yyyymmdd(end)}`;
-}
-// ── Mock mode for demos (CLAUDIAL_MOCK) ──────────────────────────────────────
-// A fake live Argentina–England match. The first live fetch is 1–1; from the
-// second fetch on, Harry Kane has scored to make it 1–2 — so the next poll (or
-// pressing `r`) fires the goal takeover with his name. Inert unless the env var
-// is set. Run: `CLAUDIAL_MOCK=1 claudial`, then press `r`.
-const MOCK = !!process.env.CLAUDIAL_MOCK;
-let mockLiveCalls = 0;
-function mockEvent() {
-    const scored = mockLiveCalls >= 2; // Kane's goal lands on the 2nd live fetch
-    return {
-        id: '9001',
-        date: new Date(Date.now() - 78 * 60_000).toISOString(),
-        status: { type: { state: 'in', name: 'STATUS_SECOND_HALF', shortDetail: scored ? "78'" : "76'" }, displayClock: scored ? "78'" : "76'" },
-        competitions: [{
-                competitors: [
-                    { homeAway: 'home', team: { id: '202', abbreviation: 'ARG', displayName: 'Argentina' }, score: '1' },
-                    { homeAway: 'away', team: { id: '448', abbreviation: 'ENG', displayName: 'England' }, score: scored ? '2' : '1' },
-                ],
-                details: [
-                    { type: { id: '137' }, clock: { value: 600, displayValue: "10'" }, scoringPlay: true, team: { id: '202' }, athletesInvolved: [{ id: '1', displayName: 'Lionel Messi', shortName: 'L. Messi' }] },
-                    { type: { id: '137' }, clock: { value: 2400, displayValue: "40'" }, scoringPlay: true, team: { id: '448' }, athletesInvolved: [{ id: '2', displayName: 'Jude Bellingham', shortName: 'J. Bellingham' }] },
-                    ...(scored ? [{ type: { id: '137' }, clock: { value: 4680, displayValue: "78'" }, scoringPlay: true, team: { id: '448' }, athletesInvolved: [{ id: '3', displayName: 'Harry Kane', shortName: 'H. Kane' }] }] : []),
-                ],
-            }],
-    };
-}
-// Kept for call-site compatibility; ESPN needs no season id to query.
-export async function resolveSeasonId() {
-    return 2026;
-}
-export async function fetchLive() {
-    if (MOCK) {
-        mockLiveCalls++;
-        return [parseEvent(mockEvent())];
-    }
-    const events = await scoreboard(todayRange(0));
-    return events.map(parseEvent).filter((m) => m.status === 'live' || m.status === 'halftime');
-}
-export async function fetchUpcoming(_seasonId) {
-    if (MOCK)
-        return [];
-    const events = await scoreboard(todayRange(10));
-    return events
-        .map(parseEvent)
-        .filter((m) => m.status === 'upcoming')
-        .sort((a, b) => a.startTimestamp - b.startTimestamp);
-}
-export async function fetchRecent(_seasonId) {
-    if (MOCK)
-        return [];
-    const events = await scoreboard(pastRange(1));
-    return events
-        .map(parseEvent)
-        .filter((m) => m.status === 'finished')
-        .sort((a, b) => a.startTimestamp - b.startTimestamp);
-}
-export async function fetchIncidents(eventId) {
-    if (MOCK)
-        return parseIncidents(mockEvent());
-    const events = await scoreboard(todayRange(0));
-    const event = events.find((e) => Number(e.id) === eventId);
-    return event ? parseIncidents(event) : [];
-}
-// Red cards in currently-live matches, drawn from the same scoreboard response
-// fetchLive uses (its details carry cards inline) — so no extra network call.
-export async function fetchLiveRedCards() {
-    if (MOCK)
-        return [];
-    const events = await scoreboard(todayRange(0));
-    const out = [];
-    for (const e of events) {
-        const m = parseEvent(e);
-        if (m.status !== 'live' && m.status !== 'halftime')
-            continue;
-        for (const inc of parseIncidents(e)) {
-            if (inc.kind === 'redCard') {
-                out.push({ id: inc.id, homeCode: m.home.code, awayCode: m.away.code, player: inc.playerShort ?? inc.player ?? '?', minute: inc.minute });
-            }
-        }
-    }
-    return out;
-}

package/dist/api/parse.js

@@ -1,103 +0,0 @@
-// claudial parses ESPN's public soccer scoreboard (league fifa.world).
-// One scoreboard response carries every match for a date plus, inline, each
-// match's goals and cards — so a single request powers scores, scorer lines,
-// and goal/red-card takeovers. Substitutions and VAR live only in ESPN's heavy
-// per-match summary endpoint and are intentionally not used here.
-function toStatus(raw) {
-    const t = raw?.status?.type;
-    const state = t?.state;
-    if (state === 'in')
-        return t?.name === 'STATUS_HALFTIME' ? 'halftime' : 'live';
-    if (state === 'post')
-        return 'finished';
-    return 'upcoming';
-}
-function competitor(raw, side) {
-    const comps = raw?.competitions?.[0]?.competitors ?? [];
-    return comps.find((c) => c.homeAway === side) ?? {};
-}
-function teamOf(c) {
-    const t = c?.team ?? {};
-    return {
-        name: t.displayName ?? t.shortDisplayName ?? t.name ?? '?',
-        code: t.abbreviation ?? t.shortDisplayName ?? '?',
-    };
-}
-function scoreOf(c, status) {
-    if (status === 'upcoming')
-        return null;
-    const n = Number(c?.score);
-    return Number.isFinite(n) ? n : null;
-}
-/** "21'" -> 21, "90'+7'" -> 90, "HT"/"" -> null */
-function minuteOf(raw, status) {
-    if (status !== 'live')
-        return null;
-    const m = /(\d+)/.exec(raw?.status?.displayClock ?? '');
-    return m ? Number(m[1]) : null;
-}
-export function parseEvent(raw) {
-    const status = toStatus(raw);
-    const home = competitor(raw, 'home');
-    const away = competitor(raw, 'away');
-    return {
-        id: Number(raw.id),
-        group: null, // ESPN's scoreboard does not expose the group letter
-        home: teamOf(home),
-        away: teamOf(away),
-        homeScore: scoreOf(home, status),
-        awayScore: scoreOf(away, status),
-        status,
-        statusText: raw?.status?.type?.shortDetail ?? raw?.status?.type?.description ?? '',
-        minute: minuteOf(raw, status),
-        startTimestamp: Math.floor(Date.parse(raw?.date ?? '') / 1000) || 0,
-        varInProgress: false, // not surfaced by the scoreboard feed
-    };
-}
-function kindOf(det) {
-    if (det?.scoringPlay)
-        return 'goal';
-    if (det?.redCard)
-        return 'redCard';
-    if (det?.yellowCard)
-        return 'yellowCard';
-    return null; // substitutions / VAR are not in the scoreboard feed
-}
-function detailOf(det, kind) {
-    if (kind !== 'goal')
-        return null;
-    if (det?.ownGoal)
-        return 'Own goal';
-    if (det?.penaltyKick)
-        return 'Penalty';
-    return null;
-}
-function minuteFromClock(det) {
-    const m = /(\d+)/.exec(det?.clock?.displayValue ?? '');
-    return m ? Number(m[1]) : null;
-}
-export function parseIncidents(raw) {
-    const homeTeamId = competitor(raw, 'home')?.team?.id;
-    const details = raw?.competitions?.[0]?.details ?? [];
-    const out = [];
-    for (const det of details) {
-        const kind = kindOf(det);
-        if (!kind)
-            continue;
-        const athlete = det?.athletesInvolved?.[0];
-        out.push({
-            // content-derived, stable across polls (the diff engine dedupes on it)
-            id: `${raw.id}-${det?.type?.id ?? '?'}-${det?.clock?.value ?? '?'}-${athlete?.id ?? '?'}`,
-            kind,
-            minute: minuteFromClock(det),
-            player: athlete?.displayName ?? null,
-            playerShort: athlete?.shortName ?? athlete?.displayName ?? null,
-            detail: detailOf(det, kind),
-            isHome: det?.team?.id != null && det.team.id === homeTeamId,
-            homeScore: null, // running score not provided per incident; unused downstream
-            awayScore: null,
-        });
-    }
-    // ESPN already lists details chronologically (earliest first)
-    return out;
-}