claudial 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wim Iliano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# claudial
+
+Live World Cup 2026 fixtures in your terminal. One line, zero install:
+
+```
+npx claudial
+```
+
+Live matches with scores, minutes and scorers on top. Upcoming fixtures in
+your local time below. Auto-refreshing while you work.
+
+```
+ ▐▛███▜▌   WORLD CUP 2026 · LIVE
+ ▝▜█████▛▘  ───────────────────────
+
+ ⏺ LIVE 67'
+   Argentina  2 — 1  Mexico
+   ⚽ 23' Messi · 51' Álvarez | 44' Lozano
+
+ ⏺ LIVE 12'
+   France  0 — 0  Senegal
+
+ ○ UPCOMING
+   18:00  Brazil — Croatia
+   21:00  Spain — Morocco
+
+ r refresh · q quit
+```
+
+And when a goal goes in — anywhere in the tournament — the whole screen
+takes over:
+
+```
+
+
+      █▀▀█  █▀▀█  █▀▀█  █
+      █ ▄▄  █  █  █▀▀█  █
+      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
+
+         LIONEL MESSI · 23'
+
+      ARGENTINA  2 — 1  MEXICO
+
+
+```
+
+Four seconds of glory, then back to the board.
+
+## Why a TUI
+
+The World Cup happens during work hours somewhere. This sits in a terminal
+split, costs nothing to glance at, and celebrates louder than a push
+notification — without you ever opening a browser tab.
+
+## Usage
+
+```
+npx claudial            # the dashboard
+npx claudial --ticker   # 4-line strip for slim split panes
+npx claudial | cat      # non-interactive snapshot (pipes, scripts, CI)
+```
+
+Or install it for good:
+
+```
+npm install -g claudial
+claudial
+```
+
+Requires Node ≥ 18. No account, no API key, no config.
+
+| Key | Action  |
+|-----|---------|
+| `r` | refresh now |
+| `q` | quit    |
+
+Beyond goals, every live match carries its incident feed: yellow cards,
+substitutions, injury time — and a `⚖ VAR` badge the moment a review starts.
+Red cards and VAR decisions get the full-screen treatment, same as goals.
+
+## Run it next to Claude Code
+
+claudial is built to sit beside [Claude Code](https://claude.com/claude-code)
+all day. One command opens both — Claude Code working, the World Cup ticking
+in a strip below it:
+
+```bash
+tmux new-session 'claude' \; split-window -v -l 5 'npx claudial --ticker' \; select-pane -U
+```
+
+Prefer the full board on the side instead:
+
+```bash
+tmux new-session 'claude' \; split-window -h -l 44 'npx claudial' \; select-pane -L
+```
+
+Make it permanent — add to your `~/.zshrc` (or `~/.bashrc`):
+
+```bash
+alias claude-mundial="tmux new-session 'claude' \; split-window -v -l 5 'npx claudial --ticker' \; select-pane -U"
+```
+
+Then `claude-mundial` starts your whole World Cup workstation. When a goal
+goes in, the strip lights up while Claude keeps working.
+
+## Status
+
+v1 is being built live during the group stage. Follow the commits.
+
+## Notes
+
+- Match data comes from SofaScore's public endpoints. This project is
+  unofficial and not affiliated with SofaScore.
+- Not affiliated with Anthropic. The aesthetic is a love letter to
+  [Claude Code](https://claude.com/claude-code), whose terminal UI this
+  proudly imitates.
+- Polling is deliberately gentle (15 s live, 5 min fixtures). Please keep
+  it that way.
+
+```js
+// Canada — Bosnia & Herzegovina, 12 June 2026, was on while this was built.
+// Jovo Lukić's 21' goal was the first one this codebase ever saw — it hit
+// the API smoke test before any UI existed to celebrate it. Legendary.
+```
+
+## License
+
+MIT

package/dist/api/parse.js

@@ -0,0 +1,114 @@
+export const WORLD_CUP_ID = 16;
+export function isWorldCup(raw) {
+    return raw?.tournament?.uniqueTournament?.id === WORLD_CUP_ID;
+}
+function toStatus(raw) {
+    const t = raw?.status?.type;
+    if (t === 'inprogress') {
+        return raw.status?.description === 'Halftime' ? 'halftime' : 'live';
+    }
+    if (t === 'finished')
+        return 'finished';
+    return 'upcoming';
+}
+export function toMinute(raw, nowSeconds) {
+    const time = raw?.time;
+    if (raw?.status?.type !== 'inprogress' || !time?.currentPeriodStartTimestamp)
+        return null;
+    if (raw.status?.description === 'Halftime')
+        return null;
+    const played = (time.initial ?? 0) + (nowSeconds - time.currentPeriodStartTimestamp);
+    // football minutes are 1-based: 0–59s of play is the 1st minute
+    const minute = Math.floor(played / 60) + 1;
+    return Math.min(minute, Math.ceil((time.max ?? 5400) / 60));
+}
+export function parseEvent(raw, nowSeconds) {
+    const group = /Group [A-L]/.exec(raw?.tournament?.name ?? '')?.[0] ?? null;
+    return {
+        id: raw.id,
+        group,
+        home: { name: raw.homeTeam?.name ?? '?', code: raw.homeTeam?.nameCode ?? raw.homeTeam?.shortName ?? '' },
+        away: { name: raw.awayTeam?.name ?? '?', code: raw.awayTeam?.nameCode ?? raw.awayTeam?.shortName ?? '' },
+        homeScore: raw.homeScore?.current ?? null,
+        awayScore: raw.awayScore?.current ?? null,
+        status: toStatus(raw),
+        statusText: raw.status?.description ?? '',
+        minute: toMinute(raw, nowSeconds),
+        startTimestamp: raw.startTimestamp ?? 0,
+        // live feed sends an object ({ homeTeam, awayTeam }); be tolerant of a plain boolean too
+        varInProgress: typeof raw.varInProgress === 'object' && raw.varInProgress !== null
+            ? !!(raw.varInProgress.homeTeam || raw.varInProgress.awayTeam)
+            : !!raw.varInProgress,
+    };
+}
+/** "goalNotAwarded" → "Goal not awarded" */
+function humanize(klass) {
+    if (!klass)
+        return '';
+    const words = klass.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function toKind(i) {
+    switch (i.incidentType) {
+        case 'goal':
+            return 'goal';
+        case 'card':
+            if (i.incidentClass === 'yellow')
+                return 'yellowCard';
+            if (i.incidentClass === 'red' || i.incidentClass === 'yellowRed')
+                return 'redCard';
+            return null;
+        case 'varDecision':
+            return 'var';
+        case 'inGamePenalty':
+            return 'penaltyMiss';
+        case 'substitution':
+            return 'substitution';
+        case 'injuryTime':
+            return 'injuryTime';
+        default:
+            return null; // 'period' and anything unknown
+    }
+}
+function toDetail(i, kind) {
+    if (kind === 'var')
+        return humanize(i.incidentClass ?? 'decision');
+    if (kind === 'goal') {
+        if (i.incidentClass === 'penalty')
+            return 'Penalty';
+        if (i.incidentClass === 'ownGoal')
+            return 'Own goal';
+        return null;
+    }
+    if (kind === 'substitution')
+        return i.playerOut?.name ? `for ${i.playerOut.name}` : null;
+    if (kind === 'injuryTime')
+        return i.length != null ? `+${i.length}` : null;
+    if (kind === 'penaltyMiss')
+        return 'Penalty missed';
+    return null;
+}
+export function parseIncidents(raw) {
+    const out = [];
+    for (const i of raw?.incidents ?? []) {
+        const kind = toKind(i);
+        if (!kind)
+            continue;
+        const player = kind === 'substitution' ? i.playerIn : i.player;
+        out.push({
+            // fallback id must be stable across polls (the diff engine dedupes on it),
+            // so derive it from incident content, never from array position
+            id: String(i.id ?? `${i.incidentType}-${i.time}-${player?.id ?? 'x'}`),
+            kind,
+            minute: i.time ?? null,
+            player: player?.name ?? null,
+            playerShort: player?.shortName ?? player?.name ?? null,
+            detail: toDetail(i, kind),
+            isHome: !!i.isHome,
+            homeScore: kind === 'goal' ? i.homeScore ?? null : null,
+            awayScore: kind === 'goal' ? i.awayScore ?? null : null,
+        });
+    }
+    // API returns newest first; we want chronological
+    return out.reverse();
+}

package/dist/api/sofascore.js

@@ -0,0 +1,51 @@
+import { isWorldCup, parseEvent, parseIncidents } from './parse.js';
+const HOST = 'https://api.sofascore.app';
+// api.sofascore.com is challenge-blocked (403). The app host works with this
+// exact recipe; Accept-Encoding is mandatory or some endpoints return empty 200s.
+const HEADERS = {
+    'User-Agent': 'SofaScore/5.95.2 (Linux; Android 13)',
+    Accept: 'application/json',
+    'Accept-Encoding': 'gzip',
+};
+async function get(path) {
+    const res = await fetch(`${HOST}${path}`, { headers: HEADERS });
+    if (!res.ok)
+        throw new Error(`sofascore ${res.status} ${path}`);
+    const text = await res.text();
+    if (!text)
+        throw new Error(`sofascore empty body ${path}`);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`sofascore: malformed JSON from ${path}: ${text.slice(0, 120)}`);
+    }
+}
+const now = () => Math.floor(Date.now() / 1000);
+export async function resolveSeasonId() {
+    const data = await get(`/api/v1/unique-tournament/16/seasons`);
+    if (!data.seasons?.length)
+        throw new Error(`sofascore: no seasons for tournament 16`);
+    return data.seasons[0].id; // newest first; 2026 = 58210
+}
+export async function fetchLive() {
+    const data = await get(`/api/v1/sport/football/events/live`);
+    const t = now();
+    return (data.events ?? []).filter(isWorldCup).map((e) => parseEvent(e, t));
+}
+export async function fetchUpcoming(seasonId) {
+    const data = await get(`/api/v1/unique-tournament/16/season/${seasonId}/events/next/0`);
+    const t = now();
+    return (data.events ?? []).map((e) => parseEvent(e, t));
+}
+export async function fetchRecent(seasonId) {
+    const data = await get(`/api/v1/unique-tournament/16/season/${seasonId}/events/last/0`);
+    const t = now();
+    const dayAgo = t - 86_400;
+    return (data.events ?? [])
+        .map((e) => parseEvent(e, t))
+        .filter((m) => m.status === 'finished' && m.startTimestamp > dayAgo);
+}
+export async function fetchIncidents(eventId) {
+    return parseIncidents(await get(`/api/v1/event/${eventId}/incidents`));
+}

package/dist/banner.js

@@ -0,0 +1,30 @@
+export const GOAL_ART = [
+    ' ██████   ██████   █████   ██      ',
+    '██       ██    ██ ██   ██  ██      ',
+    '██  ███  ██    ██ ███████  ██      ',
+    '██    ██ ██    ██ ██   ██  ██      ',
+    ' ██████   ██████  ██   ██  ███████ ',
+];
+export const VAR_ART = [
+    '██     ██  █████  ██████  ',
+    '██     ██ ██   ██ ██   ██ ',
+    '██     ██ ███████ ██████  ',
+    ' ██   ██  ██   ██ ██  ██  ',
+    '  █████   ██   ██ ██   ██ ',
+];
+// the card itself, drawn tall
+export const RED_CARD_ART = [
+    '█████████',
+    '█████████',
+    '█████████',
+    '█████████',
+    '█████████',
+    '█████████',
+];
+export function spacedCaps(s) {
+    return s
+        .toUpperCase()
+        .split(' ')
+        .map((word) => word.split('').join(' '))
+        .join('   ');
+}

package/dist/engine/diff.js

@@ -0,0 +1,38 @@
+const total = (m) => (m.homeScore ?? 0) + (m.awayScore ?? 0);
+export function diffGoals(prev, next) {
+    // duplicate ids in a snapshot should be impossible, but if they happen,
+    // keep the highest-scoring entry as baseline — we'd rather miss a goal
+    // than celebrate a phantom one
+    const before = new Map();
+    for (const p of prev) {
+        const existing = before.get(p.id);
+        if (!existing || total(p) > total(existing))
+            before.set(p.id, p);
+    }
+    const changes = [];
+    for (const m of next) {
+        const p = before.get(m.id);
+        if (!p)
+            continue;
+        // == null also passes NaN through, but NaN comparisons are all false,
+        // so corrupted scores suppress events (fail toward false negative)
+        if (m.homeScore == null || m.awayScore == null || p.homeScore == null || p.awayScore == null)
+            continue;
+        if (m.homeScore > p.homeScore)
+            changes.push({ matchId: m.id, side: 'home', homeScore: m.homeScore, awayScore: m.awayScore });
+        if (m.awayScore > p.awayScore)
+            changes.push({ matchId: m.id, side: 'away', homeScore: m.homeScore, awayScore: m.awayScore });
+    }
+    return changes;
+}
+/** Returns incidents not yet in `seen`, adding them to it. */
+export function diffIncidents(seen, incidents) {
+    const fresh = [];
+    for (const i of incidents) {
+        if (seen.has(i.id))
+            continue;
+        seen.add(i.id);
+        fresh.push(i);
+    }
+    return fresh;
+}

package/dist/engine/poller.js

@@ -0,0 +1,125 @@
+import { diffGoals, diffIncidents } from './diff.js';
+export function startPoller(deps, opts = {}) {
+    const liveMs = opts.liveMs ?? 15_000;
+    const fixturesMs = opts.fixturesMs ?? 300_000;
+    let prev = [];
+    const seenIncidents = new Map(); // matchId → incident ids
+    let failures = 0;
+    let stopped = false;
+    let liveTimer;
+    let fixturesTimer;
+    let ticking = false;
+    function takeoverFor(i, m) {
+        if (i.kind === 'redCard') {
+            return {
+                kind: 'redcard', match: m, who: i.player ?? (i.isHome ? m.home.name : m.away.name), detail: null,
+                minute: i.minute, homeScore: m.homeScore ?? 0, awayScore: m.awayScore ?? 0,
+            };
+        }
+        if (i.kind === 'var') {
+            return {
+                kind: 'var', match: m, who: i.player ?? (i.isHome ? m.home.name : m.away.name), detail: i.detail,
+                minute: i.minute, homeScore: m.homeScore ?? 0, awayScore: m.awayScore ?? 0,
+            };
+        }
+        return null;
+    }
+    async function liveTick() {
+        if (ticking)
+            return;
+        ticking = true;
+        try {
+            const matches = await deps.fetchLive();
+            const scoreChanges = diffGoals(prev, matches);
+            prev = matches;
+            deps.dispatch({ type: 'live', matches, at: Date.now() });
+            failures = 0;
+            for (const m of matches) {
+                // A match only counts as "first sight" until its first SUCCESSFUL incidents
+                // fetch. We must NOT insert into seenIncidents until the fetch succeeds;
+                // otherwise a failed first fetch leaves an empty set in the map, and on the
+                // next tick old (pre-launch) incidents are diffed against that empty set and
+                // replayed as fresh — violating the no-replay contract.
+                const firstSight = !seenIncidents.has(m.id);
+                // Attempt to fetch incidents; on failure, incidents stays empty and we
+                // skip dispatching 'incidents' and running diffIncidents — but we still
+                // process score-diff takeovers (scorer-less) so goals are never dropped.
+                let incidents = [];
+                let incidentsFetched = false;
+                try {
+                    incidents = await deps.fetchIncidents(m.id);
+                    incidentsFetched = true;
+                }
+                catch {
+                    // intentional: degrade to scorer-less takeovers rather than dropping them
+                }
+                if (incidentsFetched) {
+                    // Only register the match in seenIncidents on first SUCCESSFUL fetch.
+                    if (firstSight)
+                        seenIncidents.set(m.id, new Set());
+                    const seen = seenIncidents.get(m.id);
+                    deps.dispatch({ type: 'incidents', matchId: m.id, incidents });
+                    // Red cards & VAR come from the incident diff — but never on first sight
+                    // (prevents replaying stale events when a match is first seen mid-game).
+                    // Goal/yellow/sub/injuryTime incidents never fire takeovers from this path
+                    // (goal takeovers are deduped via the score-diff path above).
+                    // diffIncidents is always called (even on firstSight) to populate seen set.
+                    const fresh = diffIncidents(seen, incidents);
+                    if (!firstSight) {
+                        for (const i of fresh) {
+                            const t = takeoverFor(i, m);
+                            if (t)
+                                deps.dispatch({ type: 'takeover', takeover: t });
+                        }
+                    }
+                }
+                // Goal takeovers come from the score diff (faster + reliable),
+                // enriched with the scorer from the freshest incident list.
+                // If incidents fetch failed, incidents is [] so scorer will be null — degraded but not dropped.
+                for (const c of scoreChanges.filter((c) => c.matchId === m.id)) {
+                    const g = [...incidents].reverse().find((x) => x.kind === 'goal' && x.isHome === (c.side === 'home'));
+                    deps.dispatch({
+                        type: 'takeover',
+                        takeover: {
+                            kind: 'goal', match: m, who: g?.player ?? (c.side === 'home' ? m.home.name : m.away.name), detail: g?.detail ?? null,
+                            minute: g?.minute ?? m.minute, homeScore: c.homeScore, awayScore: c.awayScore,
+                        },
+                    });
+                }
+            }
+        }
+        catch {
+            failures += 1;
+            deps.dispatch({ type: 'stale' });
+        }
+        ticking = false;
+        if (!stopped) {
+            const delay = Math.min(liveMs * 2 ** Math.min(failures, 5), 300_000);
+            liveTimer = setTimeout(liveTick, delay);
+        }
+    }
+    async function fixturesTick() {
+        try {
+            const { upcoming, recent } = await deps.fetchFixtures();
+            deps.dispatch({ type: 'fixtures', upcoming, recent });
+        }
+        catch {
+            deps.dispatch({ type: 'stale' });
+        }
+        if (!stopped)
+            fixturesTimer = setTimeout(fixturesTick, fixturesMs);
+    }
+    void liveTick();
+    void fixturesTick();
+    return {
+        stop() {
+            stopped = true;
+            clearTimeout(liveTimer);
+            clearTimeout(fixturesTimer);
+        },
+        refreshNow() {
+            clearTimeout(liveTimer);
+            void liveTick();
+        },
+    };
+}

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './ui/App.js';
+import { resolveSeasonId } from './api/sofascore.js';
+// exit quietly when the consumer of a pipe closes early (e.g. `claudial | head`)
+process.stdout.on('error', (err) => {
+    if (err.code === 'EPIPE')
+        process.exit(0);
+    throw err;
+});
+async function main() {
+    let seasonId;
+    try {
+        seasonId = await resolveSeasonId();
+    }
+    catch {
+        console.error('claudial: could not reach SofaScore. Check your connection and try again.');
+        process.exit(1);
+    }
+    if (!process.stdout.isTTY) {
+        const { printSnapshot } = await import('./snapshot.js');
+        await printSnapshot(seasonId);
+        return;
+    }
+    const mode = process.argv.includes('--ticker') ? 'ticker' : 'board';
+    render(_jsx(App, { seasonId: seasonId, mode: mode }));
+}
+main().catch(() => {
+    console.error('claudial: could not reach SofaScore. Check your connection and try again.');
+    process.exit(1);
+});

package/dist/snapshot.js

@@ -0,0 +1,21 @@
+import { fetchLive, fetchRecent, fetchUpcoming } from './api/sofascore.js';
+import { formatKickoff } from './ui/UpcomingSection.js';
+function line(m) {
+    if (m.status === 'upcoming')
+        return `o ${formatKickoff(m.startTimestamp).padEnd(13)} ${m.home.name} - ${m.away.name}`;
+    const label = m.status === 'finished' ? 'FT' : m.status === 'halftime' ? 'HT' : `${m.minute ?? '?'}'`;
+    return `* ${label.padEnd(4)} ${m.home.name} ${m.homeScore ?? '-'} - ${m.awayScore ?? '-'} ${m.away.name}`;
+}
+export async function printSnapshot(seasonId) {
+    const [live, upcoming, recent] = await Promise.all([
+        fetchLive(), fetchUpcoming(seasonId), fetchRecent(seasonId),
+    ]);
+    console.log('claudial - WORLD CUP 2026');
+    const liveIds = new Set(live.map((m) => m.id));
+    for (const m of [...live, ...recent.filter((r) => !liveIds.has(r.id))])
+        console.log(line(m));
+    if (upcoming.length)
+        console.log('UPCOMING');
+    for (const m of upcoming.slice(0, 8))
+        console.log(line(m));
+}

package/dist/state.js

@@ -0,0 +1,21 @@
+export const initialState = {
+    live: [], upcoming: [], recent: [],
+    incidents: {}, takeovers: [],
+    stale: false, lastUpdated: null,
+};
+export function reducer(s, a) {
+    switch (a.type) {
+        case 'live':
+            return { ...s, live: a.matches, stale: false, lastUpdated: a.at };
+        case 'fixtures':
+            return { ...s, upcoming: a.upcoming, recent: a.recent };
+        case 'incidents':
+            return { ...s, incidents: { ...s.incidents, [a.matchId]: a.incidents } };
+        case 'takeover':
+            return { ...s, takeovers: [...s.takeovers, a.takeover] };
+        case 'takeoverDone':
+            return { ...s, takeovers: s.takeovers.slice(1) };
+        case 'stale':
+            return { ...s, stale: true };
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/App.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useReducer, useRef } from 'react';
+import { Box, useApp, useInput } from 'ink';
+import { initialState, reducer } from '../state.js';
+import { startPoller } from '../engine/poller.js';
+import { fetchIncidents, fetchLive, fetchRecent, fetchUpcoming } from '../api/sofascore.js';
+import { Header } from './Header.js';
+import { LiveSection } from './LiveSection.js';
+import { UpcomingSection } from './UpcomingSection.js';
+import { Footer } from './Footer.js';
+import { TakeoverView } from './TakeoverView.js';
+import { Ticker } from './Ticker.js';
+export function App({ seasonId, mode = 'board' }) {
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const { exit } = useApp();
+    const pollerRef = useRef(null);
+    useEffect(() => {
+        const deps = {
+            fetchLive,
+            fetchFixtures: async () => ({
+                upcoming: await fetchUpcoming(seasonId),
+                recent: await fetchRecent(seasonId),
+            }),
+            fetchIncidents,
+            dispatch,
+        };
+        pollerRef.current = startPoller(deps);
+        return () => pollerRef.current?.stop();
+    }, [seasonId]);
+    useInput((input) => {
+        if (input === 'q')
+            exit();
+        if (input === 'r')
+            pollerRef.current?.refreshNow();
+    });
+    const compact = mode === 'board' && (process.stdout.columns ?? 80) < 70;
+    const playing = state.takeovers[0] ?? null;
+    useEffect(() => {
+        if (!playing)
+            return;
+        const t = setTimeout(() => dispatch({ type: 'takeoverDone' }), 4_000);
+        return () => clearTimeout(t);
+    }, [playing]);
+    if (playing && mode === 'board')
+        return _jsx(TakeoverView, { takeover: playing });
+    if (mode === 'ticker') {
+        return _jsx(Ticker, { live: state.live, upcoming: state.upcoming, takeover: playing });
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(LiveSection, { matches: state.live, recent: state.recent, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: state.upcoming, compact: compact }), _jsx(Footer, {})] }));
+}

package/dist/ui/Footer.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+export function Footer() {
+    return _jsx(Text, { dimColor: true, children: "r refresh \u00B7 q quit" });
+}

package/dist/ui/Header.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export const ACCENT = '#D97757';
+export const RED = '#E5484D';
+export function Header({ stale, lastUpdated }) {
+    const updated = lastUpdated
+        ? new Date(lastUpdated).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', second: '2-digit' })
+        : '—';
+    return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: ACCENT, children: "claudial" }), _jsx(Text, { dimColor: true, children: " \u00B7 WORLD CUP 2026" }), _jsxs(Text, { dimColor: true, children: ['  ', "\u273B ", stale ? 'stale · retrying' : `updated ${updated}`] })] }));
+}

package/dist/ui/LiveSection.js

@@ -0,0 +1,39 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ACCENT } from './Header.js';
+function ScorerLine({ incidents }) {
+    const goals = incidents.filter((i) => i.kind === 'goal');
+    if (goals.length === 0)
+        return null;
+    const fmt = (g) => `${g.minute ?? '?'}' ${g.playerShort ?? '?'}`;
+    const home = goals.filter((g) => g.isHome).map(fmt).join(' · ');
+    const away = goals.filter((g) => !g.isHome).map(fmt).join(' · ');
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u26BD ", [home, away].filter(Boolean).join(' | ')] });
+}
+function FeedLine({ incidents }) {
+    const feed = incidents.filter((i) => i.kind === 'yellowCard' || i.kind === 'substitution');
+    if (feed.length === 0)
+        return null;
+    const fmt = (i) => i.kind === 'yellowCard'
+        ? `${i.minute ?? '?'}' 🟨 ${i.playerShort ?? '?'}`
+        : `${i.minute ?? '?'}' ⇄ ${i.playerShort ?? '?'}`;
+    // last 4 only — the feed is a pulse, not a log
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u25AA ", feed.slice(-4).map(fmt).join(' · ')] });
+}
+function statusLabel(m) {
+    if (m.status === 'halftime')
+        return 'HT';
+    if (m.status === 'finished')
+        return 'FT';
+    return m.minute != null ? `LIVE ${m.minute}'` : 'LIVE';
+}
+export function LiveSection({ matches, recent, incidents, compact }) {
+    const liveIds = new Set(matches.map((m) => m.id));
+    const rows = [...matches, ...recent.filter((r) => !liveIds.has(r.id))];
+    if (rows.length === 0)
+        return null;
+    if (compact) {
+        return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", statusLabel(m), " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }, m.id))) }));
+    }
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { bold: m.status !== 'finished', dimColor: m.status === 'finished', children: [" ", statusLabel(m)] }), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null, m.varInProgress ? _jsx(Text, { dimColor: true, children: "  \u00B7  \u2696 VAR" }) : null] }), _jsxs(Text, { children: ['   ', m.home.name, "  ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', " \u2014 ", m.awayScore ?? '–'] }), "  ", m.away.name] }), _jsx(ScorerLine, { incidents: incidents[m.id] ?? [] }), _jsx(FeedLine, { incidents: incidents[m.id] ?? [] })] }, m.id))) }));
+}

package/dist/ui/TakeoverView.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { GOAL_ART, VAR_ART, RED_CARD_ART, spacedCaps } from '../banner.js';
+import { ACCENT, RED } from './Header.js';
+const ART = {
+    goal: { art: GOAL_ART, color: ACCENT, caption: null },
+    redcard: { art: RED_CARD_ART, color: RED, caption: 'R E D   C A R D' },
+    var: { art: VAR_ART, color: ACCENT, caption: null },
+};
+export function TakeoverView({ takeover }) {
+    const { match, kind } = takeover;
+    const { art, color, caption } = ART[kind];
+    const fallback = takeover.who ?? (takeover.kind === 'goal'
+        ? (takeover.homeScore > takeover.awayScore ? match.home.name : match.away.name)
+        : match.home.name);
+    const rows = process.stdout.rows ?? 24;
+    if (rows < 14) {
+        const label = kind === 'goal' ? 'G O A L' : kind === 'redcard' ? 'R E D   C A R D' : 'V A R';
+        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [_jsx(Text, { bold: true, color: color, wrap: "truncate", children: label }), _jsxs(Text, { bold: true, wrap: "truncate", children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }), takeover.detail ? _jsx(Text, { dimColor: true, wrap: "truncate", children: takeover.detail }) : null, _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { dimColor: true, children: [match.home.name.toUpperCase(), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", match.away.name.toUpperCase()] })] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [art.map((line, i) => (_jsx(Text, { bold: true, color: color, wrap: "truncate", children: line }, i))), caption ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: color, wrap: "truncate", children: caption }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { bold: true, children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }) }), takeover.detail ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: takeover.detail }) })) : null, _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: [match.home.name.toUpperCase(), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", match.away.name.toUpperCase()] })] })] }));
+}

package/dist/ui/Ticker.js

@@ -0,0 +1,15 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { formatKickoff } from './UpcomingSection.js';
+import { ACCENT, RED } from './Header.js';
+import { spacedCaps } from '../banner.js';
+function TickerTakeover({ t }) {
+    const color = t.kind === 'redcard' ? RED : ACCENT;
+    const label = t.kind === 'goal' ? 'G O A L' : t.kind === 'redcard' ? 'R E D' : 'V A R';
+    return (_jsxs(Text, { bold: true, color: color, wrap: "truncate", children: [label, " \u00B7 ", t.who ? spacedCaps(t.who) : t.detail ?? '', " \u00B7 ", t.match.home.code, " ", t.homeScore, "\u2014", t.awayScore, " ", t.match.away.code] }));
+}
+export function Ticker({ live, upcoming, takeover }) {
+    if (takeover)
+        return _jsx(TickerTakeover, { t: takeover });
+    return (_jsxs(Box, { flexDirection: "column", children: [live.slice(0, 3).map((m) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", m.minute != null ? `${m.minute}'` : m.status === 'halftime' ? 'HT' : m.status === 'finished' ? 'FT' : '', " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }, m.id))), upcoming[0] ? (_jsxs(Text, { dimColor: true, wrap: "truncate", children: ["\u25CB ", upcoming[0].home.code, "\u2014", upcoming[0].away.code, " ", formatKickoff(upcoming[0].startTimestamp)] })) : null] }));
+}

package/dist/ui/UpcomingSection.js

@@ -0,0 +1,21 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function formatKickoff(ts, now = Date.now()) {
+    const d = new Date(ts * 1000);
+    const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+    const sameDay = d.toDateString() === new Date(now).toDateString();
+    if (sameDay)
+        return time;
+    const day = d.toLocaleDateString(undefined, { weekday: 'short' });
+    return `${day} ${time}`;
+}
+export function UpcomingSection({ matches, compact }) {
+    const shown = matches.slice(0, compact ? 1 : 8);
+    if (shown.length === 0)
+        return null;
+    if (compact) {
+        const m = shown[0];
+        return (_jsxs(Text, { dimColor: true, children: ["\u25CB ", m.home.code, "\u2014", m.away.code, " ", formatKickoff(m.startTimestamp)] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "UPCOMING" }), shown.map((m) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), m.home.name, " \u2014 ", m.away.name, m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }, m.id)))] }));
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "claudial",
+  "version": "0.1.0",
+  "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
+  "type": "module",
+  "bin": { "claudial": "dist/index.js" },
+  "files": ["dist"],
+  "engines": { "node": ">=18.18" },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.tsx",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ink": "^5.2.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/react": "^18.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.1.0"
+  },
+  "keywords": ["worldcup", "world-cup-2026", "tui", "cli", "football", "soccer", "live-scores", "ink"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/lefProg/claudial.git" },
+  "homepage": "https://github.com/lefProg/claudial#readme",
+  "bugs": "https://github.com/lefProg/claudial/issues",
+  "author": "Wim Iliano"
+}