air-status 0.1.0__tar.gz

air_status-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max
+
+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.

air_status-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: air-status
+Version: 0.1.0
+Summary: Live in-flight status from airline Wi-Fi portals, with a terminal map and flight history
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/max2697/air-status
+Project-URL: Issues, https://github.com/max2697/air-status/issues
+Keywords: flight,in-flight wifi,terminal,tui,map,aviation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# air-status
+
+Live flight status in the terminal while you're on board, read from the airline's
+in-flight Wi-Fi portal: altitude, speed, ETA, a Braille map of the route, and a
+saved history of every flight.
+
+![air-status live view: route bar, flight stats and a Braille map of the flown path](https://raw.githubusercontent.com/max2697/air-status/main/docs/screenshot.png)
+
+<sub>Made-up flight. Regenerate with `.venv/bin/python scripts/screenshot.py`.</sub>
+
+## Install
+
+```bash
+pipx install air-status        # or: pip install air-status
+air-status
+```
+
+From a checkout, for development:
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e '.[dev]'
+```
+
+## Use
+
+```bash
+.venv/bin/air-status                     # live view, airline detected from the Wi-Fi, saves history
+.venv/bin/air-status live -p aircanada --every 10
+.venv/bin/air-status live -p american     # American Airlines (Viasat aircraft)
+.venv/bin/air-status history             # list saved flights
+```
+
+Run it in a real terminal for the live full-screen view. In a plain output window
+(e.g. PyCharm's Run tab) it prints one frame per update instead.
+
+Files go in the current folder (change with `--data-dir`):
+
+- `history/<provider>/` — one file per flight, in that provider's own format.
+  Air Canada (Gogo) stores the raw portal data as change-only JSON Lines: the
+  first line is the full reading, later lines hold only the fields that changed.
+  Your device's IP/MAC address is never saved.
+  American Airlines stores the Viasat flight feed plus the route's airport
+  locations (looked up once from the portal) in the same change-only format.
+  Its feed has no vertical speed, so climb/descent is worked out from the
+  altitude change over the last minute (and saved too).
+- `mapdata/` — map outlines from [Natural Earth](https://www.naturalearthdata.com/),
+  downloaded on first run.
+
+The map draws the flown path from history (solid red). Where there is no history,
+such as before recording started or during gaps over 60 s, it draws an estimated
+shortest-path line between the known points (dashed red).
+
+## Adding an airline
+
+Providers live in `src/air_status/providers/`. A provider:
+
+- `fetch()` — gets a raw reading from its portal,
+- `parse(reading)` — turns it into the shared `FlightStatus` (`models.py`),
+- `history(directory)` — returns its `FlightHistory` (`flightlog.py`), which
+  decides how readings are written and read back. Reuse `ChangeLog` for
+  change-only JSON Lines, or implement your own format.
+
+Auto-detect (the default, `-p auto`) asks every provider's portal at once via
+`detect()` and uses the first that returns flight data. The default `detect()`
+is "fetch and parse succeed"; override it when portals are shared (Gogo
+providers also check `airline_code`).
+
+Same Wi-Fi system as an existing provider (e.g. another Gogo/Intelsat airline):
+subclass it and set `id`, `name` and `airline_code`, like `aircanada.py`. Then add an instance
+to `PROVIDERS` in `providers/__init__.py`.
+
+## Tests and lint
+
+```bash
+.venv/bin/pytest
+.venv/bin/ruff check .
+.venv/bin/ruff format .
+```
+
+GitHub Actions (`.github/workflows/ci.yml`) runs the same lint plus tests on
+Python 3.9–3.14 for every push to `main` and every pull request.
+
+## Releasing
+
+1. Bump `__version__` in `src/air_status/__init__.py` and commit.
+2. Tag and push: `git tag v0.2.0 && git push origin v0.2.0`.
+
+`.github/workflows/release.yml` checks the tag matches the version, runs lint
+and tests, builds the package, publishes it to PyPI (trusted publishing, no
+token) and creates a GitHub release with the built files.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

air_status-0.1.0/README.md

@@ -0,0 +1,95 @@
+# air-status
+
+Live flight status in the terminal while you're on board, read from the airline's
+in-flight Wi-Fi portal: altitude, speed, ETA, a Braille map of the route, and a
+saved history of every flight.
+
+![air-status live view: route bar, flight stats and a Braille map of the flown path](https://raw.githubusercontent.com/max2697/air-status/main/docs/screenshot.png)
+
+<sub>Made-up flight. Regenerate with `.venv/bin/python scripts/screenshot.py`.</sub>
+
+## Install
+
+```bash
+pipx install air-status        # or: pip install air-status
+air-status
+```
+
+From a checkout, for development:
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e '.[dev]'
+```
+
+## Use
+
+```bash
+.venv/bin/air-status                     # live view, airline detected from the Wi-Fi, saves history
+.venv/bin/air-status live -p aircanada --every 10
+.venv/bin/air-status live -p american     # American Airlines (Viasat aircraft)
+.venv/bin/air-status history             # list saved flights
+```
+
+Run it in a real terminal for the live full-screen view. In a plain output window
+(e.g. PyCharm's Run tab) it prints one frame per update instead.
+
+Files go in the current folder (change with `--data-dir`):
+
+- `history/<provider>/` — one file per flight, in that provider's own format.
+  Air Canada (Gogo) stores the raw portal data as change-only JSON Lines: the
+  first line is the full reading, later lines hold only the fields that changed.
+  Your device's IP/MAC address is never saved.
+  American Airlines stores the Viasat flight feed plus the route's airport
+  locations (looked up once from the portal) in the same change-only format.
+  Its feed has no vertical speed, so climb/descent is worked out from the
+  altitude change over the last minute (and saved too).
+- `mapdata/` — map outlines from [Natural Earth](https://www.naturalearthdata.com/),
+  downloaded on first run.
+
+The map draws the flown path from history (solid red). Where there is no history,
+such as before recording started or during gaps over 60 s, it draws an estimated
+shortest-path line between the known points (dashed red).
+
+## Adding an airline
+
+Providers live in `src/air_status/providers/`. A provider:
+
+- `fetch()` — gets a raw reading from its portal,
+- `parse(reading)` — turns it into the shared `FlightStatus` (`models.py`),
+- `history(directory)` — returns its `FlightHistory` (`flightlog.py`), which
+  decides how readings are written and read back. Reuse `ChangeLog` for
+  change-only JSON Lines, or implement your own format.
+
+Auto-detect (the default, `-p auto`) asks every provider's portal at once via
+`detect()` and uses the first that returns flight data. The default `detect()`
+is "fetch and parse succeed"; override it when portals are shared (Gogo
+providers also check `airline_code`).
+
+Same Wi-Fi system as an existing provider (e.g. another Gogo/Intelsat airline):
+subclass it and set `id`, `name` and `airline_code`, like `aircanada.py`. Then add an instance
+to `PROVIDERS` in `providers/__init__.py`.
+
+## Tests and lint
+
+```bash
+.venv/bin/pytest
+.venv/bin/ruff check .
+.venv/bin/ruff format .
+```
+
+GitHub Actions (`.github/workflows/ci.yml`) runs the same lint plus tests on
+Python 3.9–3.14 for every push to `main` and every pull request.
+
+## Releasing
+
+1. Bump `__version__` in `src/air_status/__init__.py` and commit.
+2. Tag and push: `git tag v0.2.0 && git push origin v0.2.0`.
+
+`.github/workflows/release.yml` checks the tag matches the version, runs lint
+and tests, builds the package, publishes it to PyPI (trusted publishing, no
+token) and creates a GitHub release with the built files.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

air_status-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "air-status"
+dynamic = ["version"]
+description = "Live in-flight status from airline Wi-Fi portals, with a terminal map and flight history"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = ["rich>=13"]
+keywords = ["flight", "in-flight wifi", "terminal", "tui", "map", "aviation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/max2697/air-status"
+Issues = "https://github.com/max2697/air-status/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "ruff>=0.6", "build>=1", "twine>=5"]
+
+[project.scripts]
+air-status = "air_status.cli:main"
+
+[tool.setuptools.dynamic]
+version = { attr = "air_status.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP"]

air_status-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

air_status-0.1.0/src/air_status/__init__.py

@@ -0,0 +1,3 @@
+"""Live in-flight status from airline Wi-Fi portals, with a terminal map and flight history."""
+
+__version__ = "0.1.0"

air_status-0.1.0/src/air_status/__main__.py

@@ -0,0 +1,4 @@
+from air_status.cli import main
+
+if __name__ == "__main__":
+    main()

air_status-0.1.0/src/air_status/braille.py

@@ -0,0 +1,70 @@
+"""Braille-dot canvas: each terminal cell holds a 2x4 grid of dots."""
+
+from typing import Optional
+
+from rich.text import Text
+
+# Braille dot bit for (x, y) inside a 2x4 cell
+_BITS = ((0x01, 0x02, 0x04, 0x40), (0x08, 0x10, 0x20, 0x80))
+
+
+class Canvas:
+    """Draw dots and lines in dot coordinates (width*2 x height*4), render as rich Text."""
+
+    def __init__(self, width: int, height: int):
+        self.width, self.height = width, height
+        self.bits = [[0] * width for _ in range(height)]
+        self.style: list = [[None] * width for _ in range(height)]
+        self.prio = [[0] * width for _ in range(height)]
+        self.chars: dict[tuple[int, int], tuple[str, Optional[str]]] = {}
+
+    def copy(self) -> "Canvas":
+        c = Canvas(self.width, self.height)
+        c.bits = [row[:] for row in self.bits]
+        c.style = [row[:] for row in self.style]
+        c.prio = [row[:] for row in self.prio]
+        c.chars = dict(self.chars)
+        return c
+
+    def dot(self, x: float, y: float, style: Optional[str], prio: int = 0) -> None:
+        """Set one dot. When layers share a cell, the higher priority picks its colour."""
+        x, y = int(x), int(y)
+        if 0 <= x < self.width * 2 and 0 <= y < self.height * 4:
+            cx, cy = x // 2, y // 4
+            self.bits[cy][cx] |= _BITS[x % 2][y % 4]
+            if prio >= self.prio[cy][cx]:
+                self.style[cy][cx], self.prio[cy][cx] = style, prio
+
+    def line(self, x0: float, y0: float, x1: float, y1: float, style: Optional[str], prio: int = 0) -> None:
+        w, h = self.width * 2, self.height * 4
+        if (x0 < 0 and x1 < 0) or (y0 < 0 and y1 < 0) or (x0 >= w and x1 >= w) or (y0 >= h and y1 >= h):
+            return  # fully off-screen
+        n = int(max(abs(x1 - x0), abs(y1 - y0))) + 1
+        for i in range(n + 1):
+            t = i / n
+            self.dot(x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, style, prio)
+
+    def overlay(self, other: "Canvas") -> None:
+        """Replace this canvas's cells with every non-empty cell of `other`."""
+        for y in range(self.height):
+            for x in range(self.width):
+                if other.bits[y][x]:
+                    self.bits[y][x], self.style[y][x] = other.bits[y][x], other.style[y][x]
+
+    def text(self, cx: int, cy: int, s: str, style: Optional[str]) -> None:
+        """Write plain characters in cell coordinates (labels, icons)."""
+        for i, ch in enumerate(s):
+            if 0 <= cx + i < self.width and 0 <= cy < self.height:
+                self.chars[(cx + i, cy)] = (ch, style)
+
+    def to_text(self) -> Text:
+        out = Text()
+        for y in range(self.height):
+            for x in range(self.width):
+                if (x, y) in self.chars:
+                    out.append(*self.chars[(x, y)])
+                else:
+                    out.append(chr(0x2800 + self.bits[y][x]), self.style[y][x])
+            if y < self.height - 1:
+                out.append("\n")
+        return out

air_status-0.1.0/src/air_status/cli.py

@@ -0,0 +1,69 @@
+"""Command line: `air-status` (live view) and `air-status history`."""
+
+import argparse
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+
+from air_status import __version__
+from air_status.flight_map import FlightMap
+from air_status.providers import AUTO, PROVIDERS, Provider, detect_provider, get_provider
+from air_status.tui import Poller, history_table, run_live
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="air-status", description="Live in-flight status with map and history.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--data-dir", type=Path, default=Path.cwd(), help="folder for history/ and mapdata/ (default: current folder)"
+    )
+    sub = parser.add_subparsers(dest="command")
+    live = sub.add_parser("live", help="live view, saves history (default)")
+    live.add_argument(
+        "-p",
+        "--provider",
+        choices=[AUTO, *sorted(PROVIDERS)],
+        default=AUTO,
+        help="airline / Wi-Fi system (default: auto, detected from the Wi-Fi you're on)",
+    )
+    live.add_argument(
+        "--every", type=int, metavar="SECONDS", help="refresh interval (default: the provider's own update rate)"
+    )
+    sub.add_parser("history", help="list saved flights")
+    return parser
+
+
+def pick_provider(provider_id: str) -> Optional[Provider]:
+    if provider_id != AUTO:
+        return get_provider(provider_id)
+    print("Looking for an in-flight Wi-Fi portal…", flush=True)
+    provider = detect_provider()
+    if provider is None:
+        names = ", ".join(p.name for p in PROVIDERS.values())
+        print(f"No in-flight Wi-Fi portal found (tried {names}). Connect to the plane's Wi-Fi or pick one with -p.")
+    else:
+        print(f"Detected {provider.name}.", flush=True)
+    return provider
+
+
+def main(argv: Optional[list[str]] = None) -> None:
+    args = build_parser().parse_args(argv)
+    history_dir = args.data_dir / "history"
+    try:
+        if args.command == "history":
+            table = history_table([p.history(history_dir / p.id) for p in PROVIDERS.values()])
+            if table is None:
+                print("No saved flights yet.")
+            else:
+                Console().print(table)
+                print(f"Files: {history_dir}")
+        else:
+            provider = pick_provider(getattr(args, "provider", AUTO))
+            if provider is None:
+                raise SystemExit(1)
+            every = getattr(args, "every", None) or provider.update_interval
+            poller = Poller(provider, provider.history(history_dir / provider.id), every)
+            run_live(poller, FlightMap(args.data_dir / "mapdata"))
+    except KeyboardInterrupt:
+        pass

air_status-0.1.0/src/air_status/flight_map.py

@@ -0,0 +1,206 @@
+"""Terminal map of a flight: Natural Earth outlines, route and plane on a Braille canvas."""
+
+import json
+import math
+import urllib.request
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from rich.text import Text
+
+from air_status.braille import Canvas
+from air_status.geo import LatLon, bearing_deg, distance_km, great_circle
+from air_status.models import FlightStatus
+
+SOURCE_URL = "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/v5.1.2/geojson/{}.geojson"
+# (dataset, style, priority) — a higher priority wins the colour of a shared cell
+LAYERS = (
+    ("ne_50m_admin_1_states_provinces_lines", "grey27", 1),
+    ("ne_50m_admin_0_boundary_lines_land", "grey58", 2),
+    ("ne_50m_lakes", "dodger_blue3", 3),
+    ("ne_50m_coastline", "dodger_blue3", 3),
+)
+MAX_LAKE_RANK = 2  # only big lakes; small ones are noise at this scale
+
+Path_ = list[list[float]]
+
+
+def _paths(coords) -> list[Path_]:
+    """Every [[lon, lat], ...] list inside any GeoJSON geometry."""
+    if coords and isinstance(coords[0][0], (int, float)):
+        return [coords]
+    return [p for c in coords for p in _paths(c)]
+
+
+def load_layers(map_dir: Path) -> list[tuple[list[Path_], str, int]]:
+    """Load outlines, downloading each dataset once into map_dir."""
+    map_dir.mkdir(parents=True, exist_ok=True)
+    layers = []
+    for name, style, prio in LAYERS:
+        path = map_dir / f"{name}.geojson"
+        if not path.exists():
+            urllib.request.urlretrieve(SOURCE_URL.format(name), path)
+        features = json.loads(path.read_text())["features"]
+        if name == "ne_50m_lakes":
+            features = [f for f in features if f["properties"].get("scalerank", 9) <= MAX_LAKE_RANK]
+        layers.append(([p for f in features for p in _paths(f["geometry"]["coordinates"])], style, prio))
+    return layers
+
+
+PLANE_ARROWS = "↑↗→↘↓↙←↖"  # terminals can't rotate ✈, so the map points with an arrow
+
+
+def plane_glyph(dx: float, dy: float) -> str:
+    """Arrow for a direction on screen (dy grows downwards)."""
+    if not dx and not dy:
+        return "✈"
+    angle = math.degrees(math.atan2(dx, -dy)) % 360  # clockwise from screen-up
+    return PLANE_ARROWS[round(angle / 45) % 8]
+
+
+def heading_of(status: FlightStatus) -> float:
+    """Reported heading, else the direction towards the destination."""
+    if status.heading is not None:
+        return status.heading
+    return bearing_deg(status.latitude, status.longitude, status.destination.latitude, status.destination.longitude)
+
+
+MAX_RECORDED_GAP = 60  # seconds; longer gaps between saved points are drawn as estimated
+
+
+@dataclass
+class Leg:
+    """Part of the flown path: `recorded` legs come from history, the rest are estimated."""
+
+    points: list[LatLon]
+    recorded: bool
+
+
+def geoline(a: LatLon, b: LatLon, step_km: float = 20) -> list[LatLon]:
+    """Shortest path on the globe from a to b, one point per `step_km`."""
+    n = max(1, int(distance_km(*a, *b) / step_km))
+    return great_circle(*a, *b, n=n)
+
+
+def flown_legs(status: FlightStatus, track: Sequence[FlightStatus] = ()) -> list[Leg]:
+    """Path from the origin to the current position.
+
+    Consecutive saved points less than MAX_RECORDED_GAP apart are joined as recorded;
+    everything else (origin → first point, gaps, no history at all) is a geoline
+    between the two known points, marked as estimated.
+    """
+    known: list[tuple[LatLon, Optional[datetime]]] = [((status.origin.latitude, status.origin.longitude), None)]
+    known += [((t.latitude, t.longitude), t.time) for t in track if t.time <= status.time]
+    if known[-1][1] != status.time:
+        known.append(((status.latitude, status.longitude), status.time))
+
+    legs: list[Leg] = []
+    for (a, ta), (b, tb) in zip(known, known[1:]):
+        recorded = ta is not None and tb is not None and (tb - ta).total_seconds() <= MAX_RECORDED_GAP
+        if recorded and legs and legs[-1].recorded:
+            legs[-1].points.append(b)  # extend the current recorded run
+        elif recorded:
+            legs.append(Leg([a, b], True))
+        else:
+            legs.append(Leg(geoline(a, b), False))
+    return legs
+
+
+class FlightMap:
+    """Draws the base map once per route and size, then overlays route and plane each frame."""
+
+    def __init__(self, map_dir: Path):
+        self.map_dir = map_dir
+        self._layers: Optional[list] = None
+        self._key: Optional[tuple] = None
+        self._base: Optional[Canvas] = None
+        self._route_key: Optional[tuple] = None
+        self._route: Optional[Canvas] = None
+
+    def _setup(self, status: FlightStatus, width: int, height: int) -> None:
+        if self._layers is None:
+            self._layers = load_layers(self.map_dir)
+        o, d = status.origin, status.destination
+        route = great_circle(o.latitude, o.longitude, d.latitude, d.longitude)
+        lats = [p[0] for p in route]
+        lons = [p[1] for p in route]
+        mid_lat = (max(lats) + min(lats)) / 2
+        mid_lon = (max(lons) + min(lons)) / 2
+        kx = math.cos(math.radians(mid_lat))  # squash longitude so shapes look right
+        pw, ph = width * 2, height * 4
+        span_x = (max(lons) - min(lons)) * kx * 1.3 + 1
+        span_y = (max(lats) - min(lats)) * 1.3 + 1
+        scale = min(pw / span_x, ph / span_y)
+
+        def project(lat: float, lon: float) -> tuple[float, float]:
+            return pw / 2 + (lon - mid_lon) * kx * scale, ph / 2 - (lat - mid_lat) * scale
+
+        self._project = project
+        base = Canvas(width, height)
+        for paths, style, prio in self._layers:
+            for path in paths:
+                pts = [project(lat, lon) for lon, lat, *_ in path]
+                for (x0, y0), (x1, y1) in zip(pts, pts[1:]):
+                    base.line(x0, y0, x1, y1, style, prio)
+        self._base = base
+
+    def _draw_route(self, status: FlightStatus, track: Sequence[FlightStatus], width: int, height: int) -> Canvas:
+        project = self._project
+        here = (status.latitude, status.longitude)
+        dst = (status.destination.latitude, status.destination.longitude)
+        route = Canvas(width, height)
+
+        ahead = [project(*p) for p in geoline(here, dst)]
+        for i, ((x0, y0), (x1, y1)) in enumerate(zip(ahead, ahead[1:])):
+            if i % 2 == 0:  # dashed remaining leg
+                route.line(x0, y0, x1, y1, "bright_white", 8)
+
+        for leg in flown_legs(status, track):
+            pts = [project(*p) for p in leg.points]
+            for i, ((x0, y0), (x1, y1)) in enumerate(zip(pts, pts[1:])):
+                if leg.recorded:
+                    route.line(x0, y0, x1, y1, "bold red", 10)
+                elif i % 2 == 0:  # dashed: estimated, not from history
+                    route.line(x0, y0, x1, y1, "red3", 9)
+        return route
+
+    def render(self, status: FlightStatus, width: int, height: int, track: Sequence[FlightStatus] = ()) -> Text:
+        """Map for one status, `width` x `height` terminal cells.
+
+        `track` is this flight's saved history; without it the flown path is estimated.
+        """
+        dep_code, dst_code = status.origin.code, status.destination.code
+        key = (dep_code, dst_code, width, height)
+        if key != self._key:
+            self._setup(status, width, height)
+            self._key = key
+        route_key = (key, status.time, len(track))
+        if route_key != self._route_key:  # redraw the route only when data changes
+            self._route = self._draw_route(status, track, width, height)
+            self._route_key = route_key
+        canvas = self._base.copy()
+        canvas.overlay(self._route)  # route stays crisp over borders
+        project = self._project
+        here = (status.latitude, status.longitude)
+        dep = (status.origin.latitude, status.origin.longitude)
+        dst = (status.destination.latitude, status.destination.longitude)
+
+        for code, (lat, lon) in ((dep_code, dep), (dst_code, dst)):
+            x, y = project(lat, lon)
+            cx, cy = int(x) // 2, int(y) // 4
+            canvas.text(cx, cy, "●", "bold white")
+            label = f" {code} "
+            lx = cx + 2 if cx + 2 + len(label) <= width else cx - 1 - len(label)
+            canvas.text(lx, cy, label, "bold white on red")
+
+        x, y = project(*here)
+        # Step a little along the heading and see which way that goes on screen
+        h = math.radians(heading_of(status))
+        step = 0.1  # degrees
+        ahead_lon = status.longitude + step * math.sin(h) / max(0.01, math.cos(math.radians(status.latitude)))
+        ax, ay = project(status.latitude + step * math.cos(h), ahead_lon)
+        canvas.text(int(x) // 2, int(y) // 4, plane_glyph(ax - x, ay - y), "bold yellow")
+        return canvas.to_text()