fedtail 0.19.0

• An intermediate release of the 0.19 plan (docs/en/dev/roadmap.md): the sound schemes,
  the Windows tests, the same behaviour checked across Qt, GTK, the web and the terminal
  are in; the full terminal interface and the full web page go on in 0.20 — what each
  interface lacks so far, and why, is the "Four interfaces" table of the feature list.
• Windows: a new avatar or header no longer goes to the server under the picture's whole
  local path (with the user's folder name in it) — only the file's own name.
• GTK matches Qt where it didn't: ⏸ in the video player and the gif's own key hint, the
  menu items' tooltips (where GTK shows them), the profile's tooltip in the status bar, a
  click on a post's face opens the profile (and a screen reader names it), the columns'
  tab is called so, ? in the command line opens the commands' help in a window.
• Qt: a follow request's @name opens the person's profile in fedtail, as GTK's does — no
  more "profile ↗" link out to the browser.
• "Four interfaces" in the feature list (docs/{ru,en}/features.md, and so the site): a table
  of what isn't in all of Qt, GTK, the terminal and the web page, and why — kept honest by a
  test (tests/test_parity.py): a function added to or lost in one interface doesn't pass
  without its line in docs/src/parity.toml.
• Bug reports leave the machine by themselves if you like: debug.report_repo = "user/repo"
  (or any git address) — the report from the Debugging menu, --bug-report and the nightly
  selfcheck's text zip (--send, --send-full for the whole) are pushed into that private
  repository over ssh with your own keys, a commit each; the reports already there are never
  downloaded.
• "Report a bug on GitHub…" in the ≡ menu of every interface: a draft issue with the
  version, the system and the latest errors of the log, server addresses, nicknames, IPs,
  tokens and paths replaced by placeholders — shown to read and edit first; then GitHub opens
  with it filled in and you send it yourself.
• "Translate" on every post if you like (feed.translate_all = true, as in Fedilab): in your
  own language too, and on posts that give none.
• No tray icon if you don't want one (ui.tray = false): notifications then go through the
  desktop only and the cross closes fedtail. Windows: the tray icon no longer stays behind
  after fedtail quits — every restart used to leave one more until the mouse passed over.
• The terminal shows pictures for real and plays video. With the textual-image package
  (pip install textual-image) pictures go out as sixel (Konsole, WezTerm, foot) or the kitty
  protocol (kitty) — in the lane and full screen; without it, half blocks as before
  (tui.pictures = "auto", "blocks", "key", "off"; the old "inline" is "auto").
  v hands the pictures to chafa, timg or kitty's icat when one is installed, the
  interface stepping aside until Enter (tui.viewer). Video and gifs play in mpv: a
  window of their own on a desktop, right in the terminal over ssh (sixel, kitty or
  coloured text); no mpv — the browser, and it says so (tui.video).
• The terminal: #abc or @name typed in the command line no longer closes it on
  Textual 2 (Debian 13) — the thread or profile it opened wasn't drawn yet when the line
  gave the focus back; "Reply with a quote" quotes the post's words, not its HTML; a
  redraw or an answer from the server arriving as the terminal closes is dropped quietly
  instead of an error on the way out.
• fedtail-sync gets ready to leave for a repo of its own: its own version (1.0.0) and
  changelog, --version, README in both languages with the install guide (moved there from
  docs/*/sync.md), the protocol written down (syncserver/PROTOCOL.md), and its own tests
  in syncserver/tests/ — the standard library only, every line of the server run
  (syncserver/tools/coverage.py --fail-under 100, in CI's security job).
• The language of a post: Georgian is named «ქართული (ka)» again, not in Mtavruli capitals
  («Ქართული»): Georgian text has no capital letters.
• fedtail-sync guards itself — it faces the internet and didn't: a silent or trickling
  connection is dropped (timeout_seconds; it held a thread for ever), at most
  max_connections at once, requests_per_minute_per_ip; random tokens can no longer make
  it hammer a fediverse server with checks (verifications_per_minute_per_ip,
  verifications_per_minute); a body is read only with an honest Content-Length (a
  negative one read to the end of the stream); total_mb caps the disk for everyone; the
  token check follows no redirect (one carried the token on) and with "*" talks only to
  public addresses, checked on the connected socket; an error inside says "internal error"
  only. Behind cloudflared or nginx, client_ip_header (CF-Connecting-IP, X-Real-IP)
  gives the limits the real address — believed from a loopback peer only. Tests for each
  (syncserver/tests/test_security.py) and bandit run in a CI job a release waits for.
• Sync: an action on one device always wins over what it has already seen from the
  others, however their clocks differ (a draft sent on the phone came back from the
  desktop when the desktop's clock was a little ahead).
• A settings window (≡ → Settings, in Qt, GTK, the web page and the terminal): the
  chapters of config.toml on the left, their options as cards on the right — a switch,
  a number, a choice (each choice with what it means), ticks for lists of lanes — with
  the reference's explanation under each, "Default" where it is set otherwise, and a
  search over all of them. The file stays the one place the settings live: a change
  goes into it at once, that one line (a commented-out option is switched on in place,
  a missing one goes into its section with its explanation), the comments and the rest
  stay as they are, the old file is kept as config.toml.bak, and a change that wouldn't
  read back or pass the checks is refused with the file untouched. Edited outside while
  the window is open, the file is read again. Most options are read at start: after a
  change the window offers Restart. What the window shows and does is
  frontends/common/settings.py (for the phone too), the line editing
  core/config_edit.py.
• Sync is a service of its own now, apart from the fediverse server: it is on when the
  config says where (sync.url, or sync.folder) and off otherwise. sync.enabled and
  sync.backend are gone (a config still having them gets a warning, nothing breaks), and
  so is the lookup through /.well-known/fedtail-sync on the account's server — in fedtail
  and in fedtail-sync (its public_url is ignored with a warning). The right of the status
  bar shows how it goes (Qt, GTK): "⇅ 21:40" — synced then, "⇅ …", "⇅ !" — a problem (the
  tooltip says which), "⇅ off"; About has a "Sync" row everywhere.
• What sync carries is a switch for each in [sync], all on by default (sync.what is
  gone; a config still having it gets its list turned into the switches, with a warning):
  read, threads, and new — lanes: the order of lists (servers keep none, so every
  device showed them as they came) and the tag lanes saved from a search; drafts: begun
  on one device, finished on another, sent or emptied — gone everywhere (pictures stay on
  the device they were added on); activity: notifications dismissed from Activity go on
  every device; tiles: which lanes the phone pins as tiles (Core.pinned_tiles /
  set_pinned_tiles).
• Faster after reading: which posts are read is kept in memory (the sidebar counted every
  lane from the database after each read mark and froze the window for 0.4 s on a big
  profile). A followed thread the server times out on no longer stops the others nor
  shows an error: it waits its turn (it was asked again every poll).
• KDE: a theme's font now reaches labels, lists, buttons and the status bar too (KDE
  gives those classes fonts of its own, and they won: bnw's monospace came out sans
  everywhere but the inputs). A profile or a tag opened while still connecting says
  "connecting…" instead of an error in the window. The terminal: a thread or profile
  that loads after its screen was closed no longer brings the terminal down; j / k step
  over the "new below" line.
• GTK, closer to Qt (the KDE window is the reference): the messenger themes head a
  card "Name (time)" in their colours as Qt does; a theme's fonts that come with fedtail
  (PT Sans, Arimo, Fira Mono…) are loaded and its whole list of families is used — GTK
  took only the first and fontconfig chose for it; the lane header shows the theme's
  pictures for "all read", the funnel and refresh, as Qt.
• Pictures where the desktop has none: on Windows (and macOS) Qt drew no pictures on the
  lanes but one and an empty Refresh button (Windows' own icon engine knows a few names,
  and answers the rest with nothing); fedtail's own drawings stand in there, and in GTK
  wherever the icon theme lacks a picture. GTK's sidebar rows are as dense as Qt's, its
  lane title and "N new" pill the size of Qt's.
• The editor (Qt and GTK): what the post is and what to do with it in one row when there's room
  — the two halves keep to their sides and go into two rows only in a narrow window; the
  character count sits in the text field's own bottom right corner.
• Trying a theme (≡ → Try a theme) stops the videos and the gifs looping in cards first:
  with one decoding, the restyle brought the program down (a segfault in Qt). The Qt tour
  now tries every theme on its living window.
• Themes say which window layout they're made for (layouts = ["split"]: qip, mra, psi);
  ui.themes_by_layout offers in "Try a theme" only those of the layout on — "auto": so in
  releases, every theme in development versions.
• The sidebar's ≡ ↔ ❯: their pictures a third bigger (they looked lost in the buttons).
• Pictures are plain shapes by default ([pictures] style = "silhouette"); the ...

fedtail 0.18.0

• The four interfaces offer the same things. The web page's ⋯ menu of a post is the
  windows' own (common/actions.py: the same items, the same order) and its links are
  done the way the windows do them — editing, delete and redraft, calling into a
  thread, who quoted, blocking a server, report, read up to here; a profile's buttons
  come from one place (common/profile.py) for GTK and the web — the bell, boosts and
  languages in Home, remove from followers, endorse, a private note. GTK caught up with
  Qt on: find in the lane (Ctrl+F), voting in polls, translating a post, reading the
  whole text from its server, an edit's history, reporting, who liked or boosted, the
  quotes of my post, read up to here, editing my profile, quotes that say why they
  can't be shown, "old" and "edited" marks, what each lane is (its tooltip).
  tools/parity.py says what is still missing where.
• Scrolling a long lane fast: the benches measure how often the reader hits the edge
  of what's built and waits (a hand's 6 and 15 screens a second, a fling, the thumb
  dragged); GTK builds ahead faster — while the reader keeps coming to an end, and
  while standing at it.
• Kinder to the server's rate limit. A followed thread that has gone quiet is reread
  less often (quiet an hour — 3× subs.interval_minutes, a day — 12×, three days —
  36×), and threads take at most a quarter of what the server still allows: a night
  with 97 followed threads spent 56% of its requests on them and waited 1.7 h of 10
  for the limit. A 429 no longer fails a whole round with "poll failed"; the pause
  after one counts what a full round costs, and waits a little past the server's reset.
• Smoother: the same posts fetched again keep the lanes' caches (the sidebar's counts
  stopped reading the store in the window's thread every round: 0.3–0.6 s stalls); a
  gifv in a Qt card draws at most 12 frames a second, made small first; the dock stops
  asking the X server for the pointer while the window is in the background.
• GTK caught up with Qt in nearly all: a thread's header (subscribe, why its replies
  come, "open every CW" — Qt has it too now), profiles paging back and then from the
  author's own server, pinned and featured posts and people, groups of tags, a tag's
  "feature on my profile", the curtain on Esc, the status line's words, the federation
  status's Copy and Count anew, a picture's focus point, the camelCase hint, text
  selected with "Quote in reply", a contact card on hover (split), the account a post
  came by (merged window), a video player over the window (Gtk.Video) and a tray icon
  (StatusNotifierItem over D-Bus, KDE's and the AppIndicator extension's).
• Qt: a suggestion (@name, #tag, :emoji:) goes in with Enter or Tab — it took a click.
• The server's own groups of notifications (Mastodon 4.3+, /api/v2/notifications,
  activity.server_groups): 300 likes of one post are one request and one row with its
  count ("and 297 more"), not 300 notifications in eight pages; × dismisses the whole
  group on the server. GoToSocial and older Mastodon: fedtail groups them itself, as
  before (the first 404 settles it).
• A new machine's first start keeps what you left unread elsewhere: posts newer than the
  server's home marker (another fedtail, the server's web) stay unread, and the marker
  isn't moved to "all read" by the new one — a fresh Windows install had moved the
  Linux one's place by fifty posts.
• GTK is quicker on KDE: it talks to the accessibility bus only while a screen reader
  is on (ui.accessibility = "auto"; "on" — always): with KDE's bus up and nobody
  reading, the ≡ menu took 2 s to open. The tray answers the panel without rebuilding
  the icon's pixels each time (0.1–0.3 s per new post).
• GTK: pictures in a lane at their full size again — a lane is a ListBox, which gives
  its rows their least height, and a picture's least height was a strip of it (cut, then
  shrunk to 96 px wide); its least height is now its shape's at the width it gets. A
  picture whose size the server didn't say is shown whole, not cut to a square.
• GTK on X11 follows the desktop's 125 % / 150 %: with no text DPI of its own (KDE gives
  GTK apps one only through its GTK settings daemon) it takes X's Xft.dpi, or Plasma's
  scale from kdeglobals — it sat at 100 % beside Qt's 125 %. The text grows; pictures
  and gaps keep their pixels, as in every GTK 4 app on X11. Wayland scales GTK itself.
• GTK: Esc closes the picture viewer (and the video player) wherever the keyboard is —
  the card clicked to open it kept the keys, and Esc closed the lane under it; the
  viewer takes the keys once on screen. ≡ → Quit quits (it ran inside the menu's own
  click and left the window up; the tray's Quit worked). Activity's × at the right end.
  GTK's own containers (pictures, headers, wrapping rows) let their children go when
  they go — they were kept ("Finalizing … still has children left"). The ≡ menu says
  in the log how long it took to make and to show.
• GTK's split layout starts with the roster only, as Qt's (both windows came up), and
  closing the last tab hides the messages window, the roster staying. The
  first menu GTK builds in a run took 1.5–2 s on KDE (later ones: milliseconds), and the
  click's release, handled after that freeze, closed the menu it had opened — ≡ took a
  double click. Every ≡ is now made after start, timed in the log; one click opens it.
• Debug → Federation status works again in GTK and the web: someone waiting to go into
  a list (a name and a link) was taken for a hashtag on the way to the window.
• A Qt window started in a terminal where the tests had set QT_QPA_PLATFORM=offscreen
  showed nowhere (Windows): fedtail now drops that setting for its window and says so.
  GoToSocial isn't asked for grouped notifications or a user's server blocks any more
  (it has neither: a 404 at every start).
• fedtail from the source says at start where its logs are (fedtail: logs in …);
  docs/WINDOWS.md has every Windows path and the commands to open and follow the log.
• The debugging corner of the status bar says the same in Qt and GTK, in one order:
  theme · toolkit and version · style · font · display · scale · build (Qt's had an
  empty "· ·" where its style's name was).
• docs/WINDOWS.md: fedtail on Windows from the source — Python and git by winget, the
  packages, running, the tests as CI runs them, the selfcheck; tests/test_windows_doc.py
  keeps it the same as CI and the code.
• GTK: pictures and files go into a post by dragging them onto the editor or pasting
  them (Ctrl+V — a file manager's copied files, a screenshot; Ctrl+Shift+V — always as
  text); dropped on the window, they start a new post (as in Qt). The deb package
  recommends GTK 4 (python3-gi, gir1.2-gtk-4.0, gir1.2-adw-1), and the GTK window
  is "fedtail (GTK)" on a right click on the menu entry. GTK is no longer "partly".
• The chosen lane shows in dark themes left at "auto" (Adwaita dark, Breeze dark): its
  row was nearly the sidebar's own colour.
• Qt opens a lane faster: a lane of 41–80 posts no longer builds every card at once
  (one first build, 40 by default, as for longer ones), and a post's ⋯ menu is made
  when it's first opened, not an empty one with every card.
• The gallery (tools/gallery.py) and the README's screenshots are made only when
  asked: selfcheck.py --only gallery, and CI's screenshots job by hand (Actions → CI
  → Run workflow) — not every night and every push.
• GTK 4.18: no "reported min height … natural height" warnings by the thousand — a
  card, a lane's header, a profile's top and a person's row are no longer horizontal
  boxes with wrapping text in them (4.18 takes such a box's least height at its least
  width); gtk/measure.py checks for it, on 4.14 too.
• GTK in a narrow window (or with big fonts): the lane never goes past the window's
  edge any more — a picture narrows with the window, its shape kept (it asked for its
  full width and held the lane wider); the words on a post's buttons end in "…"; the
  lane's header wraps its buttons to a second row instead of cutting the last ones;
  the sidebar's rows have no theme's pills under them (Breeze), the name in it is never
  cut to "М…"; Clear in Activity; a tag's tab
  with "Feature on my profile"; a picture's right-click menu (save, open, copy link);
  a poll's "refresh".
• selfcheck: --night runs every window on a display of its own (xvfb-run) — a locked
  screen made GTK draw a frame a second and the benches meaningless; the tests run
  there too, away from the desktop's focus. The window is tried at the sizes of real
  screens up to 4K, portrait too, at shares of the screen (half, quarter, three
  quarters, half the height), and with its bottom dragged as well as its side; at scale
  1.5 and 2 (Qt), twice the pixels and the text 1.5× (GTK) — sizes.txt says what each
  did. gtk_bench --measure names a widget that tells GTK a least height above its
  natural one.
• Sync between your devices: read marks you made and threads you followed, left or
  muted travel to your other devices (sync.*, off by default; docs/en/sync.md). Each
  device keeps a journal, sealed with AES-256-GCM under a key only your devices have, and
  exchanges it through a fedtail-sync server or a folder they all see (a NAS share, WebDAV
  mounted, Syncthing). Marks fedtail makes by itself (the first run, older history) stay
  home. The server finds itself through /.well-known/fedtail-sync on your server; it is
  given a separate token limited to read:accounts, never the main one. New terminal
  command fedtail sync status|key|join|login|now. Needs the cryptography package
  (Debian: python3-cryptography) — only for sync.
• fedtail-sync: the server for it, one file of the standard library
  (syncserver/fedtail_sync.py): who is who is asked of each account's own server, which
  servers' people are served is a list (or anyone's), a quota and a request limit per
  ...

fedtail 0.17.1

• The split layout's input line says in words where a post goes and who will see it:
  "into the thread, a reply to andy · seen by: followers", "new post · seen by: all",
  "✉ privately to sn4il · seen by: only those mentioned". In a thread it answers the
  post you came for, else the thread's newest — not the last branch of the tree.
• A private message sent from a talk's tab shows in the talk at once (it opened a
  thread tab of its own and the talk waited for the next poll).
• A quick scroll reads what it went over: a post the screen passed whole while you
  scrolled by the wheel or the keys is read, without dwelling on each (a jump — the
  scroll bar dragged far, End — still counts nothing). The check looks at the cards on
  screen only, not at every card of the lane.
• Less CPU with the split layout open for long: the roster is worked out in the
  background (it read every lane on the window's thread, a third of a second each
  time), and the face over a lane finds the post under the pointer or the lowest whole
  one without measuring every card of the lane twice a second.

fedtail 0.17.0

• A GTK 4 window, the frame of it (fedtail --ui gtk, or ui.frontend = "gtk";
  ui.adwaita = auto | on | off — libadwaita if installed, required, or never): login,
  the lanes in their groups with unread counts, posts as cards with what they answer,
  the content warning and attachments, seen posts marked read, "All read", "earlier",
  threads in tabs, ★ and ♻, every fedtail theme. The rest comes stage by stage
  (docs/GTK.md); needs python3-gi gir1.2-gtk-4.0. Inside: the theme colours
  (frontends/palette.py) and post text for GTK labels (frontends/pango.py) are
  worked out without a toolkit, ready for Qt to share.
• The server's rate limit is kept to: fedtail reads its X-RateLimit headers, keeps
  quiet once fewer requests are left than two poll rounds and a reserve, until the
  server's window starts anew, and asks nothing while it is spent. One line in the
  status bar says until when — instead of a "429" for every lane, every round (as on
  GoToSocial with a few lists, the live stream waking the poller every few seconds).
• The split layout (ui.layout = "split", for one run fedtail --layout split;
  "qip", its first name, is still understood) — fedtail as a messenger of the 2000s,
  QIP, the Mail.ru Agent or Psi (docs/LAYOUTS.md):
  • The roster, a narrow window of its own, and fedtail starts with it alone: who I
    am and what's new in Activity on top, a search line, then folding groups — the
    lanes, followed threads and private talks ("Threads", "Talks", the freshest
    ui.roster_threads), and "People": whom I follow who follows me back (asked once a
    day). A group says "(15)", or "(2/15)" when two of its items have something new.
    Each item has its count, a line of its newest post and a face. A double click (or
    Enter) opens it; hovering a person shows their card, as QIP did. At the bottom: the
    menu, the accounts, and ⚙ for how it looks — compact, without the header, the
    search or the buttons, only what's new, without groups, above other windows
    (ui.roster_on_top). Closing the roster closes fedtail (to the tray with
    ui.close_to_tray); the tray icon hides and brings back both windows.
  • The messages window is the main one, without the sidebar: every lane, thread,
    profile and talk opened is a tab of its own, in more rows when they don't fit; ×,
    the middle button or Esc close one, and with the last the window goes
    (ui.split_tabs: whether it keeps its tabs for next time). A person opens as a
    talk with only our private messages.
  • The input line is always under the posts, a bar that drags between them: in a
    thread it answers the thread (a private talk stays private), in a talk it writes to
    that person privately, in a lane it writes a new post; Reply on a card goes there
    too. Who sees it, a content warning, pictures, the language; it also runs the
    command line's commands (ui.dock_commands: "#a3f text", "! #a3f", "?" — Enter).
  • Faces (ui.faces): over a lane, in one line, the author of the post under the
    pointer (or the cursor, or the newest whole on screen) — name, address, whether we
    follow each other, Follow, Add to list, a private message, the profile; by the input
    line, whom I write to. The Agent's themes put them in a column on the right instead,
    theirs by the posts and mine by the input line. A grey silhouette stands in for a
    face not there yet.
  • Pictures on buttons of fedtail's own, drawn the theme's way
    (ui.additional_icons = "layout" | "all" | "none", in the split layout by default):
    the input line's, the author's bar's, the roster's, a post's Reply, Favourite, Boost,
    Thread and Bookmark and who sees it. A flower for a person in the QIP themes, an "@"
    in the Agent's, a star in Psi's; the psi theme brings Psi+'s own pictures (the
    Crystal and Stellar iconsets, GPL).
• The messenger themes, made from the originals' screenshots, square or nearly
  square, glossy where they were: qip-retro (QIP under Windows XP: beige, white panes
  in grey-blue frames, XP tabs with an orange line), qip-modern (QIP Infium: pale blue,
  the posts on a white-to-blue diagonal), mra, mra-blue, mra-green, mra-violet
  (the Mail.ru Agent's skins), psi (Psi+ on KDE). They write a post as a message:
  "Name (15:25:43 23/06/2007)" over it, mine and the others' in colours of their own.
  New theme keys for any theme: shape.card_header = "chat", colors.chat_me /
  chat_them, words.chat / chat_date; for the split layout shape.faces,
  roster_rows, roster_face, tab_rows, icon_set, colors.view_end, window_end,
  button_end, header_end, tab_mark, words.roster_group / roster_group_quiet.
  Their colours and pictures are fedtail's own, in the spirit, not anyone's skin.
• fedtail --layout single|columns|split and --theme NAME: the layout or the theme for
  one run, the config untouched; an account switched to from there gets them too.
• Less freezing: trying a theme no longer stops the window for seconds (the lanes out of
  sight let their cards go first), the split layout no longer lays the whole window out
  twice a second, and the roster fills in a batch of rows at a time.
• In the split layout Help (and the big Compose window) from the roster's menu brings
  the messages window up: they are panels of it, and stayed invisible while it was
  closed.
• --update-config moves an option that changed its name (ui.button_icons of the 0.17
  development builds is ui.additional_icons), and the start says what it is now
  instead of "unknown key".
• Less freezing after a poll: the lanes and their unread counts are worked out in the
  poll thread before the window hears of news, and unread counts are cached until a
  lane or a read mark changes — the sidebar asked every lane after every event, reading
  thousands of stored posts between two frames (250 ms to a second).
• fedtail --layout single|columns|split and --theme NAME: the layout or the theme for
  one run, the config untouched.
• Help gets a "Server and federation" part under its contents: About the server, What it
  can do (the probe) and Federation status open on its right side, as pages of the same
  panel — the settings-like window of Psi or QIP, only for what to read, not to set
  (settings stay a file).
• fedtail took GoToSocial 0.22 for Mastodon: its version says only "0.22.1+git-…".
  Now it reads the instance document's source_url and GoToSocial's own keys, and asks
  the server's nodeinfo when still unsure — so × in Activity hides here instead of
  asking the server, and the probe says right what GoToSocial can't. Translating is
  read from the newer instance document (Mastodon said "no" before when it could).
• Server info → What it can do: "Copy" (a Markdown table, for a bug report or a chat),
  "Save…" to a file, Ctrl+C copies the selected rows.
• ≡ → Server info has a "What it can do" tab: "Check" asks the server about two dozen
  features with harmless one-item GETs (a few seconds, in the background) and lists yes /
  no / closed to me / unclear, with the limits; the last check is kept. The answers also
  decide which buttons fedtail offers.
• Help: in the comparison tables the header row stays on top while the rows scroll under
  it, so a ✓ always says whose it is.
• Every built-in theme comes with its fonts (all SIL OFL 1.1, all with Cyrillic, nothing
  to install): PT Serif in paper, IBM Plex Mono in terminal, IBM Plex Sans in nord,
  Source Sans 3 and Source Code Pro in night and solarized, Open Sans in point,
  Arimo in juick, Comfortaa and Nunito in pink, PT Sans in contrast, Fira Mono in
  bnw where DejaVu is missing. ui.fonts chooses whose: the theme's (default), the
  system's, or your own (ui.font, ui.mono_font — any of these by name too).
• × on a row of Activity on GoToSocial: the server can't dismiss one notification (only
  clear them all), and fedtail used to ask it anyway — a 404 in the log, the row stayed,
  and "Clear" went missing until a restart. Now × hides the row here (and stays hidden
  after the next fetch); on Mastodon it goes from the server too. It never mutes
  anything: new ones of the kind come as before. The tooltip says which it is.
• Fonts of your own: ui.fonts = "custom" with ui.font (a list works: the first one
  there), ui.mono_font for #ids. Fonts needn't be installed: .ttf / .otf in
  ~/.config/fedtail/fonts/ are picked up at start, and a theme can bring its own
  ([font] files, next to its .toml).
• Muting a thread works on GoToSocial: the server can't, so fedtail mutes it itself — the
  thread's mentions are dropped as they come (replies there tag everyone in the thread by
  themselves), even replies under posts fedtail never saw, and what came before leaves
  the lanes. It used to say "Your server can't do that" and hide the item; now the item
  is always in the ⋯ menu, and on Mastodon it asks the server as well.
• Reply with quotes: ⋯ → "Reply with quote" puts the post (or what's selected in it) into
  the reply as a > quote; a right click on selected text → "Quote in reply". With the
  reply already open the quote goes where the cursor is, so a long post can be answered
  sentence by sentence without copying. post.quote_prefix.
• Web: the ≡ menu (write, my profile, refresh, all read, help, keys, about) and a post's
  ⋯ menu (reply with quote, subscribe / leave / mute the thread, copy the link, delete my
  post); q replies with a quote. A reply shows the whole post it answers: select a piece,
  "❝ Quote in reply" puts it at the cursor. The picture viewer goes through the post's
  pictures with ← / → and the side buttons.
• Terminal interface: p shows the profile for real — the screen used to scroll its header
  away as the first post was highlighted, and what stayed looked like a lane. Lanes by
  keyboard: [ / ], 1…9, h into the lane lis...

fedtail 0.16.0

• Faster reading deep into big lanes: stored posts are paged from where the last page
  ended instead of skipping the newer ones again each time, and text is pulled out of a
  post's HTML with patterns compiled once. Ctrl+F "in every lane" goes through lanes that
  share a source together, each post parsed and matched once — on 20 000 stored posts
  it takes 0.4 s instead of 0.9 s; "Deeper" and long lanes gain the same way.

• A click on the time slider of a video or an audio jumps right there; it used to move
  only one step towards the click, and only dragging the handle really seeked.

• Sending no longer gives up after 30 seconds on a slow server: it waits post.send_timeout
  (90 s). When the answer still doesn't come, fedtail looks among your latest posts first —
  the post was usually made, only the answer lost — and treats it as sent if it's there.
  If it can't tell, the message says "maybe sent: look before retrying" instead of a raw
  "Read timed out". Each post carries an Idempotency-Key: Mastodon gives back the post
  already made instead of a double when the same text is sent again.

• Ctrl+F "In every lane": a tick in the find bar searches everything stored in every lane
  at once; the counter says which lane the match is in, and the next match opens its lane
  and loads it down to the post. Ctrl+F pressed again in the find bar goes to the next
  match, as in a browser (Enter, ↓ and F3 still do too).

• The point theme closer to point.im: square avatars, the name bold in dark blue with
  @address · date under it, the post's #id under the text on the left with the number of
  replies (#a3f | 4), the buttons on the right, a hatched grey band behind the lane's
  and the new post's title, solid and clearer lines between posts, a dark "Create"
  button. New theme keys for any theme: shape.avatar_shape (circle,
  square, rounded), shape.card_header = "stacked", shape.short_id (header, footer),
  shape.actions_align (left, right), shape.rule (solid, dashed), shape.header_stripes,
  shape.header_bar (a band above the title strip, point.im's dark top bar),
  colors.primary / on_primary, colors.header, colors.header_bar, colors.name.

• The lane's and the new post's title strip is tinted with the theme's accent in every
  theme (colors.header left at "auto"), with a 3 px band of the accent above it
  (shape.header_bar, 0 turns it off); bnw and contrast keep a white strip under the band.
  Lines between posts in "rule" style are solid by default (terminal keeps its dashes).

• "Add to list" for someone you don't follow: the lists are dead now, not just greyed —
  a click on them does nothing at all (it used to send a request the server refused and
  stall the window). While fedtail is still asking the server whether you follow them,
  the lists are dead too, with "Checking…" above them, instead of looking clickable.

• Video is decoded by the processor by default (ui.video_decode = "software"): on some
  cards Qt's hardware decoding fails ("CUDA_ERROR_INVALID_VALUE", "more than 32 decode
  surfaces") and the video stutters or stalls. "hardware" brings the old way back.

• The opossum is gone from the icon and About: it comes from an official Telegram sticker
  pack, and its artist says the rights are Telegram's, not theirs to give. The drawn
  thread bubble is the icon again (in the theme's colours with ui.themed_icon);
  ui.app_icon is gone with it.

• "Activity" counts as seen what came on screen, like the other lanes, checked when you
  scroll or come back to the window. It used to mark everything once, on opening — rows
  far off screen too — and a window in the background at that moment left the newest
  unread for good.

• The debug theme: for finding what's wrong, not for reading. Each state of a post in a
  loud frame of its own — unread, "on screen but not all of it yet" (not counted read
  yet), the j/k cursor, what Ctrl+F found, the post you came to — plus the keyboard focus
  and disabled buttons. shape.debug = true turns the same on in any theme of your own.

• "Copy handle": a button in a profile, "Copy handle @…" in a post's ⋯ menu (the author,
  and the booster of a boost) and on the "boosted by" line. Always the full @user@server
  — people of your own server come as a bare user, your server's name is added.

• ⋯ → "Call into the thread…": a reply to that post with only "@" in it and the people list
  open — pick who, add a word, send. They get a notification and open the thread at home;
  no links with service ids. The thread's others aren't mentioned; the call has its own
  draft. post.invite = false hides the item.

• ≡ → Debug → "Federation status": how your server is doing — what it runs, how many answers
  and how fast, polls and the live stream — and what keeps failing that isn't the client's
  doing: what the server can't do, who waits to go into a list, and every request that
  keeps getting 404/410/401/timeouts, on your server and on other servers, grouped (ids
  folded), counted, with when it last happened and what it most likely means. Live while
  open; "Copy" as text for an issue; "Count anew". Only what this run saw: nothing is asked
  of the network for it, no queries or tokens are kept.

• Federation status: who waits to go into a list is named (my server is asked who an id
  is when no post of theirs is here), linked to their profile in a tab, with why they
  wait — a follow request unanswered, not followed (refused or withdrawn), or followed and
  going in with the next refresh.

• A slow answer about direct conversations no longer fails the whole poll ("Read timed
  out" on screen, the lanes not fetched): it is only a nicety, skipped till next time.

• Someone waiting to go into a list is tried only once they're followed; while the follow
  request waits nothing is asked, and once it's refused or withdrawn they're let go. (A
  refused follow was retried with a 404 every ten minutes, for a month.)

• What the server hasn't got — blocked domains on GoToSocial, the notification policy —
  is asked once a run, not on every silence refresh. Muted and blocked lists no longer
  ask for an empty second page.

• A post's ⋯ menu is built when it opens, not with every card: two dozen actions and
  submenus per card were most of a lane's widgets and of its drawing time; what it shows
  (unread, subscribed, pinned) is how things are at that moment.

• The log's trend line gives the rate over the whole session beside start → now (and the
  last minutes apart): 245 → 763 MB over a night read "+1950/h", the rate of three minutes.

fedtail 0.15.0

• feed.prefetch is "previews" by default: new posts' previews, avatars and link
  pictures come ahead of time; the videos themselves and full originals only with
  "all" (it fetched every new post's video before).

• Logging in to a plain http:// server is refused unless it is at home (localhost, a
  private address, .local/.lan): the token would travel in the clear.

• The web interface prints and opens a one-time link (good for 15 minutes) instead of one
  with its key; at most 32 connections, a silent client dropped after a minute; #tag
  links open the tag's page on your server.

• Leaving fedtail no longer throws "cannot schedule new futures" and "closed database"
  into the log: late jobs are turned away, running ones finish first.

• state.db is private (0600) like the token's file; on Windows the single-instance pipe
  needs the profile's key; no query string (search words, signed addresses) reaches the
  log.

• fedtail has a face: an opossum holding its own tail — the icon of the window, the tray,
  notifications and the menu entry (--install-desktop, the .deb, the Windows .exe), and
  the picture in About. ui.app_icon = "bubble" brings back the drawn thread bubble
  (in the theme's colours with ui.themed_icon).

• A boost no longer brings an old post into the feed again and again: a post comes into a
  lane once — as itself or with its first boost. A boost of a post the lane has had already,
  or of one read already (in a thread, in another lane), is not shown, not counted as
  unread and not notified about. feed.repeat_boosts = true shows every boost again, as
  other clients do. (The server drops a repeat only while the post is among the last
  few dozen of the feed.)

• The unread number on the icon (ui.icon_count) picks lanes the way notifications do:
  "lists" (all lists — it was accepted and counted nothing), "list:Друзья", "all",
  and the new ui.icon_count_except takes lanes away. The config's comments for both
  name every lane in the sidebar.

• Security: a post's link could wrap anything in fedtail:resolve/… — a local file (the
  token's auth.json too), a network share, javascript: — and a click on its text opened it
  when the server found nothing. Now that wrapper holds web addresses only, and nothing from
  a post or another server goes to the desktop but web, mail, XMPP, Gemini and magnet links:
  on Windows opening file://host/share alone hands the login's NTLM hash to that host.
  Profile, thread and account links from a post take an id, never a path.

• Security: someone else's words are shown as text, not markup — the content warning in an
  edited post's history, the alt text under a video and in picture tooltips, a link card's
  picture description, a cut name's tooltip, a link's hover address (it could show one
  address and lead to another). Desktop notifications too: a post saying <a href=…> in
  plain letters no longer becomes a link there; a name starting with -- is a name.

• Links whose address has &not=, &copy=, &para=… in it are no longer garbled
  (?a=1&not=2 became ?a=1¬=2).

• The web interface: a POST with a negative Content-Length is refused instead of read to
  the end of the connection; a fediverse link it can't find opens in the browser only when
  it is a web address.

• Security: what other servers and posts point at — ActivityPub objects, nodeinfo,
  pictures, videos — is fetched from public addresses only (not this computer, the home
  network, a cloud's metadata service; your own server is exempt), each redirect checked
  again, and only so much: 2 MB of JSON, 20 MB a picture, 100 MB an original, 300 MB a
  video on disk. A server's nodeinfo is read only from that server.

• Security: logging out revokes the token on the server too (it used to stay good there);
  logging in anew revokes the old one.

• D #id asks first in the web interface (a "sure?" in the page) and in the terminal
  (Enter again within half a minute), as the window always did.

• The live stream goes through the same proxy as everything else (HTTPS_PROXY; a SOCKS
  proxy means polling only), only to your server's own site and only over TLS.

• Profile names start with a letter, a digit or _: .. pointed outside the profiles.
  A broken auth.json or profile card means "log in", not a crash; the token's file is
  private even when a crash left a temp file behind.

• "Activity" follows feed.order like every other lane: with "oldest_first" the newest
  is at the bottom, it opens where the unseen begins (feed.start_at) and stays put when
  more comes (feed.on_new). It used to be newest-on-top whatever the config said.

• feed.emoji = false: no emoji in the feed at all — no server pictures (:blobcat:), no
  Unicode ones (🔥 🇬🇪 👨‍👩‍👧), no reactions line; a name made only of emoji shows the login.
  fedtail's own glyphs (⚠ ↔ ❯) stay.

• ≡ → "Try a theme", next to "Open themes folder": any theme at once, until restart — the
  sidebar and every card are drawn again in place, the reading place kept. ui.theme in
  the config stays what the next start brings.

• Lanes are named in the config as their titles say: people → home, comments →
  replies, global → federated, mine → my_posts, favourites → my_likes. The old
  names still work everywhere (config, command line, web API); the lane open, the columns
  and the choices over a lane that the window remembered move over by themselves. A lane's
  tooltip in the sidebar names its word. "Likes & boosts" is "Activity" now — it was always
  the follows and polls too, and its word was activity all along.

• notify.lanes = ["all"]: notifications about everything that arrives, in any lane; and
  notify.except — lanes never to notify about, whatever notify.lanes says ("bots",
  "federated", "lists", "list:News"…).

• Why a notification didn't come is in the log at the normal level now: "not asked for"
  (notify.lanes / notify.except) or "that lane is on screen" (notify.when_focused).

fedtail 0.14.0

• Leak hunting for days-long runs. With every stats line a "trend" line: memory, Python
  objects, widgets, cards, pictures, threads, files — at start, now, per hour; a number that
  rose on each of the last debug.leak_samples checks (12: an hour), by more than noise,
  gets a "possible leak" warning (the first half hour doesn't count). In the debugging mode
  a census of Python objects by type and Qt widgets by class says what grew since the last
  check and since the start (debug.object_census). debug.tracemalloc traces every
  allocation from the start. The session ends with a summary line: hours, memory, peak,
  freezes, polls. Memory snapshots go next to the logs and leave with them.

• ≡ → Debugging: "What grows: stats and object census now", "Give free memory back to the
  system", "Memory tracing (tracemalloc)" on and off, "Memory snapshot" — who holds the
  most and what grew since the first snapshot, by line of code.

• TUI: new counts arriving before a lane's line was on screen no longer crash it (CI caught
  it now and then).

• A poll slower than debug.slow_request_seconds says where the time went: poll #N took 6.20 s (markers 5.80, home 0.30, …); the stats line has core.max_poll_s since the
  last one.

• The stats thread no longer walks Qt's widgets itself (from another thread that could
  crash a window kept open for days): the window counts them every 30 s and the stats
  line reads that.

• Scrolling up a big lane no longer jumps: while cards are built above the screen, the
  next step took the place from the scroll bar before it had caught up, so a card just
  built became "the post on top" and the reading place moved by thousands of pixels. The
  held anchor decides until it is let go (CI caught it, one run in two).

• ≡ → "Account and server" (was "Accounts") also holds "About the server…": one place for
  this account, its server and the other profiles.

• ≡ → "For the tender and sensitive": word filters, muted, blocked, blocked servers and
  filtered notifications in one submenu, each opening where it is; with ui.arts_mode on, a
  line on top says server filters don't apply there (mutes and blocks still do).

• The ≡ menu is shorter: no Write, Refresh and Search (they are on screen, and their keys
  stay), no My profile / Edit profile (My profile is under Accounts; the Edit button is on
  your profile page), no "Posts across the full width" — that is a button now, ↔ between ≡
  and ❯, a drawn ↔ (icon themes have no plain one).

• The sidebar's edge drags: a long name gets room. ui.sidebar_width (272) is the start;
  a dragged width is kept till the config's number changes. A long name is cut, not
  pushing the sidebar wider.

• ≡ ↔ ❯ at the top left are one size, icons from one set (or all glyphs), centred; ≡ no
  longer reserves room for a popup arrow that pushed its icon aside. ↔ and ❯ show when on.

• The main profile ★ is a mark, not a folder named "default": ~/.config/fedtail/main-profile
  names the profile started without --profile (none: "default", as before). Accounts →
  "Make it the main one ★"; --profiles marks it with *.

• "Log in again" was dangerous: it threw the token away at once, and a cancelled login left
  the main profile logged out. Now, under "Account and server", with a question first: "Log in again…"
  keeps the old token until the new one is in and refuses another account; "Log out…"
  deletes the token, hands the main profile's ★ to another logged-in profile and switches
  the window there (none left: the login window).

• About links to the code on GitHub and to the author in the fediverse — that one opens
  in fedtail, with Follow. Which profile and account this is moved from About to the left
  of the status bar: "default: @me@server ★".

• Lanes side by side, in columns: ❯ right of the menu switches for now, ui.layout says how
  the window starts. A lane clicked on the left comes as one more column (or is scrolled
  to), ✕ takes one away, ‹ › move it; the set is remembered (ui.columns at first,
  ui.column_width each). The same lane widgets move over: place, filters and read marks
  as they were; browse lanes keep fetching while they stand in a column.

• ~~text~~ that came as it was typed (a Mastodon server knows no Markdown) is shown
  struck out, as the writer meant; not in links or code (feed.text_markup).

• All accounts in one window: "From another account" in a post's ⋯ menu — like, boost or
  reply as an account that didn't receive it; the post is looked up on that account's
  server by its address and the action goes from there (ui.act_as).

• "📄 Read it whole" in the ⋯ menu of a post from another server: the post as the author's
  server keeps it — an article whole, not a title and a link; an event with its time and
  place (asked without your token; feed.long_form).

• A profile says what the person's server runs, "🖥 GoToSocial 0.17.3", from its nodeinfo
  (asked without your token, kept a week per server; feed.server_info).

• docs/FEATURES.md: the boost carousel moves to "won't do", with the reasons.

• A post as a chain: a line of just --- splits it into posts sent at once, each answering
  the one before (pictures and the poll with the first); the counter counts each part
  (post.chain).

• "👁 Preview" in the compose panel: the Markdown made into text (when the server takes
  it), the CW, who sees it, each part of a chain; Send or back to Edit from there
  (post.preview).

• A paragraph of nothing but hashtags (more than three) folds into the first three and
  "… +N", small, in a lane; whole but small in a thread (feed.collapse_tags).

• The server's own notices in Likes & boosts (Mastodon 4.3+): follows cut because a server
  was blocked — which, why, how many — and warnings from the moderators
  (activity.server_notices).

• All accounts in one window: the "→ @nick" mark of each account has a colour of its own,
  the same every time (ui.account_colors).

• A picture bigger than the server takes is made to fit before the upload (its pixel
  limit, then JPEG — PNG with transparency — under its size limit), instead of a refusal
  after it; your file stays as it is, gifs are never flattened (post.resize_images).

• An old post says so next to its date — "old, 45 days" — when it's older than
  feed.old_days (30): ones pulled from an outbox or an old thread aren't read as news.

• fedtail open URL opens a post or a profile in the running window (or starts it and
  opens it there); --install-desktop also makes fedtail the handler of web+ap:// links.

• In the profile of someone you follow: "♻ hide their boosts" and "🌐 languages" (only their
  posts in these) — kept by the server, for every client (feed.per_person_follow).

• A moved account says so: "📦 Moved to @new" on the profile, with Open and Follow there
  (feed.show_moved).

• "Delete and redraft" in the ⋯ menu of a post of mine: deleted, and its text as typed,
  CW, visibility, language and what it answered open as a new draft; pictures go with the
  post on the server and are added again (post.redraft).

• Several hashtags as one lane: #georgia #грузия -#politics in the search (+#tag must
  have, -#tag without) opens one lane of them; "＋ to lanes" keeps it in the sidebar's new
  Tags group, browsed while open like Federated (right click: remove). Or in the config,
  [[lanes.tag_groups]] with name, any, all, none. Each tag is asked for on its own
  (GoToSocial reads one at a time) and put together by fedtail, each post once.

fedtail 0.13.0

In short: GoToSocial approvals of replies, likes and boosts; lists — who is in them,
your own order, author or booster, only people you follow; pictures and videos fetched
ahead to a disk cache with its own limits (1 GB pictures, 10 GB videos); a big lane lets go
of cards far behind and never builds them all at once (no more 6-second freezes and
gigabytes on a filter); freed memory goes back to the system; your own posts are always
read; the player goes between a post's videos; full-width posts, any post language,
a bigger compose panel, a boosts filter; errors in one line and once; docs/CONFIG.md
and a rewritten docs/FEATURES.md.

Everything in detail:

• Arts mode is called by its name: it is named after @ArtS, the founder of Point.im, and
  is not translated as «искусство» any more (config reference, docs).
• docs/FEATURES.md: each chapter is a table — feature, status, setting, API, other
  clients — with the details folded under it.
• docs/CONFIG.md: every option in tables by chapter, with its default — built from
  config.example.toml by tools/config_doc.py (a test keeps it in step).
  docs/FEATURES.md rewritten: every feature with its switch, API and the other clients,
  the plans and what won't be done, with reasons.
• Pictures of new posts are fetched to disk as soon as the posts come, by workers of their
  own: a lane opens with its pictures there, not loading for seconds from a slow server
  (feed.prefetch: "all" — the default, originals, videos and gifs too; "previews";
  "off").
• Videos, gifs and sounds have a disk cache of their own (ui.video_disk_mb, 10 GB): a
  video played once plays from disk the next time; with "all" they're fetched ahead, one
  at a time.
• The picture cache on disk keeps to ui.image_disk_mb (1000 MB): the ones not used the
  longest go, at start and along the way. It only grew before.
• Who is in a list: a server that answers "everyone at once" (limit=0) with nobody is asked
  again page by page; the log says how many came each way.
• Right click on a list in the sidebar: "Who is in it…" opens its people (the ones waiting
  to go in too), each with "Take out of the list"; "Move up" / "Move down" put the lists in
  your own order, kept by fedtail (servers have none) — new lists come at the end.
• The same error from every poll while a server is down is shown and logged once, again
  only when it changes or ten minutes later.
• A server behind a proxy that's down (a 502 from Cloudflare) showed the proxy's whole HTML
  page as the error; now "Bad Gateway — the server is down or not answering".
• "Add to list" for someone you don't follow: the lists are greyed out under "lists take
  only people you follow: follow first", with Follow right there (the server is asked when
  the menu opens, and the answer kept a few minutes).
• A right click on "♻ boosted by …": the booster's profile, or into a list.
• "♻ boosted by …" over a boost: the name opens the booster's profile.
• A boost's ⋯ menu says whom it puts in a list: "Author to a list (@…)" and "Booster to a
  list (@…)" (a relay bot, say), each its own submenu.
• A new list made from a post's menu with someone not followed stayed invisible until a
  restart (and a second try said it already exists): the refused add stopped the job
  before the lists were read again. The list now shows at once and the person waits to go
  in — the message says the server takes only people you follow.
• The short-buttons check measured every button on every resize of every card (a second's
  freeze when a lane opened); it measures once.
• Buttons under a post too wide for the card go short — icon (or glyph) and the count —
  instead of a label cut in half ("В избран…"); the full label stays in the tooltip.
• ≡ → "Posts across the full width": the column of posts takes the whole window (or back
  to ui.max_width), remembered for the next start.
• The language list of a post has "Another language…" at the bottom: any ISO 639 code (eo,
  es, cv, jbo, tok…), kept on the list after that; Toki Pona, Lojban and a few others
  get their names.
• The compose panel's size follows the window: ui.compose_size in % of it, and a ⤢
  button in the panel for normal / big (90 %), remembered.
• The filter next to Refresh can hide boosts too (for this run, like the rest of it).
• Switching the media filter (or "unread only") on a big lane froze the window for six
  seconds and took gigabytes: the lane decided the cards built reached both ends and built
  all of them. It now builds around the post on screen, as when it opens.
• A click on "older" at the very top ("nothing older") no longer jumps a few posts down:
  the button took the focus, and handed it to a card further down while it waited.
• My own posts are never unread, from whatever client: ones written in Tusky overnight came
  in as unread when they reached fedtail some other way than a lane (a catch-up after a
  restart, a thread). Ones stored before are put right on connect.
• A long lane lets go of the cards far behind the reading place (past 3 × build_at_once:
  back to that many behind and twice ahead; the post on top stays put). Reading a night's
  hundred posts kept every card built — over a megabyte each, pictures included — and took
  the client from 700 MB to 1.1 GB.
• A list add waiting for a follow to be confirmed, retried while the server was slow, showed
  "Read timed out" as an error; it now just waits for the next try.
• Approving: only the very request is answered — the same person, the same post, still
  waiting. It used to fall back to "something similar" and once approved a like for a
  reply. A request already answered elsewhere says so instead of an error; a miss logs what
  the server listed.
• Memory freed by fedtail goes back to the system every few minutes (glibc keeps it
  otherwise: a client open all night stayed at 1.3 GB holding almost nothing);
  debug.trim_memory. The stats show how much came back and open files by kind.
• Replies, likes and boosts waiting for my approval (GoToSocial interaction policies) come
  to Likes & boosts — "reply waiting for your approval" — with ✔ approve and ✘ reject
  right on the row; the server's request is answered and the notification goes. They came
  before only to clients that ask for every kind (activity.approvals).

fedtail 0.12.0

In short: tabs stop jumping (to the lanes, to the bots, from under the curtain); the
player goes between a post's gifs and videos; older posts of a profile from servers that
hide their outbox; --update-config puts new options where they belong; less memory for
pictures and fewer polls on a busy stream; old logs of the first versions cleaned up.

• Less memory and CPU for pictures: a feed picture is decoded at the size of its box
  (times the screen's pixel density), not at 1200 px — most of a lane's memory was
  pictures held at several times the pixels shown (ui.image_decode = "box"; "full" as
  before).
• The live stream wakes a poll at most every 10 s (poll.stream_gap_seconds): a busy server
  sends events many times a minute and each poll asks every lane. Refresh doesn't wait.
• The stats every 5 minutes count Python objects too (py_objects), to tell a leak.
• The log of the first versions (fedtail.log, fedtail.log.1…) now goes with the other
  old logs when a new version starts. Tabs coming to the front, the curtain lifting and
  Enter on the curtain are in the log.
• With every lane closed (Esc, the curtain), opening something whose tab was already open
  (my own profile from my name, a thread, a search) did nothing visible: the tab came to
  the front under the curtain. It now lifts the curtain.
• Several gifs or videos in a post: ‹ › at the top right of the player and the keys go
  between them without closing it (← → or the wheel for gifs; PgUp / PgDn for videos, where
  ← → seek), with "2 / 3" next to them and the keys in a faint line at the bottom.
• With every lane closed (the curtain), Enter in the sidebar search box opened the search
  and then the last lane on top of it: the box let its Enter go on to the window, where
  Enter on the curtain means "back to the lane". A tab opened from the curtain now shows.
• --update-config: a new option went under the next chapter's banner (inside the next
  section's comments) instead of at the end of its own section; and a file without blank
  lines between options stayed packed. Now options sit where they belong, a blank line
  between each.
• A search, thread or profile tab no longer jumps back to the lanes: when the sidebar was
  rebuilt (lists refreshed, say), choosing the lane again brought the lanes tab to the
  front. The lanes tab comes forward only when I choose a lane (a click, the sidebar
  keys, Alt+N, start-up). Enter in the search field stays in the search field.
• Older posts of a profile from a server that won't show its outbox to strangers
  (GoToSocial, Mastodon with authorized fetch): read through that server's public API
  instead, when it answers without a token.
• Those older posts show four at a time as my server fetches them (it takes seconds a
  post), with "n of total" on the button, instead of all at once a minute later.

fedtail 0.11.0

In short: no more freezes when a lane opens (cards are built around where you read,
the rest as you scroll); video, audio and gifs play in the window, with a download button;
who liked and boosted, quotes of your posts, muted threads, trends, suggestions, the
directory, server info; a media filter next to Refresh; older posts of a profile straight
from the author's server; lists right after a follow; times in Likes & boosts and the
follow date in your private note; logs in the profile's folder, much more detailed.
Video needs python3-pyside6.qtmultimedia and python3-pyside6.qtmultimediawidgets.

Everything in detail:

• Likes & boosts: each row says when (for a group, from when to when; the tooltip lists
  everyone with their time). A profile says "following since …" for people followed
  through fedtail — the server itself doesn't keep that date, so fedtail writes it as the
  last line of my private note on them, [fedtail followed YYYY-MM-DD]: seen on every
  device and in other clients, hidden in fedtail and kept when the note is edited, taken
  out on unfollow (feed.follow_date_note).
• The player has a ⤓ download button (key S), for gifs too; right click on a video or a
  gif in a post says "Download". Big files go to disk a piece at a time.
• A profile from another server: once my server has nothing older, "▼ further back —
  from their server" reads on in their own outbox, a page at a time (feed.remote_profiles).
• Putting someone just followed into a list: the server refuses until the follow is
  confirmed (a 404). They now go into the list in fedtail at once, and fedtail puts them
  into the server's list by itself on a later lists refresh (given up after 30 days).
• docs/FEATURES.md: what fedtail does and doesn't, next to other clients, with the config
  switch for each; linked from both READMEs.
• Terminal interface: a poll landing while a thread, a profile or the composer was open
  (right after sending a reply, say) failed and printed its traceback over the screen. The
  update now finds the lanes on the main screen, and no log lines go to the terminal while
  the interface owns it (they are in the log file).
• Logs live in the profile's data folder, logs/ (≡ → Debugging → Open the log folder),
  not in ~/fedtail-logs any more; debug.log_dir still sends them elsewhere. A new
  version deletes the old version's logs at its first start, and the old home folder ones.
• Read on scroll (read.mark_read = "on_scroll") marks what you actually scrolled through:
  a post that was on screen and that you went on past counts as read even if it never
  stood all on screen at a pause; scrolling a window without focus with the wheel (KDE
  does that) counts too; and pictures still arriving no longer hold the marks back.
• ui.arts_mode (on by default): every post as its author made it — content warnings
  open, sensitive pictures uncovered, server filters neither hide nor fold posts, no
  "Report" item. Your own mutes and blocks keep working; what the server itself cuts off
  never reaches a client. false brings back the separate switches.
• Pictures: originals (a single picture made sharp, the viewer, saving) have their own
  workers and no longer hold up the previews; a preview that hasn't come in 12 s is asked
  again 1.5 s later with a minute of patience (a server fetching it from elsewhere usually
  has it by then — before, all workers sat 30 s on such pictures and the rest waited);
  pictures are decoded straight at the size they're shown (a big JPEG is read at a fraction
  of its size), which costs less time and memory; a broken picture is retried after a
  minute, not five.
• A like, a boost or an edit redraws only the cards of that post. Every card in every lane
  used to be fetched from the database again — over a second of frozen window with a few
  hundred cards open.
• ui.unload_hidden_minutes (10): a lane not opened that long lets its cards go; opened
  again, it's drawn anew at the first unread. A client kept open for days held over a
  gigabyte in cards and their pictures. The lane in front is never unloaded; 0 keeps all.
• A funnel next to Refresh in lanes, profiles and tags: show only posts with pictures,
  gifs, video, audio or plain text; for this run only.
• "To new" with nothing unread scrolls to the newest end instead of going grey.
• Video, gifv and audio in the window (ui.video_player, QtMultimedia): a video plays over
  the window (Space, ← →, M, O for the browser, Esc); gifvs loop in their cards, muted,
  only while on screen and at most three at once (ui.gifv); audio gets a player in its
  card. Without QtMultimedia, or with "browser", they open in the browser as before.
• Around posts and people, where the server can (a feature it hasn't got disappears after
  its first "no"): who liked and who boosted a post (also the rest from the post's own
  server; a right click on ★ or ♻), mute a thread, who quoted my post and taking my post
  out of a quote; on profiles — remove a follower, feature someone, people in common; a
  tag on my profile; ≡ → Find people (server suggestions, profile directory, trends) and
  About the server (rules, description, privacy); Activity — dismiss one, clear all;
  emoji reactions shown on posts from servers that have them; reactions to announcements.
• post.default_visibility = "server": what you set on the server's web side.
• Direct messages read here are read on the server too (Mastodon conversations).
• A right click on a post's text opens the post's menu.
• Read by hand, one post at a time: "Mark read" and "Read up to here" (this one and
  everything older) in every post's menu; with read.mark_read = "manual" the lane waits
  exactly where you stopped. read.read_button puts a ✓ under each unread post.
• A bookmark button under every post (ui.bookmark_button; it was only in the ⋯ menu).
• Opening a lane no longer builds a card for every post in it: only those around the place
  reading starts at (feed.build_at_once, 40), the rest a few at a time as you scroll near
  an edge. Cards built above the screen are held in place by the same anchor that keeps
  your place when new posts come, so nothing jumps; finding (Ctrl+F), "to the first
  unread" and "all read" still cover the whole lane. 0 builds everything at once.
• Lanes with many posts under content warnings opened in seconds instead of tens of
  seconds: every such card made, and threw away, a native window of its own while it was
  built (the log showed a 16 s freeze for a list of 300 posts). Word-wrapped text also no
  longer lays itself out twice for every resize.
• Threads from other servers come whole faster: where the post's server keeps a list of
  the whole conversation (its "context", Mastodon 4.5 and others), it is read in one go
  instead of walking replies of replies; the missing posts are fetched four at a time.
• Someone from another server with no pins known here: their pins as their own server
  lists them (feed.remote_profiles).
• Honest counters (feed.honest_counters): when the author's server won't tell a
  stranger, the numbers are asked as one of your other accounts — on the author's server
  if you have one there, or on another server that already has the post
  (feed.counters_via_accounts, on). Each token goes only to its own server.
• activity.types = ["all"]: every kind of activity, now and those added later.
• The config reference reads easier: a blank line between options, and every launch key
  (--profile, --ui, --debug, --bug-report…) listed at the top of the file.
  --rebuild-config lays your file out the new way, with your values kept.
• The log tells where a freeze is: any freeze of the window over debug.stall_ms (250 ms)
  gets a line with how long it was and what the window was busy with — an event, a
  lane being drawn, a picture coming in, or Qt itself laying out and painting — with the
  stack. Every picture gets its queue, download and decode time; the stats line counts
  freezes (freezes.*) and pictures (img.*).