Cache what has been looked up, make it browsable, and say where this lives

Four things asked for in turn, landing together because they run through the
same files.

THE MAPS.  The tiles were already cached and always had been -- a second
evening on the same view was measured at nought network requests -- but the
work done on them was not.  Every window open decoded forty PNGs and resampled
a megapixel and a half into this program's own projection, for an answer that
cannot have changed, because a coastline does not move.  The finished map is
kept beside the tiles now: 0.61 seconds become 0.01, byte for byte identical,
two hundred kilobytes a view.  Both windows and both kinds of still picture get
it, all four reaching the ground through one function.  A map with squares
missing is deliberately not kept, since caching a hole would keep it for a
month and the point of calling a partial map provisional is that it is asked
for again.  And because this adds a disk consumer, the whole cache is now
pruned to four hundred megabytes, least recently *used* first: a tile fetched a
year ago and looked at last night is the receiver's own neighbourhood, and
discarding that to keep last week's holiday is the wrong way round.

THE LOOKUPS.  APRS and FT8 now ask who each station is licensed to.  Every
other mode that hears a callsign already did -- speech transcripts, Morse
idents, the recording browser -- and all five resolve through one file, so a
callsign heard on two bands is asked about once.  The rules for finding the
licensed callsign inside a heard one are now in one place rather than per band,
because getting them wrong is silent: a register asked about W1AW-9 returns
nothing, which looks exactly like a station that is not licensed.  An SSID, a
rover suffix, a guest prefix, a digipeater alias and an unspelled hash all come
off or are refused.

The bug worth recording is that the first cut of this did the lookups and threw
them away.  The book has to be told to save and was not, so every evening would
have asked the register about the same net again -- which is the one thing
caching them was for, and is invisible from inside a single run because the
answers are all in memory while it lasts.  Caught by looking at the file on
disk rather than at the display.  There is a test for each side of it now, and a
register of which modules resolve callsigns at all, which fails when a new one
starts so that somebody has to decide whether it should.

THE REGISTER.  c in saunterbrowse opens everything ever looked up: sixty-odd
callsigns and sixteen hundred aircraft here, every field of each in two columns
because a licence has a dozen and a screen is wider than it is tall.  tab
switches, / searches every field rather than the name -- the question is
usually "who was in Arizona" rather than "which callsign" -- and g opens the
place in a browser.  Only the coordinates go into that link: a map does not
need to be told whose licence it is looking at, and the link is the one part of
this that leaves the machine.  A headless box, which is the normal case for a
receiver, gets the coordinates printed instead.  Callsigns no register could
place are kept rather than dropped, because "asked about, and in no register
reachable from here" is a fact about a station.

THE FRONT OF IT.  A title screen for each program: five rows of blocks cut by
hand, a figlet dependency to draw eleven letters being the largest thing that
would then be in the requirements, coloured blue to red across the width, which
is the ramp every waterfall here already uses because it is what a spectrum
looks like.  The interesting part is where it does not appear -- everything
here can be piped into something else and a banner in the middle of that is
corruption rather than decoration, so anything that is not a terminal gets
nothing, --help is untouched because it is drawn after parsing, --no-splash
turns it off for a run and BANDSAUNTER_NO_SPLASH=1 for good.

And the address.  INSTALL.md said "git clone <the repository>" for a long time:
a placeholder in the first command anybody types, unnoticed because nothing
reads install instructions except somebody installing, who then cannot.  It is
filled in, along with the readme, the metadata, both manuals and the Homepage
field of all three packages.  The tile server's User-Agent pointed at a topic
listing on somebody else's site for want of an address of its own; the usage
policy of that service asks for one naming the application and giving somewhere
to look it up, so an operator with a question about the traffic has somebody to
ask, and now it gives the real one.  Seven tests so the placeholder cannot come
back, verified by putting it back and watching two of them fail.

One thing forced by all this: the keys page in saunterbrowse was exactly as
tall as an eighty-by-twenty-four terminal, so the register entry pushed "q
quit" off the bottom.  A test caught it.  Home and End have merged into the
Page Up line, which were always the same thought.

THE WINDOWS.  They open maximised now, this being a map and the thing anybody
wants more of being map; f goes to true full screen and back, and is written
along the top of the screen because a window with no frame is one somebody has
to know a key to get out of.  Maximised rather than frameless by default,
because the title bar is where the band and the frequency are written.

And a map made bigger now gets a sharper map, which it did not.  The window
only ever re-examined the ground when the view left the box that had been
fetched, so a window opened at its default size and taken to the whole screen
kept the map it started with until an aircraft wandered far enough to move it
-- on a quiet band, a long time to look at a blurred coastline.  Measured
before it was believed: 1100 to 1920 asked for nothing and stretched a
1364-pixel map across 1920, then across 3840.  It now compares map pixels per
degree in hand against what the view wants, and asks when it is being blown up
by more than fifteen per cent.

That comparison has to be per degree rather than pixel against pixel, which a
surviving mutation was what established: the fetched box is a quarter wider
than the view, so a map with exactly as many pixels as the window is wide has
only four fifths of them on the screen.  The two ways of measuring agree
everywhere except a narrow band, and the realistic case sits inside it.  There
is a test pinning that case now.  Asking is safe at any size, because the
request is keyed on the window's dimensions: once answered, nothing more is
asked, which is what stops a window larger than the tile budget can cover from
asking all evening.

The braille, while this was open.  The banners were blocks in capitals; they
are braille in mixed case, two dots wide and four tall to a character, which is
eight times the detail and is what makes room for two heights of letter at
once -- a five-row block font has no second height to spend, so the name came
out shouted.  Two attempts failed first: thin one-dot strokes came out as
confetti, because braille dots render as dots and a one-dot stroke reads as a
dotted line rather than a line.  What worked was cutting the font small, at cap
height seven where there is only one way to draw each letter, and doubling it.
Coloured deep blue through cyan to a cool white, which is deliberately not the
waterfall ramp the rest of the program draws in: that one has to run to red
because it stands in for a spectrum, and a title screen stands in for nothing.

One hundred and four new tests.  Full suite 2892 passed.  Built as
2026-09-24_01.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016PsWPTweCT6pwxKngvVxcg

tests/test_splash.py

@@ -0,0 +1,239 @@
+"""The title screen.
+
+Most of what matters here is when it does *not* appear.  Everything in this
+program can be piped into something else, and a banner in the middle of a
+table somebody is parsing is corruption rather than decoration.
+"""
+from rich.console import Console
+
+from bandsaunter import splash
+
+
+def _plain(console: Console, drawing) -> str:
+    with console.capture() as caught:
+        drawing()
+    return caught.get()
+
+
+# ---------------------------------------------------------------------------
+# The drawing
+# ---------------------------------------------------------------------------
+
+def test_both_names_come_out_as_four_rows_of_braille():
+    for word in (splash.SCANNER_NAME, splash.BROWSER_NAME):
+        rows = splash.banner(word)
+        assert len(rows) == splash.ROWS
+        assert all(all(0x2800 <= ord(c) <= 0x28FF for c in row)
+                   for row in rows), "something in there is not braille"
+        assert any(c != "\u2800" for row in rows for c in row)
+
+
+def test_the_names_are_written_the_way_they_are_spelled():
+    """Not shouted.  Braille gives four times the vertical detail a block
+    does, which is what makes room for two heights of letter at once."""
+    assert splash.SCANNER_NAME == "BandSaunter"
+    assert splash.BROWSER_NAME == "SaunterBrowse"
+    assert set("BS") <= set(splash.CAPS)
+    assert "a" in splash.LOWER and "d" in splash.ASCENDERS
+
+
+def test_a_capital_stands_taller_than_the_letter_beside_it():
+    """The point of the whole exercise: if both were drawn the same height
+    the name would read as BANDSAUNTER, which is not its name."""
+    def top_of(word):
+        drawn = splash.pixels(word)
+        return next(i for i, row in enumerate(drawn) if row.strip())
+
+    assert top_of("B") < top_of("a"), "the capital does not rise"
+    assert top_of("d") == top_of("B"), "the ascender does not reach"
+    assert top_of("t") < top_of("a"), "the t does not rise at all"
+    assert top_of("o") == top_of("a"), "two x-height letters disagree"
+
+
+def test_every_letter_sits_on_the_same_baseline():
+    def bottom_of(word):
+        drawn = splash.pixels(word)
+        return max(i for i, row in enumerate(drawn) if row.strip())
+
+    heights = {ch: bottom_of(ch) for ch in "BSandutersow"}
+    assert len(set(heights.values())) == 1, heights
+
+
+def test_both_names_fit_an_eighty_column_terminal():
+    """Which is the narrowest terminal anybody still has, and the width a
+    banner has to be cut to rather than wrapped at."""
+    for word in (splash.SCANNER_NAME, splash.BROWSER_NAME):
+        assert max(len(r) for r in splash.banner(word)) <= 78, word
+
+
+def test_every_letter_the_two_names_need_has_a_glyph():
+    """A missing one would silently shorten the name rather than fail."""
+    for word in (splash.SCANNER_NAME, splash.BROWSER_NAME):
+        for letter in word:
+            assert letter in splash.FONT, letter
+
+
+def test_a_stroke_is_two_dots_thick_in_both_directions():
+    """One dot thick reads as a dotted line rather than a line, which is
+    the one thing that makes drawing in braille difficult.  Doubling the
+    small font is what avoids it."""
+    doubled = splash._double(("#.",))
+    assert doubled == ["##..", "##.."]
+
+
+def test_a_letter_with_no_glyph_is_left_out_rather_than_drawn_as_a_hole():
+    assert splash.banner("Band!!") == splash.banner("Band")
+    assert splash.banner("!!!") == []
+    assert splash.banner("") == []
+    # And an uppercase name is no longer the same as a lowercase one, which
+    # is the whole change: the font has two heights now.
+    assert splash.banner("Band") != splash.banner("BAND")
+
+
+def test_the_gradient_is_cold_the_whole_way_along():
+    """Digital blues, cyans and white, and nothing warm anywhere.
+
+    Checked as an invariant rather than by naming the five stops: blue is
+    never the weakest channel and red is never the strongest, which is what
+    "blue through cyan to white" *means* and what any warm colour slipping
+    back in would break.  This is deliberately not the waterfall ramp the
+    rest of the program draws in -- that one has to run to red because it
+    stands in for a spectrum.
+    """
+    for step in range(0, 101):
+        style = splash._colour(step / 100)
+        red, green, blue = (int(v) for v in style[4:-1].split(","))
+        assert blue >= green >= red, (step, style)
+        assert blue >= 120, f"too dark to read at {step}: {style}"
+
+
+def test_the_gradient_ends_pale_and_starts_deep():
+    """A gradient that did not travel would be a colour."""
+    start = [int(v) for v in splash._colour(0.0)[4:-1].split(",")]
+    end = [int(v) for v in splash._colour(1.0)[4:-1].split(",")]
+    assert sum(end) > sum(start) * 2, "it barely brightens"
+    assert start[2] >= 120 and end[1] >= 200
+
+
+def test_the_gradient_runs_from_one_end_of_the_ramp_to_the_other():
+    first, last = splash._colour(0.0), splash._colour(1.0)
+    assert first != last
+    assert first.startswith("rgb(") and last.startswith("rgb(")
+    # And it is clamped rather than extrapolated off either end.
+    assert splash._colour(-5.0) == first
+    assert splash._colour(5.0) == last
+
+
+def test_the_lines_under_it_are_drawn_in_the_order_they_were_given():
+    console = Console(width=100, force_terminal=False)
+    shown = _plain(console, lambda: splash.show(
+        console, splash.SCANNER_NAME,
+        ("Conceived by: The Dust Council", "100% AI Coded by Claude Code."),
+        force=True))
+    assert "Conceived by: The Dust Council" in shown
+    assert "100% AI Coded by Claude Code." in shown
+    assert shown.index("Conceived") < shown.index("100%")
+
+
+# ---------------------------------------------------------------------------
+# When it stays out of the way
+# ---------------------------------------------------------------------------
+
+def test_nothing_is_drawn_when_the_output_is_not_a_terminal():
+    """The one that matters.  A table piped into something else must come
+    out as a table."""
+    console = Console(width=100, force_terminal=False)
+    shown = _plain(console, lambda: splash.show(console, splash.SCANNER_NAME,
+                                                ("a", "b")))
+    assert shown == ""
+    assert splash.wanted(console) is False
+
+
+def test_no_splash_turns_it_off_on_a_terminal_too():
+    console = Console(width=100, force_terminal=True)
+    assert splash.wanted(console) is True
+    assert splash.wanted(console, no_splash=True) is False
+    shown = _plain(console, lambda: splash.show(console, splash.SCANNER_NAME,
+                                                ("a",), no_splash=True))
+    assert shown == ""
+
+
+def test_the_environment_can_turn_it_off_for_good(monkeypatch):
+    """For anybody who would rather it did not, without having to remember a
+    flag on every invocation."""
+    console = Console(width=100, force_terminal=True)
+    monkeypatch.setenv("BANDSAUNTER_NO_SPLASH", "1")
+    assert splash.wanted(console) is False
+    shown = _plain(console, lambda: splash.show(console, splash.SCANNER_NAME,
+                                                ("a",)))
+    assert shown == ""
+
+
+def test_it_says_whether_it_drew_anything():
+    console = Console(width=100, force_terminal=False)
+    assert splash.show(console, splash.SCANNER_NAME, ("a",)) is False
+    assert splash.show(console, splash.SCANNER_NAME, ("a",), force=True) is True
+    assert splash.show(console, "!!!", ("a",), force=True) is False
+
+
+def test_nothing_sleeps_when_nothing_is_drawn(monkeypatch):
+    """The pause is for a program about to take the screen over.  Paying it
+    with no banner drawn would be a tenth of a second added to every piped
+    command for nothing."""
+    import time
+
+    slept = []
+    monkeypatch.setattr(time, "sleep", lambda s: slept.append(s))
+    console = Console(width=100, force_terminal=False)
+    splash.show(console, splash.BROWSER_NAME, ("a",), pause=5.0)
+    assert slept == []
+    splash.show(console, splash.BROWSER_NAME, ("a",), pause=0.25, force=True)
+    assert slept == [0.25]
+
+
+# ---------------------------------------------------------------------------
+# Where it is wired in
+# ---------------------------------------------------------------------------
+
+def test_both_programs_can_be_told_not_to_draw_one():
+    from bandsaunter.browse import build_parser as browse_parser
+    from bandsaunter.cli import build_parser as cli_parser
+
+    assert cli_parser().parse_args(["--no-splash", "devices"]).no_splash
+    assert not cli_parser().parse_args(["devices"]).no_splash
+    assert browse_parser().parse_args(["--no-splash"]).no_splash
+    assert not browse_parser().parse_args([]).no_splash
+
+
+def test_the_scanner_draws_its_own_name(monkeypatch):
+    drawn = []
+    monkeypatch.setattr(splash, "show",
+                        lambda console, word, lines=(), **kw:
+                        drawn.append((word, tuple(lines))) or False)
+    from bandsaunter import cli
+
+    cli.main(["devices"])
+    assert drawn and drawn[0][0] == splash.SCANNER_NAME
+    lines = drawn[0][1]
+    assert lines[0] == "Conceived by: The Dust Council"
+    assert lines[1] == "100% AI Coded by Claude Code."
+
+
+def test_the_browser_draws_its_own_name_and_waits_a_moment(monkeypatch,
+                                                           tmp_path):
+    drawn = []
+
+    def fake(console, word, lines=(), **kw):
+        drawn.append((word, tuple(lines), kw.get("pause", 0.0)))
+        return False
+
+    monkeypatch.setattr(splash, "show", fake)
+    from bandsaunter import browse
+
+    # Straight back out again: the banner is drawn before anything else.
+    browse.main([str(tmp_path), "--callsigns"])
+    assert drawn and drawn[0][0] == splash.BROWSER_NAME
+    assert drawn[0][1][0] == "Conceived by: The Dust Council"
+    assert drawn[0][1][1] == "100% AI Coded by Claude Code."
+    # The browser runs on the alternate screen, so the banner needs a beat.
+    assert drawn[0][2] > 0