Add configurable default home screen action

Themes can now specify an initialAction in home screen config to set the default selected action when entering home normally. Falls back to this theme setting when no explicit action is requested, but explicit firmware navigation still takes precedence.
Add SD theme system
2026-08-13 14:21:57 -07:00 · 2026-06-28 02:38:53 -04:00 · 2026-06-28 01:44:38 -04:00
121 changed files with 7337 additions and 3246 deletions
@@ -67,6 +67,10 @@ USB port or browser before assuming the device is locked. Only reach for the unl
 > Flashing any other firmware on a USB-locked device may **permanently brick the device** or leave it **permanently
 > stuck on that firmware with no recovery path**. Once USB flashing is re-locked, your only way back is via OTA, and if
 > the firmware you flashed doesn't support OTA, **there is no way out**.
+> 
+> **The Papyrix fork has removed OTA update support from its code.** If you flash Papyrix onto a
+> USB-locked unit, you will have **zero update or recovery path** and will be stuck on it forever. **Do not flash
+> Papyrix (or any other unsupported firmware) on a locked device.**

 ## Install firmware

@@ -127,6 +131,23 @@ Convert your own TTF/OTF files into `.cpfont` files that load from the SD card.

 Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py` script unmodified, so output matches a local host build.

+## Custom SD-card themes
+
+Downloadable themes are packaged in the tools repo under `../crosspoint-tools/public/themes/<theme-id>/`. Each theme folder must contain a `theme.json`; optional assets such as generated BMP icons live beside it, usually under `icons/`.
+
+See [SD-card theme creation](./docs/theme-creation.md) for the full JSON format, device-specific overrides, icon generation, CrossInk extension fields, and packaging rules.
+
+After adding or changing a hosted theme, regenerate the download manifest:
+
+```bash
+python3 scripts/generate-theme-manifest.py \
+  --root ../crosspoint-tools/public/themes \
+  --base-url http://crosspointreader.com/themes \
+  --output ../crosspoint-tools/public/themes/themes.json
+```
+
+The script scans every theme folder, includes every file in each package, and writes size and CRC32 values used by the device downloader. Commit changed theme package files and the regenerated `themes.json` in `crosspoint-tools`.
+
 ---

 ## Documentation
@@ -134,6 +155,7 @@ Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py`
 - [User Guide](./USER_GUIDE.md)
 - [Web server usage](./docs/webserver.md)
 - [Web server endpoints](./docs/webserver-endpoints.md)
+- [SD-card theme creation](./docs/theme-creation.md)
 - [Project scope](./SCOPE.md)
 - [Contributing docs](./docs/contributing/README.md)

@@ -245,7 +267,7 @@ One of the best things about open source is that anyone can take the code in a d

 - [papyrix-reader](https://github.com/bigbag/papyrix-reader) — Adds FB2 and MD format support. Actively maintained with Arabic script support. Custom themes via SD card.

- ~~[crosspet](https://github.com/trilwu/crosspet) — A Vietnamese fork that adds a Tamagotchi-style virtual chicken that grows based on your reading milestones (pages read, streaks, care). Also: Flashcards, Weather, Pomodoro timer, and mini-games.~~ (Unmaintained)
+- [crosspet](https://github.com/trilwu/crosspet) — A Vietnamese fork that adds a Tamagotchi-style virtual chicken that grows based on your reading milestones (pages read, streaks, care). Also: Flashcards, Weather, Pomodoro timer, and mini-games.

 - [crosspoint-reader-cjk](https://github.com/aBER0724/crosspoint-reader-cjk) — Purpose-built for Chinese, Japanese, and Korean reading.

@@ -5,7 +5,6 @@ Welcome to the **CrossPoint** firmware. This guide outlines the hardware control
 - [CrossPoint User Guide](#crosspoint-user-guide)
  - [1. Hardware Overview](#1-hardware-overview)
    - [Button Layout](#button-layout)
-    - [Taking a Screenshot](#taking-a-screenshot)
  - [2. Power \& Startup](#2-power--startup)
    - [Power On / Off](#power-on--off)
    - [First Launch](#first-launch)
@@ -15,11 +14,7 @@ Welcome to the **CrossPoint** firmware. This guide outlines the hardware control
    - [3.3 Browse Files Screen](#33-browse-files-screen)
    - [3.4 Recent Books Screen](#34-recent-books-screen)
    - [3.5 File Transfer Screen](#35-file-transfer-screen)
-    - [3.5.1 Calibre Wireless Transfers](#351-calibre-wireless-transfers)
-      - [Installing the Plugin in Calibre](#installing-the-plugin-in-calibre)
-      - [Configuring the CrossPoint Plugin in Calibre](#configuring-the-crosspoint-plugin-in-calibre)
-      - [Uploading Books](#uploading-books)
-      - [Removing a Book](#removing-a-book)
+      - [3.5.1 Calibre Wireless Transfers](#351-calibre-wireless-transfers)
    - [3.6 Settings](#36-settings)
      - [3.6.1 Display](#361-display)
      - [3.6.2 Reader](#362-reader)
@@ -28,25 +23,21 @@ Welcome to the **CrossPoint** firmware. This guide outlines the hardware control
      - [3.6.5 OPDS Servers (Multiple Libraries)](#365-opds-servers-multiple-libraries)
      - [3.6.6 Web Settings (Wi-Fi + OPDS)](#366-web-settings-wi-fi--opds)
      - [3.6.7 KOReader Sync Quick Setup](#367-koreader-sync-quick-setup)
-        - [Option A: Free Public Server (`sync.koreader.rocks`)](#option-a-free-public-server-synckoreaderrocks)
-        - [Option B: Self-Hosted Server (Docker Compose)](#option-b-self-hosted-server-docker-compose)
    - [3.7 Sleep Screen](#37-sleep-screen)
-      - [Cover settings](#cover-settings)
-      - [Custom images](#custom-images)
    - [3.8 Custom Fonts (SD Card)](#38-custom-fonts-sd-card)
  - [4. Reading Mode](#4-reading-mode)
-    - [Page Turning](#page-turning)
-    - [Chapter Navigation](#chapter-navigation)
-    - [Auto Page Turn](#auto-page-turn)
-    - [Tilt Page Turn (X3 only)](#tilt-page-turn-x3-only)
-    - [Footnote Navigation](#footnote-navigation)
-    - [System Navigation](#system-navigation)
-    - [Supported Languages](#supported-languages)
+      - [Page Turning](#page-turning)
+      - [Chapter Navigation](#chapter-navigation)
+      - [Auto Page Turn](#auto-page-turn)
+      - [Tilt Page Turn (X3 only)](#tilt-page-turn-x3-only)
+      - [Footnote Navigation](#footnote-navigation)
+      - [System Navigation](#system-navigation)
+      - [Supported Languages](#supported-languages)
  - [5. Reader Menu](#5-reader-menu)
-    - [5.1 Chapter Selection](#51-chapter-selection)
-    - [5.2 Bookmarks](#52-bookmarks)
-  - [6. Current Limitations \& Roadmap](#6-current-limitations--roadmap)
-  - [7. Troubleshooting Issues \& Escaping Bootloop](#7-troubleshooting-issues--escaping-bootloop)
+      - [5.1 Chapter Selection](#51-chapter-selection)
+      - [5.2 Bookmarks](#52-bookmarks)
+  - [6. Current Limitations & Roadmap](#6-current-limitations--roadmap)
+  - [7. Troubleshooting Issues & Escaping Bootloop](#7-troubleshooting-issues--escaping-bootloop)

 ## 1. Hardware Overview

@@ -90,13 +90,13 @@ if (parsedSize != fileSize) {

 ## `section.bin`

-### Version 28
+### Version 25

 Each file in `sections/*.bin` stores one laid-out spine section. The header is
 also the cache-busting key: if any layout-affecting setting differs from the
 current reader settings, the section is discarded and rebuilt.

-Version 28 includes:
+Version 25 includes:

 - cache-busting fields for paragraph alignment, hyphenation, embedded CSS,
  image rendering mode, and Focus Reading
@@ -105,8 +105,6 @@ Version 28 includes:
 - paragraph and list-item LUTs used by KOReader sync page refinement
 - optional per-word Focus Reading split metadata
 - per-page footnote entries
- serialized word style bits for underline, strikethrough, superscript, and
-  subscript

 ImHex pattern:

@@ -115,7 +113,7 @@ import std.mem;
 import std.string;
 import std.core;

-#define EXPECTED_VERSION 28
+#define EXPECTED_VERSION 25
 #define MAX_STRING_LENGTH 65535
 #define FOOTNOTE_NUMBER_LEN 32
 #define FOOTNOTE_HREF_LEN 96
@@ -1,7 +1,7 @@
 #include "EpdFontFamily.h"

 const EpdFont* EpdFontFamily::getFont(const Style style) const {
-  // Extract font style bits; render-time overlay bits do not affect font selection.
+  // Extract font style bits (ignore UNDERLINE bit for font selection)
  const bool hasBold = (style & BOLD) != 0;
  const bool hasItalic = (style & ITALIC) != 0;

@@ -17,7 +17,6 @@ class EpdFontFamily {
    SUP = 16,           // superscript: glyph scaled 50%, raised ~40% of ascender
    SUB = 32,           // subscript: glyph scaled 50%, lowered ~25% of ascender
  };
-  static constexpr uint8_t TEXT_DECORATION_MASK = static_cast<uint8_t>(UNDERLINE | STRIKETHROUGH);

  explicit EpdFontFamily(const EpdFont* regular, const EpdFont* bold = nullptr, const EpdFont* italic = nullptr,
                         const EpdFont* boldItalic = nullptr)
@@ -28,9 +27,6 @@ class EpdFontFamily {
  const EpdGlyph* getGlyph(uint32_t cp, Style style = REGULAR) const;
  int8_t getKerning(uint32_t leftCp, uint32_t rightCp, Style style = REGULAR) const;
  uint32_t applyLigatures(uint32_t cp, const char*& text, Style style = REGULAR) const;
-  static constexpr bool hasTextDecoration(const Style style) {
-    return (static_cast<uint8_t>(style) & TEXT_DECORATION_MASK) != 0;
-  }

 private:
  const EpdFont* regular;
@@ -33,7 +33,6 @@ import sys
 import tempfile
 import threading
 import time
-import socket
 import urllib.request
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
@@ -50,44 +49,17 @@ INSTANCE_DIR = SCRIPT_DIR / "instanced_fonts"
 DEFAULT_FALLBACK_FONT = EPDFONTS_DIR / "builtinFonts/source/NotoSans/NotoSans-Regular.ttf"


-_orig_getaddrinfo = socket.getaddrinfo
-
-
-def _ipv4_only_getaddrinfo(*args, **kwargs):
-    """getaddrinfo variant that drops AAAA records (IPv4 only)."""
-    return [ai for ai in _orig_getaddrinfo(*args, **kwargs) if ai[0] == socket.AF_INET]
-
-
-def download_font(url: str, dest: Path, retries: int = 3) -> Path:
-    """Download a font file if not already cached. Returns the local path.
-
-    Some sources (e.g. mirrors.ctan.org) are round-robin redirectors that land
-    on a different mirror each request; a mirror may advertise an IPv6 address a
-    host without an IPv6 route cannot reach ([Errno 101] Network is unreachable).
-    Retry on failure, forcing IPv4 resolution after the first attempt.
-    """
+def download_font(url: str, dest: Path) -> Path:
+    """Download a font file if not already cached. Returns the local path."""
    if dest.exists():
        return dest
    dest.parent.mkdir(parents=True, exist_ok=True)
    print(f"  Downloading {dest.name}...")
-    last_err = None
-    for attempt in range(1, retries + 1):
-        force_ipv4 = attempt > 1
-        if force_ipv4:
-            socket.getaddrinfo = _ipv4_only_getaddrinfo
-        try:
-            urllib.request.urlretrieve(url, dest)
-            break
-        except Exception as e:  # noqa: BLE001 - reported via RuntimeError below
-            last_err = e
-            dest.unlink(missing_ok=True)
-            if attempt < retries:
-                print(f"  Attempt {attempt} failed ({e}); retrying (IPv4-only)...")
-        finally:
-            if force_ipv4:
-                socket.getaddrinfo = _orig_getaddrinfo
-    else:
-        raise RuntimeError(f"Failed to download {url}: {last_err}") from last_err
+    try:
+        urllib.request.urlretrieve(url, dest)
+    except Exception as e:
+        dest.unlink(missing_ok=True)
+        raise RuntimeError(f"Failed to download {url}: {e}") from e
    size_kb = dest.stat().st_size / 1024
    print(f"  Downloaded {dest.name} ({size_kb:.0f} KB)")
    return dest
@@ -132,16 +132,7 @@ families:
      bold:       {url: "https://raw.githubusercontent.com/impallari/Libre-Baskerville/master/fonts/ttf/LibreBaskerville-Bold.ttf"}
      italic:     {url: "https://raw.githubusercontent.com/impallari/Libre-Baskerville/master/fonts/ttf/LibreBaskerville-Italic.ttf"}
      bolditalic: {url: "https://raw.githubusercontent.com/impallari/Libre-Baskerville/master/fonts/ttf/LibreBaskerville-BoldItalic.ttf"}
-
-  - name: Vollkorn
-    description: "A serif for bread and butter use by Friedrich Althausen (Latin, Greek, Cyrillic)"
-    intervals: latin-ext,greek,cyrillic
-    sizes: [12, 14, 16, 18]
-    styles:
-      regular:    {url: "https://raw.githubusercontent.com/google/fonts/main/ofl/vollkorn/Vollkorn%5Bwght%5D.ttf", variable: {wght: 400}}
-      bold:       {url: "https://raw.githubusercontent.com/google/fonts/main/ofl/vollkorn/Vollkorn%5Bwght%5D.ttf", variable: {wght: 700}}
-      italic:     {url: "https://raw.githubusercontent.com/google/fonts/main/ofl/vollkorn/Vollkorn-Italic%5Bwght%5D.ttf", variable: {wght: 400}}
-      bolditalic: {url: "https://raw.githubusercontent.com/google/fonts/main/ofl/vollkorn/Vollkorn-Italic%5Bwght%5D.ttf", variable: {wght: 700}}
+    

  # ── Sans-serif ─────────────────────────────────────────────────────────

@@ -3,14 +3,11 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <vector>

 #include "Epub.h"

 class Page;
 class GfxRenderer;
-class ChapterHtmlSlimParser;
-class CssParser;

 class Section {
  std::shared_ptr<Epub> epub;
@@ -24,67 +21,16 @@ class Section {
                              bool embeddedStyle, uint8_t imageRendering, bool focusReadingEnabled);
  uint32_t onPageComplete(std::unique_ptr<Page> page);

-  // Page-offset table entry, kept in RAM while an incremental build is running so
-  // already-built pages can be located in the partially-written .bin.
-  struct PageLutEntry {
-    uint32_t fileOffset;
-    uint16_t paragraphIndex;
-    uint16_t listItemIndex;
-  };
-  // Held only while an incremental build is in progress (see startBuild). Carries the
-  // live parser plus the strings it references (the parser stores them by reference)
-  // and the in-RAM page-offset table.
-  struct BuildContext {
-    std::unique_ptr<ChapterHtmlSlimParser> parser;
-    std::vector<PageLutEntry> lut;
-    std::string parsePath;
-    std::string contentBase;
-    std::string imageBasePath;
-    std::string htmlPath;
-    std::string tmpHtmlPath;
-    bool reusedHtml = false;
-    CssParser* cssParser = nullptr;
-    // HTML byte progress, for estimating the section's total page count while it's still building.
-    uint32_t bytesConsumed = 0;
-    uint32_t totalBytes = 0;
-    // Exponentially-smoothed page-count estimate (0 = not yet seeded) and the bytesConsumed at its
-    // last update. The raw byte-ratio estimate jitters as the build crosses dense/sparse regions;
-    // the EMA is stepped once per build advance (not per redraw) to damp that wobble.
-    float smoothedEstimate = 0;
-    uint32_t smoothedAtConsumed = 0;
-  };
-  std::unique_ptr<BuildContext> build_;
-  bool buildComplete_ = false;
-  // Pages laid out by the active build (== build_->lut.size()). Distinct from pageCount,
-  // which is the pages *available to read* and also counts a loaded partial file's pages.
-  uint16_t builtPageCount_ = 0;
-  // A partial section file (suspended build from a previous session) is loaded at filePath.
-  // Its pages 0..partialPageCount_-1 are readable while a rebuild extends past them.
-  bool partial_ = false;
-  uint16_t partialPageCount_ = 0;
-  // Parse watermark from the partial's trailer, for estimating the total page count.
-  uint32_t partialBytesConsumed_ = 0;
-  uint32_t partialTotalBytes_ = 0;
-  bool finalizeBuild();
-  // Write the LUTs/anchor map (and, for a partial, the watermark trailer), patch the
-  // header, stamp the version byte, and swap the tmp .bin over filePath.
-  bool commitBuildFile(uint8_t version, uint32_t bytesConsumed, uint32_t totalBytes);
-  // Builds write here and are swapped over filePath only on commit, so a prior
-  // partial/finalized file stays readable while a rebuild is in progress.
-  std::string binTmpPath() const { return filePath + ".part"; }
-  std::unique_ptr<Page> loadPageAt(int page) const;
-  // Read a page already laid out by the in-progress build (page < build LUT size), from
-  // the partially-written tmp .bin without disturbing the build's write cursor.
-  std::unique_ptr<Page> loadPageDuringBuild(int page);
-
 public:
  uint16_t pageCount = 0;
  int currentPage = 0;

-  // Constructor and destructor are out-of-line: BuildContext holds a unique_ptr to the
-  // forward-declared ChapterHtmlSlimParser, whose full definition is only visible in the .cpp.
-  explicit Section(const std::shared_ptr<Epub>& epub, int spineIndex, GfxRenderer& renderer);
-  ~Section();
+  explicit Section(const std::shared_ptr<Epub>& epub, const int spineIndex, GfxRenderer& renderer)
+      : epub(epub),
+        spineIndex(spineIndex),
+        renderer(renderer),
+        filePath(epub->getCachePath() + "/sections/" + std::to_string(spineIndex) + ".bin") {}
+  ~Section() = default;
  bool loadSectionFile(int fontId, float lineCompression, bool extraParagraphSpacing, uint8_t paragraphAlignment,
                       uint16_t viewportWidth, uint16_t viewportHeight, bool hyphenationEnabled, bool embeddedStyle,
                       uint8_t imageRendering, bool focusReadingEnabled);
@@ -93,56 +39,12 @@ class Section {
                         uint16_t viewportWidth, uint16_t viewportHeight, bool hyphenationEnabled, bool embeddedStyle,
                         uint8_t imageRendering, bool focusReadingEnabled,
                         const std::function<void()>& popupFn = nullptr);
-
-  // Incremental build: lay out the section a few pages at a time so a large chapter
-  // can show its first page immediately and keep the UI responsive while the rest
-  // builds. createSectionFile() above is the one-shot wrapper over these.
-  //   if (!startBuild(...)) fail;
-  //   each tick: buildSomeMore(N); render up to pageCount; when isBuildComplete() stop.
-  bool startBuild(int fontId, float lineCompression, bool extraParagraphSpacing, uint8_t paragraphAlignment,
-                  uint16_t viewportWidth, uint16_t viewportHeight, bool hyphenationEnabled, bool embeddedStyle,
-                  uint8_t imageRendering, bool focusReadingEnabled, const std::function<void()>& popupFn = nullptr);
-  // Lay out up to maxPages more pages (maxPages <= 0 = build to completion). Returns
-  // false on error (the build is abandoned). Sets isBuildComplete() when finished.
-  bool buildSomeMore(int maxPages);
-  bool isBuilding() const { return static_cast<bool>(build_); }
-  bool isBuildComplete() const { return buildComplete_; }
-  // Best-known total page count: the exact pageCount once finalized, or a smoothed byte-based
-  // estimate (pages so far scaled by totalBytes/bytesConsumed, damped by an EMA) while a giant spine
-  // is still building, so "page X of Y" / progress don't read off the small build watermark.
-  uint16_t estimatedTotalPages() const;
-  void abandonBuild();
-  // Persist an in-progress build as a partial section file (version sentinel + LUTs +
-  // watermark trailer) instead of discarding it, so the next open of this spine can show
-  // its pages instantly and only rebuild in the background. Called by the destructor, so
-  // any teardown path (exit, sleep, navigation) keeps the work already done. Keeps a
-  // pre-existing partial when it covers more pages than this build reached.
-  void suspendBuild();
-  // True when a partial file was loaded: pageCount is a watermark, not the chapter total.
-  bool isPartial() const { return partial_; }
-
-  // Unified page read: from the active build if it has reached the page, otherwise from
-  // the on-disk file (finalized section, or a partial the rebuild hasn't caught up to).
-  std::unique_ptr<Page> loadPage(int page);
-
+  std::unique_ptr<Page> loadPageFromSectionFile();
  std::string getTextFromSectionFile();

-  // Resolve an anchor from the in-progress build first, then the on-disk anchor map
-  // (covers finalized sections and partials from a previous session).
-  std::optional<uint16_t> findAnchor(const std::string& anchor) const;
-
-  // True if this spine's unzipped HTML is already cached, so a build won't pay the (multi-second on a
-  // giant spine) zip inflation. Lets the reader skip the indexing popup on a fast reopen/rebuild.
-  bool hasHtmlCache() const;
-
  // Look up the page number for an anchor id from the section cache file.
  std::optional<uint16_t> getPageForAnchor(const std::string& anchor) const;

-  // Look up an anchor among the pages built so far by the in-progress build, so an anchor jump
-  // (TOC / chapter select, usually the chapter top = page 0) can resolve without laying out the
-  // whole chapter. Returns nullopt if the anchor hasn't been reached yet (build more) or no build.
-  std::optional<uint16_t> findAnchorDuringBuild(const std::string& anchor) const;
-
  // Get the page count from the section cache file without fully loading it.
  std::optional<uint16_t> getCachedPageCount() const;

@@ -21,39 +21,6 @@ void TextBlock::render(const GfxRenderer& renderer, const int fontId, const int

  const bool scanning = renderer.isFontCacheScanning();
  const int ascender = renderer.getFontAscenderSize(fontId);
-
-  struct DecorationLineTracker {
-    EpdFontFamily::Style style;
-    int yOffset;
-    int startX = -1;
-    int endX = -1;
-    int yPos = 0;
-
-    bool active() const { return startX != -1; }
-    void reset() {
-      startX = -1;
-      endX = -1;
-      yPos = 0;
-    }
-  };
-
-  DecorationLineTracker decorationLines[] = {
-      {EpdFontFamily::UNDERLINE, ascender + 2},
-      {EpdFontFamily::STRIKETHROUGH, ascender * 4 / 5},
-  };
-
-  const auto flushDecoration = [&](DecorationLineTracker& line) {
-    if (line.active()) {
-      renderer.drawLine(line.startX, line.yPos, line.endX, line.yPos, 2, true);
-      line.reset();
-    }
-  };
-  const auto flushDecorations = [&]() {
-    for (auto& line : decorationLines) {
-      flushDecoration(line);
-    }
-  };
-
  for (size_t i = 0; i < words.size(); i++) {
    const int wordX = wordXpos[i] + x;
    const EpdFontFamily::Style currentStyle = wordStyles[i];
@@ -92,51 +59,18 @@ void TextBlock::render(const GfxRenderer& renderer, const int fontId, const int
      renderer.drawText(fontId, wordX, wordY, words[i].c_str(), true, currentStyle, baseDir);
    }

-    if (scanning) {
-      continue;
-    }
-
-    if (EpdFontFamily::hasTextDecoration(currentStyle)) {
+    if (!scanning && (currentStyle & EpdFontFamily::UNDERLINE) != 0) {
      const std::string& w = words[i];
-      int lineStartX = wordX;
-      int lineWidth = renderer.getTextWidth(fontId, w.c_str(), currentStyle, baseDir);
+      int underlineWidth = renderer.getTextWidth(fontId, w.c_str(), currentStyle, baseDir);
+      const int underlineY = wordY + ascender + 2;

      if ((currentStyle & (EpdFontFamily::SUP | EpdFontFamily::SUB)) != 0) {
-        lineWidth = (lineWidth + 1) / 2;
+        underlineWidth = (underlineWidth + 1) / 2;
      }

-      // Do not decorate the synthetic em-space used for paragraph indentation.
-      if (w.size() >= 3 && static_cast<uint8_t>(w[0]) == 0xE2 && static_cast<uint8_t>(w[1]) == 0x80 &&
-          static_cast<uint8_t>(w[2]) == 0x83) {
-        const char* visibleText = w.c_str() + 3;
-        lineStartX += renderer.getTextAdvanceX(fontId, "\xe2\x80\x83", currentStyle);
-        lineWidth = renderer.getTextWidth(fontId, visibleText, currentStyle, baseDir);
-        if ((currentStyle & (EpdFontFamily::SUP | EpdFontFamily::SUB)) != 0) {
-          lineWidth = (lineWidth + 1) / 2;
-        }
-      }
-
-      for (auto& line : decorationLines) {
-        if ((currentStyle & line.style) == 0) {
-          flushDecoration(line);
-          continue;
-        }
-
-        const int lineY = wordY + line.yOffset;
-        if (line.active() && line.yPos != lineY) {
-          flushDecoration(line);
-        }
-        if (!line.active()) {
-          line.startX = lineStartX;
-          line.yPos = lineY;
-        }
-        line.endX = lineStartX + lineWidth;
-      }
-    } else {
-      flushDecorations();
+      renderer.drawLine(wordX, underlineY, wordX + underlineWidth, underlineY, true);
    }
  }
-  flushDecorations();
 }

 bool TextBlock::serialize(HalFile& file) const {
@@ -67,6 +67,13 @@ constexpr bool iequalsAscii(std::string_view value, std::string_view lowercaseKe
                    [](char a, char b) { return asciiToLower(a) == b; });
 }

+// Case-insensitive ASCII substring search. Only needed by text-decoration,
+// which accepts multi-value strings like "underline solid red".
+constexpr bool icontainsAscii(std::string_view value, std::string_view lowercaseKeyword) {
+  return std::search(value.begin(), value.end(), lowercaseKeyword.begin(), lowercaseKeyword.end(),
+                     [](char a, char b) { return asciiToLower(a) == b; }) != value.end();
+}
+
 // Walk s and invoke fn(token) for each non-empty run between delimiters.
 // Tokens are boundary-trimmed and yielded as string_views into s; no
 // allocation. Runs of consecutive delimiters coalesce — no empty tokens are
@@ -245,20 +252,11 @@ CssFontWeight CssParser::interpretFontWeight(std::string_view val) {
 }

 CssTextDecoration CssParser::interpretDecoration(std::string_view val) {
-  // text-decoration can have multiple space-separated values. Compare whole tokens
-  // so malformed values like "notunderline" do not accidentally enable a line.
-  CssTextDecoration result = CssTextDecoration::None;
-  bool explicitNone = false;
-  forEachDelimitedToken(val, isCssWhitespace, [&](const std::string_view token) {
-    if (iequalsAscii(token, "none")) {
-      explicitNone = true;
-    } else if (iequalsAscii(token, "underline")) {
-      result = result | CssTextDecoration::Underline;
-    } else if (iequalsAscii(token, "line-through")) {
-      result = result | CssTextDecoration::LineThrough;
-    }
-  });
-  return explicitNone ? CssTextDecoration::None : result;
+  // text-decoration can have multiple space-separated values
+  if (icontainsAscii(val, "underline")) {
+    return CssTextDecoration::Underline;
+  }
+  return CssTextDecoration::None;
 }

 CssLength CssParser::interpretLength(std::string_view val) {
@@ -870,7 +868,7 @@ bool CssParser::loadFromCache() {
      rulesBySelector_.clear();
      return false;
    }
-    style.textDecoration = static_cast<CssTextDecoration>(enumVal & CSS_TEXT_DECORATION_MASK);
+    style.textDecoration = static_cast<CssTextDecoration>(enumVal);

    if (file.read(&enumVal, 1) != 1) {
      rulesBySelector_.clear();
@@ -33,7 +33,7 @@
 class CssParser {
 public:
  // Bump when CSS cache format or rules change; section caches are invalidated when this changes
-  static constexpr uint8_t CSS_CACHE_VERSION = 7;
+  static constexpr uint8_t CSS_CACHE_VERSION = 6;

  explicit CssParser(std::string cachePath) : cachePath(std::move(cachePath)) {}
  ~CssParser() = default;
@@ -52,19 +52,8 @@ enum class CssFontStyle : uint8_t { Normal = 0, Italic = 1 };
 // Font weight options - CSS supports 100-900, we simplify to normal/bold
 enum class CssFontWeight : uint8_t { Normal = 0, Bold = 1 };

-// Text decoration options. Values are bit flags so CSS can combine multiple line decorations.
-enum class CssTextDecoration : uint8_t { None = 0, Underline = 1, LineThrough = 2 };
-
-constexpr CssTextDecoration operator|(const CssTextDecoration a, const CssTextDecoration b) {
-  return static_cast<CssTextDecoration>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
-}
-
-constexpr CssTextDecoration operator&(const CssTextDecoration a, const CssTextDecoration b) {
-  return static_cast<CssTextDecoration>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
-}
-
-constexpr uint8_t CSS_TEXT_DECORATION_MASK =
-    static_cast<uint8_t>(CssTextDecoration::Underline) | static_cast<uint8_t>(CssTextDecoration::LineThrough);
+// Text decoration options
+enum class CssTextDecoration : uint8_t { None = 0, Underline = 1 };

 // Display options - only None and Block are relevant for e-ink rendering
 enum class CssDisplay : uint8_t { Block = 0, None = 1 };
@@ -34,7 +34,6 @@ constexpr const char* BLOCK_TAGS[] = {"p", "li", "div", "br", "blockquote"};
 constexpr const char* BOLD_TAGS[] = {"b", "strong"};
 constexpr const char* ITALIC_TAGS[] = {"i", "em"};
 constexpr const char* UNDERLINE_TAGS[] = {"u", "ins"};
-constexpr const char* LINETHROUGH_TAGS[] = {"del", "s", "strike"};
 constexpr const char* IMAGE_TAGS[] = {"img"};
 constexpr const char* SKIP_TAGS[] = {"head"};

@@ -90,50 +89,13 @@ void ChapterHtmlSlimParser::applyDirectionToEntry(StyleStackEntry& entry, const
  }
 }

-EpdFontFamily::Style ChapterHtmlSlimParser::fontStyleForTextDecoration(const CssTextDecoration decoration) {
-  EpdFontFamily::Style style = EpdFontFamily::REGULAR;
-  if ((decoration & CssTextDecoration::Underline) != CssTextDecoration::None) {
-    style = static_cast<EpdFontFamily::Style>(style | EpdFontFamily::UNDERLINE);
-  }
-  if ((decoration & CssTextDecoration::LineThrough) != CssTextDecoration::None) {
-    style = static_cast<EpdFontFamily::Style>(style | EpdFontFamily::STRIKETHROUGH);
-  }
-  return style;
-}
-
-void ChapterHtmlSlimParser::applyTextDecorationToEntry(StyleStackEntry& entry, const CssStyle& css) {
-  if (css.hasTextDecoration()) {
-    entry.hasTextDecoration = true;
-    entry.textDecoration = css.textDecoration;
-  }
-}
-
-void ChapterHtmlSlimParser::pushDecorationStyleEntry(const CssTextDecoration defaultDecoration,
-                                                     const CssStyle& cssStyle) {
-  StyleStackEntry entry;
-  entry.depth = depth;
-  entry.hasTextDecoration = true;
-  entry.textDecoration = cssStyle.hasTextDecoration() ? cssStyle.textDecoration : defaultDecoration;
-  if (cssStyle.hasFontWeight()) {
-    entry.hasBold = true;
-    entry.bold = cssStyle.fontWeight == CssFontWeight::Bold;
-  }
-  if (cssStyle.hasFontStyle()) {
-    entry.hasItalic = true;
-    entry.italic = cssStyle.fontStyle == CssFontStyle::Italic;
-  }
-  applyDirectionToEntry(entry, cssStyle);
-  inlineStyleStack.push_back(entry);
-  updateEffectiveInlineStyle();
-}
-
-// Update effective bold/italic/decorations based on block style and inline style stack
+// Update effective bold/italic/underline based on block style and inline style stack
 void ChapterHtmlSlimParser::updateEffectiveInlineStyle() {
  // Start with block-level styles
  effectiveBold = currentCssStyle.hasFontWeight() && currentCssStyle.fontWeight == CssFontWeight::Bold;
  effectiveItalic = currentCssStyle.hasFontStyle() && currentCssStyle.fontStyle == CssFontStyle::Italic;
-  effectiveTextDecoration =
-      currentCssStyle.hasTextDecoration() ? currentCssStyle.textDecoration : CssTextDecoration::None;
+  effectiveUnderline =
+      currentCssStyle.hasTextDecoration() && currentCssStyle.textDecoration == CssTextDecoration::Underline;
  effectiveDirectionDefined = currentCssStyle.hasDirection();
  effectiveDirection = currentCssStyle.direction;
  effectiveSup = false;
@@ -147,10 +109,8 @@ void ChapterHtmlSlimParser::updateEffectiveInlineStyle() {
    if (entry.hasItalic) {
      effectiveItalic = entry.italic;
    }
-    // CSS line decorations propagate through descendants; child entries add
-    // their own lines but cannot cancel an ancestor's already active line.
-    if (entry.hasTextDecoration) {
-      effectiveTextDecoration = effectiveTextDecoration | entry.textDecoration;
+    if (entry.hasUnderline) {
+      effectiveUnderline = entry.underline;
    }
    if (entry.hasDirection) {
      effectiveDirectionDefined = true;
@@ -204,6 +164,7 @@ void ChapterHtmlSlimParser::flushPartWordBuffer() {
  // Determine font style from depth-based tracking and CSS effective style
  const bool isBold = boldUntilDepth < depth || effectiveBold;
  const bool isItalic = italicUntilDepth < depth || effectiveItalic;
+  const bool isUnderline = underlineUntilDepth < depth || effectiveUnderline;

  // Combine style flags using bitwise OR
  EpdFontFamily::Style fontStyle = EpdFontFamily::REGULAR;
@@ -213,7 +174,9 @@ void ChapterHtmlSlimParser::flushPartWordBuffer() {
  if (isItalic) {
    fontStyle = static_cast<EpdFontFamily::Style>(fontStyle | EpdFontFamily::ITALIC);
  }
-  fontStyle = static_cast<EpdFontFamily::Style>(fontStyle | fontStyleForTextDecoration(effectiveTextDecoration));
+  if (isUnderline) {
+    fontStyle = static_cast<EpdFontFamily::Style>(fontStyle | EpdFontFamily::UNDERLINE);
+  }
  if (effectiveSup) {
    fontStyle = static_cast<EpdFontFamily::Style>(fontStyle | EpdFontFamily::SUP);
  } else if (effectiveSub) {
@@ -457,15 +420,14 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
    headerStyle.bold = false;
    headerStyle.hasItalic = true;
    headerStyle.italic = true;
+    headerStyle.hasUnderline = true;
+    headerStyle.underline = false;
    self->inlineStyleStack.push_back(headerStyle);
    self->updateEffectiveInlineStyle();
-    const CssTextDecoration savedTextDecoration = self->effectiveTextDecoration;
-    self->effectiveTextDecoration = CssTextDecoration::None;
    self->characterData(userData, headerText.c_str(), static_cast<int>(headerText.length()));
    if (self->partWordBufferIndex > 0) {
      self->flushPartWordBuffer();
    }
-    self->effectiveTextDecoration = savedTextDecoration;
    self->nextWordContinues = false;
    self->inlineStyleStack.pop_back();
    self->updateEffectiveInlineStyle();
@@ -798,11 +760,12 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
      self->currentFootnote.number[0] = '\0';
      self->currentFootnoteLinkTextLen = 0;

-      // Apply underline style to visually indicate the link.
+      // Apply underline style to visually indicate the link
+      self->underlineUntilDepth = std::min(self->underlineUntilDepth, self->depth);
      StyleStackEntry entry;
      entry.depth = self->depth;
-      entry.hasTextDecoration = true;
-      entry.textDecoration = CssTextDecoration::Underline;
+      entry.hasUnderline = true;
+      entry.underline = true;
      applyDirectionToEntry(entry, cssStyle);
      self->inlineStyleStack.push_back(entry);
      self->updateEffectiveInlineStyle();
@@ -874,14 +837,23 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
      self->flushPartWordBuffer();
      self->nextWordContinues = true;
    }
-    self->pushDecorationStyleEntry(CssTextDecoration::Underline, cssStyle);
-  } else if (matches(name, LINETHROUGH_TAGS, std::size(LINETHROUGH_TAGS))) {
-    // Flush buffer before style change so preceding text gets current style
-    if (self->partWordBufferIndex > 0) {
-      self->flushPartWordBuffer();
-      self->nextWordContinues = true;
+    self->underlineUntilDepth = std::min(self->underlineUntilDepth, self->depth);
+    // Push inline style entry for underline tag
+    StyleStackEntry entry;
+    entry.depth = self->depth;  // Track depth for matching pop
+    entry.hasUnderline = true;
+    entry.underline = true;
+    if (cssStyle.hasFontWeight()) {
+      entry.hasBold = true;
+      entry.bold = cssStyle.fontWeight == CssFontWeight::Bold;
    }
-    self->pushDecorationStyleEntry(CssTextDecoration::LineThrough, cssStyle);
+    if (cssStyle.hasFontStyle()) {
+      entry.hasItalic = true;
+      entry.italic = cssStyle.fontStyle == CssFontStyle::Italic;
+    }
+    applyDirectionToEntry(entry, cssStyle);
+    self->inlineStyleStack.push_back(entry);
+    self->updateEffectiveInlineStyle();
  } else if (matches(name, BOLD_TAGS, std::size(BOLD_TAGS))) {
    // Flush buffer before style change so preceding text gets current style
    if (self->partWordBufferIndex > 0) {
@@ -898,7 +870,10 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
      entry.hasItalic = true;
      entry.italic = cssStyle.fontStyle == CssFontStyle::Italic;
    }
-    applyTextDecorationToEntry(entry, cssStyle);
+    if (cssStyle.hasTextDecoration()) {
+      entry.hasUnderline = true;
+      entry.underline = cssStyle.textDecoration == CssTextDecoration::Underline;
+    }
    applyDirectionToEntry(entry, cssStyle);
    self->inlineStyleStack.push_back(entry);
    self->updateEffectiveInlineStyle();
@@ -918,7 +893,10 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
      entry.hasBold = true;
      entry.bold = cssStyle.fontWeight == CssFontWeight::Bold;
    }
-    applyTextDecorationToEntry(entry, cssStyle);
+    if (cssStyle.hasTextDecoration()) {
+      entry.hasUnderline = true;
+      entry.underline = cssStyle.textDecoration == CssTextDecoration::Underline;
+    }
    applyDirectionToEntry(entry, cssStyle);
    self->inlineStyleStack.push_back(entry);
    self->updateEffectiveInlineStyle();
@@ -957,7 +935,10 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
        entry.hasItalic = true;
        entry.italic = cssStyle.fontStyle == CssFontStyle::Italic;
      }
-      applyTextDecorationToEntry(entry, cssStyle);
+      if (cssStyle.hasTextDecoration()) {
+        entry.hasUnderline = true;
+        entry.underline = cssStyle.textDecoration == CssTextDecoration::Underline;
+      }
      applyDirectionToEntry(entry, cssStyle);
      if (cssStyle.hasVerticalAlign()) {
        if (cssStyle.verticalAlign == CssVerticalAlign::Super) {
@@ -1169,8 +1150,9 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
      !self->inlineStyleStack.empty() && self->inlineStyleStack.back().depth == self->depth - 1;
  const bool willClearBold = self->boldUntilDepth == self->depth - 1;
  const bool willClearItalic = self->italicUntilDepth == self->depth - 1;
+  const bool willClearUnderline = self->underlineUntilDepth == self->depth - 1;

-  const bool styleWillChange = willPopStyleStack || willClearBold || willClearItalic;
+  const bool styleWillChange = willPopStyleStack || willClearBold || willClearItalic || willClearUnderline;
  const bool headerOrBlockTag = isHeaderOrBlock(name);
  const bool tableStructuralTag = isTableStructuralTag(name);

@@ -1189,8 +1171,7 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
                             !matches(name, IMAGE_TAGS, std::size(IMAGE_TAGS)) && self->depth != 1;
    const bool shouldFlush = styleWillChange || headerOrBlockTag || matches(name, BOLD_TAGS, std::size(BOLD_TAGS)) ||
                             matches(name, ITALIC_TAGS, std::size(ITALIC_TAGS)) ||
-                             matches(name, UNDERLINE_TAGS, std::size(UNDERLINE_TAGS)) ||
-                             matches(name, LINETHROUGH_TAGS, std::size(LINETHROUGH_TAGS)) || tableStructuralTag ||
+                             matches(name, UNDERLINE_TAGS, std::size(UNDERLINE_TAGS)) || tableStructuralTag ||
                             matches(name, IMAGE_TAGS, std::size(IMAGE_TAGS)) || self->depth == 1;

    if (shouldFlush) {
@@ -1249,6 +1230,11 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
    self->italicUntilDepth = INT_MAX;
  }

+  // Leaving underline tag
+  if (self->underlineUntilDepth == self->depth) {
+    self->underlineUntilDepth = INT_MAX;
+  }
+
  // Pop from inline style stack if we pushed an entry at this depth
  // This handles all inline elements: b, i, u, span, etc.
  if (!self->inlineStyleStack.empty() && self->inlineStyleStack.back().depth == self->depth) {
@@ -1275,9 +1261,7 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
  }
 }

-ChapterHtmlSlimParser::~ChapterHtmlSlimParser() { abortParse(); }
-
-bool ChapterHtmlSlimParser::beginParse() {
+bool ChapterHtmlSlimParser::parseAndBuildPages() {
  // Initialize block style stack with a root entry representing "no ancestor block elements".
  // The user's paragraph alignment is set as the default so child elements without explicit
  // text-align inherit it correctly through getCombinedBlockStyle.
@@ -1295,78 +1279,67 @@ bool ChapterHtmlSlimParser::beginParse() {
  paragraphAlignmentBlockStyle.alignment = align;
  startNewTextBlock(paragraphAlignmentBlockStyle);

-  xmlParser_ = XML_ParserCreate(nullptr);
-  if (!xmlParser_) {
+  XML_Parser parser = XML_ParserCreate(nullptr);
+  int done;
+
+  if (!parser) {
    LOG_ERR("EHP", "Couldn't allocate memory for parser");
    return false;
  }

  // Handle HTML entities (like &nbsp;) that aren't in XML spec or DTD
  // Using DefaultHandlerExpand preserves normal entity expansion from DOCTYPE
-  XML_SetDefaultHandlerExpand(xmlParser_, defaultHandlerExpand);
+  XML_SetDefaultHandlerExpand(parser, defaultHandlerExpand);

-  if (!Storage.openFileForRead("EHP", filepath, parseFile_)) {
-    destroyXmlParser(xmlParser_);
-    xmlParser_ = nullptr;
+  HalFile file;
+  if (!Storage.openFileForRead("EHP", filepath, file)) {
+    destroyXmlParser(parser);
    return false;
  }

  // Get file size to decide whether to show indexing popup.
-  if (popupFn && parseFile_.size() >= MIN_SIZE_FOR_POPUP) {
+  if (popupFn && file.size() >= MIN_SIZE_FOR_POPUP) {
    popupFn();
  }

-  XML_SetUserData(xmlParser_, this);
-  XML_SetElementHandler(xmlParser_, startElement, endElement);
-  XML_SetCharacterDataHandler(xmlParser_, characterData);
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);

-  parseStartTime_ = millis();
-  return true;
-}
+  // Compute the time taken to parse and build pages
+  const uint32_t chapterStartTime = millis();
+  do {
+    void* const buf = XML_GetBuffer(parser, PARSE_BUFFER_SIZE);
+    if (!buf) {
+      LOG_ERR("EHP", "Couldn't allocate memory for buffer");
+      destroyXmlParser(parser);
+      file.close();
+      return false;
+    }

-ChapterHtmlSlimParser::ParseStatus ChapterHtmlSlimParser::parseStep() {
-  void* const buf = XML_GetBuffer(xmlParser_, PARSE_BUFFER_SIZE);
-  if (!buf) {
-    LOG_ERR("EHP", "Couldn't allocate memory for buffer");
-    return ParseStatus::Error;
-  }
+    const size_t len = file.read(buf, PARSE_BUFFER_SIZE);

-  const size_t len = parseFile_.read(buf, PARSE_BUFFER_SIZE);
+    if (len == 0 && file.available() > 0) {
+      LOG_ERR("EHP", "File read error");
+      destroyXmlParser(parser);
+      file.close();
+      return false;
+    }

-  if (len == 0 && parseFile_.available() > 0) {
-    LOG_ERR("EHP", "File read error");
-    return ParseStatus::Error;
-  }
+    done = file.available() == 0;

-  const int done = parseFile_.available() == 0;
+    if (XML_ParseBuffer(parser, static_cast<int>(len), done) == XML_STATUS_ERROR) {
+      LOG_ERR("EHP", "Parse error at line %lu:\n%s", XML_GetCurrentLineNumber(parser),
+              XML_ErrorString(XML_GetErrorCode(parser)));
+      destroyXmlParser(parser);
+      file.close();
+      return false;
+    }
+  } while (!done);
+  LOG_DBG("EHP", "Time to parse and build pages: %lu ms", millis() - chapterStartTime);

-  if (XML_ParseBuffer(xmlParser_, static_cast<int>(len), done) == XML_STATUS_ERROR) {
-    LOG_ERR("EHP", "Parse error at line %lu:\n%s", XML_GetCurrentLineNumber(xmlParser_),
-            XML_ErrorString(XML_GetErrorCode(xmlParser_)));
-    return ParseStatus::Error;
-  }
-
-  return done ? ParseStatus::Done : ParseStatus::More;
-}
-
-void ChapterHtmlSlimParser::abortParse() {
-  if (xmlParser_) {
-    destroyXmlParser(xmlParser_);
-    xmlParser_ = nullptr;
-  }
-  // Only close the file if it was successfully opened in beginParse()
-  if (parseFile_.isOpen()) {
-    parseFile_.close();
-  }
-}
-
-bool ChapterHtmlSlimParser::finishParse() {
-  if (xmlParser_) {
-    LOG_DBG("EHP", "Time to parse and build pages: %lu ms", millis() - parseStartTime_);
-    destroyXmlParser(xmlParser_);
-    xmlParser_ = nullptr;
-  }
-  parseFile_.close();
+  destroyXmlParser(parser);
+  file.close();

  // Process last page if there is still text
  if (currentTextBlock) {
@@ -1384,23 +1357,6 @@ bool ChapterHtmlSlimParser::finishParse() {
  return true;
 }

-bool ChapterHtmlSlimParser::parseAndBuildPages() {
-  if (!beginParse()) {
-    return false;
-  }
-  for (;;) {
-    const ParseStatus status = parseStep();
-    if (status == ParseStatus::Error) {
-      abortParse();
-      return false;
-    }
-    if (status == ParseStatus::Done) {
-      break;
-    }
-  }
-  return finishParse();
-}
-
 void ChapterHtmlSlimParser::addLineToPage(std::shared_ptr<TextBlock> line) {
  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;

@@ -1,6 +1,5 @@
 #pragma once

-#include <HalStorage.h>
 #include <expat.h>

 #include <climits>
@@ -32,6 +31,7 @@ class ChapterHtmlSlimParser {
  int skipUntilDepth = INT_MAX;
  int boldUntilDepth = INT_MAX;
  int italicUntilDepth = INT_MAX;
+  int underlineUntilDepth = INT_MAX;
  // buffer for building up words from characters, will auto break if longer than this
  // leave one char at end for null pointer
  char partWordBuffer[MAX_WORD_SIZE + 1] = {};
@@ -60,8 +60,7 @@ class ChapterHtmlSlimParser {
    int depth = 0;
    bool hasBold = false, bold = false;
    bool hasItalic = false, italic = false;
-    bool hasTextDecoration = false;
-    CssTextDecoration textDecoration = CssTextDecoration::None;
+    bool hasUnderline = false, underline = false;
    bool hasDirection = false;
    CssTextDirection direction = CssTextDirection::Ltr;
    bool hasSup = false, sup = false;
@@ -72,7 +71,7 @@ class ChapterHtmlSlimParser {
  CssStyle currentCssStyle;
  bool effectiveBold = false;
  bool effectiveItalic = false;
-  CssTextDecoration effectiveTextDecoration = CssTextDecoration::None;
+  bool effectiveUnderline = false;
  bool effectiveDirectionDefined = false;
  CssTextDirection effectiveDirection = CssTextDirection::Ltr;
  bool effectiveSup = false;
@@ -97,25 +96,12 @@ class ChapterHtmlSlimParser {
  std::vector<std::pair<int, FootnoteEntry>> pendingFootnotes;  // <wordIndex, entry>
  int wordsExtractedInBlock = 0;

-  // Resumable parse state. The one-shot parseAndBuildPages() drives these
-  // internally; the incremental section builder drives them across render ticks
-  // so a large single chapter can yield between pages instead of blocking the UI
-  // until the whole thing is laid out. parseFile_ and the expat parser stay alive
-  // for the lifetime of the parse so it can be paused and resumed at buffer
-  // boundaries.
-  XML_Parser xmlParser_ = nullptr;
-  HalFile parseFile_;
-  uint32_t parseStartTime_ = 0;
-
  void updateEffectiveInlineStyle();
  void startNewTextBlock(const BlockStyle& blockStyle);
  void flushPendingAnchor();
  void flushPartWordBuffer();
  void makePages();
-  static EpdFontFamily::Style fontStyleForTextDecoration(CssTextDecoration decoration);
  static void applyDirectionToEntry(StyleStackEntry& entry, const CssStyle& css);
-  static void applyTextDecorationToEntry(StyleStackEntry& entry, const CssStyle& css);
-  void pushDecorationStyleEntry(CssTextDecoration defaultDecoration, const CssStyle& cssStyle);
  void emitHorizontalRule(const BlockStyle& blockStyle);
  // XML callbacks
  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
@@ -155,28 +141,8 @@ class ChapterHtmlSlimParser {
        imageBasePath(imageBasePath),
        tocAnchors(std::move(tocAnchors)) {}

-  ~ChapterHtmlSlimParser();
-
-  // One-shot parse: builds every page before returning (begin + step* + finish).
+  ~ChapterHtmlSlimParser() = default;
  bool parseAndBuildPages();
-
-  // Resumable parse, for the incremental section builder. Drive as:
-  //   if (!beginParse()) fail;
-  //   loop: switch (parseStep()) { More: keep going / yield; Done: finishParse(); Error: abortParse(); }
-  // Pages are emitted via completePageFn as they complete during parseStep(), so
-  // the caller can stop once enough pages are built and resume on a later tick.
-  enum class ParseStatus { More, Done, Error };
-  bool beginParse();
-  ParseStatus parseStep();
-  bool finishParse();  // flush the trailing page and tear down; returns true
-  void abortParse();   // tear down without flushing (error / abandon)
-
  void addLineToPage(std::shared_ptr<TextBlock> line);
  const std::vector<std::pair<std::string, uint16_t>>& getAnchors() const { return anchorData; }
-
-  // Byte progress of the in-flight parse, used to estimate a still-building section's total page
-  // count (a giant single-spine book never fully lays out, so its real count is unknown). Valid
-  // between beginParse() and finishParse()/abortParse().
-  size_t parseBytesConsumed() { return parseFile_ ? parseFile_.position() : 0; }
-  size_t parseTotalBytes() { return parseFile_ ? parseFile_.size() : 0; }
 };
@@ -79,53 +79,6 @@ std::string normalisePath(const std::string& path) {
  return result;
 }

-bool naturalLess(const std::string& str1, const std::string& str2) {
-  // Naive natural sort: numeric-aware, case-insensitive
-  const char* s1 = str1.c_str();
-  const char* s2 = str2.c_str();
-
-  // ctype functions require unsigned char values: passing a negative char (UTF-8
-  // bytes above 0x7f with signed char) is undefined behavior
-  const auto isDigit = [](const char c) { return isdigit(static_cast<unsigned char>(c)) != 0; };
-
-  // Iterate while both strings have characters
-  while (*s1 && *s2) {
-    // Check if both are at the start of a number
-    if (isDigit(*s1) && isDigit(*s2)) {
-      // Skip leading zeros and track them
-      while (*s1 == '0') s1++;
-      while (*s2 == '0') s2++;
-
-      // Count digits to compare lengths first
-      int len1 = 0, len2 = 0;
-      while (isDigit(s1[len1])) len1++;
-      while (isDigit(s2[len2])) len2++;
-
-      // Different length so return smaller integer value
-      if (len1 != len2) return len1 < len2;
-
-      // Same length so compare digit by digit
-      for (int i = 0; i < len1; i++) {
-        if (s1[i] != s2[i]) return s1[i] < s2[i];
-      }
-
-      // Numbers equal so advance pointers
-      s1 += len1;
-      s2 += len2;
-    } else {
-      // Regular case-insensitive character comparison
-      const int c1 = tolower(static_cast<unsigned char>(*s1));
-      const int c2 = tolower(static_cast<unsigned char>(*s2));
-      if (c1 != c2) return c1 < c2;
-      s1++;
-      s2++;
-    }
-  }
-
-  // One string is prefix of other
-  return *s1 == '\0' && *s2 != '\0';
-}
-
 void sortFileList(std::vector<std::string>& strs) {
  std::sort(begin(strs), end(strs), [](const std::string& str1, const std::string& str2) {
    // Directories first
@@ -133,7 +86,46 @@ void sortFileList(std::vector<std::string>& strs) {
    bool isDir2 = str2.back() == '/';
    if (isDir1 != isDir2) return isDir1;

-    return naturalLess(str1, str2);
+    // Start naive natural sort
+    const char* s1 = str1.c_str();
+    const char* s2 = str2.c_str();
+
+    // Iterate while both strings have characters
+    while (*s1 && *s2) {
+      // Check if both are at the start of a number
+      if (isdigit(*s1) && isdigit(*s2)) {
+        // Skip leading zeros and track them
+        while (*s1 == '0') s1++;
+        while (*s2 == '0') s2++;
+
+        // Count digits to compare lengths first
+        int len1 = 0, len2 = 0;
+        while (isdigit(s1[len1])) len1++;
+        while (isdigit(s2[len2])) len2++;
+
+        // Different length so return smaller integer value
+        if (len1 != len2) return len1 < len2;
+
+        // Same length so compare digit by digit
+        for (int i = 0; i < len1; i++) {
+          if (s1[i] != s2[i]) return s1[i] < s2[i];
+        }
+
+        // Numbers equal so advance pointers
+        s1 += len1;
+        s2 += len2;
+      } else {
+        // Regular case-insensitive character comparison
+        char c1 = tolower(*s1);
+        char c2 = tolower(*s2);
+        if (c1 != c2) return c1 < c2;
+        s1++;
+        s2++;
+      }
+    }
+
+    // One string is prefix of other
+    return *s1 == '\0' && *s2 != '\0';
  });
 }

@@ -11,10 +11,6 @@ std::string decodeUriEscapes(const std::string& path);

 std::string normalisePath(const std::string& path);

-// Numeric-aware, case-insensitive comparison ("2" < "10"). Returns true when str1 orders
-// before str2. Same ordering sortFileList applies within the file/directory groups.
-bool naturalLess(const std::string& str1, const std::string& str2);
-
 void sortFileList(std::vector<std::string>& strs);

 /**
@@ -8,6 +8,7 @@
 #include <Utf8.h>

 #include <algorithm>
+#include <cassert>

 #include "FontCacheManager.h"

@@ -282,17 +283,8 @@ static void renderCharImpl(const GfxRenderer& renderer, GfxRenderer::RenderMode
          const uint8_t bmpVal = 3 - ((byte >> bit_index) & 0x3);

          if (renderMode == GfxRenderer::BW && bmpVal < 3) {
-            // Default: gray pixels paint solid black. Required when grayscale
-            // passes follow (their LUT lightens pixels it assumes were just
-            // driven solid black), and it is the plain non-AA look otherwise.
-            // Fast AA: partial (anti-aliased edge) coverage dithers with the
-            // same period-2 patterns as fillRectDither (dark grey = 50%
-            // checkerboard, light grey = 25%), approximating AA in a single
-            // BW pass. Skipped pixels leave the background untouched.
-            if (!renderer.isFastAntiAliasing() || bmpVal == 0 || (bmpVal == 1 && ((screenX + screenY) & 1) == 0) ||
-                (bmpVal == 2 && (screenX & 1) == 0 && (screenY & 1) == 0)) {
-              renderer.drawPixel(screenX, screenY, pixelState);
-            }
+            // Black (also paints over the grays in BW mode)
+            renderer.drawPixel(screenX, screenY, pixelState);
          } else if (renderMode == GfxRenderer::GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
            // Light gray (also mark the MSB if it's going to be a dark gray too)
            // Dedicated X3 gray LUTs now provide proper 4-level gray on both devices
@@ -1063,22 +1055,18 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co
  display.drawImage(bitmap, rotatedX, rotatedY, width, height);
 }

-void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, const int size) const {
-  // Plot the icon pixel-by-pixel through drawPixel (which applies the orientation
-  // transform) instead of the byte-aligned framebuffer blit. The blit snaps the
-  // icon's position to 8px (one byte) along the rotated axis, which prevents it
-  // from aligning with adjacent text; per-pixel plotting is pixel-precise.
-  // Icons are square and 1bpp (MSB-first, bit==0 = ink). The (size-1-row, col)
-  // mapping reproduces the Portrait orientation the blit produced; drawIcon is
-  // only called by the UI themes, which all render in forced Portrait.
-  const int rowBytes = (size + 7) / 8;
-  for (int row = 0; row < size; row++) {
-    for (int col = 0; col < size; col++) {
-      const uint8_t byte = bitmap[row * rowBytes + (col >> 3)];
-      const bool ink = ((byte >> (7 - (col & 7))) & 1) == 0;
-      if (ink) {
-        drawPixel(x + (size - 1 - row), y + col, true);
-      }
+void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const {
+  if (bitmap == nullptr || width <= 0 || height <= 0) return;
+  assert(width == height);
+
+  const int bytesPerRow = (width + 7) / 8;
+  for (int sourceY = 0; sourceY < height; ++sourceY) {
+    for (int sourceX = 0; sourceX < width; ++sourceX) {
+      const uint8_t rowByte = bitmap[sourceY * bytesPerRow + sourceX / 8];
+      const bool background = (rowByte >> (7 - (sourceX % 8))) & 0x01;
+      if (background) continue;
+
+      drawPixel(x + height - 1 - sourceY, y + sourceX, true);
    }
  }
 }