touchline 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Hamed
+
+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,67 @@
+# Touchline
+
+A live football match centre designed for the terminal. Touchline reads the same JSON feeds as the supplied SVT/eNetScores widget and turns them into a fast, keyboard-driven TUI.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-c8f560?style=flat-square)
+![dependencies](https://img.shields.io/badge/runtime_dependencies-0-54e08b?style=flat-square)
+
+## Run it
+
+No clone or installation is needed:
+
+```bash
+npx touchline
+```
+
+Touchline requires Node.js 18+ for `npx` and Python 3.10+ for the TUI runtime. It has no npm or Python package dependencies.
+
+To run the source checkout directly:
+
+```bash
+cd /Users/hamed/dev/claude-tools/touchline
+PYTHONPATH=src python3 -m touchline
+```
+
+The Spain–Argentina World Cup final is the default match. A different SVT iframe URL or direct eNetScores widget URL can be passed as the first argument:
+
+```bash
+npx touchline 'https://widget.enetscores.com/CLIENT/ev/EVENT_ID/lng/sv'
+```
+
+Commentary is translated to English by default, regardless of the language embedded in the source URL. Use `--language sv` to follow the original Swedish feed instead.
+
+## Views and keys
+
+| Key | Action |
+| --- | --- |
+| `1`–`8` | Overview, live feed, team stats, lineups, formation, player stats, H2H, bracket |
+| `←` / `→` or `h` / `l` | Previous/next view |
+| `j` / `k` | Scroll |
+| `r` | Refresh immediately |
+| `q` | Quit |
+
+The live score, commentary, team stats and player stats refresh every 10 seconds. Lineups, formations, H2H and the bracket are fetched once on startup because they rarely change. The feed itself is cached upstream for five seconds, so `--refresh 5` is the fastest useful setting.
+
+## Preview and diagnostics
+
+Render a non-interactive frame without hitting the live feed:
+
+```bash
+npx touchline --demo --snapshot --no-color
+```
+
+Useful options:
+
+```text
+--refresh SECONDS   polling interval, minimum 5 seconds
+--language, -L CODE commentary language; English by default
+--demo              use built-in sample data
+--snapshot          render once and exit
+--tab 1..8          choose the initial view
+--width / --height  set snapshot dimensions
+--no-color          plain-text snapshot output
+```
+
+## Data source
+
+Touchline does not scrape rendered HTML. It discovers and consumes the public JSON requests made by the eNetScores widget. The client code, event id and language are parsed from the supplied URL; tournament and bracket ids are discovered from the match metadata. If the provider changes its private widget schema in the future, the parsers in `src/touchline/api.py` may need to be adjusted.

package/bin/touchline.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const sourceRoot = path.join(packageRoot, "src");
+
+function pythonCandidates() {
+  const configured = process.env.TOUCHLINE_PYTHON;
+  if (configured) return [[configured, []]];
+  if (process.platform === "win32") {
+    return [["py", ["-3"]], ["python", []], ["python3", []]];
+  }
+  return [["python3", []], ["python", []]];
+}
+
+function findPython() {
+  for (const [command, prefix] of pythonCandidates()) {
+    const probe = spawnSync(
+      command,
+      [...prefix, "-c", "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) else 1)"],
+      { stdio: "ignore" },
+    );
+    if (probe.status === 0) return [command, prefix];
+  }
+  return null;
+}
+
+const python = findPython();
+if (!python) {
+  console.error("touchline needs Python 3.10 or newer, but no compatible Python was found.");
+  console.error("Install Python from https://python.org, or set TOUCHLINE_PYTHON to its path.");
+  process.exit(1);
+}
+
+const [command, prefix] = python;
+const existingPath = process.env.PYTHONPATH;
+const env = {
+  ...process.env,
+  PYTHONPATH: existingPath ? `${sourceRoot}${path.delimiter}${existingPath}` : sourceRoot,
+};
+const result = spawnSync(
+  command,
+  [...prefix, "-m", "touchline", ...process.argv.slice(2)],
+  { stdio: "inherit", env },
+);
+
+if (result.error) {
+  console.error(`touchline could not start: ${result.error.message}`);
+  process.exit(1);
+}
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+}
+process.exit(result.status ?? 1);
+

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "touchline",
+  "version": "0.1.0",
+  "description": "A live football match centre for your terminal",
+  "license": "MIT",
+  "author": "Hamed",
+  "type": "commonjs",
+  "bin": {
+    "touchline": "bin/touchline.js"
+  },
+  "files": [
+    "bin",
+    "src/touchline/*.py",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "football",
+    "soccer",
+    "live-score",
+    "terminal",
+    "tui",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/touchline/__init__.py

@@ -0,0 +1,4 @@
+"""Touchline — a live football match centre for the terminal."""
+
+__version__ = "0.1.0"
+

package/src/touchline/__main__.py

@@ -0,0 +1,5 @@
+from .app import main
+
+if __name__ == "__main__":
+    main()
+

package/src/touchline/api.py

@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import json
+import re
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from typing import Any
+
+from .model import Event, MatchState, Team
+
+DEFAULT_IFRAME_URL = (
+    "https://api.svt.se/news/embed/script-iframe?"
+    "url=https%3A%2F%2Fwidget.enetscores.com%2FFW15C12BED468AE5A7%2F"
+    "ev%2F4653858%2Flng%2Fsv"
+)
+API_VERSION = "11.546"
+THEME = "theme_webchunk_22"
+
+
+class FeedError(RuntimeError):
+    pass
+
+
+def parse_widget_url(value: str) -> tuple[str, str, str]:
+    """Return client code, event id and language from an iframe/widget URL."""
+    parsed = urllib.parse.urlparse(value)
+    query = urllib.parse.parse_qs(parsed.query)
+    inner = query.get("url", [value])[0]
+    decoded = urllib.parse.unquote(inner)
+    match = re.search(r"widget\.enetscores\.com/([^/]+)/ev/(\d+)/lng/([a-z-]+)", decoded)
+    if not match:
+        match = re.search(r"widget\.enetscores\.com/([^/]+)/(?:ev/)?(\d+)/(?:lng/)?([a-z-]+)?", decoded)
+    if not match:
+        raise FeedError("Could not find the eNetScores client and event id in that URL")
+    return match.group(1), match.group(2), match.group(3) or "sv"
+
+
+def _decode_content(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    content = payload.get("content", [])
+    if isinstance(content, str):
+        decoded = json.loads(content)
+        return [{"data": decoded, "fields": []}]
+    if isinstance(content, dict):
+        return [{"data": content, "fields": []}]
+    return content if isinstance(content, list) else []
+
+
+class EnetClient:
+    def __init__(self, iframe_url: str = DEFAULT_IFRAME_URL, timeout: float = 8.0, language: str | None = "en"):
+        self.client_code, self.event_id, url_language = parse_widget_url(iframe_url)
+        self.language = language or url_language
+        if not re.fullmatch(r"[a-z]{2}(?:-[a-z]{2})?", self.language):
+            raise FeedError(f"Unsupported language code: {self.language}")
+        self.timeout = timeout
+        self.base = f"https://es-ds.enetscores.com/{API_VERSION}/{self.client_code}"
+        self.stage_id = ""
+        self.draw_id = ""
+
+    def _get(self, url: str) -> dict[str, Any]:
+        request = urllib.request.Request(
+            url,
+            headers={
+                "Accept": "application/json",
+                "User-Agent": "Touchline/0.1 (+terminal match centre)",
+                "Origin": "https://api.svt.se",
+                "Referer": "https://api.svt.se/",
+            },
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                return json.load(response)
+        except Exception as exc:
+            raise FeedError(f"Live feed unavailable: {exc}") from exc
+
+    def _url(self, subject: str) -> str:
+        return f"{self.base}/{subject.lstrip('/')}"
+
+    def discover(self) -> dict[str, Any]:
+        subject = (
+            f"live-{self.language}-event_compound_top_component-1-{self.event_id}"
+            f"-t_g-{THEME}"
+        )
+        payload = self._get(self._url(subject))
+        blocks = _decode_content(payload)
+        data = blocks[0].get("data", {}) if blocks else {}
+        event = data.get("e", {})
+        self.stage_id = str(event.get("tsid", ""))
+        if self.stage_id:
+            full = (
+                f"live-{self.language}-event_compound-event_compound_top_component-1-{self.event_id}"
+                f"-t_g-{THEME}-event_compound-ms-standings-ts-{self.stage_id}"
+                f"-ms-draw-ts-{self.stage_id}"
+            )
+            full_blocks = _decode_content(self._get(self._url(full)))
+            if len(full_blocks) > 1:
+                self.draw_id = str(full_blocks[1].get("data", {}).get("draw", ""))
+        return data
+
+    def subjects(self) -> dict[str, str]:
+        e = self.event_id
+        lang = self.language
+        common = f"live-{lang}-event_compound"
+        result = {
+            "core": f"live-{lang}-event_compound_top_component-1-{e}-t_g-{THEME}",
+            "match": (
+                f"/{common}-event-incidents-1-{e}-t_g-id_type_event_info-{THEME}"
+                f"-icf_all-otid_0-event_compound-action_map-1-{e}-p0300-t_g-{THEME}"
+                f"-event_compound-momentum-1-{e}-t_g-{THEME}"
+            ),
+            "comments": f"/{common}-event-comments-1-{e}-t_g-cmd_type_comments-{THEME}",
+            "stats": f"{common}-event-livestats-1-{e}-t_g-lsd_type_event_stats-{THEME}-ls_dt_type_default",
+            "lineups": f"/{common}-event-lineups-1-{e}-t_g-{THEME}-ln_type_lineups-tm_tbs_yes",
+            "formation": f"/{common}-event-lineups-1-{e}-t_g-{THEME}-ln_type_formation_lineups",
+            "h2h": (
+                f"/{common}-event-h2h-1-{e}-t_g-h2hd_type_h2h-{THEME}"
+                "-otid_0-sel_tb_all-el_limit_5-ev_n_r_5-emb_yes"
+            ),
+            "players": (
+                f"{common}-extended_participants_stats-1--par_t_event-t_g-{THEME}"
+                f"-stat_cat_general--ev_{e}-fss_0"
+            ),
+        }
+        if self.draw_id:
+            result["bracket"] = f"/{common}-tournament_stage_draw-1-{self.draw_id}-t_g-{THEME}"
+        return result
+
+    def fetch(self, include_static: bool = True) -> dict[str, dict[str, Any]]:
+        if not self.stage_id:
+            core = self.discover()
+        else:
+            core = None
+        subjects = self.subjects()
+        dynamic = {"core", "match", "comments", "stats", "players"}
+        selected = subjects if include_static else {k: v for k, v in subjects.items() if k in dynamic}
+        result: dict[str, dict[str, Any]] = {}
+        if core is not None:
+            result["core"] = {"content": core}
+            selected.pop("core", None)
+        with ThreadPoolExecutor(max_workers=min(6, len(selected) or 1)) as pool:
+            futures = {pool.submit(self._get, self._url(subject)): name for name, subject in selected.items()}
+            for future in as_completed(futures):
+                name = futures[future]
+                result[name] = future.result()
+        return result
+
+
+def _event_data(payload: dict[str, Any]) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    blocks = _decode_content(payload)
+    if not blocks:
+        return {}, []
+    return blocks[0].get("data", {}), blocks[0].get("fields", [])
+
+
+def _team(raw: dict[str, Any]) -> Team:
+    return Team(
+        id=str(raw.get("pi") or raw.get("ti") or ""),
+        name=str(raw.get("pn") or raw.get("tn") or "—"),
+        short=str(raw.get("pns") or raw.get("tns") or raw.get("pn") or "—"),
+        score=str(raw.get("frs") or raw.get("rs6") or raw.get("rs1") or "0"),
+        country=str(raw.get("cns") or raw.get("cn") or ""),
+    )
+
+
+def _parse_core(state: MatchState, payload: dict[str, Any]) -> None:
+    if "content" in payload and isinstance(payload["content"], dict):
+        data = payload["content"]
+    else:
+        data, _ = _event_data(payload)
+    event = data.get("e", {})
+    participants = event.get("par", {})
+    if participants:
+        state.home = _team(participants.get("1", {}))
+        state.away = _team(participants.get("2", {}))
+    state.status = str(event.get("st", state.status))
+    state.period = str(event.get("sns") or event.get("sn") or state.period)
+    state.minute = str(event.get("et") or state.minute)
+    state.round_name = str(event.get("rnd") or state.round_name)
+    state.start_time = str(event.get("sd") or state.start_time)
+
+
+def _parse_comments(state: MatchState, payload: dict[str, Any]) -> None:
+    data, fields = _event_data(payload)
+    tournament = data.get("t", {})
+    event = data.get("e", {})
+    venue = event.get("vn", {})
+    state.competition = str(tournament.get("nm") or tournament.get("nms") or state.competition)
+    state.venue = str(venue.get("nm") or venue.get("vnm") or state.venue)
+    state.city = str(venue.get("ct") or venue.get("cts") or state.city)
+    state.minute = str(event.get("et") or state.minute)
+    parsed: list[Event] = []
+    for field in fields:
+        if not str(field.get("name", "")).startswith("ei_"):
+            continue
+        try:
+            item = json.loads(field.get("value", "{}"))
+        except (TypeError, json.JSONDecodeError):
+            continue
+        parsed.append(Event(
+            minute=str(item.get("et", "")),
+            kind=str(item.get("tp", "info")),
+            text=str(item.get("nm", "")),
+            team_id=str(item.get("ti", "")),
+            sequence=int(item.get("s", 0) or 0),
+        ))
+    state.events = sorted(parsed, key=lambda item: item.sequence, reverse=True)
+
+
+def _parse_stats(state: MatchState, payload: dict[str, Any]) -> None:
+    data, _ = _event_data(payload)
+    stats = data.get("ls", {})
+    state.stats = {
+        key: {"home": str(value.get("1", "0")), "away": str(value.get("2", "0"))}
+        for key, value in stats.items()
+        if isinstance(value, dict) and not key.endswith("_541")
+    }
+
+
+def _parse_match(state: MatchState, payload: dict[str, Any]) -> None:
+    blocks = _decode_content(payload)
+    if not blocks:
+        return
+    info = blocks[0].get("data", {})
+    event = info.get("e", {})
+    venue = info.get("vn", {})
+    tournament = info.get("t", {})
+    state.round_name = str(event.get("rnd") or state.round_name)
+    state.venue = str(venue.get("nm") or state.venue)
+    state.city = str(venue.get("ct") or state.city)
+    state.competition = str(tournament.get("nm") or state.competition)
+    if len(blocks) > 1:
+        fields = {field.get("name"): field.get("value") for field in blocks[1].get("fields", [])}
+        try:
+            actions = json.loads(fields.get("a", "{}"))
+        except (TypeError, json.JSONDecodeError):
+            actions = {}
+        state.pitch_actions = [
+            action for action in actions.values()
+            if action.get("coords_set") and action.get("coords_x") not in (None, "")
+        ]
+    if len(blocks) > 2:
+        momentum_data = blocks[2].get("data", {}).get("data", {})
+        momentum_event = momentum_data.get("e", {})
+        if momentum_event.get("et") not in (None, ""):
+            state.minute = str(momentum_event["et"])
+        incident_values = momentum_data.get("incidents", {}).values()
+        points: list[tuple[int, float]] = []
+        for item in incident_values:
+            incident = item.get("incident_data", {})
+            try:
+                minute = int(incident.get("elapsed", 0))
+                value = float(incident.get("home_pt", 0)) - float(incident.get("away_pt", 0))
+            except (TypeError, ValueError):
+                continue
+            points.append((minute, value))
+        if points:
+            try:
+                maximum = int(momentum_event.get("et", ""))
+            except (TypeError, ValueError):
+                maximum = max(minute for minute, _ in points)
+            state.momentum = [0.0] * (maximum + 1)
+            for minute, value in points:
+                if minute <= maximum:
+                    state.momentum[minute] = value
+
+
+def _parse_lineups(state: MatchState, payload: dict[str, Any]) -> None:
+    data, _ = _event_data(payload)
+    groups = data.get("lnp", {})
+    parsed: dict[str, dict[str, list[dict[str, Any]]]] = {}
+    for key, group in groups.items():
+        listing = group.get("list", {}) if isinstance(group, dict) else {}
+        parsed[key] = {
+            "home": listing.get("home", []),
+            "away": listing.get("away", []),
+        }
+    state.lineups = parsed
+
+
+def _parse_formation(state: MatchState, payload: dict[str, Any]) -> None:
+    data, _ = _event_data(payload)
+    participants = data.get("e", {}).get("par", {})
+    state.formations = {
+        "home": str(participants.get("1", {}).get("formation", "")),
+        "away": str(participants.get("2", {}).get("formation", "")),
+    }
+    if not state.lineups:
+        _parse_lineups(state, payload)
+
+
+def _event_row(item: dict[str, Any]) -> dict[str, Any]:
+    par = item.get("par", {})
+    home, away = par.get("1", {}), par.get("2", {})
+    return {
+        "date": str(item.get("sd", ""))[:10],
+        "home": home.get("pn", "—"),
+        "away": away.get("pn", "—"),
+        "home_score": home.get("frs", home.get("rs6", "–")),
+        "away_score": away.get("frs", away.get("rs6", "–")),
+        "competition": item.get("ttn", ""),
+    }
+
+
+def _parse_h2h(state: MatchState, payload: dict[str, Any]) -> None:
+    data, _ = _event_data(payload)
+    sections = data.get("data", {})
+    state.h2h = {}
+    for name in ("h2h", "home", "away"):
+        events = sections.get(name, {}).get("e", {})
+        state.h2h[name] = [_event_row(item) for item in events.values()]
+
+
+def _parse_players(state: MatchState, payload: dict[str, Any]) -> None:
+    data, _ = _event_data(payload)
+    raw = data.get("data", [])
+    if isinstance(raw, dict):
+        raw = list(raw.values())
+    state.player_stats = raw if isinstance(raw, list) else []
+
+
+def _parse_bracket(state: MatchState, payload: dict[str, Any]) -> None:
+    outer, _ = _event_data(payload)
+    draw = outer.get("data", {}).get("dr", {})
+    rounds = draw.get("dre", {})
+    parsed: dict[str, list[dict[str, Any]]] = {}
+    for round_name, round_data in rounds.items():
+        matches: list[dict[str, Any]] = []
+        for pair in round_data.get("pairs", {}).values():
+            for item in pair.get("events", {}).values():
+                matches.append(_event_row(item))
+        parsed[round_name] = matches
+    state.bracket = parsed
+
+
+PARSERS = {
+    "core": _parse_core,
+    "match": _parse_match,
+    "comments": _parse_comments,
+    "stats": _parse_stats,
+    "lineups": _parse_lineups,
+    "formation": _parse_formation,
+    "h2h": _parse_h2h,
+    "players": _parse_players,
+    "bracket": _parse_bracket,
+}
+
+
+def merge_payloads(state: MatchState, payloads: dict[str, dict[str, Any]]) -> MatchState:
+    for name, payload in payloads.items():
+        parser = PARSERS.get(name)
+        if parser:
+            parser(state, payload)
+    state.updated_at = datetime.now()
+    state.loading = False
+    state.error = ""
+    return state

package/src/touchline/app.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import argparse
+import os
+import queue
+import select
+import shutil
+import sys
+import termios
+import threading
+import time
+import tty
+from dataclasses import dataclass
+
+from .api import DEFAULT_IFRAME_URL, EnetClient, FeedError, merge_payloads
+from .demo import demo_state
+from .model import MatchState
+from .ui import Renderer, TABS, strip_ansi
+
+
+@dataclass
+class AppState:
+    tab: int = 0
+    scroll: int = 0
+    running: bool = True
+    force_refresh: bool = False
+
+
+class TouchlineApp:
+    def __init__(self, url: str, refresh: float = 10.0, demo: bool = False, language: str = "en"):
+        self.demo = demo
+        self.refresh_interval = max(5.0, refresh)
+        self.ui = AppState()
+        self.match = demo_state() if demo else MatchState(event_id="")
+        self.client = None if demo else EnetClient(url, language=language)
+        if self.client:
+            self.match.event_id = self.client.event_id
+        self.results: queue.Queue[tuple[dict | None, Exception | None]] = queue.Queue()
+        self.fetching = False
+        self.loaded_static = False
+        self.last_fetch = 0.0
+
+    def _fetch(self, include_static: bool) -> None:
+        try:
+            assert self.client is not None
+            self.results.put((self.client.fetch(include_static=include_static), None))
+        except Exception as exc:
+            self.results.put((None, exc))
+
+    def request_refresh(self, force: bool = False) -> None:
+        if self.demo or self.fetching:
+            return
+        if not force and time.monotonic() - self.last_fetch < self.refresh_interval:
+            return
+        self.fetching = True
+        thread = threading.Thread(target=self._fetch, args=(not self.loaded_static,), daemon=True)
+        thread.start()
+
+    def collect(self) -> bool:
+        changed = False
+        while True:
+            try:
+                payloads, error = self.results.get_nowait()
+            except queue.Empty:
+                break
+            self.fetching = False
+            self.last_fetch = time.monotonic()
+            if error:
+                self.match.error = str(error).replace("Live feed unavailable: ", "")
+                self.match.loading = False
+            elif payloads is not None:
+                merge_payloads(self.match, payloads)
+                self.loaded_static = True
+            changed = True
+        return changed
+
+    def frame(self, width: int, height: int) -> str:
+        return Renderer(self.match, self.ui.tab, self.ui.scroll, self.demo).render(width, height)
+
+    def handle_key(self, key: str) -> None:
+        if key in ("q", "Q", "\x03"):
+            self.ui.running = False
+        elif key in ("\x1b[C", "l", "L", "\t"):
+            self.ui.tab = (self.ui.tab + 1) % len(TABS)
+            self.ui.scroll = 0
+        elif key in ("\x1b[D", "h", "H", "\x1b[Z"):
+            self.ui.tab = (self.ui.tab - 1) % len(TABS)
+            self.ui.scroll = 0
+        elif key in ("j", "J", "\x1b[B"):
+            self.ui.scroll += 1
+        elif key in ("k", "K", "\x1b[A"):
+            self.ui.scroll = max(0, self.ui.scroll - 1)
+        elif key in ("r", "R"):
+            self.last_fetch = 0
+            self.request_refresh(force=True)
+        elif key.isdigit() and 1 <= int(key) <= len(TABS):
+            self.ui.tab = int(key) - 1
+            self.ui.scroll = 0
+
+    def run(self) -> None:
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            raise SystemExit("Interactive mode needs a TTY. Try --snapshot for a static frame.")
+        previous = termios.tcgetattr(sys.stdin)
+        try:
+            tty.setcbreak(sys.stdin.fileno())
+            sys.stdout.write("\x1b[?1049h\x1b[?25l")
+            self.request_refresh(force=True)
+            dirty = True
+            while self.ui.running:
+                self.request_refresh()
+                dirty = self.collect() or dirty
+                width, height = shutil.get_terminal_size((120, 36))
+                if dirty:
+                    sys.stdout.write("\x1b[H" + self.frame(width, height))
+                    sys.stdout.flush()
+                    dirty = False
+                ready, _, _ = select.select([sys.stdin], [], [], 0.15)
+                if ready:
+                    key = os.read(sys.stdin.fileno(), 8).decode(errors="ignore")
+                    self.handle_key(key)
+                    dirty = True
+        finally:
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, previous)
+            sys.stdout.write("\x1b[?25h\x1b[?1049l")
+            sys.stdout.flush()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Follow a live football match from your terminal")
+    parser.add_argument("url", nargs="?", default=DEFAULT_IFRAME_URL, help="SVT iframe or eNetScores widget URL")
+    parser.add_argument("--refresh", type=float, default=10.0, metavar="SECONDS", help="refresh interval (minimum 5)")
+    parser.add_argument("--language", "-L", default="en", help="commentary language (default: en; try sv, es, de)")
+    parser.add_argument("--demo", action="store_true", help="use polished sample data without a network connection")
+    parser.add_argument("--snapshot", action="store_true", help="print one frame and exit")
+    parser.add_argument("--width", type=int, default=120, help="snapshot width")
+    parser.add_argument("--height", type=int, default=36, help="snapshot height")
+    parser.add_argument("--tab", type=int, choices=range(1, 9), default=1, help="initial view, 1–8")
+    parser.add_argument("--no-color", action="store_true", help="strip ANSI color from snapshots")
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    try:
+        app = TouchlineApp(args.url, args.refresh, args.demo, args.language)
+    except FeedError as exc:
+        raise SystemExit(f"touchline: {exc}") from exc
+    app.ui.tab = args.tab - 1
+    if args.snapshot:
+        if not args.demo:
+            try:
+                assert app.client is not None
+                merge_payloads(app.match, app.client.fetch(include_static=True))
+            except Exception as exc:
+                app.match.loading = False
+                app.match.error = str(exc)
+        frame = app.frame(args.width, args.height)
+        print(strip_ansi(frame) if args.no_color else frame, end="")
+        return
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

package/src/touchline/demo.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .model import Event, MatchState, Team
+
+
+def demo_state() -> MatchState:
+    state = MatchState(event_id="4653858")
+    state.home = Team("6720", "Spain", "ESP", "2", "ESP")
+    state.away = Team("6706", "Argentina", "ARG", "1", "ARG")
+    state.status = "inprogress"
+    state.period = "2nd half"
+    state.minute = "67"
+    state.competition = "World Cup 2026"
+    state.round_name = "Final"
+    state.venue = "New York/New Jersey Stadium"
+    state.city = "East Rutherford"
+    state.events = [
+        Event("67", "shoton", "Lamine Yamal bends a shot toward the far corner. Martinez saves.", "6720", 14),
+        Event("63", "subst", "Argentina: Lautaro Martinez replaces Nicolas Gonzalez.", "6706", 13),
+        Event("58", "goal", "GOAL Spain — Dani Olmo finds the bottom-left corner.", "6720", 12),
+        Event("53", "yellowcard", "Cristian Romero is booked for a late challenge.", "6706", 11),
+        Event("46", "2h", "The second half is underway.", "", 10),
+        Event("41", "goal", "GOAL Argentina — Lionel Messi converts from the spot.", "6706", 9),
+        Event("24", "goal", "GOAL Spain — Mikel Oyarzabal heads home.", "6720", 8),
+    ]
+    state.stats = {
+        "expected_goal": {"home": "1.82", "away": "1.10"},
+        "possession": {"home": "57", "away": "43"},
+        "goal_attempt": {"home": "13", "away": "8"},
+        "shoton": {"home": "6", "away": "3"},
+        "shotoff": {"home": "4", "away": "3"},
+        "corner": {"home": "5", "away": "2"},
+        "foulcommit": {"home": "8", "away": "11"},
+        "offside": {"home": "1", "away": "2"},
+        "yellow_cards": {"home": "1", "away": "2"},
+        "red_cards": {"home": "0", "away": "0"},
+    }
+    state.momentum = [0, 1, -1, 0, 2, 3, 1, -2, -1, 2, 4, 2, 1, -3, -2, 1, 3, 2, 4, 1]
+    state.pitch_actions = [
+        {"coords_x": "22", "coords_y": "35", "ti": "6720", "tp": "shoton"},
+        {"coords_x": "71", "coords_y": "64", "ti": "6706", "tp": "foulcommit"},
+        {"coords_x": "84", "coords_y": "48", "ti": "6720", "tp": "goal"},
+        {"coords_x": "44", "coords_y": "21", "ti": "6706", "tp": "cross"},
+        {"coords_x": "66", "coords_y": "38", "ti": "6720", "tp": "shoton"},
+    ]
+    home = [
+        ("23", "Unai Simon", 0), ("12", "Pedro Porro", 1), ("22", "Pau Cubarsi", 1),
+        ("14", "Aymeric Laporte", 1), ("24", "Marc Cucurella", 1), ("16", "Rodri", 2),
+        ("8", "Fabian Ruiz", 2), ("19", "Lamine Yamal", 2), ("10", "Dani Olmo", 2),
+        ("15", "Alex Baena", 2), ("21", "Mikel Oyarzabal", 3),
+    ]
+    away = [
+        ("23", "Emiliano Martinez", 0), ("4", "Gonzalo Montiel", 1), ("13", "Cristian Romero", 1),
+        ("6", "Lisandro Martinez", 1), ("3", "Nicolas Tagliafico", 1), ("7", "Rodrigo De Paul", 2),
+        ("24", "Enzo Fernandez", 2), ("20", "Alexis Mac Allister", 2), ("15", "Nicolas Gonzalez", 2),
+        ("10", "Lionel Messi", 3), ("9", "Julian Alvarez", 3),
+    ]
+    convert = lambda rows: [{"sn": n, "pn": name, "pns": name, "so": pos} for n, name, pos in rows]
+    state.lineups = {"lineups": {"home": convert(home), "away": convert(away)}, "bench": {"home": [], "away": []}}
+    state.formations = {"home": "4-2-3-1", "away": "4-4-2"}
+    state.h2h = {"h2h": [
+        {"date": "2018-03-27", "home": "Spain", "away": "Argentina", "home_score": "6", "away_score": "1", "competition": "Friendly"},
+        {"date": "2010-09-07", "home": "Argentina", "away": "Spain", "home_score": "4", "away_score": "1", "competition": "Friendly"},
+        {"date": "2009-11-14", "home": "Spain", "away": "Argentina", "home_score": "2", "away_score": "1", "competition": "Friendly"},
+    ], "home": [], "away": []}
+    state.bracket = {
+        "Quarter Finals": [
+            {"home": "France", "away": "Morocco", "home_score": "2", "away_score": "0", "date": "2026-07-09"},
+            {"home": "Spain", "away": "Belgium", "home_score": "2", "away_score": "1", "date": "2026-07-10"},
+            {"home": "Norway", "away": "England", "home_score": "1", "away_score": "2", "date": "2026-07-11"},
+            {"home": "Argentina", "away": "Switzerland", "home_score": "3", "away_score": "1", "date": "2026-07-12"},
+        ],
+        "Semi Finals": [
+            {"home": "France", "away": "Spain", "home_score": "0", "away_score": "2", "date": "2026-07-14"},
+            {"home": "England", "away": "Argentina", "home_score": "1", "away_score": "2", "date": "2026-07-15"},
+        ],
+        "Final": [{"home": "Spain", "away": "Argentina", "home_score": "2", "away_score": "1", "date": "LIVE"}],
+    }
+    state.updated_at = datetime.now()
+    state.loading = False
+    return state

package/src/touchline/model.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class Team:
+    id: str = ""
+    name: str = "—"
+    short: str = "—"
+    score: str = "0"
+    country: str = ""
+
+
+@dataclass
+class Event:
+    minute: str
+    kind: str
+    text: str
+    team_id: str = ""
+    sequence: int = 0
+
+
+@dataclass
+class MatchState:
+    event_id: str
+    home: Team = field(default_factory=Team)
+    away: Team = field(default_factory=Team)
+    status: str = "loading"
+    period: str = ""
+    minute: str = "—"
+    competition: str = "World Cup"
+    round_name: str = "Final"
+    venue: str = ""
+    city: str = ""
+    start_time: str = ""
+    events: list[Event] = field(default_factory=list)
+    stats: dict[str, dict[str, str]] = field(default_factory=dict)
+    lineups: dict[str, dict[str, list[dict[str, Any]]]] = field(default_factory=dict)
+    formations: dict[str, str] = field(default_factory=dict)
+    player_stats: list[dict[str, Any]] = field(default_factory=list)
+    h2h: dict[str, list[dict[str, Any]]] = field(default_factory=dict)
+    bracket: dict[str, list[dict[str, Any]]] = field(default_factory=dict)
+    pitch_actions: list[dict[str, Any]] = field(default_factory=list)
+    momentum: list[float] = field(default_factory=list)
+    updated_at: datetime | None = None
+    error: str = ""
+    loading: bool = True
+
+    @property
+    def is_live(self) -> bool:
+        return self.status == "inprogress"
+
+
+STAT_LABELS = {
+    "expected_goal": "Expected goals",
+    "possession": "Possession",
+    "shoton": "Shots on target",
+    "shotoff": "Shots off target",
+    "goal_attempt": "Goal attempts",
+    "blocked_shots": "Blocked shots",
+    "corner": "Corners",
+    "cross": "Crosses",
+    "throwin": "Throw-ins",
+    "offside": "Offsides",
+    "goalkick": "Goal kicks",
+    "freekick": "Free kicks",
+    "foulcommit": "Fouls",
+    "yellow_cards": "Yellow cards",
+    "red_cards": "Red cards",
+    "saves": "Saves",
+    "treatment": "Treatments",
+    "subst": "Substitutions",
+}
+
+EVENT_ICONS = {
+    "goal": "GOAL",
+    "yellowcard": "CARD",
+    "redcard": "RED",
+    "subst": "SUB",
+    "kickoff": "KICK",
+    "corner": "CORNER",
+    "shoton": "SHOT",
+    "shotoff": "MISS",
+    "foulcommit": "FOUL",
+    "offside": "OFF",
+    "fieldpossession": "PLAY",
+    "special": "INFO",
+    "1h": "START",
+    "2h": "START",
+}

package/src/touchline/ui.py

@@ -0,0 +1,434 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Callable
+
+from .model import EVENT_ICONS, STAT_LABELS, MatchState
+
+BG = "#0a0f0d"
+PANEL = "#101814"
+PANEL_2 = "#15211b"
+LINE = "#294036"
+TEXT = "#eef5ef"
+MUTED = "#82958b"
+GREEN = "#54e08b"
+LIME = "#c8f560"
+AMBER = "#f4c95d"
+RED = "#ff6b6b"
+BLUE = "#68a8ff"
+
+
+def _rgb(value: str) -> tuple[int, int, int]:
+    value = value.lstrip("#")
+    return tuple(int(value[i:i + 2], 16) for i in (0, 2, 4))  # type: ignore[return-value]
+
+
+@dataclass(frozen=True)
+class Style:
+    fg: str = TEXT
+    bg: str = BG
+    bold: bool = False
+    dim: bool = False
+
+
+@dataclass
+class Cell:
+    char: str = " "
+    style: Style = Style()
+
+
+class Canvas:
+    def __init__(self, width: int, height: int):
+        self.width = max(40, width)
+        self.height = max(16, height)
+        self.rows = [[Cell() for _ in range(self.width)] for _ in range(self.height)]
+
+    def put(self, x: int, y: int, text: object, style: Style = Style(), max_width: int | None = None) -> None:
+        if not 0 <= y < self.height:
+            return
+        value = str(text).replace("\n", " ")
+        room = self.width - x if max_width is None else min(max_width, self.width - x)
+        if room <= 0:
+            return
+        if len(value) > room:
+            value = value[:max(0, room - 1)] + ("…" if room else "")
+        for offset, char in enumerate(value):
+            px = x + offset
+            if 0 <= px < self.width:
+                self.rows[y][px] = Cell(char, style)
+
+    def fill(self, x: int, y: int, width: int, height: int, style: Style, char: str = " ") -> None:
+        for py in range(max(0, y), min(self.height, y + height)):
+            for px in range(max(0, x), min(self.width, x + width)):
+                self.rows[py][px] = Cell(char, style)
+
+    def box(self, x: int, y: int, width: int, height: int, title: str = "") -> None:
+        if width < 3 or height < 2:
+            return
+        border = Style(LINE, PANEL)
+        self.fill(x, y, width, height, Style(TEXT, PANEL))
+        self.put(x, y, "┌" + "─" * (width - 2) + "┐", border)
+        self.put(x, y + height - 1, "└" + "─" * (width - 2) + "┘", border)
+        for row in range(y + 1, y + height - 1):
+            self.put(x, row, "│", border)
+            self.put(x + width - 1, row, "│", border)
+        if title:
+            label = f" {title.upper()} "
+            self.put(x + 2, y, label, Style(LIME, PANEL, bold=True), width - 4)
+
+    def render(self) -> str:
+        output: list[str] = []
+        previous: Style | None = None
+        for row in self.rows:
+            for cell in row:
+                if cell.style != previous:
+                    fg = _rgb(cell.style.fg)
+                    bg = _rgb(cell.style.bg)
+                    attrs = [f"38;2;{fg[0]};{fg[1]};{fg[2]}", f"48;2;{bg[0]};{bg[1]};{bg[2]}"]
+                    if cell.style.bold:
+                        attrs.append("1")
+                    if cell.style.dim:
+                        attrs.append("2")
+                    output.append("\x1b[0;" + ";".join(attrs) + "m")
+                    previous = cell.style
+                output.append(cell.char)
+            output.append("\x1b[0m\n")
+            previous = None
+        return "".join(output)
+
+
+TABS = ["Overview", "Live", "Stats", "Lineups", "Formation", "Players", "H2H", "Bracket"]
+
+
+class Renderer:
+    def __init__(self, state: MatchState, tab: int = 0, scroll: int = 0, demo: bool = False):
+        self.state = state
+        self.tab = tab
+        self.scroll = max(0, scroll)
+        self.demo = demo
+
+    def render(self, width: int, height: int) -> str:
+        c = Canvas(width, height)
+        self._header(c)
+        self._tabs(c)
+        content_y = 9
+        content_h = c.height - content_y - 2
+        renderers: list[Callable[[Canvas, int, int], None]] = [
+            self._overview, self._live, self._stats, self._lineups,
+            self._formation, self._players, self._h2h, self._bracket,
+        ]
+        renderers[self.tab](c, content_y, content_h)
+        self._footer(c)
+        return c.render()
+
+    def _header(self, c: Canvas) -> None:
+        c.fill(0, 0, c.width, 7, Style(TEXT, PANEL_2))
+        live_color = RED if self.state.is_live else MUTED
+        c.put(2, 1, "TOUCHLINE", Style(LIME, PANEL_2, bold=True))
+        c.put(13, 1, "●", Style(live_color, PANEL_2, bold=True))
+        c.put(15, 1, "LIVE" if self.state.is_live else self.state.status.upper(), Style(live_color, PANEL_2, bold=True))
+        descriptor = f"{self.state.competition}  /  {self.state.round_name}"
+        c.put(2, 3, descriptor, Style(MUTED, PANEL_2), max(0, c.width // 3 - 2))
+
+        score = f"{self.state.home.score}  :  {self.state.away.score}"
+        centre = c.width // 2
+        c.put(max(2, centre - len(score) // 2), 2, score, Style(TEXT, PANEL_2, bold=True))
+        home = f"{self.state.home.short.upper()}  {self.state.home.name}"
+        away = f"{self.state.away.name}  {self.state.away.short.upper()}"
+        c.put(max(2, centre - 8 - len(home)), 2, home, Style(GREEN, PANEL_2, bold=True))
+        c.put(centre + 9, 2, away, Style(BLUE, PANEL_2, bold=True), max(0, c.width - centre - 11))
+        phase = f"{self.state.minute}'  {self.state.period}" if self.state.is_live else self.state.period
+        c.put(max(2, centre - len(phase) // 2), 4, phase, Style(AMBER, PANEL_2, bold=True))
+        location = " · ".join(part for part in (self.state.venue, self.state.city) if part)
+        c.put(max(2, centre - len(location) // 2), 5, location, Style(MUTED, PANEL_2), c.width - 4)
+
+        updated = self.state.updated_at.strftime("%H:%M:%S") if self.state.updated_at else "waiting"
+        status = f"SYNC {updated}"
+        if self.demo:
+            status = "DEMO DATA"
+        c.put(max(2, c.width - len(status) - 2), 1, status, Style(MUTED, PANEL_2))
+        c.put(0, 6, "─" * c.width, Style(LINE, PANEL_2))
+
+    def _tabs(self, c: Canvas) -> None:
+        c.fill(0, 7, c.width, 2, Style(MUTED, BG))
+        x = 2
+        compact = c.width < 100
+        for index, name in enumerate(TABS):
+            label = f" {index + 1} {name if not compact else name[:4]} "
+            if x + len(label) >= c.width - 1:
+                break
+            selected = index == self.tab
+            c.put(x, 7, label, Style(BG if selected else MUTED, LIME if selected else BG, bold=selected))
+            x += len(label) + 1
+
+    def _footer(self, c: Canvas) -> None:
+        y = c.height - 1
+        c.fill(0, y, c.width, 1, Style(MUTED, PANEL_2))
+        left = "  ←/→ views   j/k scroll   r refresh   q quit"
+        c.put(0, y, left, Style(MUTED, PANEL_2))
+        if self.state.error:
+            c.put(max(1, c.width - len(self.state.error) - 2), y, self.state.error, Style(RED, PANEL_2), c.width // 2)
+
+    def _overview(self, c: Canvas, y: int, h: int) -> None:
+        if c.width < 88:
+            self._event_panel(c, 1, y, c.width - 2, h)
+            return
+        left = int(c.width * 0.61)
+        self._event_panel(c, 1, y, left - 2, h)
+        self._snapshot_panel(c, left, y, c.width - left - 1, h)
+
+    def _event_panel(self, c: Canvas, x: int, y: int, w: int, h: int) -> None:
+        c.box(x, y, w, h, "Latest from the pitch")
+        events = self.state.events[self.scroll:]
+        row = y + 2
+        for event in events:
+            if row >= y + h - 1:
+                break
+            icon = EVENT_ICONS.get(event.kind, event.kind[:5].upper())
+            accent = RED if event.kind == "goal" else AMBER if "card" in event.kind else GREEN
+            c.put(x + 2, row, f"{event.minute:>3}'", Style(MUTED, PANEL))
+            c.put(x + 8, row, f"{icon:<6}", Style(accent, PANEL, bold=True))
+            c.put(x + 15, row, event.text, Style(TEXT, PANEL), w - 17)
+            row += 2 if w < 70 else 1
+        if not events:
+            self._empty(c, x, y, w, h, "Waiting for the first match event…")
+
+    def _snapshot_panel(self, c: Canvas, x: int, y: int, w: int, h: int) -> None:
+        c.box(x, y, w, h, "Match pulse")
+        keys = ["possession", "expected_goal", "goal_attempt", "shoton"]
+        row = y + 2
+        for key in keys:
+            if row >= y + h - 2:
+                break
+            value = self.state.stats.get(key)
+            if not value:
+                continue
+            self._stat_row(c, x + 2, row, w - 4, STAT_LABELS.get(key, key), value)
+            row += 2
+        if self.state.momentum and row + 4 < y + h:
+            c.put(x + 2, row + 1, "MOMENTUM", Style(MUTED, PANEL, bold=True))
+            self._momentum(c, x + 2, row + 3, w - 4)
+        elif row == y + 2:
+            self._empty(c, x, y, w, h, "Stats will appear as play develops")
+
+    def _live(self, c: Canvas, y: int, h: int) -> None:
+        if c.width < 100:
+            self._event_panel(c, 1, y, c.width - 2, h)
+            return
+        left = int(c.width * 0.68)
+        self._event_panel(c, 1, y, left - 2, h)
+        self._pitch_map(c, left, y, c.width - left - 1, h)
+
+    def _momentum(self, c: Canvas, x: int, y: int, w: int, show_labels: bool = True) -> None:
+        points = self.state.momentum[-w:]
+        if not points:
+            return
+        maximum = max(max(abs(point) for point in points), 1)
+        glyphs = "▁▂▃▄▅▆▇█"
+        for index, point in enumerate(points):
+            level = min(7, int(abs(point) / maximum * 7))
+            color = GREEN if point >= 0 else BLUE
+            c.put(x + index, y, glyphs[level], Style(color, PANEL, bold=abs(point) == maximum))
+        if show_labels:
+            c.put(x, y + 1, self.state.home.short, Style(GREEN, PANEL), min(8, w))
+            away = self.state.away.short
+            c.put(x + max(0, w - len(away)), y + 1, away, Style(BLUE, PANEL))
+
+    def _pitch_map(self, c: Canvas, x: int, y: int, w: int, h: int) -> None:
+        c.box(x, y, w, h, "Action map")
+        px, py = x + 2, y + 2
+        pw, ph = w - 4, max(5, h - 8)
+        c.fill(px, py, pw, ph, Style(TEXT, "#123323"))
+        c.put(px, py, "┌" + "─" * max(0, pw - 2) + "┐", Style("#3b7657", "#123323"))
+        c.put(px, py + ph - 1, "└" + "─" * max(0, pw - 2) + "┘", Style("#3b7657", "#123323"))
+        for row in range(py + 1, py + ph - 1):
+            c.put(px, row, "│", Style("#3b7657", "#123323"))
+            c.put(px + pw - 1, row, "│", Style("#3b7657", "#123323"))
+            c.put(px + pw // 2, row, "│", Style("#3b7657", "#123323"))
+        c.put(px + pw // 2, py + ph // 2, "○", Style("#3b7657", "#123323"))
+        actions = self.state.pitch_actions[-40:]
+        for index, action in enumerate(actions):
+            try:
+                ax = float(action.get("coords_x", 0)) / 100
+                ay = float(action.get("coords_y", 0)) / 100
+            except (TypeError, ValueError):
+                continue
+            plot_x = px + 1 + int(ax * max(1, pw - 3))
+            plot_y = py + 1 + int(ay * max(1, ph - 3))
+            home = str(action.get("ti", "")) == self.state.home.id
+            color = GREEN if home else BLUE
+            marker = "●" if index == len(actions) - 1 else "·"
+            c.put(plot_x, plot_y, marker, Style(color, "#123323", bold=marker == "●"))
+        legend_y = y + h - 4
+        c.put(x + 2, legend_y, f"● {self.state.home.short}", Style(GREEN, PANEL, bold=True))
+        away = f"● {self.state.away.short}"
+        c.put(x + max(2, w - len(away) - 2), legend_y, away, Style(BLUE, PANEL, bold=True))
+        if self.state.momentum:
+            c.put(x + 2, legend_y + 1, "MOMENTUM", Style(MUTED, PANEL, bold=True))
+            self._momentum(c, x + 2, legend_y + 2, w - 4, show_labels=False)
+
+    def _stat_row(self, c: Canvas, x: int, y: int, w: int, label: str, values: dict[str, str]) -> None:
+        home = values.get("home", "0")
+        away = values.get("away", "0")
+        c.put(x, y, f"{home:>5}", Style(GREEN, PANEL, bold=True))
+        c.put(x + max(7, (w - len(label)) // 2), y, label, Style(MUTED, PANEL), w - 14)
+        c.put(x + w - 5, y, f"{away:<5}", Style(BLUE, PANEL, bold=True))
+        try:
+            hv, av = float(home), float(away)
+        except ValueError:
+            hv = av = 0
+        total = max(hv + av, 1)
+        bar_w = max(4, w - 14)
+        home_w = int(bar_w * hv / total)
+        c.put(x + 7, y + 1, "━" * home_w, Style(GREEN, PANEL))
+        c.put(x + 7 + home_w, y + 1, "━" * (bar_w - home_w), Style(BLUE, PANEL))
+
+    def _stats(self, c: Canvas, y: int, h: int) -> None:
+        c.box(1, y, c.width - 2, h, "Team statistics")
+        c.put(4, y + 1, self.state.home.name, Style(GREEN, PANEL, bold=True), c.width // 3)
+        away = self.state.away.name
+        c.put(max(4, c.width - len(away) - 4), y + 1, away, Style(BLUE, PANEL, bold=True))
+        preferred = list(STAT_LABELS)
+        keys = [key for key in preferred if key in self.state.stats]
+        keys += [key for key in self.state.stats if key not in keys]
+        row = y + 3
+        for key in keys[self.scroll:]:
+            if row >= y + h - 1:
+                break
+            self._stat_row(c, 4, row, c.width - 8, STAT_LABELS.get(key, key.replace("_", " ").title()), self.state.stats[key])
+            row += 2
+        if not keys:
+            self._empty(c, 1, y, c.width - 2, h, "Stats will appear as play develops")
+
+    def _lineups(self, c: Canvas, y: int, h: int) -> None:
+        gap = 1
+        width = (c.width - 3 - gap) // 2
+        self._squad(c, 1, y, width, h, "home")
+        self._squad(c, 2 + width, y, c.width - width - 3, h, "away")
+
+    def _squad(self, c: Canvas, x: int, y: int, w: int, h: int, side: str) -> None:
+        team = self.state.home if side == "home" else self.state.away
+        accent = GREEN if side == "home" else BLUE
+        c.box(x, y, w, h, f"{team.name} · {self.state.formations.get(side, '')}")
+        starters = self.state.lineups.get("lineups", {}).get(side, [])
+        bench = self.state.lineups.get("bench", {}).get(side, [])
+        rows = [("STARTING XI", None)] + [("", p) for p in starters] + [("BENCH", None)] + [("", p) for p in bench]
+        row = y + 2
+        for label, player in rows[self.scroll:]:
+            if row >= y + h - 1:
+                break
+            if player is None:
+                c.put(x + 2, row, label, Style(MUTED, PANEL, bold=True), w - 4)
+            else:
+                number = str(player.get("sn", ""))
+                name = str(player.get("pn") or player.get("pns") or "—")
+                c.put(x + 2, row, f"{number:>2}", Style(accent, PANEL, bold=True))
+                c.put(x + 6, row, name, Style(TEXT, PANEL), w - 8)
+            row += 1
+        if not starters:
+            self._empty(c, x, y, w, h, "Lineups not announced")
+
+    def _formation(self, c: Canvas, y: int, h: int) -> None:
+        gap = 1
+        width = (c.width - 3 - gap) // 2
+        self._pitch(c, 1, y, width, h, "home")
+        self._pitch(c, 2 + width, y, c.width - width - 3, h, "away")
+
+    def _pitch(self, c: Canvas, x: int, y: int, w: int, h: int, side: str) -> None:
+        team = self.state.home if side == "home" else self.state.away
+        accent = GREEN if side == "home" else BLUE
+        formation = self.state.formations.get(side, "")
+        c.box(x, y, w, h, f"{team.name} · {formation or 'TBC'}")
+        players = self.state.lineups.get("lineups", {}).get(side, [])
+        if not players:
+            self._empty(c, x, y, w, h, "Formation not available")
+            return
+        inner_h = h - 3
+        c.fill(x + 2, y + 2, w - 4, inner_h, Style(TEXT, "#123323"))
+        c.put(x + 2, y + 2 + inner_h // 2, "─" * (w - 4), Style("#2d664a", "#123323"))
+        groups: list[list[dict]] = []
+        for player in players:
+            pos = int(player.get("so", 0) or 0)
+            while len(groups) <= pos:
+                groups.append([])
+            groups[pos].append(player)
+        groups = [group for group in groups if group]
+        for group_index, group in enumerate(groups):
+            py = y + 3 + int(group_index * max(1, inner_h - 2) / max(1, len(groups) - 1))
+            for index, player in enumerate(group):
+                name = str(player.get("pns") or player.get("pn") or "—")
+                if w < 48:
+                    name = name.split()[-1][:8]
+                slot = (w - 6) / len(group)
+                px = x + 3 + int((index + 0.5) * slot - len(name) / 2)
+                c.put(px, py, name, Style(TEXT, "#123323", bold=True), int(slot))
+                c.put(max(x + 2, px - 2), py, "●", Style(accent, "#123323", bold=True))
+
+    def _players(self, c: Canvas, y: int, h: int) -> None:
+        c.box(1, y, c.width - 2, h, "Player statistics")
+        headers = "PLAYER                         TEAM      MIN    RATING     xG    G    A"
+        c.put(3, y + 2, headers, Style(MUTED, PANEL, bold=True), c.width - 6)
+        row = y + 4
+        for player in self.state.player_stats[self.scroll:]:
+            if row >= y + h - 1:
+                break
+            name = str(player.get("pn") or player.get("participant_name") or "—")
+            team = str(player.get("tn") or player.get("team_name") or "—")
+            values = [player.get(key, player.get(f"sd_{key}", "0")) for key in ("min", "rating", "expected_goal", "goals", "assists")]
+            line = f"{name:<30} {team:<9} {str(values[0]):>4} {str(values[1]):>9} {str(values[2]):>6} {str(values[3]):>4} {str(values[4]):>4}"
+            c.put(3, row, line, Style(TEXT, PANEL), c.width - 6)
+            row += 1
+        if not self.state.player_stats:
+            self._empty(c, 1, y, c.width - 2, h, "Player ratings appear once enough match data is collected")
+
+    def _h2h(self, c: Canvas, y: int, h: int) -> None:
+        c.box(1, y, c.width - 2, h, "Head to head · last meetings")
+        games = self.state.h2h.get("h2h", [])
+        row = y + 2
+        for game in games[self.scroll:]:
+            if row >= y + h - 1:
+                break
+            date = game.get("date", "")
+            home, away = game.get("home", "—"), game.get("away", "—")
+            score = f"{game.get('home_score', '–')} : {game.get('away_score', '–')}"
+            c.put(3, row, date, Style(MUTED, PANEL))
+            centre = c.width // 2
+            c.put(max(15, centre - len(str(home)) - 6), row, home, Style(TEXT, PANEL, bold=True))
+            c.put(centre - 3, row, score, Style(LIME, PANEL, bold=True))
+            c.put(centre + 5, row, away, Style(TEXT, PANEL, bold=True), c.width - centre - 8)
+            row += 2
+        if not games:
+            self._empty(c, 1, y, c.width - 2, h, "No previous meetings found")
+
+    def _bracket(self, c: Canvas, y: int, h: int) -> None:
+        c.box(1, y, c.width - 2, h, "Road to the final")
+        rounds = sorted(self.state.bracket.items(), key=lambda item: -len(item[1]))
+        if not rounds:
+            self._empty(c, 1, y, c.width - 2, h, "Tournament bracket not available")
+            return
+        columns = min(len(rounds), 3 if c.width >= 100 else 2)
+        col_w = (c.width - 6) // columns
+        for col, (round_name, games) in enumerate(rounds[-columns:]):
+            x = 3 + col * col_w
+            c.put(x, y + 2, round_name.upper(), Style(MUTED, PANEL, bold=True), col_w - 2)
+            row = y + 4
+            for game in games:
+                if row + 2 >= y + h:
+                    break
+                home = str(game.get("home", "—"))
+                away = str(game.get("away", "—"))
+                c.put(x, row, home, Style(TEXT, PANEL), col_w - 7)
+                c.put(x + col_w - 5, row, str(game.get("home_score", "–")), Style(LIME, PANEL, bold=True))
+                c.put(x, row + 1, away, Style(TEXT, PANEL), col_w - 7)
+                c.put(x + col_w - 5, row + 1, str(game.get("away_score", "–")), Style(LIME, PANEL, bold=True))
+                c.put(x, row + 2, "─" * max(2, col_w - 3), Style(LINE, PANEL))
+                row += 4
+
+    def _empty(self, c: Canvas, x: int, y: int, w: int, h: int, message: str) -> None:
+        px = max(x + 2, x + (w - len(message)) // 2)
+        c.put(px, y + h // 2, message, Style(MUTED, PANEL), w - 4)
+
+
+def strip_ansi(value: str) -> str:
+    return re.sub(r"\x1b\[[0-9;]*m", "", value)