Wordmark: an .ans is CP437, and its newlines are not its rows

The extension is .ans now, not .ansi — the software that draws this stuff is
old and particular about 8.3 names, and .ans is what it expects to open.

The wide mark is a real ANSI-art export rather than something colour-logo.py
painted, which brings two DOS habits the loader had never met. Its blocks and
box-drawing are single bytes in codepage 437, so reading it as UTF-8 raised
instead of drawing; we try UTF-8 first and fall back, and the 53-column mark
keeps its own encoding either way. And an art editor drops the line break on a
row that fills the canvas, trusting the terminal to wrap it — so the file has
nine newlines for sixteen rows. The canvas width comes from the SAUCE record,
which is trimmed off in the same breath, being metadata and not art.

Re-breaking a wrapped row has to restate the colour across the seam: each row
becomes its own Text.from_ansi, so nothing carries state the way a terminal
does when it never stopped reading the one stream.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jean-Pierre MartineauandClaude Opus 5 committed 2026-08-25 01:04:53 -04:00
1 parent f870bff990
commit c439dec289
5 files changed
+98 -15

No files matched your search

Binary file not shown.
-6
View File
@@ -1,6 +0,0 @@
███╗ ███╗███████╗███████╗██╗ ██╗████████╗███████╗██████╗ ███╗ ███╗
████╗ ████║██╔════╝██╔════╝██║ ██║╚══██╔══╝██╔════╝██╔══██╗████╗ ████║
██╔████╔██║█████╗ ███████╗███████║ ██║ █████╗ ██████╔╝██╔████╔██║
██║╚██╔╝██║██╔══╝ ╚════██║██╔══██║ ██║ ██╔══╝ ██╔══██╗██║╚██╔╝██║
██║ ╚═╝ ██║███████╗███████║██║ ██║ ██║ ███████╗██║ ██║██║ ╚═╝ ██║
╚═╝ ╚═╝╚══════╝╚══════╝╚═╝ ╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝
File renamed without changes.
+96 -7
View File
@@ -1,9 +1,23 @@
"""The MeshTerm wordmark for the startup splash, loaded from the assets folder.
The art itself lives in ``meshterm/assets`` — hand-drawn ``.txt`` sources beside the
pre-coloured ``.ansi`` the splash actually draws (``scripts/colour-logo.py`` paints one
into the other). Files are read fresh on every call, so the wordmark can be re-styled by
editing the art alone: no code change and no restart of the design loop.
The art itself lives in ``meshterm/assets`` as pre-coloured ``.ans`` files — the classic
ANSI-art extension, kept short because the editors that draw this stuff are old and
particular about 8.3 names. A ``.txt`` beside one is its hand-drawn source for marks we
colour ourselves (``scripts/colour-logo.py`` paints one into the other); a mark drawn in
an ANSI-art editor arrives already finished and has no source but itself. Files are read
fresh on every call, so the wordmark can be re-styled by editing the art alone: no code
change and no restart of the design loop.
Two things separate a real ``.ans`` from a text file with colour in it, and :func:`_rows`
handles both so the art stays authorable in the tools that drew it:
* **Codepage 437.** The blocks and box-drawing (``█▓▒░`` and ``╔═╗``) are single bytes in
DOS's codepage, not UTF-8. We try UTF-8 first and fall back, so a mark we generated
ourselves and a mark exported from an art editor both read.
* **Auto-wrap.** An art editor omits the line break on a row that fills the canvas and
lets the terminal wrap it, so the file's newlines are *not* the picture's rows. The
canvas width comes from the SAUCE record on the end of the file — which has to be
trimmed off in the same breath, being metadata rather than art.
There is more than one mark, at different widths, and the *screen* picks — not the
platform. A 53-column PicoCalc console and a desktop terminal dragged narrow have the same
@@ -13,6 +27,7 @@ mark that fits the columns I have?
from __future__ import annotations
import re
from pathlib import Path
from typing import Optional
@@ -25,18 +40,92 @@ _ASSETS = Path(__file__).resolve().parent.parent / "assets"
#: Every wordmark, widest first. :func:`load_logo` walks this and takes the first that
#: fits, so adding a size is dropping a file in and naming it here.
_VARIANTS: tuple[str, ...] = ("logo.ansi", "logo_53.ansi")
_VARIANTS: tuple[str, ...] = ("logo.ans", "logo_53.ans")
#: A colour change and nothing else. Every escape these marks use is an SGR, so re-breaking
#: a row only ever has to carry a *colour* across the seam — never a cursor move.
_SGR = re.compile(r"\x1b\[[0-9;]*m")
#: SAUCE rides on the end of an art file behind DOS's end-of-file mark: 128 bytes naming
#: the author, the canvas and the font. None of it is meant to reach the screen.
_EOF_MARK = b"\x1a"
_SAUCE_LEN = 128
def _split_sauce(raw: bytes) -> tuple[bytes, Optional[int]]:
"""The art alone, and the canvas width SAUCE claims for it (``None`` when unsigned).
A file with no record is returned whole and unmeasured: its newlines are its rows, and
re-breaking one would be inventing a canvas the author never declared.
"""
cut = raw.rfind(_EOF_MARK)
if cut < 0:
return raw, None
trailer = raw[cut + 1 :]
if not trailer.startswith(b"SAUCE") or len(trailer) < _SAUCE_LEN:
return raw, None
width = int.from_bytes(trailer[96:98], "little") # TInfo1 — characters per row
return raw[:cut], width or None
def _decode(raw: bytes) -> str:
"""An art file's text, in whichever of the two codepages it was written."""
try:
return raw.decode("utf-8")
except UnicodeDecodeError:
return raw.decode("cp437")
def _rewrap(line: str, width: int) -> list[str]:
"""Re-break one auto-wrapping line into rows of ``width`` printable cells.
The rows are drawn independently — each becomes its own ``Text.from_ansi`` — so a
colour set before the seam has to be restated after it. A real terminal needs no such
help: it never stopped reading the one stream, so the state simply persisted.
"""
rows: list[str] = []
buf: list[str] = []
state = ""
cells = 0
at = 0
while at < len(line):
found = _SGR.match(line, at)
if found:
seq = found.group()
buf.append(seq)
params = seq[2:-1]
if params in ("", "0"):
state = "" # a plain reset leaves nothing to restate
elif params.split(";")[0] in ("", "0"):
state = seq # reset-and-set: this sequence *is* the whole state
else:
state += seq
at = found.end()
continue
buf.append(line[at])
at += 1
cells += 1
if cells == width:
rows.append("".join(buf))
buf = [state] if state else []
cells = 0
if cells or not rows: # the short last row, or a blank line that is still a row
rows.append("".join(buf))
return rows
def _rows(name: str) -> list[str]:
"""The named mark's rows, or ``[]`` when it can't be read."""
try:
text = (_ASSETS / name).read_text(encoding="utf-8")
raw = (_ASSETS / name).read_bytes()
except OSError:
return []
lines = text.split("\n")
art, width = _split_sauce(raw)
lines = [line.rstrip("\r") for line in _decode(art).split("\n")]
if lines and lines[-1] == "": # drop the trailing newline's empty row
lines.pop()
if width:
return [row for line in lines for row in _rewrap(line, width)]
return lines
+2 -2
View File
@@ -2,7 +2,7 @@
"""Colour a plain-text wordmark into the pre-coloured ANSI the splash draws.
The art itself is hand-drawn and lives in ``meshterm/assets`` as a ``.txt``; this paints
it and writes the matching ``.ansi`` beside it, so the colour scheme is stated once here
it and writes the matching ``.ans`` beside it, so the colour scheme is stated once here
rather than re-typed into every escape sequence by hand.
python scripts/colour-logo.py # repaint every asset/*.txt
@@ -64,7 +64,7 @@ def main() -> None:
names = sys.argv[1:] or sorted(p.stem for p in ASSETS.glob("*.txt"))
for name in names:
source = ASSETS / f"{name}.txt"
target = ASSETS / f"{name}.ansi"
target = ASSETS / f"{name}.ans"
target.write_text(colour(source.read_text(encoding="utf-8")), encoding="utf-8")
print(f"{source.name} -> {target.name}")