Add 16px icon size and remove hardcoded bookmark icon

Generate 16px variants for all icons and remove the old hardcoded bookmark icon in favor of using the generated icon system. This provides better consistency across icon sizes and simplifies icon management.

.gitmodules

@@ -1,3 +1,4 @@
-[submodule "open-x4-sdk"]
-	path = open-x4-sdk
-	url = https://github.com/crosspoint-reader/community-sdk.git
+[submodule "freeink-sdk"]
+	path = freeink-sdk
+	url = https://github.com/Free-Ink/freeink-sdk.git
+	branch = main

.skills/SKILL.md

@@ -7,7 +7,7 @@ Mission: Provide a lightweight, high-performance reading experience focused on E
 * Role: Senior Embedded Systems Engineer (ESP-IDF/Arduino-ESP32 specialized).
 * Primary Constraint: 380KB RAM is the hard ceiling. Stability is non-negotiable.
 * Evidence-Based Reasoning: Before proposing a change, you MUST cite the specific file path and line numbers that justify the modification.
-* Anti-Hallucination: Do not assume the existence of libraries or ESP-IDF functions. If you are unsure of an API's availability for the ESP32-C3 RISC-V target, check the open-x4-sdk or official docs first.
+* Anti-Hallucination: Do not assume the existence of libraries or ESP-IDF functions. If you are unsure of an API's availability for the ESP32-C3 RISC-V target, check the freeink-sdk source or the FreeInk SDK docs (https://freeink.org/llms.txt for an LLM-readable index) first.
 * No Unfounded Claims: Do not claim performance gains or memory savings without explaining the technical mechanism (e.g., DRAM vs IRAM usage).
 * Resource Justification: You must justify any new heap allocation (new, malloc, std::vector) or explain why a stack/static alternative was rejected.
 * Verification: After suggesting a fix, instruct the user on how to verify it (e.g., monitoring heap via Serial or checking a specific cache file).
@@ -127,7 +127,7 @@ These flags in `platformio.ini` fundamentally affect firmware behavior:
   * lib/hal/: Hardware Abstraction Layer (HalDisplay, HalGPIO, HalStorage)
   * lib/I18n/: Internationalization (translations in `translations/*.yaml`, generated string tables)
 * src/activities/: UI logic using the Activity Lifecycle (onEnter, loop, onExit)
-* open-x4-sdk/: Low-level SDK (EInkDisplay, InputManager, BatteryMonitor, SDCardManager)
+* freeink-sdk/: Low-level SDK (EInkDisplay, InputManager, BatteryMonitor, SDCardManager)
 * .crosspoint/: SD-based binary cache for EPUB metadata and pre-rendered layout sections
 
 ### Hardware Abstraction Layer (HAL)

USER_GUIDE.md

@@ -122,19 +122,43 @@ A **Wi-Fi signal strength indicator** (dBm) is displayed on-screen during joined
 
 CrossPoint supports sending books from Calibre using the CrossPoint Reader device plugin.
 
-1. Install the plugin in Calibre:
-   
-   - Head to https://github.com/crosspoint-reader/calibre-plugins/releases to download the latest version of the crosspoint_reader plugin.
-   
-   - Download the zip file.
-   
-   - Open Calibre → Preferences → Plugins → Load plugin from file → Select the zip file.
+#### Installing the Plugin in Calibre
 
-2. On the device: File Transfer -> Calibre Wireless, then join a network.
+If you don't already have the plugin installed:
 
-3. Make sure your computer is on the same Wi-Fi network.
+1. Head to https://github.com/crosspoint-reader/calibre-plugins/releases to download the latest version of the crosspoint_reader plugin.
+2. Download the zip file.
+3. Open Calibre → Preferences → Plugins → Load plugin from file → Select the zip file.
+4. Restart Calibre.
 
-4. In Calibre, click "Send to device" to transfer books.
+#### Configuring the CrossPoint Plugin in Calibre
+1. In Calibre select Preferences.
+2. In the Preferences dialog select Plugins.
+3. In Plugins search for "crosspoint".
+4. Click on "Customize plugin".
+5. Update the value for "Host" to match the IP for your device.
+6. Leave the other settings as they are.
+7. [optional] Modify the "Upload path" to point to a subfolder other than the root "/" folder. Enter this as a path relative to the root folder. Example: `/mybooks`
+8. Restart Calibre.
+
+<img width="420" height="385" alt="Image" src="https://github.com/user-attachments/assets/01fc7e33-a9a7-48ba-9e26-2e68d1f9daec" />
+
+#### Uploading Books
+
+To upload a book using the CrossPoint plugin in Calibre:
+
+1. On the device: File Transfer -> Calibre Wireless, then join a network.
+2. Select one or more books.
+3. Right-click on that selection.
+4. Select "Send to Device" > "Send to main memory"
+
+The CrossPoint plugin will connect to your device, create a folder for the book's author in the root folder (or the folder you configured for the plugin), then copy the book into that folder.
+
+<img width="783" height="310" alt="Image" src="https://github.com/user-attachments/assets/741b0909-2e1d-4f16-8af0-2c43fbda5ce6" />
+
+#### Removing a Book
+
+Books cannot be removed from your device through Calibre. Use the web interface instead.
 
 ### 3.6 Settings
 
@@ -150,6 +174,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
   - "Cover" - The book cover image (Note: this is experimental and may not work as expected)
   - "None" - A blank screen
   - "Cover + Custom" - The book cover image while actively reading, falls back to "Custom" behavior otherwise
+  - "Quick resume" - The text of the last page read will be displayed on the sleep screen and a moon icon is shown on the edge of the screen. Waking up the device will return to the same page of the opened book. This is useful for quickly resuming reading without waiting for the device to fully wake up and load the book.
 
 - **Sleep Screen Cover Mode**: How to display the book cover when "Cover" sleep screen is selected:
   
@@ -162,6 +187,8 @@ The Settings screen allows you to configure the device's behavior. There are a f
   - "Contrast" - The image will be displayed as a black & white image without grayscale conversion
   - "Inverted" - The image will be inverted as in white & black and will be displayed without grayscale conversion
 
+- **Quick Resume on Timeout**: Whether to enable the "Quick Resume" sleep screen when the device goes to sleep due to inactivity (System > Time to Sleep). This is useful for quickly resuming reading without waiting for the device to fully wake up and load the book. This overwrites the Sleep Screen Cover Mode when enabled.
+
 - **Status Bar**: Configure the status bar displayed while reading:
   
   - "None" - No status bar
@@ -241,6 +268,10 @@ The Settings screen allows you to configure the device's behavior. There are a f
   
   - "Chapter Skip" (default) - Long-pressing skips to next/previous chapter
   - "Page Scroll" - Long-pressing scrolls a page up/down
+- **Long-press Menu**: Selects the function bound to holding the menu button (Confirm) while reading an EPUB. **Cycles through the available functions** each time the setting is selected — additional functions may be added in future releases, so this is not a binary on/off toggle. A short press of Confirm always opens the reader menu as normal:
+  - "Bookmark" (default) - Hold Confirm (~0.4 second) to drop a bookmark at the current page.
+  - "KOSync" - Hold Confirm (~1 second) to launch KOReader sync directly.
+  - "Disabled" - Long-press is ignored; only short-press opens the reader menu.
 
 - **Short Power Button Click**: Controls the effect of a short click of the power button:
   
@@ -523,11 +554,14 @@ On the **Xteink X3**, the gyroscope can be used to turn pages by tilting the dev
 
 When reading an EPUB that contains footnotes, you can navigate to the footnote text by selecting the footnote reference in the book. From the footnote, you can return to your original reading position.
 
+If the device goes to sleep or you close the book while viewing a footnote, the book reopens to your original reading position, not the footnote.
+
 ### System Navigation
 
 * **Return to Home:** Press the **Back** button to close the book and return to the **[Home](#31-home-screen)** screen.
 * **Return to Browse Files:** Press and hold the **Back** button to close the book and return to the **[Browse Files](#33-browse-files-screen)** screen.
 * **Reader Menu:** Press **Confirm** to open the **[Reader Menu](#5-reader-menu)**, which includes chapter navigation, reading options, and more.
+* **Long-press Confirm (configurable):** Holding **Confirm** runs the function chosen by the **Long-press Menu** setting in **[Controls Settings](#363-controls)** — "Bookmark" (default) drops a bookmark, "KOSync" launches KOReader Sync, "Disabled" does nothing. A short press always opens the Reader Menu.
 
 ### Supported Languages
 
@@ -574,9 +608,9 @@ Accessible by selecting **Chapters** from the Reader Menu.
 
 Bookmarks can be created to quickly save and restore your place in a book.
 
-To create a bookmark, hold **Confirm** for 1 second while inside a book. A popup will appear letting you know a bookmark was created. The popup message will automatically disappear in a couple of seconds.
+To create a bookmark, hold **Confirm** for about half a second while inside a book. A popup will appear letting you know a bookmark was created. The popup message will automatically disappear in a couple of seconds.
 
-To open bookmarks, press **Confirm** while inside a book. Then navigate to the **Bookmarks** menu. Bookmarks can be opened by navigating to them and pressing **Confirm**, which will redirect you to that place in the book. You can delete bookmarks by holding **Confirm** for 1 second, and then pressing **Confirm** again to confirm deletion, or **Back** to cancel.
+To open bookmarks, press **Confirm** while inside a book. Then navigate to the **Bookmarks** menu. Bookmarks can be opened by navigating to them and pressing **Confirm**, which will redirect you to that place in the book. You can delete bookmarks by holding **Confirm** for about 0.7 seconds, and then pressing **Confirm** again to confirm deletion, or **Back** to cancel.
 
 Bookmarks are stored in the `.crosspoint/bookmarks` folder in the JSON format.
 

bin/clang-format-fix.ps1

@@ -4,7 +4,7 @@
 
 .DESCRIPTION
     Formats all C/C++ source and header files in the repository, excluding
-    generated, vendored, and build directories (open-x4-sdk, builtinFonts,
+    generated, vendored, and build directories (freeink-sdk, builtinFonts,
     hyphenation tries, uzlib, .pio, *.generated.h).
 
     The clang-format binary path is resolved once and cached in
@@ -92,7 +92,7 @@ function Resolve-ClangFormat {
 $clangFormat = Resolve-ClangFormat
 
 $exclude = @(
-    'open-x4-sdk'
+    'freeink-sdk'
     'lib\EpdFont\builtinFonts'
     'lib\Epub\Epub\hyphenation\generated'
     'lib\uzlib'

docs/contributing/architecture.md

@@ -8,7 +8,7 @@ At a high level, it is firmware that uses an activity-driven application archite
 
 ```mermaid
 graph TD
-    A[Hardware: ESP32-C3 + SD + E-ink + Buttons] --> B[open-x4-sdk]
+    A[Hardware: ESP32-C3 + SD + E-ink + Buttons] --> B[freeink-sdk]
     B --> C[lib/hal wrappers]
     C --> D[src/main.cpp runtime loop]
     D --> E[Activities layer]
@@ -195,10 +195,10 @@ When editing related source assets, regenerate via normal build steps/scripts.
 - `src/`: app orchestration, settings/state, and activity implementations
 - `src/network/`: web server and OTA/update networking
 - `src/components/`: theming and shared UI components
-- `lib/hal/`: hardware abstraction wrappers around open-x4-sdk
+- `lib/hal/`: hardware abstraction wrappers around freeink-sdk
 - `lib/Epub/`: EPUB parser, layout, CSS handling, and hyphenation
 - `lib/`: supporting libraries (fonts, text, filesystem helpers, etc.)
-- `open-x4-sdk/`: hardware SDK submodule (display, input, storage, battery)
+- `freeink-sdk/`: hardware SDK submodule (display, input, storage, battery). Docs: https://freeink.org/docs
 - `docs/`: user and technical documentation
 
 ## Embedded constraints that shape design

lib/EpdFont/EpdFont.cpp

@@ -101,6 +101,9 @@ static uint8_t lookupKernClass(const EpdKernClassEntry* entries, const uint16_t
 }
 
 int8_t EpdFont::getKerning(const uint32_t leftCp, const uint32_t rightCp) const {
+  if (utf8IsCjkBreakable(leftCp) || utf8IsCjkBreakable(rightCp)) {
+    return 0;
+  }
   if (!data->kernMatrix) {
     return 0;
   }

lib/EpdFont/SdCardFont.cpp

@@ -115,6 +115,9 @@ void SdCardFont::freeStyleAll(PerStyle& s) {
   freeStyleMiniData(s);
   delete[] s.fullIntervals;
   s.fullIntervals = nullptr;
+  delete[] s.bmpIntervals;
+  s.bmpIntervals = nullptr;
+  s.intervalsAreBmp16 = false;
   freeStyleKernLigatureData(s);
   s.present = false;
 }
@@ -516,59 +519,94 @@ bool SdCardFont::load(const char* path) {
   styleCount_ = styleCount;
   contentHash_ = hash;
 
-  // Load full intervals into RAM for each present style
+  // Load full intervals into RAM for each present style. BMP-only fonts with
+  // fewer than 65536 glyphs use a compact 6-byte interval table instead of the
+  // on-disk 12-byte table; large sparse CJK subsets otherwise keep tens of KB
+  // of always-resident heap just for lookup metadata.
   for (uint8_t i = 0; i < MAX_STYLES; i++) {
     auto& s = styles_[i];
     if (!s.present) continue;
 
-    s.fullIntervals = new (std::nothrow) EpdUnicodeInterval[s.header.intervalCount];
-    if (!s.fullIntervals) {
-      LOG_ERR("SDCF", "Failed to allocate %u intervals for style %u", s.header.intervalCount, i);
-      freeAll();
-      return false;
-    }
-
     if (!file.seekSet(s.intervalsFileOffset)) {
       LOG_ERR("SDCF", "Failed to seek to intervals for style %u", i);
       freeAll();
       return false;
     }
-    size_t intervalsBytes = s.header.intervalCount * sizeof(EpdUnicodeInterval);
-    if (file.read(reinterpret_cast<uint8_t*>(s.fullIntervals), intervalsBytes) != static_cast<int>(intervalsBytes)) {
-      LOG_ERR("SDCF", "Failed to read intervals for style %u", i);
-      freeAll();
-      return false;
-    }
 
     // Validate interval contents before any later code (findGlobalGlyphIndex,
     // glyph reads) trusts them. A malformed file could otherwise drive
     // out-of-range glyph indices into bogus on-disk reads.
-    {
-      uint32_t expectedOffset = 0;
-      uint32_t prevLast = 0;
+    bool canUseBmp16 = s.header.glyphCount <= UINT16_MAX;
+    uint32_t expectedOffset = 0;
+    uint32_t prevLast = 0;
+    EpdUnicodeInterval iv{};
+    for (uint32_t j = 0; j < s.header.intervalCount; ++j) {
+      if (file.read(reinterpret_cast<uint8_t*>(&iv), sizeof(iv)) != sizeof(iv)) {
+        LOG_ERR("SDCF", "Failed to read interval %u for style %u", j, i);
+        freeAll();
+        return false;
+      }
+      if (iv.first > iv.last) {
+        LOG_ERR("SDCF", "Style %u: invalid interval %u (first 0x%lX > last 0x%lX)", i, j,
+                static_cast<unsigned long>(iv.first), static_cast<unsigned long>(iv.last));
+        file.close();
+        freeAll();
+        return false;
+      }
+      const uint32_t span = iv.last - iv.first + 1;
+      const bool overlapsPrev = (j > 0 && iv.first <= prevLast);
+      const bool spanTooBig = (span > s.header.glyphCount);
+      const bool offsetMismatch = (iv.offset != expectedOffset);
+      const bool offsetOverruns = (iv.offset > s.header.glyphCount - span);
+      if (overlapsPrev || spanTooBig || offsetMismatch || offsetOverruns) {
+        LOG_ERR("SDCF", "Style %u: invalid interval layout at %u (overlap=%d span=%u offMis=%d offOver=%d)", i, j,
+                overlapsPrev, span, offsetMismatch, offsetOverruns);
+        file.close();
+        freeAll();
+        return false;
+      }
+      if (iv.first > UINT16_MAX || iv.last > UINT16_MAX || iv.offset > UINT16_MAX) {
+        canUseBmp16 = false;
+      }
+      expectedOffset += span;
+      prevLast = iv.last;
+    }
+
+    if (!file.seekSet(s.intervalsFileOffset)) {
+      LOG_ERR("SDCF", "Failed to seek back to intervals for style %u", i);
+      freeAll();
+      return false;
+    }
+
+    if (canUseBmp16) {
+      s.bmpIntervals = new (std::nothrow) PerStyle::BmpInterval16[s.header.intervalCount];
+      if (!s.bmpIntervals) {
+        LOG_ERR("SDCF", "Failed to allocate compact intervals for style %u", i);
+        freeAll();
+        return false;
+      }
       for (uint32_t j = 0; j < s.header.intervalCount; ++j) {
-        const auto& iv = s.fullIntervals[j];
-        if (iv.first > iv.last) {
-          LOG_ERR("SDCF", "Style %u: invalid interval %u (first 0x%lX > last 0x%lX)", i, j,
-                  static_cast<unsigned long>(iv.first), static_cast<unsigned long>(iv.last));
-          file.close();
+        if (file.read(reinterpret_cast<uint8_t*>(&iv), sizeof(iv)) != sizeof(iv)) {
+          LOG_ERR("SDCF", "Failed to read compact interval %u for style %u", j, i);
           freeAll();
           return false;
         }
-        const uint32_t span = iv.last - iv.first + 1;
-        const bool overlapsPrev = (j > 0 && iv.first <= prevLast);
-        const bool spanTooBig = (span > s.header.glyphCount);
-        const bool offsetMismatch = (iv.offset != expectedOffset);
-        const bool offsetOverruns = (iv.offset > s.header.glyphCount - span);
-        if (overlapsPrev || spanTooBig || offsetMismatch || offsetOverruns) {
-          LOG_ERR("SDCF", "Style %u: invalid interval layout at %u (overlap=%d span=%u offMis=%d offOver=%d)", i, j,
-                  overlapsPrev, span, offsetMismatch, offsetOverruns);
-          file.close();
-          freeAll();
-          return false;
-        }
-        expectedOffset += span;
-        prevLast = iv.last;
+        s.bmpIntervals[j] = {static_cast<uint16_t>(iv.first), static_cast<uint16_t>(iv.last),
+                             static_cast<uint16_t>(iv.offset)};
+      }
+      s.intervalsAreBmp16 = true;
+    } else {
+      s.fullIntervals = new (std::nothrow) EpdUnicodeInterval[s.header.intervalCount];
+      if (!s.fullIntervals) {
+        LOG_ERR("SDCF", "Failed to allocate %u intervals for style %u", s.header.intervalCount, i);
+        freeAll();
+        return false;
+      }
+      size_t intervalsBytes = s.header.intervalCount * sizeof(EpdUnicodeInterval);
+      if (file.read(reinterpret_cast<uint8_t*>(s.fullIntervals), intervalsBytes) != static_cast<int>(intervalsBytes)) {
+        LOG_ERR("SDCF", "Failed to read intervals for style %u", i);
+        freeAll();
+        return false;
       }
     }
 
@@ -603,13 +641,15 @@ int32_t SdCardFont::findGlobalGlyphIndex(const PerStyle& s, uint32_t codepoint)
   int right = static_cast<int>(s.header.intervalCount) - 1;
   while (left <= right) {
     int mid = left + (right - left) / 2;
-    const auto& interval = s.fullIntervals[mid];
-    if (codepoint < interval.first) {
+    const uint32_t first = s.intervalsAreBmp16 ? s.bmpIntervals[mid].first : s.fullIntervals[mid].first;
+    const uint32_t last = s.intervalsAreBmp16 ? s.bmpIntervals[mid].last : s.fullIntervals[mid].last;
+    if (codepoint < first) {
       right = mid - 1;
-    } else if (codepoint > interval.last) {
+    } else if (codepoint > last) {
       left = mid + 1;
     } else {
-      return static_cast<int32_t>(interval.offset + (codepoint - interval.first));
+      const uint32_t offset = s.intervalsAreBmp16 ? s.bmpIntervals[mid].offset : s.fullIntervals[mid].offset;
+      return static_cast<int32_t>(offset + (codepoint - first));
     }
   }
   return -1;
@@ -1257,7 +1297,7 @@ const EpdGlyph* SdCardFont::onGlyphMiss(void* ctx, uint32_t codepoint) {
 
   if (!self->loaded_ || styleIdx >= MAX_STYLES || !self->styles_[styleIdx].present) return nullptr;
   const auto& s = self->styles_[styleIdx];
-  if (!s.fullIntervals) return nullptr;
+  if (!s.fullIntervals && !s.bmpIntervals) return nullptr;
 
   // Check overflow cache first (matching both codepoint and style)
   for (uint32_t i = 0; i < self->overflowCount_; i++) {

lib/EpdFont/SdCardFont.h

@@ -58,9 +58,9 @@ class SdCardFont {
   // Returns true if advance table is populated for at least one style.
   bool hasAdvanceTable() const;
 
-  // Free mini data for all styles, restore stub EpdFontData.
-  // Also clears the temporary advance table (built per layout pass) but
-  // preserves the persistent advance cache (reused across passes).
+  // Free mini data for all styles and restore stub EpdFontData.
+  // Preserves the persistent advance cache so repeated layout passes can reuse
+  // previously fetched metrics.
   void clearCache();
 
   // Drop the persistent advance cache. Call when unloading the SD font or
@@ -140,6 +140,14 @@ class SdCardFont {
 
     // Full intervals loaded from file (kept in RAM for codepoint lookup)
     EpdUnicodeInterval* fullIntervals = nullptr;
+    struct BmpInterval16 {
+      uint16_t first;
+      uint16_t last;
+      uint16_t offset;
+    } __attribute__((packed));
+    static_assert(sizeof(BmpInterval16) == 6, "BmpInterval16 must remain compact");
+    BmpInterval16* bmpIntervals = nullptr;
+    bool intervalsAreBmp16 = false;
 
     // Persistent kern-class + ligature tables (lazy-loaded on first prewarm).
     // The full kern MATRIX is NOT resident — on Literata-class fonts a single

lib/EpdFont/SdCardFontManager.cpp

@@ -34,19 +34,15 @@ bool SdCardFontManager::loadFamily(const SdCardFontFamilyInfo& family, GfxRender
     unloadAll(renderer);
   }
 
-  // Select by ordinal position: sort available sizes, then map the font size
-  // enum (SMALL=0 .. EXTRA_LARGE=3) to the corresponding slot. When the
-  // family has fewer sizes than 4, clamp to the last available size.
-  auto sizes = family.availableSizes();
-  if (sizes.empty()) {
+  // Select the physical point size closest to the built-in reader sizes. Some
+  // CJK font packs only ship larger sizes, so ordinal selection can make
+  // MEDIUM load 18pt+ and produce oversized pages on small devices.
+  const SdCardFontFileInfo* selected = family.findClosestReaderSize(fontSizeEnum);
+  if (!selected) {
     LOG_ERR("SDMGR", "Family %s has no files to load", family.name.c_str());
     return false;
   }
 
-  uint8_t idx = fontSizeEnum;
-  if (idx >= sizes.size()) idx = sizes.size() - 1;
-  const SdCardFontFileInfo* selected = family.findFile(sizes[idx]);
-
   auto* font = new (std::nothrow) SdCardFont();
   if (!font) {
     LOG_ERR("SDMGR", "Failed to allocate SdCardFont for %s", selected->path.c_str());

lib/EpdFont/SdCardFontManager.h

@@ -15,10 +15,10 @@ class SdCardFontManager {
   SdCardFontManager(const SdCardFontManager&) = delete;
   SdCardFontManager& operator=(const SdCardFontManager&) = delete;
 
-  // Load the font file matching fontSizeEnum (SMALL=0 .. EXTRA_LARGE=3) by
-  // ordinal position in the family's sorted size list. Only one .cpfont file
-  // is loaded; other sizes remain on disk. This keeps resident interval +
-  // kern/ligature tables to one size's worth of memory.
+  // Load the font file whose physical point size is closest to the reader
+  // fontSizeEnum (SMALL=12, MEDIUM=14, LARGE=16, EXTRA_LARGE=18). Only one
+  // .cpfont file is loaded; other sizes remain on disk. This keeps resident
+  // interval + kern/ligature tables to one size's worth of memory.
   // Returns true on success.
   bool loadFamily(const SdCardFontFamilyInfo& family, GfxRenderer& renderer, uint8_t fontSizeEnum);
 
@@ -32,7 +32,7 @@ class SdCardFontManager {
   // Get name of currently loaded family (empty if none).
   const std::string& currentFamilyName() const { return loadedFamilyName_; };
 
-  // Point size that was actually loaded (closest match to targetPtSize).
+  // Point size that was actually loaded.
   // 0 if nothing loaded.
   uint8_t currentPointSize() const { return loadedPointSize_; };
 

lib/EpdFont/SdCardFontRegistry.cpp

@@ -15,6 +15,60 @@ const SdCardFontFileInfo* SdCardFontFamilyInfo::findFile(uint8_t size, uint8_t s
   return nullptr;
 }
 
+const SdCardFontFileInfo* SdCardFontFamilyInfo::findClosestReaderSize(const uint8_t fontSizeEnum,
+                                                                      const uint8_t style) const {
+  if (files.empty()) return nullptr;
+
+  // Collect sizes matching the requested style, sorted ascending.
+  std::vector<uint8_t> sizes;
+  for (const auto& f : files) {
+    if (f.style != style) continue;
+    sizes.push_back(f.pointSize);
+  }
+  if (sizes.empty()) return nullptr;
+  std::sort(sizes.begin(), sizes.end());
+
+  // When the family provides at least 4 sizes, use ordinal (index-based)
+  // selection so custom-built font sets (e.g. 10/12/14/16) map SMALL to
+  // the smallest file, not to a hardcoded 12pt target.
+  if (sizes.size() >= 4) {
+    uint8_t idx = fontSizeEnum;
+    if (idx >= sizes.size()) idx = sizes.size() - 1;
+    return findFile(sizes[idx], style);
+  }
+
+  // Fewer sizes than enum slots (e.g. CJK packs with only 2-3 sizes):
+  // fall back to closest-match against the built-in reader targets.
+  uint8_t target = 14;
+  switch (fontSizeEnum) {
+    case 0:
+      target = 12;
+      break;
+    case 2:
+      target = 16;
+      break;
+    case 3:
+      target = 18;
+      break;
+    case 1:
+    default:
+      target = 14;
+      break;
+  }
+
+  const SdCardFontFileInfo* best = nullptr;
+  uint8_t bestDelta = 255;
+  for (const auto& f : files) {
+    if (f.style != style) continue;
+    const uint8_t delta = f.pointSize > target ? f.pointSize - target : target - f.pointSize;
+    if (!best || delta < bestDelta || (delta == bestDelta && f.pointSize < best->pointSize)) {
+      best = &f;
+      bestDelta = delta;
+    }
+  }
+  return best;
+}
+
 bool SdCardFontFamilyInfo::hasSize(uint8_t size) const {
   for (const auto& f : files) {
     if (f.pointSize == size) return true;

lib/EpdFont/SdCardFontRegistry.h

@@ -18,6 +18,7 @@ struct SdCardFontFamilyInfo {
   std::vector<SdCardFontFileInfo> files;
 
   const SdCardFontFileInfo* findFile(uint8_t size, uint8_t style = 0) const;
+  const SdCardFontFileInfo* findClosestReaderSize(uint8_t fontSizeEnum, uint8_t style = 0) const;
   bool hasSize(uint8_t size) const;
   std::vector<uint8_t> availableSizes() const;
 };

lib/EpdFont/builtinFonts/all.h

@@ -37,3 +37,5 @@
 #include <builtinFonts/ubuntu_10_regular.h>
 #include <builtinFonts/ubuntu_12_bold.h>
 #include <builtinFonts/ubuntu_12_regular.h>
+#include <builtinFonts/ubuntu_14_bold.h>
+#include <builtinFonts/ubuntu_14_regular.h>

lib/EpdFont/scripts/build-font-ids.sh

@@ -94,6 +94,13 @@ ruby -rdigest -e 'puts [
 ].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
 ))"
 
+echo "#define UI_14_FONT_ID ($(
+ruby -rdigest -e 'puts [
+  "./ubuntu_14_regular.h",
+  "./ubuntu_14_bold.h",
+].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
+))"
+
 echo "#define SMALL_FONT_ID ($(
 ruby -rdigest -e 'puts [
   "./notosans_8_regular.h",

lib/EpdFont/scripts/convert-builtin-fonts.sh

@@ -28,23 +28,42 @@ for size in ${NOTOSANS_FONT_SIZES[@]}; do
   done
 done
 
+# Small UI chrome (button devices, uiScale 1.0). Rendered 1-bit: crisp at these
+# sizes and half the flash of 2-bit.
 UI_FONT_SIZES=(10 12)
+# Larger UI chrome substituted in on touch/high-density boards via the uiScale
+# remap (see src/main.cpp setupFonts). Rendered 2-bit so it stays smooth when
+# enlarged. Touch boards use uiScale 1.2, so UI_12 -> 14.4 -> 14 is the size the
+# remap actually lands on; add larger sizes here if a board adopts a higher scale.
+UI_FONT_SIZES_LARGE=(14)
 UI_FONT_STYLES=("Regular" "Bold")
 
+# Ubuntu lacks the Latin Extended Additional block (U+1EA0-U+1EF9) used for
+# Vietnamese tone marks. Append a Vietnamese-only Ubuntu cut so those glyphs are
+# filled from it while every glyph Ubuntu already has stays unchanged (fontstack
+# is ordered by descending priority). NotoSansHebrew fills U+05D0-U+05EA so the
+# Hebrew UI translation renders in menus and settings.
+generate_ui_font() {
+  local size="$1" style="$2" extra_flags="$3"
+  local font_name="ubuntu_${size}_$(echo $style | tr '[:upper:]' '[:lower:]')"
+  local font_path="../builtinFonts/source/Ubuntu/Ubuntu-${style}.ttf"
+  local hebrew_path="../builtinFonts/source/NotoSansHebrew/NotoSansHebrew-${style}.ttf"
+  local viet_path="../builtinFonts/source/Ubuntu/Ubuntu-Vietnamese-${style}.ttf"
+  local output_path="../builtinFonts/${font_name}.h"
+  python fontconvert.py $font_name $size $font_path $hebrew_path $viet_path \
+    --additional-intervals 0x05D0,0x05EA $extra_flags > $output_path
+  echo "Generated $output_path"
+}
+
 for size in ${UI_FONT_SIZES[@]}; do
   for style in ${UI_FONT_STYLES[@]}; do
-    font_name="ubuntu_${size}_$(echo $style | tr '[:upper:]' '[:lower:]')"
-    font_path="../builtinFonts/source/Ubuntu/Ubuntu-${style}.ttf"
-    hebrew_path="../builtinFonts/source/NotoSansHebrew/NotoSansHebrew-${style}.ttf"
-    # Ubuntu lacks the Latin Extended Additional block (U+1EA0-U+1EF9) used for
-    # Vietnamese tone marks. Append a Vietnamese-only Ubuntu cut so those glyphs
-    # are filled from it while every glyph Ubuntu already has stays unchanged
-    # (fontstack is ordered by descending priority).
-    viet_path="../builtinFonts/source/Ubuntu/Ubuntu-Vietnamese-${style}.ttf"
-    output_path="../builtinFonts/${font_name}.h"
-    python fontconvert.py $font_name $size $font_path $hebrew_path $viet_path \
-      --additional-intervals 0x05D0,0x05EA > $output_path
-    echo "Generated $output_path"
+    generate_ui_font $size $style ""
+  done
+done
+
+for size in ${UI_FONT_SIZES_LARGE[@]}; do
+  for style in ${UI_FONT_STYLES[@]}; do
+    generate_ui_font $size $style "--2bit --compress"
   done
 done
 

lib/EpdFont/scripts/fontconvert.py

@@ -248,7 +248,7 @@ unmerged_intervals = sorted(intervals + add_ints)
 intervals = []
 unvalidated_intervals = []
 for i_start, i_end in unmerged_intervals:
-    if len(unvalidated_intervals) > 0 and i_start + 1 <= unvalidated_intervals[-1][1]:
+    if len(unvalidated_intervals) > 0 and i_start <= unvalidated_intervals[-1][1] + 1:
         unvalidated_intervals[-1] = (unvalidated_intervals[-1][0], max(unvalidated_intervals[-1][1], i_end))
         continue
     unvalidated_intervals.append((i_start, i_end))

lib/EpdFont/scripts/fontconvert_sdcard.py

@@ -40,7 +40,8 @@ INTERVAL_PRESETS = {
     "ascii":       [(0x0020, 0x007E)],
     "latin1":      [(0x0080, 0x00FF)],
     "latin-ext":   [(0x0020, 0x007E), (0x0080, 0x00FF), (0x0100, 0x024F),
-                    (0x1E00, 0x1EFF), (0x2000, 0x206F), (0xFB00, 0xFB06)],
+                    (0x02B0, 0x02FF), (0x1E00, 0x1EFF), (0x2000, 0x206F),
+                    (0xFB00, 0xFB06)],
     "greek":       [(0x0370, 0x03FF), (0x1F00, 0x1FFF)],
     "cyrillic":    [(0x0400, 0x04FF), (0x0500, 0x052F)],
     "hebrew":      [(0x0590, 0x05FF), (0xFB1D, 0xFB4F)],
@@ -62,7 +63,7 @@ INTERVAL_PRESETS = {
     # Composite preset for English-language literary fiction including scifi/popsci.
     # Greek for physics terms, math operators, geometric shapes, uncommon
     # dialogue punctuation, CJK quote marks, miscellaneous symbols (♪♫♬), dingbats.
-    "reading":     [(0x0020, 0x024F), (0x0300, 0x036F), (0x0370, 0x03FF),
+    "reading":     [(0x0020, 0x024F), (0x02B0, 0x02FF), (0x0300, 0x036F), (0x0370, 0x03FF),
                     (0x0400, 0x04FF), (0x1E00, 0x1EFF), (0x2000, 0x206F),
                     (0x2070, 0x209F), (0x20A0, 0x20CF), (0x2150, 0x218F),
                     (0x2190, 0x21FF), (0x2200, 0x22FF), (0x2500, 0x257F),

lib/Epub/Epub.cpp

@@ -5,6 +5,7 @@
 #include <JpegToBmpConverter.h>
 #include <Logging.h>
 #include <PngToBmpConverter.h>
+#include <Utf8.h>
 #include <ZipFile.h>
 
 #include "Epub/parsers/ContainerParser.h"
@@ -73,8 +74,9 @@ bool Epub::parseContentOpf(BookMetadataCache::BookMetadata& bookMetadata, const
     return false;
   }
 
-  // Grab data from opfParser into epub
-  bookMetadata.title = opfParser.title;
+  // Grab data from opfParser into epub. Normalize titles to NFC so NFD (combining
+  // mark) text renders correctly — the device fonts have no mark positioning.
+  bookMetadata.title = utf8ComposeNfc(opfParser.title);
   bookMetadata.author = opfParser.author;
   bookMetadata.language = opfParser.language;
   bookMetadata.coverItemHref = opfParser.coverItemHref;

lib/Epub/Epub/BookMetadataCache.cpp

@@ -2,6 +2,7 @@
 
 #include <Logging.h>
 #include <Serialization.h>
+#include <Utf8.h>
 #include <ZipFile.h>
 
 #include <deque>
@@ -9,12 +10,51 @@
 #include "FsHelpers.h"
 
 namespace {
-constexpr uint8_t BOOK_CACHE_VERSION = 7;
+constexpr uint8_t BOOK_CACHE_VERSION = 8;  // v8: TOC/book titles stored NFC-composed
 constexpr char bookBinFile[] = "/book.bin";
 constexpr char tmpSpineBinFile[] = "/spine.bin.tmp";
 constexpr char tmpTocBinFile[] = "/toc.bin.tmp";
+constexpr uint32_t MAX_CACHE_STRING_LEN = 4096;
+
+bool readStringBounded(HalFile& file, std::string& out, const uint32_t maxLen = MAX_CACHE_STRING_LEN) {
+  uint32_t len = 0;
+  if (file.read(&len, sizeof(len)) != static_cast<int>(sizeof(len))) {
+    return false;
+  }
+  if (len > maxLen || len > static_cast<uint32_t>(file.available())) {
+    LOG_ERR("BMC", "Invalid cache string length: %lu (max=%lu available=%d)", static_cast<unsigned long>(len),
+            static_cast<unsigned long>(maxLen), file.available());
+    return false;
+  }
+  out.clear();
+  if (len == 0) {
+    return true;
+  }
+  out.resize(len);
+  return file.read(out.data(), len) == static_cast<int>(len);
+}
+
+class CacheIoLock {
+ public:
+  explicit CacheIoLock(SemaphoreHandle_t mutex) : mutex(mutex) {
+    if (mutex) xSemaphoreTakeRecursive(mutex, portMAX_DELAY);
+  }
+  ~CacheIoLock() {
+    if (mutex) xSemaphoreGiveRecursive(mutex);
+  }
+
+ private:
+  SemaphoreHandle_t mutex;
+};
 }  // namespace
 
+BookMetadataCache::~BookMetadataCache() {
+  if (ioMutex) {
+    vSemaphoreDelete(ioMutex);
+    ioMutex = nullptr;
+  }
+}
+
 /* ============= WRITING / BUILDING FUNCTIONS ================ */
 
 bool BookMetadataCache::beginWrite() {
@@ -364,7 +404,9 @@ void BookMetadataCache::createTocEntry(const std::string& title, const std::stri
     }
   }
 
-  const TocEntry entry(title, href, anchor, level, spineIndex);
+  // Compose the title to NFC at index time so the cache stores precomposed glyphs;
+  // device fonts have no combining-mark positioning, so NFD titles render broken.
+  const TocEntry entry(utf8ComposeNfc(title), href, anchor, level, spineIndex);
   writeTocEntry(tocFile, entry);
   tocCount++;
 }
@@ -372,6 +414,7 @@ void BookMetadataCache::createTocEntry(const std::string& title, const std::stri
 /* ============= READING / LOADING FUNCTIONS ================ */
 
 bool BookMetadataCache::load() {
+  CacheIoLock ioLock(ioMutex);
   if (!Storage.openFileForRead("BMC", cachePath + bookBinFile, bookFile)) {
     return false;
   }
@@ -389,11 +432,13 @@ bool BookMetadataCache::load() {
   serialization::readPod(bookFile, spineCount);
   serialization::readPod(bookFile, tocCount);
 
-  serialization::readString(bookFile, coreMetadata.title);
-  serialization::readString(bookFile, coreMetadata.author);
-  serialization::readString(bookFile, coreMetadata.language);
-  serialization::readString(bookFile, coreMetadata.coverItemHref);
-  serialization::readString(bookFile, coreMetadata.textReferenceHref);
+  if (!readStringBounded(bookFile, coreMetadata.title) || !readStringBounded(bookFile, coreMetadata.author) ||
+      !readStringBounded(bookFile, coreMetadata.language) || !readStringBounded(bookFile, coreMetadata.coverItemHref) ||
+      !readStringBounded(bookFile, coreMetadata.textReferenceHref)) {
+    LOG_ERR("BMC", "Invalid cache metadata strings");
+    bookFile.close();
+    return false;
+  }
 
   loaded = true;
   LOG_DBG("BMC", "Loaded cache data: %d spine, %d TOC entries", spineCount, tocCount);
@@ -401,6 +446,7 @@ bool BookMetadataCache::load() {
 }
 
 BookMetadataCache::SpineEntry BookMetadataCache::getSpineEntry(const int index) {
+  CacheIoLock ioLock(ioMutex);
   if (!loaded) {
     LOG_ERR("BMC", "getSpineEntry called but cache not loaded");
     return {};
@@ -415,11 +461,16 @@ BookMetadataCache::SpineEntry BookMetadataCache::getSpineEntry(const int index)
   bookFile.seek(lutOffset + sizeof(uint32_t) * index);
   uint32_t spineEntryPos;
   serialization::readPod(bookFile, spineEntryPos);
+  if (spineEntryPos >= bookFile.size()) {
+    LOG_ERR("BMC", "Spine entry offset out of range: %lu", static_cast<unsigned long>(spineEntryPos));
+    return {};
+  }
   bookFile.seek(spineEntryPos);
   return readSpineEntry(bookFile);
 }
 
 BookMetadataCache::TocEntry BookMetadataCache::getTocEntry(const int index) {
+  CacheIoLock ioLock(ioMutex);
   if (!loaded) {
     LOG_ERR("BMC", "getTocEntry called but cache not loaded");
     return {};
@@ -434,24 +485,34 @@ BookMetadataCache::TocEntry BookMetadataCache::getTocEntry(const int index) {
   bookFile.seek(lutOffset + sizeof(uint32_t) * spineCount + sizeof(uint32_t) * index);
   uint32_t tocEntryPos;
   serialization::readPod(bookFile, tocEntryPos);
+  if (tocEntryPos >= bookFile.size()) {
+    LOG_ERR("BMC", "TOC entry offset out of range: %lu", static_cast<unsigned long>(tocEntryPos));
+    return {};
+  }
   bookFile.seek(tocEntryPos);
   return readTocEntry(bookFile);
 }
 
 BookMetadataCache::SpineEntry BookMetadataCache::readSpineEntry(HalFile& file) const {
   SpineEntry entry;
-  serialization::readString(file, entry.href);
-  serialization::readPod(file, entry.cumulativeSize);
-  serialization::readPod(file, entry.tocIndex);
+  if (!readStringBounded(file, entry.href) ||
+      file.read(&entry.cumulativeSize, sizeof(entry.cumulativeSize)) !=
+          static_cast<int>(sizeof(entry.cumulativeSize)) ||
+      file.read(&entry.tocIndex, sizeof(entry.tocIndex)) != static_cast<int>(sizeof(entry.tocIndex))) {
+    LOG_ERR("BMC", "Invalid spine cache entry");
+    return {};
+  }
   return entry;
 }
 
 BookMetadataCache::TocEntry BookMetadataCache::readTocEntry(HalFile& file) const {
   TocEntry entry;
-  serialization::readString(file, entry.title);
-  serialization::readString(file, entry.href);
-  serialization::readString(file, entry.anchor);
-  serialization::readPod(file, entry.level);
-  serialization::readPod(file, entry.spineIndex);
+  if (!readStringBounded(file, entry.title) || !readStringBounded(file, entry.href) ||
+      !readStringBounded(file, entry.anchor) ||
+      file.read(&entry.level, sizeof(entry.level)) != static_cast<int>(sizeof(entry.level)) ||
+      file.read(&entry.spineIndex, sizeof(entry.spineIndex)) != static_cast<int>(sizeof(entry.spineIndex))) {
+    LOG_ERR("BMC", "Invalid TOC cache entry");
+    return {};
+  }
   return entry;
 }

lib/Epub/Epub/BookMetadataCache.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <HalStorage.h>
+#include <freertos/semphr.h>
 
 #include <algorithm>
 #include <deque>
@@ -54,6 +55,7 @@ class BookMetadataCache {
   // Temp file handles during build
   HalFile spineFile;
   HalFile tocFile;
+  SemaphoreHandle_t ioMutex;
 
   // Index for fast href→spineIndex lookup (used only for large EPUBs)
   struct SpineHrefIndexEntry {
@@ -85,8 +87,14 @@ class BookMetadataCache {
   BookMetadata coreMetadata;
 
   explicit BookMetadataCache(std::string cachePath)
-      : cachePath(std::move(cachePath)), lutOffset(0), spineCount(0), tocCount(0), loaded(false), buildMode(false) {}
-  ~BookMetadataCache() = default;
+      : cachePath(std::move(cachePath)),
+        lutOffset(0),
+        spineCount(0),
+        tocCount(0),
+        loaded(false),
+        buildMode(false),
+        ioMutex(xSemaphoreCreateRecursiveMutex()) {}
+  ~BookMetadataCache();
 
   // Building phase (stream to disk immediately)
   bool beginWrite();

lib/Epub/Epub/Page.cpp

@@ -6,6 +6,20 @@
 
 #include <new>
 
+namespace {
+
+template <typename Predicate>
+void renderFilteredPageElements(const std::vector<std::shared_ptr<PageElement>>& elements, GfxRenderer& renderer,
+                                const int fontId, const int xOffset, const int yOffset, Predicate&& predicate) {
+  for (const auto& element : elements) {
+    if (predicate(*element)) {
+      element->render(renderer, fontId, xOffset, yOffset);
+    }
+  }
+}
+
+}  // namespace
+
 void PageLine::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) {
   block->render(renderer, fontId, xPos + xOffset, yPos + yOffset);
 }
@@ -93,9 +107,12 @@ std::unique_ptr<PageHorizontalRule> PageHorizontalRule::deserialize(HalFile& fil
 }
 
 void Page::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) const {
-  for (auto& element : elements) {
-    element->render(renderer, fontId, xOffset, yOffset);
-  }
+  renderFilteredPageElements(elements, renderer, fontId, xOffset, yOffset, [](const PageElement&) { return true; });
+}
+
+void Page::renderImages(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) const {
+  renderFilteredPageElements(elements, renderer, fontId, xOffset, yOffset,
+                             [](const PageElement& element) { return element.getTag() == TAG_PageImage; });
 }
 
 bool Page::serialize(HalFile& file) const {

lib/Epub/Epub/Page.h

@@ -88,6 +88,7 @@ class Page {
   }
 
   void render(GfxRenderer& renderer, int fontId, int xOffset, int yOffset) const;
+  void renderImages(GfxRenderer& renderer, int fontId, int xOffset, int yOffset) const;
   bool serialize(HalFile& file) const;
   static std::unique_ptr<Page> deserialize(HalFile& file);
 

lib/Epub/Epub/ParsedText.cpp

@@ -24,6 +24,7 @@ constexpr size_t RTL_PARAGRAPH_PROBE_WORDS = 3;
 // Per-word: scan enough chars to see through leading neutrals (quotes, numbers)
 // before giving up. 64 is a hedge for pathological cases like long numeric tokens.
 constexpr int RTL_PER_WORD_PROBE_DEPTH = 64;
+constexpr size_t MIN_JUSTIFY_GAPS = 1;
 
 // Byte-level pre-check: Hebrew UTF-8 lead bytes 0xD6-0xD7, Arabic/Syriac 0xD8-0xDB.
 bool mayContainRtlBytes(const char* str) {
@@ -57,6 +58,134 @@ uint32_t lastCodepoint(const std::string& word) {
 
 bool containsSoftHyphen(const std::string& word) { return word.find(SOFT_HYPHEN_UTF8) != std::string::npos; }
 
+bool isNoBreakBeforeCjkPunctuation(const uint32_t cp) {
+  switch (cp) {
+    case '.':
+    case ',':
+    case ':':
+    case ';':
+    case '!':
+    case '?':
+    case ')':
+    case ']':
+    case '}':
+    case 0x00BB:  // »
+    case 0x2019:  // ’
+    case 0x201D:  // ”
+    case 0x3001:  // 、
+    case 0x3002:  // 。
+    case 0x3009:  // 〉
+    case 0x300B:  // 》
+    case 0x300D:  // 」
+    case 0x300F:  // 』
+    case 0x3011:  // 】
+    case 0x3015:  // 〕
+    case 0x3017:  // 〗
+    case 0x3019:  // 〙
+    case 0x301B:  // 〛
+    case 0xFF01:  // ！
+    case 0xFF09:  // ）
+    case 0xFF0C:  // ，
+    case 0xFF0E:  // ．
+    case 0xFF1A:  // ：
+    case 0xFF1B:  // ；
+    case 0xFF1F:  // ？
+    case 0xFF3D:  // ］
+    case 0xFF5D:  // ｝
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool isNoBreakAfterCjkPunctuation(const uint32_t cp) {
+  switch (cp) {
+    case '(':
+    case '[':
+    case '{':
+    case 0x00AB:  // «
+    case 0x2018:  // ‘
+    case 0x201C:  // “
+    case 0x3008:  // 〈
+    case 0x300A:  // 《
+    case 0x300C:  // 「
+    case 0x300E:  // 『
+    case 0x3010:  // 【
+    case 0x3014:  // 〔
+    case 0x3016:  // 〖
+    case 0x3018:  // 〘
+    case 0x301A:  // 〚
+    case 0xFF08:  // （
+    case 0xFF3B:  // ［
+    case 0xFF5B:  // ｛
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool containsCjkBreakableCodepoint(const std::string& text) {
+  const auto* ptr = reinterpret_cast<const unsigned char*>(text.c_str());
+  while (*ptr) {
+    const uint32_t cp = utf8NextCodepoint(&ptr);
+    if (utf8IsCjkBreakable(cp)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool hasCjkBreakOpportunityBetween(const uint32_t leftCp, const uint32_t rightCp) {
+  if (!utf8IsCjkBreakable(leftCp) && !utf8IsCjkBreakable(rightCp)) return false;
+  if (isNoBreakAfterCjkPunctuation(leftCp) || isNoBreakBeforeCjkPunctuation(rightCp)) return false;
+  if (utf8IsCombiningMark(rightCp)) return false;
+  return true;
+}
+
+std::vector<size_t> cjkCharacterBreakByteOffsets(const std::string& text) {
+  struct CodepointBoundary {
+    uint32_t cp;
+    size_t endOffset;
+  };
+
+  std::vector<CodepointBoundary> codepoints;
+  codepoints.reserve(text.size());
+  bool hasCjkBreakable = false;
+
+  const auto* ptr = reinterpret_cast<const unsigned char*>(text.c_str());
+  const auto* const start = ptr;
+  while (*ptr) {
+    const uint32_t cp = utf8NextCodepoint(&ptr);
+    if (cp == 0) break;
+    if (utf8IsCjkBreakable(cp)) {
+      hasCjkBreakable = true;
+    }
+    codepoints.push_back({cp, static_cast<size_t>(ptr - start)});
+  }
+
+  if (!hasCjkBreakable || codepoints.size() < 2) return {};
+
+  std::vector<size_t> allowedOffsets;
+  allowedOffsets.reserve(codepoints.size() - 1);
+  for (size_t i = 0; i + 1 < codepoints.size(); ++i) {
+    const uint32_t current = codepoints[i].cp;
+    const uint32_t next = codepoints[i + 1].cp;
+    if (!hasCjkBreakOpportunityBetween(current, next)) continue;
+    allowedOffsets.push_back(codepoints[i].endOffset);
+  }
+  return allowedOffsets;
+}
+
+int computeJustifyExtra(const int spareSpace, const size_t gapCount) {
+  if (gapCount < MIN_JUSTIFY_GAPS || spareSpace <= 0) return 0;
+  // Distribute the spare space evenly across gaps. Do NOT bail out to 0 when the
+  // per-gap stretch is large: a sparse line (few words on a wide page) legitimately
+  // needs big gaps to reach the margin. Returning 0 there disables justification for
+  // that line, leaving it right-aligned (RTL) / left-aligned (LTR) — the mismatched
+  // alignment bug. Match the un-capped behavior of the old code.
+  return spareSpace / static_cast<int>(gapCount);
+}
+
 // Removes every soft hyphen in-place so rendered glyphs match measured widths.
 void stripSoftHyphensInPlace(std::string& word) {
   size_t pos = 0;
@@ -125,6 +254,14 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
                          const bool attachToPrevious) {
   if (word.empty()) return;
 
+  // The device fonts carry no combining-mark positioning, so EPUB text stored in NFD
+  // (a base letter followed by separate combining accents -- common for Vietnamese,
+  // and used for many EPUB <h1> chapter headings) renders with the marks detached or
+  // misplaced. Compose to NFC here, the single funnel every word passes through, so a
+  // precomposed glyph is used instead. This runs once per word at layout time (the
+  // result is cached in the section file) and is a cheap no-op for mark-free text.
+  word = utf8ComposeNfc(word);
+
   EpdFontFamily::Style baseStyle = fontStyle;
   if (underline) {
     baseStyle = static_cast<EpdFontFamily::Style>(baseStyle | EpdFontFamily::UNDERLINE);
@@ -132,12 +269,54 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
   const bool wordStartsRtl = !hasRtlWord && mayContainRtlBytes(word.c_str()) &&
                              BidiUtils::startsWithRtl(word.c_str(), RTL_PER_WORD_PROBE_DEPTH);
 
+  const auto pushToken = [&](std::string token, const bool continues, const bool noSpaceBefore,
+                             const bool isFocusSuffix) {
+    words.push_back(std::move(token));
+    wordStyles.push_back(baseStyle);
+    wordContinues.push_back(continues);
+    wordNoSpaceBefore.push_back(noSpaceBefore);
+    wordIsFocusSuffix.push_back(isFocusSuffix);
+  };
+
+  bool effectiveAttachToPrevious = attachToPrevious;
+  bool effectiveNoSpaceBefore = false;
+  if (attachToPrevious && !words.empty() &&
+      hasCjkBreakOpportunityBetween(lastCodepoint(words.back()), firstCodepoint(word))) {
+    effectiveAttachToPrevious = false;
+    effectiveNoSpaceBefore = true;
+  }
+
+  if (auto breakOffsets = cjkCharacterBreakByteOffsets(word); !breakOffsets.empty()) {
+    bool firstToken = true;
+    size_t tokenStart = 0;
+    for (const size_t breakOffset : breakOffsets) {
+      if (breakOffset <= tokenStart || breakOffset > word.size()) continue;
+      pushToken(word.substr(tokenStart, breakOffset - tokenStart), firstToken ? effectiveAttachToPrevious : false,
+                firstToken ? effectiveNoSpaceBefore : true, false);
+      firstToken = false;
+      tokenStart = breakOffset;
+    }
+    if (tokenStart < word.size()) {
+      pushToken(word.substr(tokenStart), firstToken ? effectiveAttachToPrevious : false,
+                firstToken ? effectiveNoSpaceBefore : true, false);
+    }
+    if (wordStartsRtl) {
+      hasRtlWord = true;
+    }
+    return;
+  }
+
+  if (containsCjkBreakableCodepoint(word)) {
+    pushToken(std::move(word), effectiveAttachToPrevious, effectiveNoSpaceBefore, false);
+    if (wordStartsRtl) {
+      hasRtlWord = true;
+    }
+    return;
+  }
+
   // Already-bold text should stay fully bold; focus splitting would make its suffix regular later.
   if (!this->focusReadingEnabled || (baseStyle & EpdFontFamily::BOLD) != 0) {
-    words.push_back(std::move(word));
-    wordStyles.push_back(baseStyle);
-    wordContinues.push_back(attachToPrevious);
-    wordIsFocusSuffix.push_back(false);
+    pushToken(std::move(word), effectiveAttachToPrevious, effectiveNoSpaceBefore, false);
     if (wordStartsRtl) {
       hasRtlWord = true;
     }
@@ -166,17 +345,19 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
     words.reserve(newCapacity);
     wordStyles.reserve(newCapacity);
     wordContinues.reserve(newCapacity);
+    wordNoSpaceBefore.reserve(newCapacity);
     wordIsFocusSuffix.reserve(newCapacity);
   }
 
   // Lambda helper to process and push individual sub-segments of the string
   // Use std::string_view to avoid heap allocations when slicing
-  auto processSegment = [&](std::string_view segment, bool isWord, bool attach) {
+  auto processSegment = [&](std::string_view segment, bool isWord, bool attach, bool noSpaceBefore) {
     if (!isWord) {
       // Punctuation and Numbers stay regular
       words.emplace_back(segment);
       wordStyles.push_back(baseStyle);
       wordContinues.push_back(attach);
+      wordNoSpaceBefore.push_back(noSpaceBefore);
       wordIsFocusSuffix.push_back(false);
     } else {
       size_t charCount = 0;
@@ -198,6 +379,7 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
         words.emplace_back(segment);
         wordStyles.push_back(static_cast<EpdFontFamily::Style>(baseStyle | EpdFontFamily::BOLD));
         wordContinues.push_back(attach);
+        wordNoSpaceBefore.push_back(noSpaceBefore);
         wordIsFocusSuffix.push_back(false);
       } else {
         countPtr = reinterpret_cast<const unsigned char*>(segment.data());
@@ -210,12 +392,14 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
         words.emplace_back(segment.substr(0, splitByteOffset));
         wordStyles.push_back(static_cast<EpdFontFamily::Style>(baseStyle | EpdFontFamily::BOLD));
         wordContinues.push_back(attach);
+        wordNoSpaceBefore.push_back(noSpaceBefore);
         wordIsFocusSuffix.push_back(false);
 
         // Regular suffix - marked so extractLine can merge it back into single TextBlock entry
         words.emplace_back(segment.substr(splitByteOffset));
         wordStyles.push_back(baseStyle);
         wordContinues.push_back(true);
+        wordNoSpaceBefore.push_back(false);
         wordIsFocusSuffix.push_back(true);
       }
     }
@@ -243,7 +427,8 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
 
       // Only the very first segment inherits the original attachToPrevious flag.
       // Every subsequent segment MUST attach=true so it glues seamlessly to the prefix.
-      processSegment(segment, inWordSegment, isFirstSegment ? attachToPrevious : true);
+      processSegment(segment, inWordSegment, isFirstSegment ? effectiveAttachToPrevious : true,
+                     isFirstSegment ? effectiveNoSpaceBefore : false);
 
       // Setup for the next segment
       segmentStart = currentCpStart;
@@ -255,7 +440,8 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
   // Process the final remaining segment
   size_t segmentLen = end - segmentStart;
   std::string_view segment(reinterpret_cast<const char*>(segmentStart), segmentLen);
-  processSegment(segment, inWordSegment, isFirstSegment ? attachToPrevious : true);
+  processSegment(segment, inWordSegment, isFirstSegment ? effectiveAttachToPrevious : true,
+                 isFirstSegment ? effectiveNoSpaceBefore : false);
   if (wordStartsRtl) {
     hasRtlWord = true;
   }
@@ -324,14 +510,16 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
   std::vector<size_t> lineBreakIndices;
   if (hyphenationEnabled) {
     // Use greedy layout that can split words mid-loop when a hyphenated prefix fits.
-    lineBreakIndices = computeHyphenatedLineBreaks(renderer, fontId, pageWidth, wordWidths, wordContinues);
+    lineBreakIndices =
+        computeHyphenatedLineBreaks(renderer, fontId, pageWidth, wordWidths, wordContinues, wordNoSpaceBefore);
   } else {
-    lineBreakIndices = computeLineBreaks(renderer, fontId, pageWidth, wordWidths, wordContinues);
+    lineBreakIndices = computeLineBreaks(renderer, fontId, pageWidth, wordWidths, wordContinues, wordNoSpaceBefore);
   }
   const size_t lineCount = includeLastLine ? lineBreakIndices.size() : lineBreakIndices.size() - 1;
 
   for (size_t i = 0; i < lineCount; ++i) {
-    extractLine(i, pageWidth, wordWidths, wordContinues, lineBreakIndices, processLine, renderer, fontId);
+    extractLine(i, pageWidth, wordWidths, wordContinues, wordNoSpaceBefore, lineBreakIndices, processLine, renderer,
+                fontId);
   }
 
   // Remove consumed words so size() reflects only remaining words
@@ -340,6 +528,7 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
     words.erase(words.begin(), words.begin() + consumed);
     wordStyles.erase(wordStyles.begin(), wordStyles.begin() + consumed);
     wordContinues.erase(wordContinues.begin(), wordContinues.begin() + consumed);
+    wordNoSpaceBefore.erase(wordNoSpaceBefore.begin(), wordNoSpaceBefore.begin() + consumed);
     wordIsFocusSuffix.erase(wordIsFocusSuffix.begin(), wordIsFocusSuffix.begin() + consumed);
   }
 }
@@ -356,7 +545,8 @@ std::vector<uint16_t> ParsedText::calculateWordWidths(const GfxRenderer& rendere
 }
 
 std::vector<size_t> ParsedText::computeLineBreaks(const GfxRenderer& renderer, const int fontId, const int pageWidth,
-                                                  std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec) {
+                                                  std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec,
+                                                  std::vector<bool>& noSpaceBeforeVec) {
   if (words.empty()) {
     return {};
   }
@@ -395,7 +585,9 @@ std::vector<size_t> ParsedText::computeLineBreaks(const GfxRenderer& renderer, c
     for (size_t j = i; j < totalWordCount; ++j) {
       // Add space before word j, unless it's the first word on the line or a continuation
       int gap = 0;
-      if (j > static_cast<size_t>(i) && !continuesVec[j]) {
+      if (j > static_cast<size_t>(i) && noSpaceBeforeVec[j]) {
+        gap = 0;
+      } else if (j > static_cast<size_t>(i) && !continuesVec[j]) {
         gap =
             renderer.getSpaceAdvance(fontId, lastCodepoint(words[j - 1]), firstCodepoint(words[j]), wordStyles[j - 1]);
       } else if (j > static_cast<size_t>(i) && continuesVec[j]) {
@@ -470,7 +662,8 @@ std::vector<size_t> ParsedText::computeLineBreaks(const GfxRenderer& renderer, c
 // Builds break indices while opportunistically splitting the word that would overflow the current line.
 std::vector<size_t> ParsedText::computeHyphenatedLineBreaks(const GfxRenderer& renderer, const int fontId,
                                                             const int pageWidth, std::vector<uint16_t>& wordWidths,
-                                                            std::vector<bool>& continuesVec) {
+                                                            std::vector<bool>& continuesVec,
+                                                            std::vector<bool>& noSpaceBeforeVec) {
   const int firstLineIndent = resolveFirstLineIndent(true, renderer, fontId);
 
   std::vector<size_t> lineBreakIndices;
@@ -488,7 +681,9 @@ std::vector<size_t> ParsedText::computeHyphenatedLineBreaks(const GfxRenderer& r
     while (currentIndex < wordWidths.size()) {
       const bool isFirstWord = currentIndex == lineStart;
       int spacing = 0;
-      if (!isFirstWord && !continuesVec[currentIndex]) {
+      if (!isFirstWord && noSpaceBeforeVec[currentIndex]) {
+        spacing = 0;
+      } else if (!isFirstWord && !continuesVec[currentIndex]) {
         spacing = renderer.getSpaceAdvance(fontId, lastCodepoint(words[currentIndex - 1]),
                                            firstCodepoint(words[currentIndex]), wordStyles[currentIndex - 1]);
       } else if (!isFirstWord && continuesVec[currentIndex]) {
@@ -618,6 +813,7 @@ bool ParsedText::hyphenateWordAtIndex(const size_t wordIndex, const int availabl
   // line, while "kilometer" moves to the next line.
   // wordContinues[wordIndex] is intentionally left unchanged — the prefix keeps its original attachment.
   wordContinues.insert(wordContinues.begin() + wordIndex + 1, false);
+  wordNoSpaceBefore.insert(wordNoSpaceBefore.begin() + wordIndex + 1, false);
 
   // Update cached widths to reflect the new prefix/remainder pairing.
   wordWidths[wordIndex] = static_cast<uint16_t>(chosenWidth);
@@ -627,7 +823,8 @@ bool ParsedText::hyphenateWordAtIndex(const size_t wordIndex, const int availabl
 }
 
 void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const std::vector<uint16_t>& wordWidths,
-                             const std::vector<bool>& continuesVec, const std::vector<size_t>& lineBreakIndices,
+                             const std::vector<bool>& continuesVec, const std::vector<bool>& noSpaceBeforeVec,
+                             const std::vector<size_t>& lineBreakIndices,
                              const std::function<void(std::shared_ptr<TextBlock>)>& processLine,
                              const GfxRenderer& renderer, const int fontId) {
   const size_t lineBreak = lineBreakIndices[breakIndex];
@@ -660,7 +857,11 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
   for (size_t wordIdx = 0; wordIdx < lineWordCount; wordIdx++) {
     lineWordWidthSum += wordWidths[lastBreakAt + wordIdx];
     // Count gaps: each word after the first creates a gap, unless it's a continuation
-    if (wordIdx > 0 && !continuesVec[lastBreakAt + wordIdx]) {
+    if (wordIdx > 0 && noSpaceBeforeVec[lastBreakAt + wordIdx]) {
+      // Unicode break opportunity with no inserted Latin-style space. It is still
+      // a stretchable gap for justified CJK/Korean text.
+      actualGapCount++;
+    } else if (wordIdx > 0 && !continuesVec[lastBreakAt + wordIdx]) {
       actualGapCount++;
       totalNaturalGaps += renderer.getSpaceAdvance(fontId, lastCodepoint(lineWords[wordIdx - 1]),
                                                    firstCodepoint(lineWords[wordIdx]), lineWordStyles[wordIdx - 1]);
@@ -689,8 +890,8 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
 
   // For justified text, compute per-gap extra to distribute remaining space evenly
   const int spareSpace = effectivePageWidth - lineWordWidthSum - totalNaturalGaps;
-  const int justifyExtra = (effectiveAlignment == CssTextAlign::Justify && !isLastLine && actualGapCount >= 1)
-                               ? spareSpace / static_cast<int>(actualGapCount)
+  const int justifyExtra = (effectiveAlignment == CssTextAlign::Justify && !isLastLine)
+                               ? computeJustifyExtra(spareSpace, actualGapCount)
                                : 0;
 
   // BiDi processing: reorder words with UAX#9 in full-line context.
@@ -709,11 +910,13 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
     reorderedStylesScratch.clear();
     reorderedWidthsScratch.clear();
     reorderedContinuesScratch.clear();
+    reorderedNoSpaceBeforeScratch.clear();
     reorderedFocusSuffixScratch.clear();
     reorderedWordsScratch.reserve(visualOrderScratch.size());
     reorderedStylesScratch.reserve(visualOrderScratch.size());
     reorderedWidthsScratch.reserve(visualOrderScratch.size());
     reorderedContinuesScratch.reserve(visualOrderScratch.size());
+    reorderedNoSpaceBeforeScratch.reserve(visualOrderScratch.size());
     reorderedFocusSuffixScratch.reserve(visualOrderScratch.size());
 
     for (size_t i = 0; i < visualOrderScratch.size(); ++i) {
@@ -740,6 +943,7 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
         }
       }
       reorderedContinuesScratch.push_back(continues);
+      reorderedNoSpaceBeforeScratch.push_back(!continues && noSpaceBeforeVec[lastBreakAt + src]);
     }
 
     int reorderedWordWidthSum = 0;
@@ -747,7 +951,11 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
     int reorderedNaturalGaps = 0;
     for (size_t wordIdx = 0; wordIdx < reorderedWidthsScratch.size(); wordIdx++) {
       reorderedWordWidthSum += reorderedWidthsScratch[wordIdx];
-      if (wordIdx > 0 && !reorderedContinuesScratch[wordIdx]) {
+      if (wordIdx > 0 && reorderedNoSpaceBeforeScratch[wordIdx]) {
+        // Unicode break opportunity with no inserted Latin-style space. It is still
+        // a stretchable gap for justified CJK/Korean text.
+        reorderedGapCount++;
+      } else if (wordIdx > 0 && !reorderedContinuesScratch[wordIdx]) {
         reorderedGapCount++;
         reorderedNaturalGaps += renderer.getSpaceAdvance(fontId, lastCodepoint(reorderedWordsScratch[wordIdx - 1]),
                                                          firstCodepoint(reorderedWordsScratch[wordIdx]),
@@ -763,10 +971,9 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
     }
 
     const int reorderedSpare = effectivePageWidth - reorderedWordWidthSum - reorderedNaturalGaps;
-    const int reorderedJustifyExtra =
-        (effectiveAlignment == CssTextAlign::Justify && !isLastLine && reorderedGapCount >= 1)
-            ? reorderedSpare / static_cast<int>(reorderedGapCount)
-            : 0;
+    const int reorderedJustifyExtra = (effectiveAlignment == CssTextAlign::Justify && !isLastLine)
+                                          ? computeJustifyExtra(reorderedSpare, reorderedGapCount)
+                                          : 0;
 
     const int justifyContribution = (effectiveAlignment == CssTextAlign::Justify && !isLastLine)
                                         ? reorderedJustifyExtra * static_cast<int>(reorderedGapCount)
@@ -799,15 +1006,20 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
         int advance =
             renderer.getKerning(fontId, lastCodepoint(reorderedWordsScratch[wordIdx]),
                                 firstCodepoint(reorderedWordsScratch[wordIdx + 1]), reorderedStylesScratch[wordIdx]);
-        if (reorderedWordsScratch[wordIdx] == " " && reorderedContinuesScratch[wordIdx] &&
+        // wordIdx > 0 mirrors the gap accounting above (which skips index 0): a leading
+        // no-break space must not receive justifyExtra, or the line over-stretches by one
+        // gap and the last word is pushed past the right margin (issue #2185).
+        if (wordIdx > 0 && reorderedWordsScratch[wordIdx] == " " && reorderedContinuesScratch[wordIdx] &&
             effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
           advance += reorderedJustifyExtra;
         }
         xpos += advance;
       } else if (wordIdx + 1 < reorderedWidthsScratch.size()) {
-        int gap = renderer.getSpaceAdvance(fontId, lastCodepoint(reorderedWordsScratch[wordIdx]),
-                                           firstCodepoint(reorderedWordsScratch[wordIdx + 1]),
-                                           reorderedStylesScratch[wordIdx]);
+        const bool nextNoSpace = reorderedNoSpaceBeforeScratch[wordIdx + 1];
+        int gap = nextNoSpace ? 0
+                              : renderer.getSpaceAdvance(fontId, lastCodepoint(reorderedWordsScratch[wordIdx]),
+                                                         firstCodepoint(reorderedWordsScratch[wordIdx + 1]),
+                                                         reorderedStylesScratch[wordIdx]);
         if (effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
           gap += reorderedJustifyExtra;
         }
@@ -839,18 +1051,23 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
           // Cross-boundary kerning for continuation words
           int advance = renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]),
                                             firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
-          if (lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
+          // wordIdx > 0: see the LTR branch — a leading no-break space is not a justifiable gap.
+          if (wordIdx > 0 && lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
               effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
             advance += justifyExtra;
           }
           xpos -= advance;
         } else {
           int gap = 0;
+          bool nextNoSpace = false;
           if (wordIdx + 1 < lineWordCount) {
-            gap = renderer.getSpaceAdvance(fontId, lastCodepoint(lineWords[wordIdx]),
-                                           firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
+            nextNoSpace = noSpaceBeforeVec[lastBreakAt + wordIdx + 1];
+            gap = nextNoSpace
+                      ? 0
+                      : renderer.getSpaceAdvance(fontId, lastCodepoint(lineWords[wordIdx]),
+                                                 firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
           }
-          if (effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
+          if (wordIdx + 1 < lineWordCount && effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
             gap += justifyExtra;
           }
           xpos -= gap;
@@ -873,18 +1090,25 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
           int advance = wordWidths[lastBreakAt + wordIdx];
           advance += renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]),
                                          firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
-          if (lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
+          // wordIdx > 0 mirrors the gap accounting above (which skips index 0): a leading
+          // no-break space must not receive justifyExtra, or the line over-stretches by one
+          // gap and the last word is pushed past the right margin (issue #2185).
+          if (wordIdx > 0 && lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
               effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
             advance += justifyExtra;
           }
           xpos += advance;
         } else {
           int gap = 0;
+          bool nextNoSpace = false;
           if (wordIdx + 1 < lineWordCount) {
-            gap = renderer.getSpaceAdvance(fontId, lastCodepoint(lineWords[wordIdx]),
-                                           firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
+            nextNoSpace = noSpaceBeforeVec[lastBreakAt + wordIdx + 1];
+            gap = nextNoSpace
+                      ? 0
+                      : renderer.getSpaceAdvance(fontId, lastCodepoint(lineWords[wordIdx]),
+                                                 firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
           }
-          if (effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
+          if (wordIdx + 1 < lineWordCount && effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
             gap += justifyExtra;
           }
           xpos += wordWidths[lastBreakAt + wordIdx] + gap;

lib/Epub/Epub/ParsedText.h

@@ -15,7 +15,8 @@ class GfxRenderer;
 class ParsedText {
   std::vector<std::string> words;
   std::vector<EpdFontFamily::Style> wordStyles;
-  std::vector<bool> wordContinues;      // true = word attaches to previous (no space before it)
+  std::vector<bool> wordContinues;      // true = word attaches to previous with no break
+  std::vector<bool> wordNoSpaceBefore;  // true = may break before token, but no synthetic space when joined
   std::vector<bool> wordIsFocusSuffix;  // true = token is the regular tail of a focus bold-prefix split
   BlockStyle blockStyle;
   bool extraParagraphSpacing;
@@ -27,18 +28,22 @@ class ParsedText {
   std::vector<EpdFontFamily::Style> reorderedStylesScratch;
   std::vector<uint16_t> reorderedWidthsScratch;
   std::vector<bool> reorderedContinuesScratch;
+  std::vector<bool> reorderedNoSpaceBeforeScratch;
   std::vector<bool> reorderedFocusSuffixScratch;
   std::vector<uint16_t> visualOrderScratch;
 
   int resolveFirstLineIndent(bool isFirstLine, const GfxRenderer& renderer, int fontId) const;
   std::vector<size_t> computeLineBreaks(const GfxRenderer& renderer, int fontId, int pageWidth,
-                                        std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec);
+                                        std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec,
+                                        std::vector<bool>& noSpaceBeforeVec);
   std::vector<size_t> computeHyphenatedLineBreaks(const GfxRenderer& renderer, int fontId, int pageWidth,
-                                                  std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec);
+                                                  std::vector<uint16_t>& wordWidths, std::vector<bool>& continuesVec,
+                                                  std::vector<bool>& noSpaceBeforeVec);
   bool hyphenateWordAtIndex(size_t wordIndex, int availableWidth, const GfxRenderer& renderer, int fontId,
                             std::vector<uint16_t>& wordWidths, bool allowFallbackBreaks);
   void extractLine(size_t breakIndex, int pageWidth, const std::vector<uint16_t>& wordWidths,
-                   const std::vector<bool>& continuesVec, const std::vector<size_t>& lineBreakIndices,
+                   const std::vector<bool>& continuesVec, const std::vector<bool>& noSpaceBeforeVec,
+                   const std::vector<size_t>& lineBreakIndices,
                    const std::function<void(std::shared_ptr<TextBlock>)>& processLine, const GfxRenderer& renderer,
                    int fontId);
   std::vector<uint16_t> calculateWordWidths(const GfxRenderer& renderer, int fontId);

lib/Epub/Epub/Section.cpp

@@ -10,7 +10,8 @@
 #include "parsers/ChapterHtmlSlimParser.h"
 
 namespace {
-constexpr uint8_t SECTION_FILE_VERSION = 26;
+// v27: words NFC-composed at layout time; bump invalidates NFD section caches.
+constexpr uint8_t SECTION_FILE_VERSION = 27;
 constexpr uint32_t HEADER_SIZE = sizeof(uint8_t) + sizeof(int) + sizeof(float) + sizeof(bool) + sizeof(uint8_t) +
                                  sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(bool) + sizeof(bool) +
                                  sizeof(uint8_t) + sizeof(bool) + sizeof(uint32_t) + sizeof(uint32_t) +

lib/Epub/Epub/htmlEntities.cpp

@@ -13,54 +13,57 @@ struct EntityPair {
 
 // Sorted lexicographically by key to allow binary search.
 static constexpr EntityPair ENTITY_LOOKUP[] = {
-    {"Æ", "Æ"},    {"Á", "Á"},     {"Â", "Â"},      {"À", "À"},   {"Α", "Α"},
-    {"Å", "Å"},    {"Ã", "Ã"},     {"Ä", "Ä"},       {"Β", "Β"},     {"Ç", "Ç"},
-    {"Χ", "Χ"},      {"‡", "‡"},     {"Δ", "Δ"},      {"Ð", "Ð"},      {"É", "É"},
-    {"Ê", "Ê"},    {"È", "È"},     {"Ε", "Ε"},    {"Η", "Η"},      {"Ë", "Ë"},
-    {"Γ", "Γ"},    {"Í", "Í"},     {"Î", "Î"},      {"Ì", "Ì"},   {"Ι", "Ι"},
-    {"Ï", "Ï"},     {"Κ", "Κ"},      {"Λ", "Λ"},     {"Μ", "Μ"},       {"Ñ", "Ñ"},
-    {"Ν", "Ν"},       {"Œ", "Œ"},      {"Ó", "Ó"},     {"Ô", "Ô"},    {"Ò", "Ò"},
-    {"Ω", "Ω"},    {"Ο", "Ο"},    {"Ø", "Ø"},     {"Õ", "Õ"},   {"Ö", "Ö"},
-    {"Φ", "Φ"},      {"Π", "Π"},         {"″", "″"},      {"Ψ", "Ψ"},      {"Ρ", "Ρ"},
-    {"Š", "Š"},   {"Σ", "Σ"},      {"Þ", "Þ"},      {"Τ", "Τ"},      {"Θ", "Θ"},
-    {"Ú", "Ú"},   {"Û", "Û"},      {"Ù", "Ù"},     {"Υ", "Υ"},  {"Ü", "Ü"},
-    {"Ξ", "Ξ"},       {"Ý", "Ý"},     {"Ÿ", "Ÿ"},       {"Ζ", "Ζ"},     {"á", "á"},
-    {"â", "â"},    {"´", "´"},      {"æ", "æ"},      {"à", "à"},   {"α", "α"},
-    {"&", "&"},      {"∧", "∧"},        {"∠", "∠"},        {"å", "å"},    {"≈", "≈"},
-    {"ã", "ã"},   {"ä", "ä"},       {"„", "„"},      {"β", "β"},     {"¦", "¦"},
-    {"•", "•"},     {"∩", "∩"},        {"ç", "ç"},     {"¸", "¸"},    {"¢", "¢"},
-    {"χ", "χ"},      {"ˆ", "ˆ"},       {"♣", "♣"},      {"≅", "≅"},     {"©", "©"},
-    {"↵", "↵"},    {"∪", "∪"},        {"¤", "¤"},     {"†", "†"},   {"↓", "↓"},
-    {"°", "°"},      {"δ", "δ"},      {"♦", "♦"},      {"÷", "÷"},   {"é", "é"},
-    {"ê", "ê"},    {"è", "è"},     {"∅", "∅"},      {" ", " "},     {" ", " "},
-    {"ε", "ε"},  {"≡", "≡"},      {"η", "η"},        {"ð", "ð"},      {"ë", "ë"},
-    {"€", "€"},     {"∃", "∃"},      {"ƒ", "ƒ"},       {"∀", "∀"},   {"½", "½"},
-    {"¼", "¼"},   {"¾", "¾"},     {"⁄", "⁄"},      {"γ", "γ"},    {"≥", "≥"},
-    {">", ">"},       {"↔", "↔"},       {"♥", "♥"},     {"…", "…"},   {"í", "í"},
-    {"î", "î"},    {"¡", "¡"},      {"ì", "ì"},     {"∞", "∞"},    {"∫", "∫"},
-    {"ι", "ι"},     {"¿", "¿"},     {"∈", "∈"},       {"ï", "ï"},     {"κ", "κ"},
-    {"λ", "λ"},   {"«", "«"},      {"←", "←"},       {"⌈", "⌈"},    {"“", "\u201C"},
-    {"≤", "≤"},       {"⌊", "⌊"},     {"∗", "∗"},     {"◊", "◊"},      {"‎", "\u200E"},
-    {"&lsaquo;", "‹"},   {"&lsquo;", "\u2018"}, {"&lt;", "<"},         {"&macr;", "¯"},     {"&mdash;", "—"},
-    {"&micro;", "µ"},    {"&minus;", "−"},      {"&mu;", "μ"},         {"&nabla;", "∇"},    {"&nbsp;", "\xC2\xA0"},
-    {"&ndash;", "–"},    {"&ne;", "≠"},         {"&ni;", "∋"},         {"&not;", "¬"},      {"&notin;", "∉"},
-    {"&nsub;", "⊄"},     {"&ntilde;", "ñ"},     {"&nu;", "ν"},         {"&oacute;", "ó"},   {"&ocirc;", "ô"},
-    {"&oelig;", "œ"},    {"&ograve;", "ò"},     {"&oline;", "‾"},      {"&omega;", "ω"},    {"&omicron;", "ο"},
-    {"&oplus;", "⊕"},    {"&or;", "∨"},         {"&ordf;", "ª"},       {"&ordm;", "º"},     {"&oslash;", "ø"},
-    {"&otilde;", "õ"},   {"&otimes;", "⊗"},     {"&ouml;", "ö"},       {"&para;", "¶"},     {"&part;", "∂"},
-    {"&permil;", "‰"},   {"&perp;", "⊥"},       {"&phi;", "φ"},        {"&pi;", "π"},       {"&piv;", "ϖ"},
-    {"&plusmn;", "±"},   {"&pound;", "£"},      {"&prime;", "′"},      {"&prod;", "∏"},     {"&prop;", "∝"},
-    {"&psi;", "ψ"},      {"&quot;", "\""},      {"&radic;", "√"},      {"&raquo;", "»"},    {"&rarr;", "→"},
-    {"&rceil;", "⌉"},    {"&rdquo;", "\u201D"}, {"&reg;", "®"},        {"&rfloor;", "⌋"},   {"&rho;", "ρ"},
-    {"&rlm;", "\u200F"}, {"&rsaquo;", "›"},     {"&rsquo;", "\u2019"}, {"&sbquo;", "‚"},    {"&scaron;", "š"},
-    {"&sdot;", "⋅"},     {"&sect;", "§"},       {"&shy;", "\xC2\xAD"}, {"&sigma;", "σ"},    {"&sigmaf;", "ς"},
-    {"&sim;", "∼"},      {"&spades;", "♠"},     {"&sub;", "⊂"},        {"&sube;", "⊆"},     {"&sum;", "∑"},
-    {"&sup1;", "¹"},     {"&sup2;", "²"},       {"&sup3;", "³"},       {"&sup;", "⊃"},      {"&supe;", "⊇"},
-    {"&szlig;", "ß"},    {"&tau;", "τ"},        {"&there4;", "∴"},     {"&theta;", "θ"},    {"&thetasym;", "ϑ"},
-    {"&thinsp;", " "},   {"&thorn;", "þ"},      {"&tilde;", "˜"},      {"&times;", "×"},    {"&trade;", "™"},
-    {"&uacute;", "ú"},   {"&uarr;", "↑"},       {"&ucirc;", "û"},      {"&ugrave;", "ù"},   {"&uml;", "¨"},
-    {"&upsih;", "ϒ"},    {"&upsilon;", "υ"},    {"&uuml;", "ü"},       {"&xi;", "ξ"},       {"&yacute;", "ý"},
-    {"&yen;", "¥"},      {"&yuml;", "ÿ"},       {"&zeta;", "ζ"},       {"&zwj;", "\u200D"}, {"&zwnj;", "\u200C"},
+    {"&AElig;", "Æ"},      {"&Aacute;", "Á"},      {"&Acirc;", "Â"},      {"&Agrave;", "À"},  {"&Alpha;", "Α"},
+    {"&Aring;", "Å"},      {"&Atilde;", "Ã"},      {"&Auml;", "Ä"},       {"&Beta;", "Β"},    {"&Ccedil;", "Ç"},
+    {"&Chi;", "Χ"},        {"&Dagger;", "‡"},      {"&Delta;", "Δ"},      {"&ETH;", "Ð"},     {"&Eacute;", "É"},
+    {"&Ecirc;", "Ê"},      {"&Egrave;", "È"},      {"&Epsilon;", "Ε"},    {"&Eta;", "Η"},     {"&Euml;", "Ë"},
+    {"&Gamma;", "Γ"},      {"&Iacute;", "Í"},      {"&Icirc;", "Î"},      {"&Igrave;", "Ì"},  {"&Iota;", "Ι"},
+    {"&Iuml;", "Ï"},       {"&Kappa;", "Κ"},       {"&Lambda;", "Λ"},     {"&Mu;", "Μ"},      {"&Ntilde;", "Ñ"},
+    {"&Nu;", "Ν"},         {"&OElig;", "Œ"},       {"&Oacute;", "Ó"},     {"&Ocirc;", "Ô"},   {"&Ograve;", "Ò"},
+    {"&Omega;", "Ω"},      {"&Omicron;", "Ο"},     {"&Oslash;", "Ø"},     {"&Otilde;", "Õ"},  {"&Ouml;", "Ö"},
+    {"&Phi;", "Φ"},        {"&Pi;", "Π"},          {"&Prime;", "″"},      {"&Psi;", "Ψ"},     {"&Rho;", "Ρ"},
+    {"&Scaron;", "Š"},     {"&Sigma;", "Σ"},       {"&THORN;", "Þ"},      {"&Tau;", "Τ"},     {"&Theta;", "Θ"},
+    {"&Uacute;", "Ú"},     {"&Ucirc;", "Û"},       {"&Ugrave;", "Ù"},     {"&Upsilon;", "Υ"}, {"&Uuml;", "Ü"},
+    {"&Xi;", "Ξ"},         {"&Yacute;", "Ý"},      {"&Yuml;", "Ÿ"},       {"&Zeta;", "Ζ"},    {"&aacute;", "á"},
+    {"&acirc;", "â"},      {"&acute;", "´"},       {"&aelig;", "æ"},      {"&agrave;", "à"},  {"&alefsym;", "ℵ"},
+    {"&alpha;", "α"},      {"&amp;", "&"},         {"&and;", "∧"},        {"&ang;", "∠"},     {"&aring;", "å"},
+    {"&asymp;", "≈"},      {"&atilde;", "ã"},      {"&auml;", "ä"},       {"&bdquo;", "„"},   {"&beta;", "β"},
+    {"&brvbar;", "¦"},     {"&bull;", "•"},        {"&cap;", "∩"},        {"&ccedil;", "ç"},  {"&cedil;", "¸"},
+    {"&cent;", "¢"},       {"&chi;", "χ"},         {"&circ;", "ˆ"},       {"&clubs;", "♣"},   {"&cong;", "≅"},
+    {"&copy;", "©"},       {"&crarr;", "↵"},       {"&cup;", "∪"},        {"&curren;", "¤"},  {"&dArr;", "⇓"},
+    {"&dagger;", "†"},     {"&darr;", "↓"},        {"&deg;", "°"},        {"&delta;", "δ"},   {"&diams;", "♦"},
+    {"&divide;", "÷"},     {"&eacute;", "é"},      {"&ecirc;", "ê"},      {"&egrave;", "è"},  {"&empty;", "∅"},
+    {"&emsp;", " "},       {"&ensp;", " "},        {"&epsilon;", "ε"},    {"&equiv;", "≡"},   {"&eta;", "η"},
+    {"&eth;", "ð"},        {"&euml;", "ë"},        {"&euro;", "€"},       {"&exist;", "∃"},   {"&fnof;", "ƒ"},
+    {"&forall;", "∀"},     {"&frac12;", "½"},      {"&frac14;", "¼"},     {"&frac34;", "¾"},  {"&frasl;", "⁄"},
+    {"&gamma;", "γ"},      {"&ge;", "≥"},          {"&gt;", ">"},         {"&hArr;", "⇔"},    {"&harr;", "↔"},
+    {"&hearts;", "♥"},     {"&hellip;", "…"},      {"&iacute;", "í"},     {"&icirc;", "î"},   {"&iexcl;", "¡"},
+    {"&igrave;", "ì"},     {"&image;", "ℑ"},       {"&infin;", "∞"},      {"&int;", "∫"},     {"&iota;", "ι"},
+    {"&iquest;", "¿"},     {"&isin;", "∈"},        {"&iuml;", "ï"},       {"&kappa;", "κ"},   {"&lArr;", "⇐"},
+    {"&lambda;", "λ"},     {"&lang;", "〈"},       {"&laquo;", "«"},      {"&larr;", "←"},    {"&lceil;", "⌈"},
+    {"&ldquo;", "\u201C"}, {"&le;", "≤"},          {"&lfloor;", "⌊"},     {"&lowast;", "∗"},  {"&loz;", "◊"},
+    {"&lrm;", "\u200E"},   {"&lsaquo;", "‹"},      {"&lsquo;", "\u2018"}, {"&lt;", "<"},      {"&macr;", "¯"},
+    {"&mdash;", "—"},      {"&micro;", "µ"},       {"&middot;", "·"},     {"&minus;", "−"},   {"&mu;", "μ"},
+    {"&nabla;", "∇"},      {"&nbsp;", "\xC2\xA0"}, {"&ndash;", "–"},      {"&ne;", "≠"},      {"&ni;", "∋"},
+    {"&not;", "¬"},        {"&notin;", "∉"},       {"&nsub;", "⊄"},       {"&ntilde;", "ñ"},  {"&nu;", "ν"},
+    {"&oacute;", "ó"},     {"&ocirc;", "ô"},       {"&oelig;", "œ"},      {"&ograve;", "ò"},  {"&oline;", "‾"},
+    {"&omega;", "ω"},      {"&omicron;", "ο"},     {"&oplus;", "⊕"},      {"&or;", "∨"},      {"&ordf;", "ª"},
+    {"&ordm;", "º"},       {"&oslash;", "ø"},      {"&otilde;", "õ"},     {"&otimes;", "⊗"},  {"&ouml;", "ö"},
+    {"&para;", "¶"},       {"&part;", "∂"},        {"&permil;", "‰"},     {"&perp;", "⊥"},    {"&phi;", "φ"},
+    {"&pi;", "π"},         {"&piv;", "ϖ"},         {"&plusmn;", "±"},     {"&pound;", "£"},   {"&prime;", "′"},
+    {"&prod;", "∏"},       {"&prop;", "∝"},        {"&psi;", "ψ"},        {"&quot;", "\""},   {"&rArr;", "⇒"},
+    {"&radic;", "√"},      {"&rang;", "〉"},       {"&raquo;", "»"},      {"&rarr;", "→"},    {"&rceil;", "⌉"},
+    {"&rdquo;", "\u201D"}, {"&real;", "\u211C"},   {"&reg;", "®"},        {"&rfloor;", "⌋"},  {"&rho;", "ρ"},
+    {"&rlm;", "\u200F"},   {"&rsaquo;", "›"},      {"&rsquo;", "\u2019"}, {"&sbquo;", "‚"},   {"&scaron;", "š"},
+    {"&sdot;", "⋅"},       {"&sect;", "§"},        {"&shy;", "\xC2\xAD"}, {"&sigma;", "σ"},   {"&sigmaf;", "ς"},
+    {"&sim;", "∼"},        {"&spades;", "♠"},      {"&sub;", "⊂"},        {"&sube;", "⊆"},    {"&sum;", "∑"},
+    {"&sup1;", "¹"},       {"&sup2;", "²"},        {"&sup3;", "³"},       {"&sup;", "⊃"},     {"&supe;", "⊇"},
+    {"&szlig;", "ß"},      {"&tau;", "τ"},         {"&there4;", "∴"},     {"&theta;", "θ"},   {"&thetasym;", "ϑ"},
+    {"&thinsp;", " "},     {"&thorn;", "þ"},       {"&tilde;", "˜"},      {"&times;", "×"},   {"&trade;", "™"},
+    {"&uArr;", "⇑"},       {"&uacute;", "ú"},      {"&uarr;", "↑"},       {"&ucirc;", "û"},   {"&ugrave;", "ù"},
+    {"&uml;", "¨"},        {"&upsih;", "ϒ"},       {"&upsilon;", "υ"},    {"&uuml;", "ü"},    {"&weierp;", "℘"},
+    {"&xi;", "ξ"},         {"&yacute;", "ý"},      {"&yen;", "¥"},        {"&yuml;", "ÿ"},    {"&zeta;", "ζ"},
+    {"&zwj;", "\u200D"},   {"&zwnj;", "\u200C"},
 };
 
 // Verify the table is sorted at compile time.

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp

@@ -317,6 +317,14 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
         const bool isTocAnchor =
             std::find(self->tocAnchors.begin(), self->tocAnchors.end(), idValue) != self->tocAnchors.end();
         if (isTocAnchor || (!isNonNavigableInlineElement(name) && self->anchorData.size() < MAX_ANCHORS_PER_CHAPTER)) {
+          // Flush a displaced anchor before overwriting. Consecutive non-block elements
+          // (e.g. <aside id="fn1">text</aside><aside id="fn2">) with no intervening block
+          // never trigger startNewTextBlock, so fn1 gets silently overwritten. That leaves
+          // fn1 missing from the anchor map -> getPageForAnchor returns nullopt -> reader
+          // lands at page 0 (section start) instead of the footnote.
+          if (!self->pendingAnchorId.empty()) {
+            self->flushPendingAnchor();
+          }
           self->pendingAnchorId = idValue;
         }
       } else if (strcmp(atts[i], "dir") == 0) {

lib/Epub/Epub/parsers/ContentOpfParser.cpp

@@ -150,7 +150,6 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
 
   if (self->state == IN_PACKAGE && (strcmp(name, "guide") == 0 || strcmp(name, "opf:guide") == 0)) {
     self->state = IN_GUIDE;
-    // TODO Remove print
     LOG_DBG("COF", "Entering guide state.");
     if (!Storage.openFileForRead("COF", self->cachePath + itemCacheFile, self->tempItemStore)) {
       LOG_ERR("COF", "Couldn't open temp items file for reading. This is probably going to be a fatal error.");

lib/FsHelpers/FsHelpers.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <cctype>
 #include <cstring>
+#include <string_view>
 #include <vector>
 
 namespace FsHelpers {
@@ -36,12 +37,14 @@ std::string decodeUriEscapes(const std::string& path) {
 }
 
 std::string normalisePath(const std::string& path) {
-  std::vector<std::string> components;
-  std::string component;
+  std::vector<std::string_view> components;
+  components.reserve(8);  // Eight nested folders is more than we might expect
 
-  for (const auto c : path) {
-    if (c == '/') {
-      if (!component.empty()) {
+  size_t start = 0;
+  for (size_t i = 0; i <= path.length(); ++i) {
+    if (i == path.length() || path[i] == '/') {
+      if (i > start) {
+        std::string_view component(path.data() + start, i - start);
         if (component == "..") {
           if (!components.empty()) {
             components.pop_back();
@@ -49,23 +52,28 @@ std::string normalisePath(const std::string& path) {
         } else {
           components.push_back(component);
         }
-        component.clear();
       }
-    } else {
-      component += c;
+      start = i + 1;
     }
   }
 
-  if (!component.empty()) {
-    components.push_back(component);
+  if (components.empty()) {
+    return "";
+  }
+
+  size_t total_len = 0;
+  for (const auto& c : components) {
+    total_len += c.length() + 1;
   }
 
   std::string result;
-  for (const auto& c : components) {
-    if (!result.empty()) {
-      result += "/";
+  result.reserve(total_len - 1);
+
+  for (size_t i = 0; i < components.size(); ++i) {
+    if (i > 0) {
+      result += '/';
     }
-    result += c;
+    result.append(components[i].data(), components[i].length());
   }
 
   return result;

lib/GfxRenderer/GfxRenderer.cpp

@@ -3,6 +3,7 @@
 #include <BidiUtils.h>
 #include <FontDecompressor.h>
 #include <HalGPIO.h>
+#include <Icon.h>
 #include <Logging.h>
 #include <SdCardFont.h>
 #include <Utf8.h>
@@ -100,6 +101,23 @@ void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) {
   }
 }
 
+void GfxRenderer::setUiFontRemap(const int* from, const int* to, int count) {
+  if (count < 0) count = 0;
+  if (count > MAX_UI_FONT_REMAP) count = MAX_UI_FONT_REMAP;
+  for (int i = 0; i < count; ++i) {
+    uiFontFrom_[i] = from[i];
+    uiFontTo_[i] = to[i];
+  }
+  uiFontRemapCount_ = count;
+}
+
+int GfxRenderer::remapUiFont(const int fontId) const {
+  for (int i = 0; i < uiFontRemapCount_; ++i) {
+    if (uiFontFrom_[i] == fontId) return uiFontTo_[i];
+  }
+  return fontId;
+}
+
 // Translate logical (x,y) coordinates to physical panel coordinates based on current orientation
 // This should always be inlined for better performance
 static inline void rotateCoordinates(const GfxRenderer::Orientation orientation, const int x, const int y, int* phyX,
@@ -365,7 +383,7 @@ int GfxRenderer::getTextWidth(const int fontId, const char* text, const EpdFontF
     return 0;
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -407,7 +425,7 @@ void GfxRenderer::drawText(const int fontId, const int x, const int y, const cha
     return;
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return;
@@ -661,8 +679,10 @@ void GfxRenderer::drawRoundedRect(const int x, const int y, const int width, con
 }
 
 void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const {
-  for (int fillY = y; fillY < y + height; fillY++) {
-    drawLine(x, fillY, x + width - 1, fillY, state);
+  if (state) {
+    fillRectImpl<Color::Black>(x, y, width, height);
+  } else {
+    fillRectImpl<Color::White>(x, y, width, height);
   }
 }
 
@@ -694,26 +714,194 @@ void GfxRenderer::drawPixelDither<Color::DarkGray>(const int x, const int y) con
 }
 
 void GfxRenderer::fillRectDither(const int x, const int y, const int width, const int height, Color color) const {
-  if (color == Color::Clear) {
-  } else if (color == Color::Black) {
-    fillRect(x, y, width, height, true);
-  } else if (color == Color::White) {
-    fillRect(x, y, width, height, false);
-  } else if (color == Color::LightGray) {
-    for (int fillY = y; fillY < y + height; fillY++) {
-      for (int fillX = x; fillX < x + width; fillX++) {
-        drawPixelDither<Color::LightGray>(fillX, fillY);
+  switch (color) {
+    case Color::Clear:
+      break;
+    case Color::Black:
+      fillRectImpl<Color::Black>(x, y, width, height);
+      break;
+    case Color::White:
+      fillRectImpl<Color::White>(x, y, width, height);
+      break;
+    case Color::LightGray:
+      fillRectImpl<Color::LightGray>(x, y, width, height);
+      break;
+    case Color::DarkGray:
+      fillRectImpl<Color::DarkGray>(x, y, width, height);
+      break;
+  }
+}
+
+template <Color C>
+void GfxRenderer::fillRectImpl(const int x, const int y, const int width, const int height) const {
+  if constexpr (C == Color::Clear) return;
+  if (width <= 0 || height <= 0) return;
+  if (fontCacheManager_ && fontCacheManager_->isScanning()) return;
+
+  // Clip in logical space.
+  const int screenW = getScreenWidth();
+  const int screenH = getScreenHeight();
+  const int lx0 = std::max(0, x);
+  const int ly0 = std::max(0, y);
+  const int lx1 = std::min(screenW, x + width);
+  const int ly1 = std::min(screenH, y + height);
+  if (lx0 >= lx1 || ly0 >= ly1) return;
+
+  // Rotate the two opposing logical corners into physical-framebuffer space.
+  // The bounding rect in physical space is the rect we need to fill — rotation
+  // is rigid (no shear/stretch) so the bbox of the two corners IS the rect.
+  int paX, paY, pbX, pbY;
+  rotateCoordinates(orientation, lx0, ly0, &paX, &paY, panelWidth, panelHeight);
+  rotateCoordinates(orientation, lx1 - 1, ly1 - 1, &pbX, &pbY, panelWidth, panelHeight);
+
+  const int phyX0 = std::min(paX, pbX);
+  const int phyX1 = std::max(paX, pbX);  // inclusive
+  int phyY0 = std::min(paY, pbY);
+  int phyY1 = std::max(paY, pbY);
+
+  // Strip mode: clip Y range to the active band and redirect writes.
+  uint8_t* target = getWriteTarget();
+  const int originY = getWriteOriginY();
+  const int writeRows = getWriteRows();
+  phyY0 = std::max(phyY0, originY);
+  phyY1 = std::min(phyY1, originY + writeRows - 1);
+  if (phyY0 > phyY1) return;
+
+  // Bit/byte layout: MSB-first within a byte, so phyX → bit (7 - (phyX & 7)).
+  // Head and tail masks cover only the in-rect bits of the first/last byte.
+  const int byteStart = phyX0 >> 3;
+  const int byteEnd = phyX1 >> 3;  // inclusive
+  const uint8_t headMask = static_cast<uint8_t>(0xFFu >> (phyX0 & 7));
+  const uint8_t tailMask = static_cast<uint8_t>(0xFFu << (7 - (phyX1 & 7)));
+  const int32_t panelStride = static_cast<int32_t>(panelWidthBytes);
+
+  if constexpr (C == Color::Black || C == Color::White) {
+    // Solid fill. Framebuffer: 0 = black, 1 = white.
+    const uint8_t fillByte = (C == Color::Black) ? 0x00u : 0xFFu;
+    for (int py = phyY0; py <= phyY1; ++py) {
+      uint8_t* row = target + static_cast<int32_t>(py - originY) * panelStride;
+      if (byteStart == byteEnd) {
+        const uint8_t mask = headMask & tailMask;
+        if constexpr (C == Color::Black) {
+          row[byteStart] &= static_cast<uint8_t>(~mask);
+        } else {
+          row[byteStart] |= mask;
+        }
+      } else {
+        if constexpr (C == Color::Black) {
+          row[byteStart] &= static_cast<uint8_t>(~headMask);
+          if (byteEnd > byteStart + 1) {
+            memset(row + byteStart + 1, fillByte, byteEnd - byteStart - 1);
+          }
+          row[byteEnd] &= static_cast<uint8_t>(~tailMask);
+        } else {
+          row[byteStart] |= headMask;
+          if (byteEnd > byteStart + 1) {
+            memset(row + byteStart + 1, fillByte, byteEnd - byteStart - 1);
+          }
+          row[byteEnd] |= tailMask;
+        }
       }
     }
-  } else if (color == Color::DarkGray) {
-    for (int fillY = y; fillY < y + height; fillY++) {
-      for (int fillX = x; fillX < x + width; fillX++) {
-        drawPixelDither<Color::DarkGray>(fillX, fillY);
+  } else {
+    // Dither (LightGray / DarkGray). Both patterns have period 2 in logical
+    // (x, y), so per physical row we precompute one byte that represents the
+    // pattern across an 8-pixel stretch — every full byte in the row uses
+    // that same value.
+    //
+    // dlxPerPhyX / dlyPerPhyX: how logical (x, y) change as phyX increments
+    // along a physical row. Derived from inverting rotateCoordinates.
+    int dlxPerPhyX = 0, dlyPerPhyX = 0;
+    switch (orientation) {
+      case Portrait:
+        dlxPerPhyX = 0;
+        dlyPerPhyX = 1;
+        break;
+      case PortraitInverted:
+        dlxPerPhyX = 0;
+        dlyPerPhyX = -1;
+        break;
+      case LandscapeClockwise:
+        dlxPerPhyX = -1;
+        dlyPerPhyX = 0;
+        break;
+      case LandscapeCounterClockwise:
+        dlxPerPhyX = 1;
+        dlyPerPhyX = 0;
+        break;
+    }
+
+    // The dither pattern has period 2 in logical space, and each orientation
+    // maps py to logical coords with a fixed parity relationship. The
+    // blackMask byte therefore repeats with period 2 in py. Precompute both
+    // variants outside the row loop to eliminate the per-row switch + 8-bit
+    // construction loop.
+    uint8_t blackMasks[2];
+    for (int parityIdx = 0; parityIdx < 2; ++parityIdx) {
+      const int samplePy = phyY0 + parityIdx;
+      int lxBase = 0, lyBase = 0;
+      switch (orientation) {
+        case Portrait:
+          lxBase = panelHeight - 1 - samplePy;
+          lyBase = byteStart * 8;
+          break;
+        case PortraitInverted:
+          lxBase = samplePy;
+          lyBase = panelWidth - 1 - byteStart * 8;
+          break;
+        case LandscapeClockwise:
+          lxBase = panelWidth - 1 - byteStart * 8;
+          lyBase = panelHeight - 1 - samplePy;
+          break;
+        case LandscapeCounterClockwise:
+          lxBase = byteStart * 8;
+          lyBase = samplePy;
+          break;
+      }
+      uint8_t mask = 0;
+      for (int b = 0; b < 8; ++b) {
+        const int lx = lxBase + b * dlxPerPhyX;
+        const int ly = lyBase + b * dlyPerPhyX;
+        bool isBlack;
+        if constexpr (C == Color::LightGray) {
+          isBlack = ((lx & 1) == 0) && ((ly & 1) == 0);
+        } else {  // DarkGray
+          isBlack = (((lx + ly) & 1) == 0);
+        }
+        if (isBlack) mask |= static_cast<uint8_t>(1u << (7 - b));
+      }
+      blackMasks[samplePy & 1] = mask;
+    }
+
+    for (int py = phyY0; py <= phyY1; ++py) {
+      const uint8_t blackMask = blackMasks[py & 1];
+      const uint8_t whiteMask = static_cast<uint8_t>(~blackMask);
+
+      // Dither writes BOTH inks (the slow path called drawPixel for every
+      // pixel — setting or clearing — so we must do the same). Inside the
+      // rect mask: write whiteMask (1s where white, 0s where black). Outside
+      // the rect mask: leave the framebuffer untouched.
+      uint8_t* row = target + static_cast<int32_t>(py - originY) * panelStride;
+      if (byteStart == byteEnd) {
+        const uint8_t rectMask = headMask & tailMask;
+        row[byteStart] = static_cast<uint8_t>((row[byteStart] & ~rectMask) | (rectMask & whiteMask));
+      } else {
+        row[byteStart] = static_cast<uint8_t>((row[byteStart] & ~headMask) | (headMask & whiteMask));
+        if (byteEnd > byteStart + 1) {
+          // Period 2, so every full byte in this row is exactly whiteMask.
+          memset(row + byteStart + 1, whiteMask, byteEnd - byteStart - 1);
+        }
+        row[byteEnd] = static_cast<uint8_t>((row[byteEnd] & ~tailMask) | (tailMask & whiteMask));
       }
     }
   }
 }
 
+template void GfxRenderer::fillRectImpl<Color::Black>(int, int, int, int) const;
+template void GfxRenderer::fillRectImpl<Color::White>(int, int, int, int) const;
+template void GfxRenderer::fillRectImpl<Color::LightGray>(int, int, int, int) const;
+template void GfxRenderer::fillRectImpl<Color::DarkGray>(int, int, int, int) const;
+
 void GfxRenderer::maskRoundedRectOutsideCorners(const int x, const int y, const int width, const int height,
                                                 const int radius, const Color color) const {
   if (radius <= 0 || color == Color::Clear) {
@@ -888,6 +1076,21 @@ void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, con
   display.drawImageTransparent(bitmap, y, getScreenWidth() - width - x, height, width);
 }
 
+void GfxRenderer::drawIcon(const freeink::Icon& icon, const int x, const int y, const bool black) const {
+  // Bits are un-rotated, so each drawn pixel goes through drawPixel (which applies
+  // the orientation transform) — correct in every orientation, unlike the legacy
+  // uint8_t* overload that pre-rotates for one orientation.
+  const int rowBytes = (icon.w + 7) / 8;
+  for (int row = 0; row < icon.h; ++row) {
+    const uint8_t* r = icon.bits + static_cast<int>(row) * rowBytes;
+    for (int col = 0; col < icon.w; ++col) {
+      if (((r[col >> 3] >> (7 - (col & 7))) & 1) == 0) {  // 0 = drawn
+        drawPixel(x + col, y + row, black);
+      }
+    }
+  }
+}
+
 void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight,
                              const float cropX, const float cropY) const {
   if (fontCacheManager_ && fontCacheManager_->isScanning()) return;
@@ -1296,6 +1499,38 @@ int GfxRenderer::getScreenHeight() const {
   return panelWidth;
 }
 
+void GfxRenderer::tapToLogical(float nx, float ny, int& outX, int& outY) const {
+  // Native panel pixel of the tap (wasTouchTap normalizes over the native panel).
+  int phyX = static_cast<int>(nx * panelWidth);
+  int phyY = static_cast<int>(ny * panelHeight);
+  if (phyX < 0) phyX = 0;
+  if (phyX > panelWidth - 1) phyX = panelWidth - 1;
+  if (phyY < 0) phyY = 0;
+  if (phyY > panelHeight - 1) phyY = panelHeight - 1;
+
+  // Inverse of rotateCoordinates() (see the forward transform above): map a
+  // physical/native point back into the current orientation's logical frame.
+  switch (orientation) {
+    case Portrait:  // forward: phyX=logY, phyY=panelHeight-1-logX
+      outX = panelHeight - 1 - phyY;
+      outY = phyX;
+      break;
+    case PortraitInverted:  // forward: phyX=panelWidth-1-logY, phyY=logX
+      outX = phyY;
+      outY = panelWidth - 1 - phyX;
+      break;
+    case LandscapeClockwise:  // forward: phyX=panelWidth-1-logX, phyY=panelHeight-1-logY
+      outX = panelWidth - 1 - phyX;
+      outY = panelHeight - 1 - phyY;
+      break;
+    case LandscapeCounterClockwise:  // forward: identity
+    default:
+      outX = phyX;
+      outY = phyY;
+      break;
+  }
+}
+
 // Translate a logical rect through rotateCoordinates and take the bounding
 // box of its four corners on the physical panel. Output coords are inclusive
 // and clamped. Returns false if the rect ends up fully off-panel.
@@ -1387,7 +1622,7 @@ int GfxRenderer::getSpaceWidth(const int fontId, const EpdFontFamily::Style styl
     return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle));
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -1408,7 +1643,7 @@ int GfxRenderer::getSpaceAdvance(const int fontId, const uint32_t leftCp, const
     return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle));
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) return 0;
   const auto& font = fontIt->second;
   const EpdGlyph* spaceGlyph = font.getGlyph(' ', style);
@@ -1422,7 +1657,7 @@ int GfxRenderer::getSpaceAdvance(const int fontId, const uint32_t leftCp, const
 
 int GfxRenderer::getKerning(const int fontId, const uint32_t leftCp, const uint32_t rightCp,
                             const EpdFontFamily::Style style) const {
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) return 0;
   const int kernFP = fontIt->second.getKerning(leftCp, rightCp, style);  // 4.4 fixed-point
   return fp4::toPixel(kernFP);                                           // snap 4.4 fixed-point to nearest pixel
@@ -1437,14 +1672,24 @@ int GfxRenderer::getTextAdvanceX(const int fontId, const char* text, EpdFontFami
     int32_t widthFP = 0;
     const bool isSupSub = (style & (EpdFontFamily::SUP | EpdFontFamily::SUB)) != 0;
     const uint8_t styleIdx = resolveSdCardStyle(*sdIt->second, style);
+    const auto fontIt = fontMap.find(fontId);
+    if (fontIt == fontMap.end()) {
+      LOG_ERR("GFX", "Font %d not found", fontId);
+      return 0;
+    }
+    const auto& font = fontIt->second;
     while (uint32_t cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text))) {
       int32_t advFP = sdIt->second->getAdvance(cp, styleIdx);
+      if (advFP == 0 && !utf8IsCombiningMark(cp)) {
+        const EpdGlyph* glyph = font.getGlyph(cp, style);
+        advFP = glyph ? glyph->advanceX : 0;
+      }
       widthFP += isSupSub ? (advFP + 1) / 2 : advFP;
     }
     return fp4::toPixel(widthFP);
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -1480,7 +1725,7 @@ int GfxRenderer::getTextAdvanceX(const int fontId, const char* text, EpdFontFami
 }
 
 int GfxRenderer::getFontAscenderSize(const int fontId) const {
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -1490,7 +1735,7 @@ int GfxRenderer::getFontAscenderSize(const int fontId) const {
 }
 
 int GfxRenderer::getLineHeight(const int fontId) const {
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -1500,7 +1745,7 @@ int GfxRenderer::getLineHeight(const int fontId) const {
 }
 
 int GfxRenderer::getTextHeight(const int fontId) const {
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return 0;
@@ -1508,6 +1753,27 @@ int GfxRenderer::getTextHeight(const int fontId) const {
   return fontIt->second.getData(EpdFontFamily::REGULAR)->ascender;
 }
 
+// Height of a reference glyph above the baseline (glyph->top): 'H' gives the real
+// cap height, the actual visible font extent for vertical centering.
+int GfxRenderer::glyphTop(const int fontId, const uint32_t cp) const {
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
+  if (fontIt == fontMap.end()) return 0;
+  const EpdGlyph* g = fontIt->second.getGlyph(cp, EpdFontFamily::REGULAR);
+  return g ? g->top : 0;
+}
+
+int GfxRenderer::getFontCapHeight(const int fontId) const { return glyphTop(fontId, 'H'); }
+
+int GfxRenderer::getTextVisualCenterOffset(const int fontId) const {
+  // Cap-height middle: baseline is at top + ascender, caps reach capHeight above it,
+  // so the optical center is ascender - capHeight/2 below the top. Cap (not x) height
+  // because UI labels are capital-led. Falls back to ascender*0.65 without an 'H'.
+  const int ascender = getFontAscenderSize(fontId);
+  const int capHeight = getFontCapHeight(fontId);
+  if (capHeight <= 0) return (ascender * 65) / 100;
+  return ascender - capHeight / 2;
+}
+
 void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y, const char* text, const bool black,
                                       const EpdFontFamily::Style style) const {
   // Cannot draw a NULL / empty string
@@ -1515,7 +1781,7 @@ void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y
     return;
   }
 
-  const auto fontIt = fontMap.find(fontId);
+  const auto fontIt = fontMap.find(remapUiFont(fontId));
   if (fontIt == fontMap.end()) {
     LOG_ERR("GFX", "Font %d not found", fontId);
     return;
@@ -1577,6 +1843,30 @@ size_t GfxRenderer::getBufferSize() const { return frameBufferSize; }
 // unused
 // void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); }
 
+void GfxRenderer::displayGrayscaleBase(HalDisplay::RefreshMode fallback) const {
+  display.displayGrayscaleBase(fallback, fadingFix);
+}
+
+void GfxRenderer::preconditionGrayscale() const { display.preconditionGrayscale(); }
+
+void GfxRenderer::preconditionGrayscale(int x, int y, int w, int h) const {
+  if (w <= 0 || h <= 0) return;
+  // Rotate the logical rect's opposite corners to physical panel coords; the
+  // physical bbox stays axis-aligned for all four orientations.
+  int ax, ay, bx, by;
+  rotateCoordinates(orientation, x, y, &ax, &ay, panelWidth, panelHeight);
+  rotateCoordinates(orientation, x + w - 1, y + h - 1, &bx, &by, panelWidth, panelHeight);
+  int x0 = ax < bx ? ax : bx, x1 = ax > bx ? ax : bx;
+  int y0 = ay < by ? ay : by, y1 = ay > by ? ay : by;
+  if (x0 < 0) x0 = 0;
+  if (y0 < 0) y0 = 0;
+  if (x1 >= panelWidth) x1 = panelWidth - 1;
+  if (y1 >= panelHeight) y1 = panelHeight - 1;
+  if (x1 < x0 || y1 < y0) return;
+  display.preconditionGrayscale(static_cast<uint16_t>(x0), static_cast<uint16_t>(y0),
+                                static_cast<uint16_t>(x1 - x0 + 1), static_cast<uint16_t>(y1 - y0 + 1));
+}
+
 void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(frameBuffer); }
 
 void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(frameBuffer); }

lib/GfxRenderer/GfxRenderer.h

@@ -13,6 +13,9 @@ enum class BidiBaseDir : signed char { AUTO = -1, LTR = 0, RTL = 1 };
 
 class FontCacheManager;
 class SdCardFont;
+namespace freeink {
+struct Icon;
+}
 
 #include <cstring>
 #include <map>
@@ -51,6 +54,13 @@ class GfxRenderer {
   uint32_t frameBufferSize = HalDisplay::BUFFER_SIZE;
   std::vector<uint8_t*> bwBufferChunks;
   std::map<int, EpdFontFamily> fontMap;
+  // UI chrome font remap table (see setUiFontRemap). Empty = identity.
+  static constexpr int MAX_UI_FONT_REMAP = 8;
+  int uiFontFrom_[MAX_UI_FONT_REMAP] = {0};
+  int uiFontTo_[MAX_UI_FONT_REMAP] = {0};
+  int uiFontRemapCount_ = 0;
+  int remapUiFont(int fontId) const;
+  int glyphTop(int fontId, uint32_t cp) const;
   // Mutable because ensureSdCardFontReady() is const (called from layout code
   // that holds a const GfxRenderer&) but triggers SD card reads and heap
   // allocation inside the SdCardFont objects. Same pragmatic compromise as
@@ -81,6 +91,12 @@ class GfxRenderer {
   void drawPixelDither(int x, int y) const;
   template <Color color>
   void fillArc(int maxRadius, int cx, int cy, int xDir, int yDir) const;
+  // Byte-aligned, orientation-specialized rectangle fill. Rotates the rect's
+  // two opposing corners into physical-framebuffer space once, then walks each
+  // physical row with head-mask / middle memset / tail-mask byte writes — no
+  // per-pixel rotation, no per-pixel RMW.
+  template <Color color>
+  void fillRectImpl(int x, int y, int width, int height) const;
 
  public:
   explicit GfxRenderer(HalDisplay& halDisplay)
@@ -95,6 +111,14 @@ class GfxRenderer {
   // Setup
   void begin();  // must be called right after display.begin()
   void insertFont(int fontId, EpdFontFamily font);
+  // Orientation-correct icon blit for the freeink::Icon format (un-rotated bits +
+  // optical-center metadata). Prefer this over the legacy raw-bitmap drawIcon.
+  void drawIcon(const freeink::Icon& icon, int x, int y, bool black = true) const;
+  // UI chrome font scaling: firmware supplies a small remap table (from the board
+  // uiScale) that substitutes a larger font for each scaled UI font id at lookup
+  // time, so layout and drawing stay consistent with no call-site changes. Reader
+  // body fonts aren't in the table, so book text is unaffected. count <= 8.
+  void setUiFontRemap(const int* from, const int* to, int count);
   // Clears both the flash-font map and any SD-font registration for fontId.
   // Coupled to avoid dangling SdCardFont* in sdCardFonts_ when callers free
   // the underlying SdCardFont and forget the SD-side unregister.
@@ -135,6 +159,11 @@ class GfxRenderer {
   void clearScreen(uint8_t color = 0xFF) const;
   void getOrientedViewableTRBL(int* outTop, int* outRight, int* outBottom, int* outLeft) const;
 
+  // Map a touch tap (normalized 0..1 in panel-native orientation, from
+  // InputManager::wasTouchTap) to logical screen coordinates matching the Rects the
+  // UI draws in. Inverse of rotateCoordinates() for the current orientation.
+  void tapToLogical(float nx, float ny, int& outX, int& outY) const;
+
   // Tiled grayscale strip target. While active, drawPixel() and clearScreen()
   // operate on `scratch` (panelWidthBytes * stripRows bytes, holding physical
   // rows [stripY0, stripY0 + stripRows)) instead of the framebuffer; pixels
@@ -202,6 +231,12 @@ class GfxRenderer {
   int getTextAdvanceX(int fontId, const char* text, EpdFontFamily::Style style) const;
   int getFontAscenderSize(int fontId) const;
   int getLineHeight(int fontId) const;
+  // Cap height (from the 'H' glyph), the real visible font extent for vertical
+  // alignment that follows the font instead of a guessed ascender fraction.
+  int getFontCapHeight(int fontId) const;
+  // Offset from text top (drawText's y) to the text's optical center; align an
+  // element to a line via centerY = textTop + getTextVisualCenterOffset(fontId).
+  int getTextVisualCenterOffset(int fontId) const;
   std::string truncatedText(int fontId, const char* text, int maxWidth,
                             EpdFontFamily::Style style = EpdFontFamily::REGULAR) const;
   /// Word-wrap \p text into at most \p maxLines lines, each no wider than
@@ -218,6 +253,16 @@ class GfxRenderer {
   // Grayscale functions
   void setRenderMode(const RenderMode mode) { this->renderMode = mode; }
   RenderMode getRenderMode() const { return renderMode; }
+  // Grayscale preconditioning settle pass (no-op on X4). The rect overload
+  // takes the gray region in LOGICAL screen coordinates and rotates it to the
+  // panel; the no-arg overload settles the full frame. Call after the BW base
+  // frame is displayed and before the grayscale planes are written.
+  void preconditionGrayscale() const;
+  void preconditionGrayscale(int x, int y, int w, int h) const;
+  // Display the framebuffer as the base frame for a grayscale overlay that
+  // follows (X3: OEM differential base waveform; others: plain display with
+  // `fallback`).
+  void displayGrayscaleBase(HalDisplay::RefreshMode fallback = HalDisplay::HALF_REFRESH) const;
   void copyGrayscaleLsbBuffers() const;
   void copyGrayscaleMsbBuffers() const;
   void displayGrayBuffer() const;

lib/I18n/translations/belarusian.yaml

@@ -68,8 +68,10 @@ STR_TEXT_AA: "Згладжванне тэксту"
 STR_SHORT_PWR_BTN: "Кароткае націсканне PWR"
 STR_ORIENTATION: "Арыентацыя чытання"
 STR_SIDE_BTN_LAYOUT: "Бакавыя кнопкі"
+STR_TOUCH_READER_CONTROLS: "Сэнсарнае кіраванне чытаннем"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Арыентаваць пярэднія кнопкі"
 STR_LONG_PRESS_SKIP: "Доўгае націсканне - змена раздзела"
+STR_FONT_PREVIEW_TEXT: "У Іўі худы жвавы чорт у зялёнай камізэльцы пабег пад'есці фаршу з юшкай"
 STR_FONT_FAMILY: "Шрыфт чытання"
 STR_FONT_SIZE: "Памер шрыфту інтэрфейсу"
 STR_LINE_SPACING: "Міжрадковы інтэрвал"
@@ -125,6 +127,7 @@ STR_PAGE_TURN: "Перагортванне"
 STR_PORTRAIT: "Партрэт"
 STR_LANDSCAPE_CW: "Ландшафт (CW)"
 STR_INVERTED: "Інверсія"
+STR_ORIENTATION_INVERTED: "Партрэт 180°"
 STR_LANDSCAPE_CCW: "Ландшафт (CCW)"
 STR_PREV_NEXT: "Назад/Наперад"
 STR_NEXT_PREV: "Наперад/Назад"
@@ -175,6 +178,9 @@ STR_EXIT: "« Выхад"
 STR_HOME: "« Галоўная"
 STR_SELECT: "Абраць"
 STR_TOGGLE: "Выбар"
+STR_TOGGLE_BOOKMARK: "Пераключыць закладку"
+STR_BOOKMARK_REMOVED: "Закладка выдалена."
+STR_HOLD_OPEN_TO_DELETE: "Утрымлівайце Адкрыць, каб выдаліць"
 STR_CONFIRM: "Пацв."
 STR_CANCEL: "Адмена"
 STR_CONNECT: "Падкл."

lib/I18n/translations/catalan.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Suprimir"
 STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada"
 STR_ORIENTATION: "Orientació de lectura"
 STR_SIDE_BTN_LAYOUT: "Disposició botons laterals"
+STR_TOUCH_READER_CONTROLS: "Controls tàctils del lector"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals"
 STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saltar capítols"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Canvi d'orientació"
+STR_LONG_PRESS_MENU: "Funció de pulsació llarga"
 STR_FONT_FAMILY: "Tipus de lletra"
 STR_FONT_SIZE: "Mida de la lletra (UI)"
 STR_LINE_SPACING: "Interlineat del lector"
@@ -135,9 +137,12 @@ STR_PAGE_TURN: "Canvi de pàgina"
 STR_PORTRAIT: "Vertical"
 STR_LANDSCAPE_CW: "Horitzontal horari"
 STR_INVERTED: "Invertit"
+STR_ORIENTATION_INVERTED: "Vertical 180°"
 STR_LANDSCAPE_CCW: "Horitzontal antihorari"
 STR_PREV_NEXT: "Anterior/Següent"
 STR_NEXT_PREV: "Següent/Anterior"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Punt de llibre"
 STR_DISABLED: "Desactivats"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -172,8 +177,7 @@ STR_DOWNLOADING: "S'està baixant..."
 STR_DOWNLOAD_FAILED: "Ha fallat la baixada"
 STR_ERROR_MSG: "Error:"
 STR_UNNAMED: "Sense nom"
-STR_HOLD_CONFIRM_TO_DELETE: "Manteniu premut Confirma per esborrar"
-STR_BOOKMARK_INSTRUCTIONS: "Manteniu premut Confirma al lector per crear un punt de llibre."
+STR_HOLD_OPEN_TO_DELETE: "Manteniu premut Obre per esborrar"
 STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor"
 STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed"
 STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed"
@@ -189,6 +193,7 @@ STR_HOME: "« Inici"
 STR_SELECT: "Selecciona"
 STR_SELECTED: "Seleccionat"
 STR_TOGGLE: "Canvia"
+STR_TOGGLE_BOOKMARK: "Commuta punt de llibre"
 STR_CONFIRM: "Confirma"
 STR_CANCEL: "Cancel·la"
 STR_CONNECT: "Connecta"
@@ -233,6 +238,7 @@ STR_QUICK_RESUME_TIMEOUT: "Represa ràpida després del temps"
 STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals"
 STR_BOOKMARKS: "Punts de llibre"
 STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre."
+STR_BOOKMARK_REMOVED: "S'ha eliminat el punt de llibre."
 STR_OPDS_BROWSER: "Navegador OPDS"
 STR_COVER_CUSTOM: "Portada + Personalitzat"
 STR_QUICK_RESUME: "Represa ràpida"
@@ -294,6 +300,7 @@ STR_BOOK_S_STYLE: "Estil del llibre"
 STR_EMBEDDED_STYLE: "Estil incrustat"
 STR_FOCUS_READING: "Lectura enfocada"
 STR_OPDS_SERVER_URL: "URL del servidor OPDS"
+STR_PWR_BTN_FOOTNOTE_BACK: "Retorn ràpid des de les notes al peu"
 STR_FOOTNOTES: "Notes al peu"
 STR_NO_FOOTNOTES: "No hi ha notes al peu en aquesta pàgina"
 STR_LINK: "[enllaç]"
@@ -338,6 +345,7 @@ STR_MANAGE_FONTS: "Gestiona els tipus de lletra"
 STR_FONT_BROWSER: "Navegador de tipus de lletra"
 STR_LOADING_FONT_LIST: "S'està carregant la llista de tipus de lletra..."
 STR_NO_FONTS_AVAILABLE: "No hi ha tipus de lletra disponibles"
+STR_FONT_PREVIEW_TEXT: "Jove xef, porti whisky amb quinze glaçons d'hidrogen, coi!"
 STR_FONT_INSTALLED: "Tipus de lletra instal·lat!"
 STR_FONT_INSTALL_FAILED: "Ha fallat la instal·lació del tipus de lletra"
 STR_INSTALLED: "Instal·lat"

lib/I18n/translations/czech.yaml

@@ -68,11 +68,13 @@ STR_TEXT_AA: "Vyhlazování textu"
 STR_SHORT_PWR_BTN: "Krátké stisknutí tlačítka napájení"
 STR_ORIENTATION: "Orientace čtení"
 STR_SIDE_BTN_LAYOUT: "Rozvržení bočních tlačítek (čtečka)"
+STR_TOUCH_READER_CONTROLS: "Dotykové ovládání čtečky"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientovat přední tlačítka"
 STR_LONG_PRESS_BEHAVIOR: "Chování při dlouhém stisknutí tlačítka"
 STR_LONG_PRESS_BEHAVIOR_OFF: "VYP"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Přeskočení kapitoly"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Změna orientace"
+STR_FONT_PREVIEW_TEXT: "Příliš žluťoučký kůň úpěl ďábelské ódy"
 STR_FONT_FAMILY: "Rodina písem čtečky"
 STR_FONT_SIZE: "Velikost písma rozhraní"
 STR_LINE_SPACING: "Řádkování čtečky"
@@ -130,6 +132,7 @@ STR_PAGE_TURN: "Otáčení stránek"
 STR_PORTRAIT: "Na výšku"
 STR_LANDSCAPE_CW: "Na šířku po směru hod. ručiček"
 STR_INVERTED: "Invertovaný"
+STR_ORIENTATION_INVERTED: "Na výšku 180°"
 STR_LANDSCAPE_CCW: "Na šířku proti směru hod. ručiček"
 STR_PREV_NEXT: "Předchozí/Další"
 STR_NEXT_PREV: "Další/Předchozí"
@@ -180,6 +183,9 @@ STR_EXIT: "« Konec"
 STR_HOME: "« Domů"
 STR_SELECT: "Vybrat"
 STR_TOGGLE: "Přepnout"
+STR_TOGGLE_BOOKMARK: "Přepnout záložku"
+STR_BOOKMARK_REMOVED: "Záložka odstraněna."
+STR_HOLD_OPEN_TO_DELETE: "Podržte Otevřít pro smazání"
 STR_CONFIRM: "Potvrdit"
 STR_CANCEL: "Zrušit"
 STR_CONNECT: "Připojit"

lib/I18n/translations/danish.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Skjul"
 STR_SHORT_PWR_BTN: "Kort tryk på tænd/sluk-knap"
 STR_ORIENTATION: "Læseretning"
 STR_SIDE_BTN_LAYOUT: "Knaplayout på siden (læser)"
+STR_TOUCH_READER_CONTROLS: "Touch-betjening (læser)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientér forreste knapper"
 STR_LONG_PRESS_BEHAVIOR: "Comportamiento al mantener pulsado el botón"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivado"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saltar capítulo"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Cambio de orientación"
+STR_FONT_PREVIEW_TEXT: "Høj bly gom vandt fræk sexquiz på wc"
 STR_FONT_FAMILY: "Læser skrifttype"
 STR_FONT_SIZE: "Læser skriftstørrelse"
 STR_LINE_SPACING: "Linjeafstand"
@@ -135,6 +137,7 @@ STR_PAGE_TURN: "Sideskift"
 STR_PORTRAIT: "Portræt"
 STR_LANDSCAPE_CW: "Liggende med uret"
 STR_INVERTED: "Inverteret"
+STR_ORIENTATION_INVERTED: "Portræt 180°"
 STR_LANDSCAPE_CCW: "Liggende mod uret"
 STR_PREV_NEXT: "Forrige/Næste"
 STR_NEXT_PREV: "Næste/Forrige"
@@ -186,6 +189,9 @@ STR_HOME: "« Hjem"
 STR_SELECT: "Vælg"
 STR_SELECTED: "Valgt"
 STR_TOGGLE: "Skift"
+STR_TOGGLE_BOOKMARK: "Skift bogmærke"
+STR_BOOKMARK_REMOVED: "Bogmærke fjernet."
+STR_HOLD_OPEN_TO_DELETE: "Hold Åbn nede for at slette"
 STR_CONFIRM: "Bekræft"
 STR_CANCEL: "Annuller"
 STR_CONNECT: "Forbind"

lib/I18n/translations/dutch.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Verbergen"
 STR_SHORT_PWR_BTN: "Korte klik aan/uit-knop"
 STR_ORIENTATION: "Leesstand"
 STR_SIDE_BTN_LAYOUT: "Indeling zijknoppen (lezer)"
+STR_TOUCH_READER_CONTROLS: "Aanraakbediening lezer"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Richt voorste knoppen"
 STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Chapter skip"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientation change"
+STR_FONT_PREVIEW_TEXT: "Pa's wijze lynx bezag vroom het fikse aquaduct"
 STR_FONT_FAMILY: "Lettertype lezer"
 STR_FONT_SIZE: "Lettergrootte lezer"
 STR_LINE_SPACING: "Regelafstand lezer"
@@ -134,7 +136,8 @@ STR_SLEEP: "Slaap"
 STR_PAGE_TURN: "Pagina omslaan"
 STR_PORTRAIT: "Staand"
 STR_LANDSCAPE_CW: "Liggend (rechtsom)"
-STR_INVERTED: "Omgekeerd"
+STR_INVERTED: "Geïnverteerd"
+STR_ORIENTATION_INVERTED: "Staand 180°"
 STR_LANDSCAPE_CCW: "Liggend (linksom)"
 STR_PREV_NEXT: "Vorige/Volgende"
 STR_NEXT_PREV: "Volgende/Vorige"
@@ -186,6 +189,9 @@ STR_HOME: "« Home"
 STR_SELECT: "Kies"
 STR_SELECTED: "Geselecteerd"
 STR_TOGGLE: "Wissel"
+STR_TOGGLE_BOOKMARK: "Bladwijzer wisselen"
+STR_BOOKMARK_REMOVED: "Bladwijzer verwijderd."
+STR_HOLD_OPEN_TO_DELETE: "Houd Openen ingedrukt om te verwijderen"
 STR_CONFIRM: "Bevestig"
 STR_CANCEL: "Annuleer"
 STR_CONNECT: "Verbind"

lib/I18n/translations/english.yaml

@@ -73,11 +73,14 @@ STR_IMAGES_SUPPRESS: "Suppress"
 STR_SHORT_PWR_BTN: "Short Power Button Click"
 STR_ORIENTATION: "Reading Orientation"
 STR_SIDE_BTN_LAYOUT: "Side Button Layout (reader)"
+STR_TOUCH_READER_CONTROLS: "Touch Reader Controls"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orient front buttons"
 STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Chapter skip"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientation change"
+STR_LONG_PRESS_MENU: "Long-press Menu"
+STR_FONT_PREVIEW_TEXT: "The quick brown fox jumps over the lazy dog"
 STR_FONT_FAMILY: "Reader Font Family"
 STR_FONT_SIZE: "Reader Font Size"
 STR_LINE_SPACING: "Reader Line Spacing"
@@ -137,9 +140,12 @@ STR_FORCE_REFRESH: "Refresh Screen"
 STR_PORTRAIT: "Portrait"
 STR_LANDSCAPE_CW: "Landscape CW"
 STR_INVERTED: "Inverted"
+STR_ORIENTATION_INVERTED: "Portrait 180°"
 STR_LANDSCAPE_CCW: "Landscape CCW"
 STR_PREV_NEXT: "Prev/Next"
 STR_NEXT_PREV: "Next/Prev"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Bookmark"
 STR_DISABLED: "Disabled"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -175,8 +181,7 @@ STR_DOWNLOADING: "Downloading..."
 STR_DOWNLOAD_FAILED: "Download failed"
 STR_ERROR_MSG: "Error:"
 STR_UNNAMED: "Unnamed"
-STR_HOLD_CONFIRM_TO_DELETE: "Hold Confirm to Delete"
-STR_BOOKMARK_INSTRUCTIONS: "Hold Confirm from the reader to create a bookmark."
+STR_HOLD_OPEN_TO_DELETE: "Hold Open to Delete"
 STR_NO_SERVER_URL: "No server URL configured"
 STR_FETCH_FEED_FAILED: "Failed to fetch feed"
 STR_PARSE_FEED_FAILED: "Failed to parse feed"
@@ -194,6 +199,7 @@ STR_HOME: "« Home"
 STR_SELECT: "Select"
 STR_SELECTED: "Selected"
 STR_TOGGLE: "Toggle"
+STR_TOGGLE_BOOKMARK: "Toggle Bookmark"
 STR_CONFIRM: "Confirm"
 STR_CANCEL: "Cancel"
 STR_CONNECT: "Connect"
@@ -256,6 +262,7 @@ STR_SUNLIGHT_FADING_FIX: "Sunlight Fading Fix"
 STR_REMAP_FRONT_BUTTONS: "Remap Front Buttons"
 STR_BOOKMARKS: "Bookmarks"
 STR_BOOKMARK_ADDED: "Bookmark added."
+STR_BOOKMARK_REMOVED: "Bookmark removed."
 STR_OPDS_BROWSER: "OPDS Browser"
 STR_SEARCH: "Search"
 STR_COVER_CUSTOM: "Cover + Custom"

lib/I18n/translations/finnish.yaml

@@ -68,11 +68,13 @@ STR_TEXT_AA: "Tekstin reunanpehmennys"
 STR_SHORT_PWR_BTN: "Lyhyt virtapainikkeen painallus"
 STR_ORIENTATION: "Lukusuunta"
 STR_SIDE_BTN_LAYOUT: "Sivupainikkeiden asettelu (lukija)"
+STR_TOUCH_READER_CONTROLS: "Kosketusohjaus (lukija)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Suuntaa etupainikkeet"
 STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Chapter skip"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientation change"
+STR_FONT_PREVIEW_TEXT: "Törkylempijävongahdus"
 STR_FONT_FAMILY: "Lukijan fonttiperhe"
 STR_FONT_SIZE: "Käyttöliittymän fonttikoko"
 STR_LINE_SPACING: "Lukijan riviväli"
@@ -129,7 +131,8 @@ STR_SLEEP: "Lepotila"
 STR_PAGE_TURN: "Sivunkääntö"
 STR_PORTRAIT: "Pysty"
 STR_LANDSCAPE_CW: "Vaaka myötäpäivään"
-STR_INVERTED: "Käännetty"
+STR_INVERTED: "Käänteinen"
+STR_ORIENTATION_INVERTED: "Pysty 180°"
 STR_LANDSCAPE_CCW: "Vaaka vastapäivään"
 STR_PREV_NEXT: "Edell/Seur"
 STR_NEXT_PREV: "Seur/Edell"
@@ -180,6 +183,9 @@ STR_EXIT: "« Poistu"
 STR_HOME: "« Koti"
 STR_SELECT: "Valitse"
 STR_TOGGLE: "Vaihda"
+STR_TOGGLE_BOOKMARK: "Vaihda kirjanmerkki"
+STR_BOOKMARK_REMOVED: "Kirjanmerkki poistettu."
+STR_HOLD_OPEN_TO_DELETE: "Pidä Avaa painettuna poistaaksesi"
 STR_CONFIRM: "Vahvista"
 STR_CANCEL: "Peruuta"
 STR_CONNECT: "Yhdistä"

lib/I18n/translations/french.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Masquer"
 STR_SHORT_PWR_BTN: "Appui court alim."
 STR_ORIENTATION: "Orientation de lecture"
 STR_SIDE_BTN_LAYOUT: "Boutons latéraux"
+STR_TOUCH_READER_CONTROLS: "Commandes tactiles (lecteur)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienter boutons avant"
 STR_LONG_PRESS_BEHAVIOR: "Comportement lors d'un appui long"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Désactivé"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saut de chapitre"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Changement d'orientation"
+STR_FONT_PREVIEW_TEXT: "Portez ce vieux whisky au juge blond qui fume"
 STR_FONT_FAMILY: "Police de caractères du lecteur"
 STR_FONT_SIZE: "Taille police lecteur"
 STR_LINE_SPACING: "Interligne"
@@ -135,6 +137,7 @@ STR_PAGE_TURN: "Page suivante"
 STR_PORTRAIT: "Portrait"
 STR_LANDSCAPE_CW: "Paysage"
 STR_INVERTED: "Inversé"
+STR_ORIENTATION_INVERTED: "Portrait 180°"
 STR_LANDSCAPE_CCW: "Paysage inversé"
 STR_PREV_NEXT: "Préc/Suiv"
 STR_NEXT_PREV: "Suiv/Préc"
@@ -186,6 +189,9 @@ STR_HOME: "« Accueil"
 STR_SELECT: "OK"
 STR_SELECTED: "Sélectionné"
 STR_TOGGLE: "Modifier"
+STR_TOGGLE_BOOKMARK: "Basculer le marque-page"
+STR_BOOKMARK_REMOVED: "Marque-page supprimé."
+STR_HOLD_OPEN_TO_DELETE: "Maintenir Ouvrir pour supprimer"
 STR_CONFIRM: "Confirmer"
 STR_CANCEL: "Annuler"
 STR_CONNECT: "Connecter"

lib/I18n/translations/german.yaml

@@ -68,18 +68,21 @@ STR_TEXT_AA: "Schriftglättung"
 STR_SHORT_PWR_BTN: "An-Taste kurz drücken"
 STR_ORIENTATION: "Leseausrichtung"
 STR_SIDE_BTN_LAYOUT: "Seitliche Tasten (Lesen)"
+STR_TOUCH_READER_CONTROLS: "Touch-Steuerung (Lesen)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Vordere Tasten ausrichten"
 STR_LONG_PRESS_BEHAVIOR: "Verhalten bei langem Tastendruck"
-STR_LONG_PRESS_BEHAVIOR_OFF: "AUS"
+STR_LONG_PRESS_BEHAVIOR_OFF: "Aus"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Kapitel überspringen"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Ausrichtung ändern"
+STR_FONT_PREVIEW_TEXT: "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich"
 STR_FONT_FAMILY: "Lese-Schriftfamilie"
 STR_FONT_SIZE: "Schriftgröße"
 STR_LINE_SPACING: "Lese-Zeilenabstand"
 STR_SCREEN_MARGIN: "Lese-Seitenränder"
 STR_PARA_ALIGNMENT: "Lese-Absatzausrichtung"
+STR_LONG_PRESS_MENU: "Menütaste lang drücken"
 STR_HYPHENATION: "Silbentrennung"
-STR_TIME_TO_SLEEP: "Standby nach"
+STR_TIME_TO_SLEEP: "Standby-Modus nach"
 STR_REFRESH_FREQ: "Anti-Ghosting nach"
 STR_KOREADER_SYNC: "KOReader-Synchr."
 STR_CHECK_UPDATES: "Nach Updates suchen"
@@ -128,7 +131,8 @@ STR_PAGE_TURN: "Umblättern"
 STR_FORCE_REFRESH: "Bildschirm regenerieren"
 STR_PORTRAIT: "Hochformat"
 STR_LANDSCAPE_CW: "Querformat rechts"
-STR_INVERTED: "Hochformat 180°"
+STR_INVERTED: "Invertiert"
+STR_ORIENTATION_INVERTED: "Hochformat 180°"
 STR_LANDSCAPE_CCW: "Querformat links"
 STR_PREV_NEXT: "Zurück/Weiter"
 STR_NEXT_PREV: "Weiter/Zurück"
@@ -167,8 +171,7 @@ STR_DOWNLOADING: "Herunterladen…"
 STR_DOWNLOAD_FAILED: "Ladefehler"
 STR_ERROR_MSG: "Fehler:"
 STR_UNNAMED: "Unbenannt"
-STR_HOLD_CONFIRM_TO_DELETE: "Halte Bestätigen zum Löschen"
-STR_BOOKMARK_INSTRUCTIONS: "Halte Bestätigen im Lesemodus um ein Lesezeichen anzulegen."
+STR_HOLD_OPEN_TO_DELETE: "Halte Öffnen zum Löschen"
 STR_NO_SERVER_URL: "Keine Server-URL konfiguriert"
 STR_FETCH_FEED_FAILED: "Feedfehler"
 STR_PARSE_FEED_FAILED: "Feed-Format ungültig"
@@ -186,6 +189,7 @@ STR_HOME: "« Start"
 STR_SELECT: "Auswahl"
 STR_SELECTED: "Ausgewählt"
 STR_TOGGLE: "Ändern"
+STR_TOGGLE_BOOKMARK: "Lesezeichen umschalten"
 STR_CONFIRM: "Bestätigen"
 STR_CANCEL: "Abbrechen"
 STR_CONNECT: "Verbinden"
@@ -249,6 +253,7 @@ STR_QUICK_RESUME_TIMEOUT: "Schnelles Fortsetzen nach Timeout"
 STR_REMAP_FRONT_BUTTONS: "Vordere Tasten belegen"
 STR_BOOKMARKS: "Lesezeichen"
 STR_BOOKMARK_ADDED: "Lesezeichen hinzugefügt."
+STR_BOOKMARK_REMOVED: "Lesezeichen entfernt."
 STR_SEARCH: "Suche"
 STR_OPDS_BROWSER: "OPDS-Browser"
 STR_COVER_CUSTOM: "Cover + Eigenes"

lib/I18n/translations/hebrew.yaml

@@ -73,10 +73,12 @@ STR_IMAGES_SUPPRESS: "הסתר תמונות"
 STR_SHORT_PWR_BTN: "לחיצה קצרה על כפתור ההפעלה"
 STR_ORIENTATION: "כיוון קריאה (מסך)"
 STR_SIDE_BTN_LAYOUT: "פריסת כפתורי צד (בקריאה)"
+STR_TOUCH_READER_CONTROLS: "פקדי מגע בקריאה"
 STR_LONG_PRESS_BEHAVIOR: "פעולת לחיצה ארוכה"
 STR_LONG_PRESS_BEHAVIOR_OFF: "כבוי"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "דלג פרק"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "שנה כיוון מסך"
+STR_FONT_PREVIEW_TEXT: "דג סקרן שט בים מאוכזב ולפתע מצא חברה"
 STR_FONT_FAMILY: "גופן הקריאה"
 STR_FONT_SIZE: "גודל גופן"
 STR_LINE_SPACING: "מרווח בין שורות"
@@ -133,7 +135,8 @@ STR_PAGE_TURN: "העברת דף"
 STR_FORCE_REFRESH: "רענון מסך מלא"
 STR_PORTRAIT: "לאורך"
 STR_LANDSCAPE_CW: "לרוחב (ימינה)"
-STR_INVERTED: "הפוך"
+STR_INVERTED: "היפוך צבעים"
+STR_ORIENTATION_INVERTED: "לאורך 180°"
 STR_LANDSCAPE_CCW: "לרוחב (שמאלה)"
 STR_PREV_NEXT: "הקודם/הבא"
 STR_NEXT_PREV: "הבא/הקודם"
@@ -188,6 +191,7 @@ STR_HOME: "מסך הבית »"
 STR_SELECT: "בחר"
 STR_SELECTED: "נבחר"
 STR_TOGGLE: "בחר"
+STR_TOGGLE_BOOKMARK: "הוסף/הסר סימנייה"
 STR_CONFIRM: "אישור"
 STR_CANCEL: "ביטול"
 STR_CONNECT: "התחבר"
@@ -359,8 +363,7 @@ STR_FRONT_BTN_FOLLOW_ORIENTATION: "התאמת לחצנים קדמיים לכיו
 STR_REMOVE_READ_FROM_RECENTS: "הסר ספרים שנקראו מרשימת האחרונים"
 STR_MOVE_FINISHED_TO_READ: "העבר ספרים שהסתיימו לתיקיית 'נקראו'"
 STR_DISABLED: "מבוטל"
-STR_HOLD_CONFIRM_TO_DELETE: "החזק לחוץ על אישור כדי למחוק"
-STR_BOOKMARK_INSTRUCTIONS: "החזק לחוץ על כפתור אישור בזמן הקריאה כדי להוסיף סימנייה"
+STR_HOLD_OPEN_TO_DELETE: "לחיצה ארוכה על 'פתח' כדי למחוק"
 STR_CLOCK: "שעון"
 STR_CLOCK_UTC_OFFSET: "הפרש זמן UTC"
 STR_CLOCK_FORMAT: "תבנית השעון"
@@ -378,6 +381,14 @@ STR_CLOCK_SYNC_NO_WIFI_HINT: "התחבר תחילה לרשת אלחוטית, ו
 STR_CLOCK_SYNCED: "השעון סונכרן"
 STR_BOOKMARKS: "סימניות"
 STR_BOOKMARK_ADDED: "הסימנייה התווספה"
+STR_BOOKMARK_REMOVED: "הסימנייה הוסרה"
 STR_QUICK_RESUME: "חזרה מהירה"
 STR_REMOVE_FROM_RECENTS: "להסיר מרשימת הספרים האחרונים?"
 STR_CONFIRM_DELETE_BOOKMARK: "למחוק סימנייה זו?"
+STR_LONG_PRESS_MENU: "לחיצה ארוכה על אישור"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "סימנייה"
+STR_PWR_BTN_FOOTNOTE_BACK: "חזרה מהירה מהערות שוליים"
+STR_SLEEP_TIMER_VALUE_FORMAT: "%u דקות"
+STR_SLEEP_NEVER: "אף פעם"
+STR_SLEEP_TIMER_STEP_HINT: "שמאל/ימין: 1 דק'  למעלה/למטה: 5 דק'"

lib/I18n/translations/hungarian.yaml

@@ -72,8 +72,10 @@ STR_IMAGES_SUPPRESS: "Elnyomás"
 STR_SHORT_PWR_BTN: "Rövid bekapcsológomb nyomás"
 STR_ORIENTATION: "Olvasási irány"
 STR_SIDE_BTN_LAYOUT: "Oldalsó gomb elrendezés (olvasó)"
+STR_TOUCH_READER_CONTROLS: "Érintőképernyős vezérlés (olvasó)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Elülső gombok tájolása"
 STR_LONG_PRESS_SKIP: "Hosszú nyomás - fejezet ugrás"
+STR_FONT_PREVIEW_TEXT: "Egy hűtlen vejét fülöncsípő, dühös mexikói úr Wesselényinél mázol Quitóban"
 STR_FONT_FAMILY: "Olvasó betűkészlet"
 STR_FONT_SIZE: "Olvasó betűméret"
 STR_LINE_SPACING: "Olvasó sorköz"
@@ -131,7 +133,8 @@ STR_SLEEP: "Alvás"
 STR_PAGE_TURN: "Lapozás"
 STR_PORTRAIT: "Álló"
 STR_LANDSCAPE_CW: "Fekvő jobbra"
-STR_INVERTED: "Fordított"
+STR_INVERTED: "Invertált"
+STR_ORIENTATION_INVERTED: "Álló 180°"
 STR_LANDSCAPE_CCW: "Fekvő balra"
 STR_PREV_NEXT: "Előző/Következő"
 STR_NEXT_PREV: "Következő/Előző"
@@ -183,6 +186,9 @@ STR_HOME: "« Főoldal"
 STR_SELECT: "Kiválasztás"
 STR_SELECTED: "Kiválasztva"
 STR_TOGGLE: "Váltás"
+STR_TOGGLE_BOOKMARK: "Könyvjelző váltása"
+STR_BOOKMARK_REMOVED: "Könyvjelző eltávolítva."
+STR_HOLD_OPEN_TO_DELETE: "Tartsa lenyomva a Megnyitás gombot a törléshez"
 STR_CONFIRM: "Megerősítés"
 STR_CANCEL: "Mégse"
 STR_CONNECT: "Csatlakozás"

lib/I18n/translations/italian.yaml

@@ -72,11 +72,14 @@ STR_IMAGES_SUPPRESS: "Nascondi"
 STR_SHORT_PWR_BTN: "Press. breve pul. accensione"
 STR_ORIENTATION: "Orientamento lettura"
 STR_SIDE_BTN_LAYOUT: "Pul. laterali (lettore)"
+STR_TOUCH_READER_CONTROLS: "Controlli touch (lettore)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienta pul. frontali"
 STR_LONG_PRESS_BEHAVIOR: "Press. lunga pul. laterali"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Salta capitolo"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientamento"
+STR_LONG_PRESS_MENU: "Menu press. lunga"
+STR_FONT_PREVIEW_TEXT: "Pranzo d'acqua fa volti sghembi"
 STR_FONT_FAMILY: "Font lettore"
 STR_FONT_SIZE: "Dimensione font"
 STR_LINE_SPACING: "Interlinea lettore"
@@ -135,7 +138,8 @@ STR_PAGE_TURN: "Cambio pagina"
 STR_FORCE_REFRESH: "Refresh"
 STR_PORTRAIT: "Verticale"
 STR_LANDSCAPE_CW: "Orizzontale Dx"
-STR_INVERTED: "Capovolto"
+STR_INVERTED: "Invertito"
+STR_ORIENTATION_INVERTED: "Verticale 180°"
 STR_LANDSCAPE_CCW: "Orizzontale Sx"
 STR_PREV_NEXT: "Prec/Succ"
 STR_NEXT_PREV: "Succ/Prec"
@@ -190,6 +194,7 @@ STR_HOME: "« Home"
 STR_SELECT: "Seleziona"
 STR_SELECTED: "Selezionato"
 STR_TOGGLE: "Cambia"
+STR_TOGGLE_BOOKMARK: "Attiva/disattiva segnalibro"
 STR_CONFIRM: "Conferma"
 STR_CANCEL: "Annulla"
 STR_CONNECT: "Connetti"
@@ -355,9 +360,9 @@ STR_FIRMWARE_WRITE_FAILED: "Aggiornamento firmware non riuscito"
 STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Non spegnere il dispositivo!"
 STR_RECOVERY_MODE: "Modalità ripristino"
 STR_RECOVERY_MODE_HINT: "Metti firmware.bin nella scheda SD e selezionalo"
-STR_BOOKMARK_INSTRUCTIONS: "Tieni premuto Conferma nel lettore per creare un segnalibro"
 STR_BOOKMARKS: "Segnalibri"
 STR_BOOKMARK_ADDED: "Segnalibro aggiunto"
+STR_BOOKMARK_REMOVED: "Segnalibro rimosso"
 STR_CONFIRM_DELETE_BOOKMARK: "Eliminare questo segnalibro?"
 STR_CLOCK_SYNC_NO_WIFI_HINT: "Connettiti prima al Wi-Fi e poi riprova"
 STR_CLOCK_SYNC_OK: "Orologio sincronizzato"
@@ -372,7 +377,10 @@ STR_CLOCK_SYNCING: "Sincronizzazione con il server NTP..."
 STR_CLOCK_SYNC_FAIL: "Sincronizzazione non riuscita"
 STR_CLOCK_SYNC_NOW: "Sincronizza l'orologio adesso"
 STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi non connesso"
-STR_HOLD_CONFIRM_TO_DELETE: "Tieni premuto Conferma per cancellare"
+STR_HOLD_OPEN_TO_DELETE: "Tieni premuto Apri per eliminare"
 STR_NEXT_FIELD: "Succ."
 STR_CURRENT_TIME: "Ora attuale: "
-STR_DISABLED: "Disattivato"
+STR_DISABLED: "Disattivato"
+STR_BOOKMARK_OPTION: "Segnalibro"
+STR_KOSYNC: "KOSync"
+STR_PWR_BTN_FOOTNOTE_BACK: "Rientro rapido dalle note"

lib/I18n/translations/kazakh.yaml

@@ -67,8 +67,10 @@ STR_TEXT_AA: "Мәтін сырғытпасы"
 STR_SHORT_PWR_BTN: "Қуат түймесін қысқа басу"
 STR_ORIENTATION: "Оқу бағдары"
 STR_SIDE_BTN_LAYOUT: "Бүйірлік түймелер орналасуы (оқырман)"
+STR_TOUCH_READER_CONTROLS: "Сенсорлық басқару (оқырман)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Алдыңғы түймелерді бағдарлау"
 STR_LONG_PRESS_SKIP: "Ұзақ басу арқылы тарау өткізу"
+STR_FONT_PREVIEW_TEXT: "Канагаттандырылмагандыктарыныздан"
 STR_FONT_FAMILY: "Оқырман қаріп тобы"
 STR_FONT_SIZE: "Интерфейс қаріп өлшемі"
 STR_LINE_SPACING: "Оқырман жол аралығы"
@@ -125,7 +127,8 @@ STR_SLEEP: "Ұйқы"
 STR_PAGE_TURN: "Бет аудару"
 STR_PORTRAIT: "Тік бағдар"
 STR_LANDSCAPE_CW: "Көлденең (сағат бағытымен)"
-STR_INVERTED: "Төңкерілген"
+STR_INVERTED: "Инверсия"
+STR_ORIENTATION_INVERTED: "Тік бағдар 180°"
 STR_LANDSCAPE_CCW: "Көлденең (сағат тіліне қарсы)"
 STR_PREV_NEXT: "Алдыңғы/Келесі"
 STR_NEXT_PREV: "Келесі/Алдыңғы"
@@ -176,6 +179,9 @@ STR_EXIT: "« Шығу"
 STR_HOME: "« Басты"
 STR_SELECT: "Таңдау"
 STR_TOGGLE: "Ауыстыру"
+STR_TOGGLE_BOOKMARK: "Бетбелгіні ауыстыру"
+STR_BOOKMARK_REMOVED: "Бетбелгі жойылды."
+STR_HOLD_OPEN_TO_DELETE: "Жою үшін Ашу түймесін ұстап тұрыңыз"
 STR_CONFIRM: "Растау"
 STR_CANCEL: "Болдырмау"
 STR_CONNECT: "Қосылу"

lib/I18n/translations/lithuanian.yaml

@@ -72,8 +72,10 @@ STR_IMAGES_SUPPRESS: "Slėpti"
 STR_SHORT_PWR_BTN: "Trumpas įjungimo pasp."
 STR_ORIENTATION: "Orientacija"
 STR_SIDE_BTN_LAYOUT: "Šoniniai mygtukai"
+STR_TOUCH_READER_CONTROLS: "Liečiamasis valdymas (skaityklė)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuoti priekinius mygtukus"
 STR_LONG_PRESS_SKIP: "Praleisti skyrių (ilgai)"
+STR_FONT_PREVIEW_TEXT: "Įlinkdama fechtuotojo špaga sublykčiojusi pragręžė apvalų arbūzą"
 STR_FONT_FAMILY: "Šriftas"
 STR_FONT_SIZE: "Šrifto dydis"
 STR_LINE_SPACING: "Tarpai tarp eilučių"
@@ -131,7 +133,8 @@ STR_SLEEP: "Miegas"
 STR_PAGE_TURN: "Versti psl."
 STR_PORTRAIT: "Stačias"
 STR_LANDSCAPE_CW: "Gulsčias (P)"
-STR_INVERTED: "Apverstas"
+STR_INVERTED: "Invertuotas"
+STR_ORIENTATION_INVERTED: "Stačias 180°"
 STR_LANDSCAPE_CCW: "Gulsčias (A)"
 STR_PREV_NEXT: "Atgal/Pirmyn"
 STR_NEXT_PREV: "Pirmyn/Atgal"
@@ -183,6 +186,9 @@ STR_HOME: "« Pradžia"
 STR_SELECT: "Rinktis"
 STR_SELECTED: "Pasirinkta"
 STR_TOGGLE: "Keisti"
+STR_TOGGLE_BOOKMARK: "Perjungti žymę"
+STR_BOOKMARK_REMOVED: "Žymė pašalinta."
+STR_HOLD_OPEN_TO_DELETE: "Laikykite Atidaryti, kad ištrintumėte"
 STR_CONFIRM: "Gerai"
 STR_CANCEL: "Atšaukti"
 STR_CONNECT: "Jungtis"

lib/I18n/translations/polish.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Pomijaj"
 STR_SHORT_PWR_BTN: "Krótkie naciśnięcie zasilania"
 STR_ORIENTATION: "Układ czytania"
 STR_SIDE_BTN_LAYOUT: "Układ przycisków bocznych"
+STR_TOUCH_READER_CONTROLS: "Sterowanie dotykowe (czytnik)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuj przednie przyciski"
 STR_LONG_PRESS_BEHAVIOR: "Funkcja długiego przyciśnięcia"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Wył."
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Przeskocz rozdział"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientacja ekranu"
+STR_FONT_PREVIEW_TEXT: "Pchnąć w tę łódź jeża lub ośm skrzyń fig"
 STR_FONT_FAMILY: "Czcionka"
 STR_FONT_SIZE: "Rozmiar czcionki"
 STR_LINE_SPACING: "Odstępy między wierszami"
@@ -135,7 +137,8 @@ STR_PAGE_TURN: "Nast. str."
 STR_FORCE_REFRESH: "Odśwież ekran"
 STR_PORTRAIT: "Pionowo"
 STR_LANDSCAPE_CW: "Poziomo P"
-STR_INVERTED: "Odwrócony"
+STR_INVERTED: "Inwersja"
+STR_ORIENTATION_INVERTED: "Pionowo 180°"
 STR_LANDSCAPE_CCW: "Poziomo L"
 STR_PREV_NEXT: "Poprz./Nast."
 STR_NEXT_PREV: "Nast./Poprz."
@@ -190,6 +193,9 @@ STR_HOME: "« Home"
 STR_SELECT: "Wybierz"
 STR_SELECTED: "Wybrano"
 STR_TOGGLE: "Zmień"
+STR_TOGGLE_BOOKMARK: "Przełącz zakładkę"
+STR_BOOKMARK_REMOVED: "Zakładka usunięta."
+STR_HOLD_OPEN_TO_DELETE: "Przytrzymaj Otwórz, aby usunąć"
 STR_CONFIRM: "Potwierdź"
 STR_CANCEL: "Anuluj"
 STR_CONNECT: "Połącz"

lib/I18n/translations/portuguese.yaml

@@ -68,11 +68,13 @@ STR_TEXT_AA: "Suavização de texto"
 STR_SHORT_PWR_BTN: "Clique curto botão ligar"
 STR_ORIENTATION: "Orientação de leitura"
 STR_SIDE_BTN_LAYOUT: "Disposição botões laterais"
+STR_TOUCH_READER_CONTROLS: "Controlos táteis do leitor"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botões frontais"
 STR_LONG_PRESS_BEHAVIOR: "Comportamento do botão de premir e segurar"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desligado"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saltar capítulo"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Alterar orientação"
+STR_FONT_PREVIEW_TEXT: "Vejo galã sexy pôr quinze kiwis à força em baú achatado"
 STR_FONT_FAMILY: "Fonte do leitor"
 STR_FONT_SIZE: "Tam. fonte UI"
 STR_LINE_SPACING: "Espaçamento entre linhas"
@@ -130,6 +132,7 @@ STR_PAGE_TURN: "Virar página"
 STR_PORTRAIT: "Retrato"
 STR_LANDSCAPE_CW: "Paisagem H"
 STR_INVERTED: "Invertido"
+STR_ORIENTATION_INVERTED: "Retrato 180°"
 STR_LANDSCAPE_CCW: "Paisagem AH"
 STR_PREV_NEXT: "Ant/Próx"
 STR_NEXT_PREV: "Próx/Ant"
@@ -180,6 +183,9 @@ STR_EXIT: "« Sair"
 STR_HOME: "« Início"
 STR_SELECT: "Escolher"
 STR_TOGGLE: "Alternar"
+STR_TOGGLE_BOOKMARK: "Alternar marcador"
+STR_BOOKMARK_REMOVED: "Marcador removido."
+STR_HOLD_OPEN_TO_DELETE: "Mantenha Abrir pressionado para excluir"
 STR_CONFIRM: "Confirmar"
 STR_CANCEL: "Cancelar"
 STR_CONNECT: "Conectar"

lib/I18n/translations/romanian.yaml

@@ -72,11 +72,13 @@ STR_IMAGES_SUPPRESS: "Suprimare"
 STR_SHORT_PWR_BTN: "Apăsare scurtă întrerupător"
 STR_ORIENTATION: "Orientare lectură"
 STR_SIDE_BTN_LAYOUT: "Aspect butoane laterale (lectură)"
+STR_TOUCH_READER_CONTROLS: "Control tactil (lectură)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientare butoane frontale"
 STR_LONG_PRESS_BEHAVIOR: "Comportament buton apăsat lung"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Dezactivat"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Sărire capitol"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Schimbă orientarea"
+STR_FONT_PREVIEW_TEXT: "Încă vând gem, whisky bej și tequila roz, preț fix"
 STR_FONT_FAMILY: "Familie font lectură"
 STR_FONT_SIZE: "Dimensiune font"
 STR_LINE_SPACING: "Spaţiere între rânduri"
@@ -135,6 +137,7 @@ STR_PAGE_TURN: "Răsfoire pagină"
 STR_PORTRAIT: "Vertical"
 STR_LANDSCAPE_CW: "Orizontal dreapta"
 STR_INVERTED: "Invers"
+STR_ORIENTATION_INVERTED: "Vertical 180°"
 STR_LANDSCAPE_CCW: "Orizontal stânga"
 STR_PREV_NEXT: "Înainte/Înapoi"
 STR_NEXT_PREV: "Înapoi/Înainte"
@@ -186,6 +189,9 @@ STR_HOME: "« Acasă"
 STR_SELECT: "Selectează"
 STR_SELECTED: "Selectat"
 STR_TOGGLE: "Schimbă"
+STR_TOGGLE_BOOKMARK: "Comută marcajul"
+STR_BOOKMARK_REMOVED: "Marcaj eliminat."
+STR_HOLD_OPEN_TO_DELETE: "Țineți apăsat Deschideți pentru a șterge"
 STR_CONFIRM: "Confirmă"
 STR_CANCEL: "Anulare"
 STR_CONNECT: "Conectare"

lib/I18n/translations/russian.yaml

@@ -73,11 +73,14 @@ STR_IMAGES_SUPPRESS: "Скрыть"
 STR_SHORT_PWR_BTN: "Короткое нажатие PWR"
 STR_ORIENTATION: "Ориентация чтения"
 STR_SIDE_BTN_LAYOUT: "Боковые кнопки"
+STR_TOUCH_READER_CONTROLS: "Сенсорное управление чтением"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ориентировать передние кнопки"
 STR_LONG_PRESS_BEHAVIOR: "Долгое нажатие"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Ничего"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Пропуск главы"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Изменить ориентацию"
+STR_LONG_PRESS_MENU: "Долгое нажатие меню"
+STR_FONT_PREVIEW_TEXT: "Съешь ещё этих мягких французских булок, да выпей же чаю"
 STR_FONT_FAMILY: "Шрифт чтения"
 STR_FONT_SIZE: "Размер шрифта интерфейса"
 STR_LINE_SPACING: "Межстрочный интервал"
@@ -138,10 +141,13 @@ STR_FORCE_REFRESH: "Обновление экрана"
 STR_PORTRAIT: "Портрет"
 STR_LANDSCAPE_CW: "Ландшафт (CW)"
 STR_INVERTED: "Инверсия"
+STR_ORIENTATION_INVERTED: "Портрет 180°"
 STR_LANDSCAPE_CCW: "Ландшафт (CCW)"
 STR_PREV_NEXT: "Назад/Вперёд"
 STR_NEXT_PREV: "Вперёд/Назад"
-STR_DISABLED: "Выключены"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Закладка"
+STR_DISABLED: "Выключено"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
 STR_SMALL: "Маленький"
@@ -176,8 +182,7 @@ STR_DOWNLOADING: "Загрузка..."
 STR_DOWNLOAD_FAILED: "Ошибка загрузки"
 STR_ERROR_MSG: "Ошибка:"
 STR_UNNAMED: "Без имени"
-STR_HOLD_CONFIRM_TO_DELETE: "Удерживайте ОТКРЫТЬ для удаления закладки"
-STR_BOOKMARK_INSTRUCTIONS: "Удерживайте ВЫБРАТЬ для добавления закладки"
+STR_HOLD_OPEN_TO_DELETE: "Удерживайте Открыть для удаления"
 STR_NO_SERVER_URL: "URL сервера не настроен"
 STR_FETCH_FEED_FAILED: "Не удалось получить ленту"
 STR_PARSE_FEED_FAILED: "Не удалось обработать ленту"
@@ -195,6 +200,7 @@ STR_HOME: "« Главная"
 STR_SELECT: "Выбрать"
 STR_SELECTED: "Выбран"
 STR_TOGGLE: "Выбор"
+STR_TOGGLE_BOOKMARK: "Переключить закладку"
 STR_CONFIRM: "Подтв."
 STR_CANCEL: "Отмена"
 STR_CONNECT: "Подкл."
@@ -257,6 +263,7 @@ STR_SUNLIGHT_FADING_FIX: "Компенсация выцветания"
 STR_REMAP_FRONT_BUTTONS: "Переназначить передние кнопки"
 STR_BOOKMARKS: "Закладки"
 STR_BOOKMARK_ADDED: "Закладка добавлена"
+STR_BOOKMARK_REMOVED: "Закладка удалена"
 STR_OPDS_BROWSER: "OPDS браузер"
 STR_SEARCH: "Поиск"
 STR_COVER_CUSTOM: "Обложка + Свой"

lib/I18n/translations/slovak.yaml

@@ -1,378 +1,382 @@
-_language_name: "Slovenčina"
-_language_code: "SK"
-_order: "24"
-
-STR_CROSSPOINT: "CrossPoint"
-STR_BOOTING: "SPÚŠŤANIE"
-STR_SLEEPING: "SPÁNOK"
-STR_ENTERING_SLEEP: "Prechod do režimu spánku"
-STR_BROWSE_FILES: "Prehliadať súbory"
-STR_FILE_TRANSFER: "Prenos súborov"
-STR_SETTINGS_TITLE: "Nastavenia"
-STR_CONTINUE_READING: "Pokračovať v čítaní"
-STR_NO_OPEN_BOOK: "Žiadna otvorená kniha"
-STR_START_READING: "Začnite čítať nižšie"
-STR_NO_FILES_FOUND: "Neboli nájdené žiadne súbory"
-STR_SELECT_CHAPTER: "Vybrať kapitolu"
-STR_NO_CHAPTERS: "Žiadne kapitoly"
-STR_END_OF_BOOK: "Koniec knihy"
-STR_EMPTY_CHAPTER: "Prázdna kapitola"
-STR_INDEXING: "Indexovanie"
-STR_MEMORY_ERROR: "Chyba pamäte"
-STR_PAGE_LOAD_ERROR: "Chyba načítania stránky"
-STR_EMPTY_FILE: "Prázdny súbor"
-STR_OUT_OF_BOUNDS: "Mimo rozsahu"
-STR_LOADING: "Načítava sa..."
-STR_LOADING_POPUP: "Načítavanie"
-STR_WIFI_NETWORKS: "Wi-Fi siete"
-STR_NO_NETWORKS: "Nenašli sa žiadne siete"
-STR_NETWORKS_FOUND: "Nájdených %zu sietí"
-STR_SCANNING: "Skenovanie..."
-STR_CONNECTING: "Pripájanie..."
-STR_CONNECTED: "Pripojené!"
-STR_CONNECTION_FAILED: "Pripojenie zlyhalo"
-STR_FORGET_NETWORK: "Zabudnúť sieť?"
-STR_SAVE_PASSWORD: "Uložiť heslo na nabudúce?"
-STR_PRESS_OK_SCAN: "Stlačte OK pre opätovné skenovanie"
-STR_JOIN_NETWORK: "Pripojiť sa k sieti"
-STR_CREATE_HOTSPOT: "Vytvoriť hotspot"
-STR_JOIN_DESC: "Pripojiť sa k existujúcej Wi-Fi sieti"
-STR_HOTSPOT_DESC: "Vytvoriť Wi-Fi sieť, ku ktorej sa môžu pripojiť ostatní"
-STR_STARTING_HOTSPOT: "Spúšťanie hotspotu..."
-STR_HOTSPOT_MODE: "Režim hotspotu"
-STR_CONNECT_WIFI_HINT: "Pripojte svoje zariadenie k tejto Wi-Fi sieti"
-STR_OPEN_URL_HINT: "Otvorte túto URL adresu vo svojom prehliadači"
-STR_OR_HTTP_PREFIX: "alebo http://"
-STR_SCAN_QR_HINT: "alebo naskenujte QR kód telefónom:"
-STR_CALIBRE_WIRELESS: "Calibre Wireless"
-STR_NETWORK_LEGEND: "* = Šifrované | + = Uložené"
-STR_MAC_ADDRESS: "MAC adresa:"
-STR_CHECKING_WIFI: "Kontrola Wi-Fi..."
-STR_ENTER_WIFI_PASSWORD: "Zadajte heslo Wi-Fi"
-STR_TO_PREFIX: "pre"
-STR_CALIBRE_RECEIVING: "Prijímanie:"
-STR_CALIBRE_RECEIVED: "Prijaté:"
-STR_CALIBRE_INSTRUCTION_1: "1) Nainštalujte plugin CrossPoint Reader"
-STR_CALIBRE_INSTRUCTION_2: "2) Buďte v rovnakej Wi-Fi sieti"
-STR_CALIBRE_INSTRUCTION_3: "3) V Calibre: „Odoslať do zariadenia“"
-STR_CALIBRE_INSTRUCTION_4: "„Pri odosielaní nechajte túto obrazovku otvorenú“"
-STR_CAT_DISPLAY: "Displej"
-STR_CAT_READER: "Čítačka"
-STR_CAT_CONTROLS: "Ovládanie"
-STR_CAT_SYSTEM: "Systém"
-STR_SLEEP_SCREEN: "Obrazovka spánku"
-STR_QUICK_RESUME_TIMEOUT: "Rýchle obnovenie pri nečinnosti"
-STR_SLEEP_COVER_MODE: "Obrazovka spánku – režim krytu"
-STR_HIDE_BATTERY: "Skryť % batérie"
-STR_EXTRA_SPACING: "Dodatočné medzery medzi odsekmi"
-STR_TEXT_AA: "Vyhladzovanie textu"
-STR_IMAGES: "Obrázky"
-STR_IMAGES_DISPLAY: "Zobraz"
-STR_IMAGES_PLACEHOLDER: "Rezervované miesto"
-STR_IMAGES_SUPPRESS: "Potlačiť"
-STR_SHORT_PWR_BTN: "Krátke stlačenie tlačidla napájania"
-STR_ORIENTATION: "Orientácia čítania"
-STR_SIDE_BTN_LAYOUT: "Rozloženie bočných tlačidiel (čítačka)"
-STR_FRONT_BTN_FOLLOW_ORIENTATION: "Prispôsobiť predné tlačidlá orientácii"
-STR_LONG_PRESS_BEHAVIOR: "Správanie pri dlhom stlačení tlačidla"
-STR_LONG_PRESS_BEHAVIOR_OFF: "VYP"
-STR_LONG_PRESS_BEHAVIOR_SKIP: "Preskočiť kapitolu"
-STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Zmeniť orientáciu"
-STR_FONT_FAMILY: "Rodina písiem čítačky"
-STR_FONT_SIZE: "Veľkosť písma rozhrania"
-STR_LINE_SPACING: "Riadkovanie čítačky"
-STR_SCREEN_MARGIN: "Okraj obrazovky čítačky"
-STR_PARA_ALIGNMENT: "Zarovnanie odsekov čítačky"
-STR_HYPHENATION: "Delenie slov"
-STR_TIME_TO_SLEEP: "Čas do uspania"
-STR_SHOW_HIDDEN_FILES: "Zobraz Skryté Súbory"
-STR_REMOVE_READ_FROM_RECENTS: "Odstrániť prečítané knihy zo zoznamu nedávnych"
-STR_MOVE_FINISHED_TO_READ: "Presunúť prečítané knihy do priečinka Read"
-STR_REFRESH_FREQ: "Frekvencia obnovovania"
-STR_KOREADER_SYNC: "KOReader Sync"
-STR_CHECK_UPDATES: "Skontrolovať aktualizácie"
-STR_LANGUAGE: "Jazyk"
-STR_CLEAR_READING_CACHE: "Vymazať vyrovnávaciu pamäť čítania"
-STR_USERNAME: "Používateľské meno"
-STR_PASSWORD: "Heslo"
-STR_SYNC_SERVER_URL: "URL synchronizačného servera"
-STR_DOCUMENT_MATCHING: "Párovanie dokumentov"
-STR_AUTHENTICATE: "Overiť"
-STR_KOREADER_USERNAME: "Používateľské meno KOReader"
-STR_KOREADER_PASSWORD: "Heslo KOReader"
-STR_FILENAME: "Názov súboru"
-STR_BINARY: "Binárny"
-STR_SET_CREDENTIALS_FIRST: "Najprv nastavte prihlasovacie údaje"
-STR_WIFI_CONN_FAILED: "Pripojenie k Wi-Fi zlyhalo"
-STR_AUTHENTICATING: "Overovanie..."
-STR_AUTH_SUCCESS: "Overenie úspešné!"
-STR_KOREADER_AUTH: "Overenie KOReader"
-STR_SYNC_READY: "Synchronizácia KOReader je pripravená na použitie"
-STR_AUTH_FAILED: "Overenie zlyhalo"
-STR_DONE: "Hotovo"
-STR_CLEAR_CACHE_WARNING_1: "Týmto vymažete všetky údaje kníh vo vyrovnávacej pamäti."
-STR_CLEAR_CACHE_WARNING_2: "Všetok priebeh čítania bude stratený!"
-STR_CLEAR_CACHE_WARNING_3: "Knihy bude potrebné znova indexovať"
-STR_CLEAR_CACHE_WARNING_4: "pri ich opätovnom otvorení."
-STR_CLEARING_CACHE: "Mazanie vyrovnávacej pamäte..."
-STR_CACHE_CLEARED: "Vyrovnávacia pamäť vymazaná"
-STR_ITEMS_REMOVED: "položiek odstránených"
-STR_FAILED_LOWER: "zlyhalo"
-STR_CLEAR_CACHE_FAILED: "Vymazanie vyrovnávacej pamäte zlyhalo"
-STR_CHECK_SERIAL_OUTPUT: "Podrobnosti nájdete v sériovom výstupe"
-STR_DARK: "Tmavý"
-STR_LIGHT: "Svetlý"
-STR_CUSTOM: "Vlastný"
-STR_COVER: "Obálka"
-STR_NONE_OPT: "Žiadny"
-STR_FIT: "Prispôsobiť"
-STR_CROP: "Orezať"
-STR_NEVER: "Nikdy"
-STR_IN_READER: "V čítačke"
-STR_ALWAYS: "Vždy"
-STR_IGNORE: "Ignorovať"
-STR_SLEEP: "Spánok"
-STR_PAGE_TURN: "Otáčanie stránok"
-STR_FORCE_REFRESH: "Obnoviť obrazovku"
-STR_PORTRAIT: "Na výšku"
-STR_LANDSCAPE_CW: "Na šírku v smere hodinových ručičiek"
-STR_INVERTED: "Obrátený"
-STR_LANDSCAPE_CCW: "Na šírku proti smeru hodinových ručičiek"
-STR_PREV_NEXT: "Predchádzajúca/Nasledujúca"
-STR_NEXT_PREV: "Nasledujúca/Predchádzajúca"
-STR_DISABLED: "Vypnuté"
-STR_NOTO_SERIF: "Noto Serif"
-STR_NOTO_SANS: "Noto Sans"
-STR_SMALL: "Malý"
-STR_MEDIUM: "Stredný"
-STR_LARGE: "Veľký"
-STR_X_LARGE: "Obrovský"
-STR_TIGHT: "Tesný"
-STR_NORMAL: "Normálny"
-STR_WIDE: "Široký"
-STR_JUSTIFY: "Zarovnať do bloku"
-STR_ALIGN_LEFT: "Vľavo"
-STR_CENTER: "Na stred"
-STR_ALIGN_RIGHT: "Vpravo"
-STR_PAGES_1: "1 strana"
-STR_PAGES_5: "5 strán"
-STR_PAGES_10: "10 strán"
-STR_PAGES_15: "15 strán"
-STR_PAGES_30: "30 strán"
-STR_UPDATE: "Aktualizácia"
-STR_CHECKING_UPDATE: "Kontrola aktualizácií…"
-STR_NEW_UPDATE: "K dispozícii je nová aktualizácia!"
-STR_CURRENT_VERSION: "Aktuálna verzia:"
-STR_NEW_VERSION: "Nová verzia:"
-STR_UPDATING: "Aktualizácia..."
-STR_NO_UPDATE: "Nie je k dispozícii žiadna aktualizácia"
-STR_UPDATE_FAILED: "Aktualizácia zlyhala"
-STR_UPDATE_COMPLETE: "Aktualizácia dokončená"
-STR_POWER_ON_HINT: "Stlačte a podržte tlačidlo napájania pre zapnutie"
-STR_RESTARTING_HINT: "Reštartujem... Ak sa zariadenie nereštartuje, podrž tlačidlo na zapnutie niekoľko s."
-STR_NO_ENTRIES: "Neboli nájdené žiadne položky"
-STR_DOWNLOADING: "Sťahovanie..."
-STR_DOWNLOAD_FAILED: "Sťahovanie zlyhalo"
-STR_ERROR_MSG: "Chyba:"
-STR_UNNAMED: "Nepomenované"
-STR_HOLD_CONFIRM_TO_DELETE: "Podrž potvrdiť pre vymazanie"
-STR_BOOKMARK_INSTRUCTIONS: "Podrž tlačidlo Potvrdiť pre vytvorenie záložky."
-STR_NO_SERVER_URL: "Nie je nakonfigurovaná URL adresa servera"
-STR_FETCH_FEED_FAILED: "Načítanie kanála zlyhalo"
-STR_PARSE_FEED_FAILED: "Spracovanie kanála zlyhalo"
-STR_NEXT_PAGE: "Ďaľsia strana »"
-STR_PREV_PAGE: "« Predchádzajúca str."
-STR_NETWORK_PREFIX: "Sieť:"
-STR_IP_ADDRESS_PREFIX: "IP adresa:"
-STR_ERROR_GENERAL_FAILURE: "Chyba: Všeobecná chyba"
-STR_ERROR_NETWORK_NOT_FOUND: "Chyba: Sieť nebola nájdená"
-STR_ERROR_CONNECTION_TIMEOUT: "Chyba: Časový limit pripojenia"
-STR_SD_CARD: "SD karta"
-STR_BACK: "« Späť"
-STR_EXIT: "« Koniec"
-STR_HOME: "« Domov"
-STR_SELECT: "Vybrať"
-STR_SELECTED: "Vybrané"
-STR_TOGGLE: "Prepnúť"
-STR_CONFIRM: "Potvrdiť"
-STR_CANCEL: "Zrušiť"
-STR_CONNECT: "Pripojiť"
-STR_OPEN: "Otvoriť"
-STR_DOWNLOAD: "Stiahnuť"
-STR_RETRY: "Skúsiť znova"
-STR_YES: "Áno"
-STR_NO: "Nie"
-STR_SHOW: "Zobraz"
-STR_HIDE: "Skryť"
-STR_STATE_ON: "ZAP"
-STR_STATE_OFF: "VYP"
-STR_NOT_SET: "Nenastavené"
-STR_DIR_LEFT: "Vľavo"
-STR_DIR_RIGHT: "Vpravo"
-STR_DIR_UP: "Hore"
-STR_DIR_DOWN: "Dole"
-STR_OK_BUTTON: "OK"
-STR_SLEEP_COVER_FILTER: "Filter obrazovky spánku"
-STR_FILTER_CONTRAST: "Kontrast"
-STR_CUSTOMISE_STATUS_BAR: "Uprav status bar"
-STR_CHAPTER_PAGE_COUNT: "Počítadlo strán kapitoly"
-STR_BOOK_PROGRESS_PERCENTAGE: "Prečítané percent"
-STR_PROGRESS_BAR: "Ukazovateľ čítania"
-STR_PROGRESS_BAR_THICKNESS: "Hrúbka indikátora priebehu"
-STR_PROGRESS_BAR_THIN: "Tenký"
-STR_PROGRESS_BAR_MEDIUM: "Stredný"
-STR_PROGRESS_BAR_THICK: "Hrubý"
-STR_BOOK: "Kniha"
-STR_CHAPTER: "Kapitola"
-STR_EXAMPLE_CHAPTER: "Kapitola 21"
-STR_EXAMPLE_BOOK: "Názov knihy"
-STR_PREVIEW: "Ukážka"
-STR_TITLE: "Názov"
-STR_BATTERY: "Batéria"
-STR_XTC_STATUS_BAR: "Stavový panel XTC"
-STR_BOTTOM: "Dole"
-STR_TOP: "Hore"
-STR_CLOCK: "Hodiny"
-STR_CLOCK_UTC_OFFSET: "UTC posun hodín"
-STR_CLOCK_FORMAT: "Formát času"
-STR_CLOCK_FORMAT_24H: "24-hodinový"
-STR_CLOCK_FORMAT_12H: "12-hodinový"
-STR_CURRENT_TIME: "Aktuálny čas:"
-STR_NEXT_FIELD: "Ďalej"
-STR_CLOCK_SYNC: "Synchronizácia hodín"
-STR_CLOCK_SYNC_NOW: "Synchronizovať teraz"
-STR_CLOCK_SYNCING: "Synchronizácia cez NTP..."
-STR_CLOCK_SYNC_OK: "Hodiny synchronizované"
-STR_CLOCK_SYNC_FAIL: "Synchronizácia zlyhala"
-STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi nie je pripojená"
-STR_CLOCK_SYNC_NO_WIFI_HINT: "Najprv sa pripojte k Wi-Fi a potom skúste znova."
-STR_CLOCK_SYNCED: "Hodiny synchronizované"
-STR_UI_THEME: "Téma rozhrania"
-STR_THEME_CLASSIC: "Klasická"
-STR_THEME_LYRA: "Lyra"
-STR_THEME_ROUNDEDRAFF: "RoundedRaff"
-STR_THEME_LYRA_EXTENDED: "Lyra Extended"
-STR_SUNLIGHT_FADING_FIX: "Oprava blednutia na slnku"
-STR_REMAP_FRONT_BUTTONS: "Premapovať predné tlačidlá"
-STR_BOOKMARKS: "Záložky"
-STR_BOOKMARK_ADDED: "Záložka pridaná."
-STR_OPDS_BROWSER: "Prehliadač OPDS"
-STR_SEARCH: "Hľadať"
-STR_COVER_CUSTOM: "Obálka + Vlastné"
-STR_QUICK_RESUME: "Rýchle obnovenie"
-STR_MENU_RECENT_BOOKS: "Nedávne knihy"
-STR_REMOVE_FROM_RECENTS: "Odstrániť z nedávnych kníh?"
-STR_NO_RECENT_BOOKS: "Žiadne nedávne knihy"
-STR_CALIBRE_DESC: "Používať bezdrôtové prenosy zariadení Calibre"
-STR_FORGET_AND_REMOVE: "Zabudnúť sieť a odstrániť uložené heslo?"
-STR_FORGET_BUTTON: "Zabudnúť"
-STR_CALIBRE_STARTING: "Spúšťanie Calibre..."
-STR_CALIBRE_SETUP: "Nastavenie"
-STR_CALIBRE_STATUS: "Stav"
-STR_CLEAR_BUTTON: "Vymazať"
-STR_DEFAULT_VALUE: "Predvolené"
-STR_REMAP_PROMPT: "Stlačte predné tlačidlo pre každú funkciu"
-STR_UNASSIGNED: "Nepriradené"
-STR_ALREADY_ASSIGNED: "Už priradené"
-STR_REMAP_RESET_HINT: "Bočné tlačidlo Hore: Obnoviť predvolené rozloženie"
-STR_REMAP_CANCEL_HINT: "Bočné tlačidlo Dole: Zrušiť premapovanie"
-STR_HW_BACK_LABEL: "Späť (1. tlačidlo)"
-STR_HW_CONFIRM_LABEL: "Potvrdiť (2. tlačidlo)"
-STR_HW_LEFT_LABEL: "Vľavo (3. tlačidlo)"
-STR_HW_RIGHT_LABEL: "Vpravo (4. tlačidlo)"
-STR_GO_TO_PERCENT: "Prejsť na %"
-STR_GO_HOME_BUTTON: "Prejsť na Domov"
-STR_SYNC_PROGRESS: "Priebeh synchronizácie"
-STR_DELETE_CACHE: "Vymazať vyrovnávaciu pamäť knihy"
-STR_DELETE: "Vymazať"
-STR_CONFIRM_DELETE_BOOKMARK: "Vymazať záložku?"
-STR_DISPLAY_QR: "Zobraz stránku ako QR"
-STR_CHAPTER_PREFIX: "Kapitola:"
-STR_PAGES_SEPARATOR: "strán |"
-STR_BOOK_PREFIX: "Kniha:"
-STR_CALIBRE_URL_HINT: "Pre Calibre pridajte /opds na koniec URL adresy"
-STR_PERCENT_STEP_HINT: "Vľavo/Vpravo: 1 %  Hore/Dole: 10 %"
-STR_SYNCING_TIME: "Čas synchronizácie..."
-STR_CALC_HASH: "Výpočet hashu dokumentu..."
-STR_HASH_FAILED: "Nepodarilo sa vypočítať hash dokumentu"
-STR_FETCH_PROGRESS: "Načítavanie vzdialeného priebehu..."
-STR_UPLOAD_PROGRESS: "Nahrávanie priebehu..."
-STR_NO_CREDENTIALS_MSG: "Prihlasovacie údaje nie sú nastavené"
-STR_KOREADER_SETUP_HINT: "Nastavte účet KOReader v Nastaveniach"
-STR_PROGRESS_FOUND: "Priebeh nájdený!"
-STR_REMOTE_LABEL: "Vzdialený:"
-STR_LOCAL_LABEL: "Lokálny:"
-STR_PAGE_OVERALL_FORMAT: "Strana %d, celkovo %.2f%%"
-STR_PAGE_TOTAL_OVERALL_FORMAT: "Strana %d/%d, celkovo %.2f%%"
-STR_DEVICE_FROM_FORMAT: "  Zo zariadenia: %s"
-STR_APPLY_REMOTE: "Použiť vzdialený priebeh"
-STR_UPLOAD_LOCAL: "Nahrať lokálny priebeh"
-STR_NO_REMOTE_MSG: "Nenašiel sa žiadny vzdialený priebeh"
-STR_UPLOAD_PROMPT: "Nahrať aktuálnu pozíciu?"
-STR_UPLOAD_SUCCESS: "Priebeh nahraný!"
-STR_SYNC_FAILED_MSG: "Synchronizácia zlyhala"
-STR_SAVE_PROGRESS_FAILED: "Nepodarilo sa uložiť priebeh"
-STR_SECTION_PREFIX: "Sekcia"
-STR_UPLOAD: "Nahrať"
-STR_BOOK_S_STYLE: "Štýl knihy"
-STR_EMBEDDED_STYLE: "Vložený štýl"
-STR_FOCUS_READING: "Sústredené čítanie"
-STR_OPDS_SERVER_URL: "URL adresa OPDS servera"
-STR_SET_SLEEP_COVER: "Nastav obal"
-STR_FOOTNOTES: "Poznámky pod čiarou"
-STR_NO_FOOTNOTES: "Žiadne poznámky pod čiarou"
-STR_LINK: "[link]"
-STR_SCREENSHOT_BUTTON: "Urobiť snímku obrazovky"
-STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
-STR_SLEEP_NEVER: "Nikdy"
-STR_SLEEP_TIMER_STEP_HINT: "Vľavo/Vpravo: 1 min  Hore/Dole: 5 min"
-STR_ADD_SERVER: "Pridať server"
-STR_SERVER_NAME: "Názov servera"
-STR_NO_SERVERS: "Nie sú nakonfigurované žiadne OPDS servery"
-STR_DELETE_SERVER: "Odstrániť server"
-STR_OPDS_SERVERS: "OPDS servery"
-STR_AUTO_TURN_ENABLED: "Automatické otáčanie strán zapnuté: "
-STR_AUTO_TURN_PAGES_PER_MIN: "Automatické otáčanie (strán za minútu)"
-STR_MANAGE_FONTS: "Správa písiem"
-STR_FONT_BROWSER: "Prehliadač písiem"
-STR_LOADING_FONT_LIST: "Načítava sa zoznam písiem..."
-STR_NO_FONTS_AVAILABLE: "Nie sú dostupné žiadne písma"
-STR_FONT_INSTALLED: "Písmo nainštalované!"
-STR_FONT_INSTALL_FAILED: "Inštalácia písma zlyhala"
-STR_INSTALLED: "Nainštalované"
-STR_DOWNLOAD_ALL: "Stiahnuť všetko"
-STR_UPDATE_ALL: "Aktualizovať všetko"
-STR_UPDATE_AVAILABLE: "Aktualizovať"
-STR_CRASH_TITLE: "Zlyhanie systému"
-STR_CRASH_DESCRIPTION: "Podrobná správa bola uložená do súboru crash_report.txt. Priložte tento súbor k hláseniu chyby."
-STR_CRASH_REASON: "Dôvod zlyhania:"
-STR_CRASH_NO_REASON: "(Nebola zaznamenaná žiadna príčina)"
-STR_TILT_PAGE_TURN: "Otáčanie strán naklonením"
-STR_KB_HINT_MOVE_CURSOR: "Stlačte VĽAVO alebo VPRAVO pre presun kurzora"
-STR_KB_HINT_RETURN_CURSOR: "Stlačte VĽAVO pre návrat na pozíciu kurzora"
-STR_KB_HINT_HIDE_PASSWORD: "Podržte VPRAVO a potom stlačte [***] na skrytie hesla"
-STR_KB_HINT_SHOW_PASSWORD: "Podržte VPRAVO a potom stlačte [abc] na zobrazenie hesla"
-STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "Stlačte [***] na skrytie hesla"
-STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "Stlačte [abc] na zobrazenie hesla"
-STR_KB_HINT_EDIT_ENTRY: "Podržte HORE pre úpravu položky"
-STR_KB_TIPS: "Tipy:"
-STR_KB_HINT_RETURN_KEYBOARD: "Stlačte DOLE pre návrat ku klávesnici"
-STR_KB_HINT_EXIT_URL_MODE: "Stlačte ABC pre ukončenie režimu URL"
-STR_KB_HINT_CLEAR_TEXT: "Podržte DEL pre vymazanie celého textu"
-STR_KB_HINT_SECONDARY_CHAR: "Podržte SELECT pre alternatívny znak"
-STR_KB_HINT_UPPER_SECONDARY: "Podržte SELECT pre VEĽKÉ písmeno alebo alternatívny znak"
-STR_KB_HINT_LOWER_SECONDARY: "Podržte SELECT pre malé písmeno alebo alternatívny znak"
-STR_KB_HINT_URL_SNIPPETS: "Stlačte URL pre úryvky"
-STR_SD_FIRMWARE_UPDATE: "Aktualizácia firmvéru z SD karty"
-STR_SELECT_FIRMWARE_FILE: "Vyberte súbor firmvéru (.bin)"
-STR_NO_BIN_FILES: "Nenašli sa žiadne súbory .bin"
-STR_VALIDATING_FIRMWARE: "Overuje sa firmvér..."
-STR_INVALID_FIRMWARE: "Neplatný súbor firmvéru"
-STR_FIRMWARE_TOO_LARGE: "Firmvér je príliš veľký pre partíciu"
-STR_FIRMWARE_TOO_SMALL: "Súbor firmvéru je príliš malý"
-STR_FIRMWARE_UPDATE_PROMPT: "Aktualizovať firmvér?"
-STR_FIRMWARE_FILE_OPEN_FAILED: "Nie je možné otvoriť súbor"
-STR_FIRMWARE_WRITE_FAILED: "Zápis firmvéru zlyhal"
-STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nevypínajte zariadenie!"
-STR_RECOVERY_MODE: "Režim obnovenia"
-STR_RECOVERY_MODE_HINT: "Umiestnite firmware.bin do koreňového adresára SD karty a vyberte ho"
+_language_name: "Slovenčina"
+_language_code: "SK"
+_order: "24"
+
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "SPÚŠŤANIE"
+STR_SLEEPING: "SPÁNOK"
+STR_ENTERING_SLEEP: "Prechod do režimu spánku"
+STR_BROWSE_FILES: "Prehliadať súbory"
+STR_FILE_TRANSFER: "Prenos súborov"
+STR_SETTINGS_TITLE: "Nastavenia"
+STR_CONTINUE_READING: "Pokračovať v čítaní"
+STR_NO_OPEN_BOOK: "Žiadna otvorená kniha"
+STR_START_READING: "Začnite čítať nižšie"
+STR_NO_FILES_FOUND: "Neboli nájdené žiadne súbory"
+STR_SELECT_CHAPTER: "Vybrať kapitolu"
+STR_NO_CHAPTERS: "Žiadne kapitoly"
+STR_END_OF_BOOK: "Koniec knihy"
+STR_EMPTY_CHAPTER: "Prázdna kapitola"
+STR_INDEXING: "Indexovanie"
+STR_MEMORY_ERROR: "Chyba pamäte"
+STR_PAGE_LOAD_ERROR: "Chyba načítania stránky"
+STR_EMPTY_FILE: "Prázdny súbor"
+STR_OUT_OF_BOUNDS: "Mimo rozsahu"
+STR_LOADING: "Načítava sa..."
+STR_LOADING_POPUP: "Načítavanie"
+STR_WIFI_NETWORKS: "Wi-Fi siete"
+STR_NO_NETWORKS: "Nenašli sa žiadne siete"
+STR_NETWORKS_FOUND: "Nájdených %zu sietí"
+STR_SCANNING: "Skenovanie..."
+STR_CONNECTING: "Pripájanie..."
+STR_CONNECTED: "Pripojené!"
+STR_CONNECTION_FAILED: "Pripojenie zlyhalo"
+STR_FORGET_NETWORK: "Zabudnúť sieť?"
+STR_SAVE_PASSWORD: "Uložiť heslo na nabudúce?"
+STR_PRESS_OK_SCAN: "Stlačte OK pre opätovné skenovanie"
+STR_JOIN_NETWORK: "Pripojiť sa k sieti"
+STR_CREATE_HOTSPOT: "Vytvoriť hotspot"
+STR_JOIN_DESC: "Pripojiť sa k existujúcej Wi-Fi sieti"
+STR_HOTSPOT_DESC: "Vytvoriť Wi-Fi sieť, ku ktorej sa môžu pripojiť ostatní"
+STR_STARTING_HOTSPOT: "Spúšťanie hotspotu..."
+STR_HOTSPOT_MODE: "Režim hotspotu"
+STR_CONNECT_WIFI_HINT: "Pripojte svoje zariadenie k tejto Wi-Fi sieti"
+STR_OPEN_URL_HINT: "Otvorte túto URL adresu vo svojom prehliadači"
+STR_OR_HTTP_PREFIX: "alebo http://"
+STR_SCAN_QR_HINT: "alebo naskenujte QR kód telefónom:"
+STR_CALIBRE_WIRELESS: "Calibre Wireless"
+STR_NETWORK_LEGEND: "* = Šifrované | + = Uložené"
+STR_MAC_ADDRESS: "MAC adresa:"
+STR_CHECKING_WIFI: "Kontrola Wi-Fi..."
+STR_ENTER_WIFI_PASSWORD: "Zadajte heslo Wi-Fi"
+STR_TO_PREFIX: "pre"
+STR_CALIBRE_RECEIVING: "Prijímanie:"
+STR_CALIBRE_RECEIVED: "Prijaté:"
+STR_CALIBRE_INSTRUCTION_1: "1) Nainštalujte plugin CrossPoint Reader"
+STR_CALIBRE_INSTRUCTION_2: "2) Buďte v rovnakej Wi-Fi sieti"
+STR_CALIBRE_INSTRUCTION_3: "3) V Calibre: „Odoslať do zariadenia“"
+STR_CALIBRE_INSTRUCTION_4: "„Pri odosielaní nechajte túto obrazovku otvorenú“"
+STR_CAT_DISPLAY: "Displej"
+STR_CAT_READER: "Čítačka"
+STR_CAT_CONTROLS: "Ovládanie"
+STR_CAT_SYSTEM: "Systém"
+STR_SLEEP_SCREEN: "Obrazovka spánku"
+STR_QUICK_RESUME_TIMEOUT: "Rýchle obnovenie pri nečinnosti"
+STR_SLEEP_COVER_MODE: "Obrazovka spánku – režim krytu"
+STR_HIDE_BATTERY: "Skryť % batérie"
+STR_EXTRA_SPACING: "Dodatočné medzery medzi odsekmi"
+STR_TEXT_AA: "Vyhladzovanie textu"
+STR_IMAGES: "Obrázky"
+STR_IMAGES_DISPLAY: "Zobraz"
+STR_IMAGES_PLACEHOLDER: "Rezervované miesto"
+STR_IMAGES_SUPPRESS: "Potlačiť"
+STR_SHORT_PWR_BTN: "Krátke stlačenie tlačidla napájania"
+STR_ORIENTATION: "Orientácia čítania"
+STR_SIDE_BTN_LAYOUT: "Rozloženie bočných tlačidiel (čítačka)"
+STR_TOUCH_READER_CONTROLS: "Dotykové ovládanie čítačky"
+STR_FRONT_BTN_FOLLOW_ORIENTATION: "Prispôsobiť predné tlačidlá orientácii"
+STR_LONG_PRESS_BEHAVIOR: "Správanie pri dlhom stlačení tlačidla"
+STR_LONG_PRESS_BEHAVIOR_OFF: "VYP"
+STR_LONG_PRESS_BEHAVIOR_SKIP: "Preskočiť kapitolu"
+STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Zmeniť orientáciu"
+STR_FONT_PREVIEW_TEXT: "Vypätá dcéra grófa Maxwella s IQ nižším ako kôň núti čeľaď hrýzť hŕbu jabĺk"
+STR_FONT_FAMILY: "Rodina písiem čítačky"
+STR_FONT_SIZE: "Veľkosť písma rozhrania"
+STR_LINE_SPACING: "Riadkovanie čítačky"
+STR_SCREEN_MARGIN: "Okraj obrazovky čítačky"
+STR_PARA_ALIGNMENT: "Zarovnanie odsekov čítačky"
+STR_HYPHENATION: "Delenie slov"
+STR_TIME_TO_SLEEP: "Čas do uspania"
+STR_SHOW_HIDDEN_FILES: "Zobraz Skryté Súbory"
+STR_REMOVE_READ_FROM_RECENTS: "Odstrániť prečítané knihy zo zoznamu nedávnych"
+STR_MOVE_FINISHED_TO_READ: "Presunúť prečítané knihy do priečinka Read"
+STR_REFRESH_FREQ: "Frekvencia obnovovania"
+STR_KOREADER_SYNC: "KOReader Sync"
+STR_CHECK_UPDATES: "Skontrolovať aktualizácie"
+STR_LANGUAGE: "Jazyk"
+STR_CLEAR_READING_CACHE: "Vymazať vyrovnávaciu pamäť čítania"
+STR_USERNAME: "Používateľské meno"
+STR_PASSWORD: "Heslo"
+STR_SYNC_SERVER_URL: "URL synchronizačného servera"
+STR_DOCUMENT_MATCHING: "Párovanie dokumentov"
+STR_AUTHENTICATE: "Overiť"
+STR_KOREADER_USERNAME: "Používateľské meno KOReader"
+STR_KOREADER_PASSWORD: "Heslo KOReader"
+STR_FILENAME: "Názov súboru"
+STR_BINARY: "Binárny"
+STR_SET_CREDENTIALS_FIRST: "Najprv nastavte prihlasovacie údaje"
+STR_WIFI_CONN_FAILED: "Pripojenie k Wi-Fi zlyhalo"
+STR_AUTHENTICATING: "Overovanie..."
+STR_AUTH_SUCCESS: "Overenie úspešné!"
+STR_KOREADER_AUTH: "Overenie KOReader"
+STR_SYNC_READY: "Synchronizácia KOReader je pripravená na použitie"
+STR_AUTH_FAILED: "Overenie zlyhalo"
+STR_DONE: "Hotovo"
+STR_CLEAR_CACHE_WARNING_1: "Týmto vymažete všetky údaje kníh vo vyrovnávacej pamäti."
+STR_CLEAR_CACHE_WARNING_2: "Všetok priebeh čítania bude stratený!"
+STR_CLEAR_CACHE_WARNING_3: "Knihy bude potrebné znova indexovať"
+STR_CLEAR_CACHE_WARNING_4: "pri ich opätovnom otvorení."
+STR_CLEARING_CACHE: "Mazanie vyrovnávacej pamäte..."
+STR_CACHE_CLEARED: "Vyrovnávacia pamäť vymazaná"
+STR_ITEMS_REMOVED: "položiek odstránených"
+STR_FAILED_LOWER: "zlyhalo"
+STR_CLEAR_CACHE_FAILED: "Vymazanie vyrovnávacej pamäte zlyhalo"
+STR_CHECK_SERIAL_OUTPUT: "Podrobnosti nájdete v sériovom výstupe"
+STR_DARK: "Tmavý"
+STR_LIGHT: "Svetlý"
+STR_CUSTOM: "Vlastný"
+STR_COVER: "Obálka"
+STR_NONE_OPT: "Žiadny"
+STR_FIT: "Prispôsobiť"
+STR_CROP: "Orezať"
+STR_NEVER: "Nikdy"
+STR_IN_READER: "V čítačke"
+STR_ALWAYS: "Vždy"
+STR_IGNORE: "Ignorovať"
+STR_SLEEP: "Spánok"
+STR_PAGE_TURN: "Otáčanie stránok"
+STR_FORCE_REFRESH: "Obnoviť obrazovku"
+STR_PORTRAIT: "Na výšku"
+STR_LANDSCAPE_CW: "Na šírku v smere hodinových ručičiek"
+STR_INVERTED: "Invertovaný"
+STR_ORIENTATION_INVERTED: "Na výšku 180°"
+STR_LANDSCAPE_CCW: "Na šírku proti smeru hodinových ručičiek"
+STR_PREV_NEXT: "Predchádzajúca/Nasledujúca"
+STR_NEXT_PREV: "Nasledujúca/Predchádzajúca"
+STR_DISABLED: "Vypnuté"
+STR_NOTO_SERIF: "Noto Serif"
+STR_NOTO_SANS: "Noto Sans"
+STR_SMALL: "Malý"
+STR_MEDIUM: "Stredný"
+STR_LARGE: "Veľký"
+STR_X_LARGE: "Obrovský"
+STR_TIGHT: "Tesný"
+STR_NORMAL: "Normálny"
+STR_WIDE: "Široký"
+STR_JUSTIFY: "Zarovnať do bloku"
+STR_ALIGN_LEFT: "Vľavo"
+STR_CENTER: "Na stred"
+STR_ALIGN_RIGHT: "Vpravo"
+STR_PAGES_1: "1 strana"
+STR_PAGES_5: "5 strán"
+STR_PAGES_10: "10 strán"
+STR_PAGES_15: "15 strán"
+STR_PAGES_30: "30 strán"
+STR_UPDATE: "Aktualizácia"
+STR_CHECKING_UPDATE: "Kontrola aktualizácií…"
+STR_NEW_UPDATE: "K dispozícii je nová aktualizácia!"
+STR_CURRENT_VERSION: "Aktuálna verzia:"
+STR_NEW_VERSION: "Nová verzia:"
+STR_UPDATING: "Aktualizácia..."
+STR_NO_UPDATE: "Nie je k dispozícii žiadna aktualizácia"
+STR_UPDATE_FAILED: "Aktualizácia zlyhala"
+STR_UPDATE_COMPLETE: "Aktualizácia dokončená"
+STR_POWER_ON_HINT: "Stlačte a podržte tlačidlo napájania pre zapnutie"
+STR_RESTARTING_HINT: "Reštartujem... Ak sa zariadenie nereštartuje, podrž tlačidlo na zapnutie niekoľko s."
+STR_NO_ENTRIES: "Neboli nájdené žiadne položky"
+STR_DOWNLOADING: "Sťahovanie..."
+STR_DOWNLOAD_FAILED: "Sťahovanie zlyhalo"
+STR_ERROR_MSG: "Chyba:"
+STR_UNNAMED: "Nepomenované"
+STR_HOLD_OPEN_TO_DELETE: "Podržte Otvoriť pre vymazanie"
+STR_NO_SERVER_URL: "Nie je nakonfigurovaná URL adresa servera"
+STR_FETCH_FEED_FAILED: "Načítanie kanála zlyhalo"
+STR_PARSE_FEED_FAILED: "Spracovanie kanála zlyhalo"
+STR_NEXT_PAGE: "Ďaľsia strana »"
+STR_PREV_PAGE: "« Predchádzajúca str."
+STR_NETWORK_PREFIX: "Sieť:"
+STR_IP_ADDRESS_PREFIX: "IP adresa:"
+STR_ERROR_GENERAL_FAILURE: "Chyba: Všeobecná chyba"
+STR_ERROR_NETWORK_NOT_FOUND: "Chyba: Sieť nebola nájdená"
+STR_ERROR_CONNECTION_TIMEOUT: "Chyba: Časový limit pripojenia"
+STR_SD_CARD: "SD karta"
+STR_BACK: "« Späť"
+STR_EXIT: "« Koniec"
+STR_HOME: "« Domov"
+STR_SELECT: "Vybrať"
+STR_SELECTED: "Vybrané"
+STR_TOGGLE: "Prepnúť"
+STR_TOGGLE_BOOKMARK: "Prepnúť záložku"
+STR_CONFIRM: "Potvrdiť"
+STR_CANCEL: "Zrušiť"
+STR_CONNECT: "Pripojiť"
+STR_OPEN: "Otvoriť"
+STR_DOWNLOAD: "Stiahnuť"
+STR_RETRY: "Skúsiť znova"
+STR_YES: "Áno"
+STR_NO: "Nie"
+STR_SHOW: "Zobraz"
+STR_HIDE: "Skryť"
+STR_STATE_ON: "ZAP"
+STR_STATE_OFF: "VYP"
+STR_NOT_SET: "Nenastavené"
+STR_DIR_LEFT: "Vľavo"
+STR_DIR_RIGHT: "Vpravo"
+STR_DIR_UP: "Hore"
+STR_DIR_DOWN: "Dole"
+STR_OK_BUTTON: "OK"
+STR_SLEEP_COVER_FILTER: "Filter obrazovky spánku"
+STR_FILTER_CONTRAST: "Kontrast"
+STR_CUSTOMISE_STATUS_BAR: "Uprav status bar"
+STR_CHAPTER_PAGE_COUNT: "Počítadlo strán kapitoly"
+STR_BOOK_PROGRESS_PERCENTAGE: "Prečítané percent"
+STR_PROGRESS_BAR: "Ukazovateľ čítania"
+STR_PROGRESS_BAR_THICKNESS: "Hrúbka indikátora priebehu"
+STR_PROGRESS_BAR_THIN: "Tenký"
+STR_PROGRESS_BAR_MEDIUM: "Stredný"
+STR_PROGRESS_BAR_THICK: "Hrubý"
+STR_BOOK: "Kniha"
+STR_CHAPTER: "Kapitola"
+STR_EXAMPLE_CHAPTER: "Kapitola 21"
+STR_EXAMPLE_BOOK: "Názov knihy"
+STR_PREVIEW: "Ukážka"
+STR_TITLE: "Názov"
+STR_BATTERY: "Batéria"
+STR_XTC_STATUS_BAR: "Stavový panel XTC"
+STR_BOTTOM: "Dole"
+STR_TOP: "Hore"
+STR_CLOCK: "Hodiny"
+STR_CLOCK_UTC_OFFSET: "UTC posun hodín"
+STR_CLOCK_FORMAT: "Formát času"
+STR_CLOCK_FORMAT_24H: "24-hodinový"
+STR_CLOCK_FORMAT_12H: "12-hodinový"
+STR_CURRENT_TIME: "Aktuálny čas:"
+STR_NEXT_FIELD: "Ďalej"
+STR_CLOCK_SYNC: "Synchronizácia hodín"
+STR_CLOCK_SYNC_NOW: "Synchronizovať teraz"
+STR_CLOCK_SYNCING: "Synchronizácia cez NTP..."
+STR_CLOCK_SYNC_OK: "Hodiny synchronizované"
+STR_CLOCK_SYNC_FAIL: "Synchronizácia zlyhala"
+STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi nie je pripojená"
+STR_CLOCK_SYNC_NO_WIFI_HINT: "Najprv sa pripojte k Wi-Fi a potom skúste znova."
+STR_CLOCK_SYNCED: "Hodiny synchronizované"
+STR_UI_THEME: "Téma rozhrania"
+STR_THEME_CLASSIC: "Klasická"
+STR_THEME_LYRA: "Lyra"
+STR_THEME_ROUNDEDRAFF: "RoundedRaff"
+STR_THEME_LYRA_EXTENDED: "Lyra Extended"
+STR_SUNLIGHT_FADING_FIX: "Oprava blednutia na slnku"
+STR_REMAP_FRONT_BUTTONS: "Premapovať predné tlačidlá"
+STR_BOOKMARKS: "Záložky"
+STR_BOOKMARK_ADDED: "Záložka pridaná."
+STR_BOOKMARK_REMOVED: "Záložka odstránená."
+STR_OPDS_BROWSER: "Prehliadač OPDS"
+STR_SEARCH: "Hľadať"
+STR_COVER_CUSTOM: "Obálka + Vlastné"
+STR_QUICK_RESUME: "Rýchle obnovenie"
+STR_MENU_RECENT_BOOKS: "Nedávne knihy"
+STR_REMOVE_FROM_RECENTS: "Odstrániť z nedávnych kníh?"
+STR_NO_RECENT_BOOKS: "Žiadne nedávne knihy"
+STR_CALIBRE_DESC: "Používať bezdrôtové prenosy zariadení Calibre"
+STR_FORGET_AND_REMOVE: "Zabudnúť sieť a odstrániť uložené heslo?"
+STR_FORGET_BUTTON: "Zabudnúť"
+STR_CALIBRE_STARTING: "Spúšťanie Calibre..."
+STR_CALIBRE_SETUP: "Nastavenie"
+STR_CALIBRE_STATUS: "Stav"
+STR_CLEAR_BUTTON: "Vymazať"
+STR_DEFAULT_VALUE: "Predvolené"
+STR_REMAP_PROMPT: "Stlačte predné tlačidlo pre každú funkciu"
+STR_UNASSIGNED: "Nepriradené"
+STR_ALREADY_ASSIGNED: "Už priradené"
+STR_REMAP_RESET_HINT: "Bočné tlačidlo Hore: Obnoviť predvolené rozloženie"
+STR_REMAP_CANCEL_HINT: "Bočné tlačidlo Dole: Zrušiť premapovanie"
+STR_HW_BACK_LABEL: "Späť (1. tlačidlo)"
+STR_HW_CONFIRM_LABEL: "Potvrdiť (2. tlačidlo)"
+STR_HW_LEFT_LABEL: "Vľavo (3. tlačidlo)"
+STR_HW_RIGHT_LABEL: "Vpravo (4. tlačidlo)"
+STR_GO_TO_PERCENT: "Prejsť na %"
+STR_GO_HOME_BUTTON: "Prejsť na Domov"
+STR_SYNC_PROGRESS: "Priebeh synchronizácie"
+STR_DELETE_CACHE: "Vymazať vyrovnávaciu pamäť knihy"
+STR_DELETE: "Vymazať"
+STR_CONFIRM_DELETE_BOOKMARK: "Vymazať záložku?"
+STR_DISPLAY_QR: "Zobraz stránku ako QR"
+STR_CHAPTER_PREFIX: "Kapitola:"
+STR_PAGES_SEPARATOR: "strán |"
+STR_BOOK_PREFIX: "Kniha:"
+STR_CALIBRE_URL_HINT: "Pre Calibre pridajte /opds na koniec URL adresy"
+STR_PERCENT_STEP_HINT: "Vľavo/Vpravo: 1 %  Hore/Dole: 10 %"
+STR_SYNCING_TIME: "Čas synchronizácie..."
+STR_CALC_HASH: "Výpočet hashu dokumentu..."
+STR_HASH_FAILED: "Nepodarilo sa vypočítať hash dokumentu"
+STR_FETCH_PROGRESS: "Načítavanie vzdialeného priebehu..."
+STR_UPLOAD_PROGRESS: "Nahrávanie priebehu..."
+STR_NO_CREDENTIALS_MSG: "Prihlasovacie údaje nie sú nastavené"
+STR_KOREADER_SETUP_HINT: "Nastavte účet KOReader v Nastaveniach"
+STR_PROGRESS_FOUND: "Priebeh nájdený!"
+STR_REMOTE_LABEL: "Vzdialený:"
+STR_LOCAL_LABEL: "Lokálny:"
+STR_PAGE_OVERALL_FORMAT: "Strana %d, celkovo %.2f%%"
+STR_PAGE_TOTAL_OVERALL_FORMAT: "Strana %d/%d, celkovo %.2f%%"
+STR_DEVICE_FROM_FORMAT: "  Zo zariadenia: %s"
+STR_APPLY_REMOTE: "Použiť vzdialený priebeh"
+STR_UPLOAD_LOCAL: "Nahrať lokálny priebeh"
+STR_NO_REMOTE_MSG: "Nenašiel sa žiadny vzdialený priebeh"
+STR_UPLOAD_PROMPT: "Nahrať aktuálnu pozíciu?"
+STR_UPLOAD_SUCCESS: "Priebeh nahraný!"
+STR_SYNC_FAILED_MSG: "Synchronizácia zlyhala"
+STR_SAVE_PROGRESS_FAILED: "Nepodarilo sa uložiť priebeh"
+STR_SECTION_PREFIX: "Sekcia"
+STR_UPLOAD: "Nahrať"
+STR_BOOK_S_STYLE: "Štýl knihy"
+STR_EMBEDDED_STYLE: "Vložený štýl"
+STR_FOCUS_READING: "Sústredené čítanie"
+STR_OPDS_SERVER_URL: "URL adresa OPDS servera"
+STR_SET_SLEEP_COVER: "Nastav obal"
+STR_FOOTNOTES: "Poznámky pod čiarou"
+STR_NO_FOOTNOTES: "Žiadne poznámky pod čiarou"
+STR_LINK: "[link]"
+STR_SCREENSHOT_BUTTON: "Urobiť snímku obrazovky"
+STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
+STR_SLEEP_NEVER: "Nikdy"
+STR_SLEEP_TIMER_STEP_HINT: "Vľavo/Vpravo: 1 min  Hore/Dole: 5 min"
+STR_ADD_SERVER: "Pridať server"
+STR_SERVER_NAME: "Názov servera"
+STR_NO_SERVERS: "Nie sú nakonfigurované žiadne OPDS servery"
+STR_DELETE_SERVER: "Odstrániť server"
+STR_OPDS_SERVERS: "OPDS servery"
+STR_AUTO_TURN_ENABLED: "Automatické otáčanie strán zapnuté: "
+STR_AUTO_TURN_PAGES_PER_MIN: "Automatické otáčanie (strán za minútu)"
+STR_MANAGE_FONTS: "Správa písiem"
+STR_FONT_BROWSER: "Prehliadač písiem"
+STR_LOADING_FONT_LIST: "Načítava sa zoznam písiem..."
+STR_NO_FONTS_AVAILABLE: "Nie sú dostupné žiadne písma"
+STR_FONT_INSTALLED: "Písmo nainštalované!"
+STR_FONT_INSTALL_FAILED: "Inštalácia písma zlyhala"
+STR_INSTALLED: "Nainštalované"
+STR_DOWNLOAD_ALL: "Stiahnuť všetko"
+STR_UPDATE_ALL: "Aktualizovať všetko"
+STR_UPDATE_AVAILABLE: "Aktualizovať"
+STR_CRASH_TITLE: "Zlyhanie systému"
+STR_CRASH_DESCRIPTION: "Podrobná správa bola uložená do súboru crash_report.txt. Priložte tento súbor k hláseniu chyby."
+STR_CRASH_REASON: "Dôvod zlyhania:"
+STR_CRASH_NO_REASON: "(Nebola zaznamenaná žiadna príčina)"
+STR_TILT_PAGE_TURN: "Otáčanie strán naklonením"
+STR_KB_HINT_MOVE_CURSOR: "Stlačte VĽAVO alebo VPRAVO pre presun kurzora"
+STR_KB_HINT_RETURN_CURSOR: "Stlačte VĽAVO pre návrat na pozíciu kurzora"
+STR_KB_HINT_HIDE_PASSWORD: "Podržte VPRAVO a potom stlačte [***] na skrytie hesla"
+STR_KB_HINT_SHOW_PASSWORD: "Podržte VPRAVO a potom stlačte [abc] na zobrazenie hesla"
+STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "Stlačte [***] na skrytie hesla"
+STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "Stlačte [abc] na zobrazenie hesla"
+STR_KB_HINT_EDIT_ENTRY: "Podržte HORE pre úpravu položky"
+STR_KB_TIPS: "Tipy:"
+STR_KB_HINT_RETURN_KEYBOARD: "Stlačte DOLE pre návrat ku klávesnici"
+STR_KB_HINT_EXIT_URL_MODE: "Stlačte ABC pre ukončenie režimu URL"
+STR_KB_HINT_CLEAR_TEXT: "Podržte DEL pre vymazanie celého textu"
+STR_KB_HINT_SECONDARY_CHAR: "Podržte SELECT pre alternatívny znak"
+STR_KB_HINT_UPPER_SECONDARY: "Podržte SELECT pre VEĽKÉ písmeno alebo alternatívny znak"
+STR_KB_HINT_LOWER_SECONDARY: "Podržte SELECT pre malé písmeno alebo alternatívny znak"
+STR_KB_HINT_URL_SNIPPETS: "Stlačte URL pre úryvky"
+STR_SD_FIRMWARE_UPDATE: "Aktualizácia firmvéru z SD karty"
+STR_SELECT_FIRMWARE_FILE: "Vyberte súbor firmvéru (.bin)"
+STR_NO_BIN_FILES: "Nenašli sa žiadne súbory .bin"
+STR_VALIDATING_FIRMWARE: "Overuje sa firmvér..."
+STR_INVALID_FIRMWARE: "Neplatný súbor firmvéru"
+STR_FIRMWARE_TOO_LARGE: "Firmvér je príliš veľký pre partíciu"
+STR_FIRMWARE_TOO_SMALL: "Súbor firmvéru je príliš malý"
+STR_FIRMWARE_UPDATE_PROMPT: "Aktualizovať firmvér?"
+STR_FIRMWARE_FILE_OPEN_FAILED: "Nie je možné otvoriť súbor"
+STR_FIRMWARE_WRITE_FAILED: "Zápis firmvéru zlyhal"
+STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nevypínajte zariadenie!"
+STR_RECOVERY_MODE: "Režim obnovenia"
+STR_RECOVERY_MODE_HINT: "Umiestnite firmware.bin do koreňového adresára SD karty a vyberte ho"

lib/I18n/translations/slovenian.yaml

@@ -72,8 +72,10 @@ STR_IMAGES_SUPPRESS: "Zatdi"
 STR_SHORT_PWR_BTN: "Kratek pritisk na gumb za vklop"
 STR_ORIENTATION: "Orientacija branja"
 STR_SIDE_BTN_LAYOUT: "Razpored stranskih gumbov"
+STR_TOUCH_READER_CONTROLS: "Dotikalni nadzor (bralnik)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Usmeri sprednje gumbe"
 STR_LONG_PRESS_SKIP: "Dolgi pritisk za preskok poglavja"
+STR_FONT_PREVIEW_TEXT: "V kožuščku hudobnega fanta stopiclja mizar"
 STR_FONT_FAMILY: "Pisava bralnika"
 STR_FONT_SIZE: "Velikost pisave"
 STR_LINE_SPACING: "Razmik med vrsticami"
@@ -131,7 +133,8 @@ STR_SLEEP: "Spanje"
 STR_PAGE_TURN: "Obračanje strani"
 STR_PORTRAIT: "Pokončno"
 STR_LANDSCAPE_CW: "Ležeče (v smeri urinega kazalca)"
-STR_INVERTED: "Obrnjeno"
+STR_INVERTED: "Invertirano"
+STR_ORIENTATION_INVERTED: "Pokončno 180°"
 STR_LANDSCAPE_CCW: "Ležeče (proti smeri urinega kazalca)"
 STR_PREV_NEXT: "Nazaj/Naprej"
 STR_NEXT_PREV: "Naprej/Nazaj"
@@ -183,6 +186,9 @@ STR_HOME: "« Domov"
 STR_SELECT: "Izberi"
 STR_SELECTED: "Izbrano"
 STR_TOGGLE: "Preklopi"
+STR_TOGGLE_BOOKMARK: "Preklopi zaznamek"
+STR_BOOKMARK_REMOVED: "Zaznamek odstranjen."
+STR_HOLD_OPEN_TO_DELETE: "Držite Odpri za brisanje"
 STR_CONFIRM: "Potrdi"
 STR_CANCEL: "Prekliči"
 STR_CONNECT: "Poveži"

lib/I18n/translations/spanish.yaml

@@ -72,11 +72,14 @@ STR_IMAGES_SUPPRESS: "Ocultar"
 STR_SHORT_PWR_BTN: "Toque corto del encendido"
 STR_ORIENTATION: "Orientación"
 STR_SIDE_BTN_LAYOUT: "Función botones laterales (lector)"
+STR_TOUCH_READER_CONTROLS: "Controles táctiles (lector)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botones frontales"
 STR_LONG_PRESS_BEHAVIOR: "Al mantener pulsado un botón"
 STR_LONG_PRESS_BEHAVIOR_OFF: "No hacer nada"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saltar capítulo"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Cambiar orient."
+STR_LONG_PRESS_MENU: "Función de pulsación larga"
+STR_FONT_PREVIEW_TEXT: "Benjamín pidió una bebida de kiwi y fresa. Noé, sin vergüenza, la más exquisita champaña del menú"
 STR_FONT_FAMILY: "Tipografía"
 STR_FONT_SIZE: "Tamaño"
 STR_LINE_SPACING: "Interlineado"
@@ -136,9 +139,12 @@ STR_FORCE_REFRESH: "Refrescar pant."
 STR_PORTRAIT: "Vertical"
 STR_LANDSCAPE_CW: "Horizontal (horario)"
 STR_INVERTED: "Invertido"
+STR_ORIENTATION_INVERTED: "Al revés"
 STR_LANDSCAPE_CCW: "Horizontal (antihorario)"
 STR_PREV_NEXT: "Ant./Sig."
 STR_NEXT_PREV: "Sig./Ant."
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Marcador"
 STR_DISABLED: "Desactivados"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -174,8 +180,7 @@ STR_DOWNLOADING: "Descargando..."
 STR_DOWNLOAD_FAILED: "Fallo de descarga"
 STR_ERROR_MSG: "Error:"
 STR_UNNAMED: "Sin nombre"
-STR_HOLD_CONFIRM_TO_DELETE: "Mantenga pulsado Confirmar para borrar"
-STR_BOOKMARK_INSTRUCTIONS: "Mantenga pulsado Confirmar en el lector para crear un marcador."
+STR_HOLD_OPEN_TO_DELETE: "Mantenga pulsado Abrir para borrar"
 STR_NO_SERVER_URL: "No se configuró URL de servidor"
 STR_FETCH_FEED_FAILED: "Fallo al obtener el feed"
 STR_PARSE_FEED_FAILED: "Fallo al procesar el feed"
@@ -193,6 +198,7 @@ STR_HOME: "« Inicio"
 STR_SELECT: "Selecc."
 STR_SELECTED: "Seleccionado"
 STR_TOGGLE: "Cambiar"
+STR_TOGGLE_BOOKMARK: "Alternar marcador"
 STR_CONFIRM: "Confirmar"
 STR_CANCEL: "Cancelar"
 STR_CONNECT: "Conectar"
@@ -256,6 +262,7 @@ STR_QUICK_RESUME_TIMEOUT: "Reanudación rápida tras tiempo"
 STR_REMAP_FRONT_BUTTONS: "Reconfigurar botones frontales"
 STR_BOOKMARKS: "Marcadores"
 STR_BOOKMARK_ADDED: "Marcador añadido."
+STR_BOOKMARK_REMOVED: "Marcador eliminado."
 STR_OPDS_BROWSER: "Navegador OPDS"
 STR_SEARCH: "Buscar"
 STR_COVER_CUSTOM: "Portada + Pers."
@@ -318,8 +325,9 @@ STR_BOOK_S_STYLE: "Estilo del libro"
 STR_EMBEDDED_STYLE: "Estilo integrado"
 STR_FOCUS_READING: "Lectura enfocada"
 STR_OPDS_SERVER_URL: "URL del servidor OPDS"
+STR_PWR_BTN_FOOTNOTE_BACK: "Retorno rápido desde las notas al pie"
 STR_SET_SLEEP_COVER: "Pant. sus."
-STR_FOOTNOTES: "Pie de página"
+STR_FOOTNOTES: "Notas al pie"
 STR_NO_FOOTNOTES: "No hay notas al pie de esta página"
 STR_LINK: "[enlace]"
 STR_SLEEP_TIMER_VALUE_FORMAT: "%u min."

lib/I18n/translations/swedish.yaml

@@ -73,11 +73,13 @@ STR_IMAGES_SUPPRESS: "Dölj"
 STR_SHORT_PWR_BTN: "Kort strömknappsklick"
 STR_ORIENTATION: "Läsrikting"
 STR_SIDE_BTN_LAYOUT: "Sidoknappslayout (Läsare)"
+STR_TOUCH_READER_CONTROLS: "Pekkontroller (läsare)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Rikta främre knappar"
 STR_LONG_PRESS_BEHAVIOR: "Beteende vid lång knapptryckning"
 STR_LONG_PRESS_BEHAVIOR_OFF: "AV"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Hoppa över kapitel"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Ändra orientering"
+STR_FONT_PREVIEW_TEXT: "Flygande bäckasiner söka hwila på mjuka tuvor"
 STR_FONT_FAMILY: "Eboksläsarens typsnittsfamilj"
 STR_FONT_SIZE: "Eboksläsarens typsnittsstorlek"
 STR_LINE_SPACING: "Eboksläsarens linjemellanrum"
@@ -137,6 +139,7 @@ STR_FORCE_REFRESH: "Uppdatera skärmen"
 STR_PORTRAIT: "Porträtt"
 STR_LANDSCAPE_CW: "Landskap medurs"
 STR_INVERTED: "Inverterad"
+STR_ORIENTATION_INVERTED: "Porträtt 180°"
 STR_LANDSCAPE_CCW: "Landskap moturs"
 STR_PREV_NEXT: "Förra/Nästa"
 STR_NEXT_PREV: "Nästa/Förra"
@@ -175,8 +178,7 @@ STR_DOWNLOADING: "Laddar ner…"
 STR_DOWNLOAD_FAILED: "Nedladdning misslyckades"
 STR_ERROR_MSG: "Fel:"
 STR_UNNAMED: "Ej namngiven"
-STR_HOLD_CONFIRM_TO_DELETE: "Håll ned Bekräfta för att radera"
-STR_BOOKMARK_INSTRUCTIONS: "Håll Bekräfta i läsaren för att skapa ett bokmärke."
+STR_HOLD_OPEN_TO_DELETE: "Håll ned Öppna för att radera"
 STR_NO_SERVER_URL: "Ingen serveradress konfigurerad"
 STR_FETCH_FEED_FAILED: "Misslyckades att hämta flöde"
 STR_PARSE_FEED_FAILED: "Misslyckades att analysera flöde"
@@ -194,6 +196,7 @@ STR_HOME: "« Hem"
 STR_SELECT: "Välj "
 STR_SELECTED: "Vald"
 STR_TOGGLE: "Växla"
+STR_TOGGLE_BOOKMARK: "Växla bokmärke"
 STR_CONFIRM: "Bekräfta"
 STR_CANCEL: "Avbryt"
 STR_CONNECT: "Anslut"
@@ -257,6 +260,7 @@ STR_QUICK_RESUME_TIMEOUT: "Snabb återupptagning efter timeout"
 STR_REMAP_FRONT_BUTTONS: "Ändra frontknappar"
 STR_BOOKMARKS: "Bokmärken"
 STR_BOOKMARK_ADDED: "Bokmärke tillagt."
+STR_BOOKMARK_REMOVED: "Bokmärke borttaget."
 STR_OPDS_BROWSER: "OPDS-webbläsare"
 STR_SEARCH: "Sök"
 STR_COVER_CUSTOM: "Omslag + Valfri"

lib/I18n/translations/turkish.yaml

@@ -67,11 +67,13 @@ STR_TEXT_AA: "Metin Yumuşatma (AA)"
 STR_SHORT_PWR_BTN: "Kısa Güç Tuşu Tıklaması"
 STR_ORIENTATION: "Okuma Yönü"
 STR_SIDE_BTN_LAYOUT: "Yan Tuş Dizilimi (okuyucu)"
+STR_TOUCH_READER_CONTROLS: "Dokunmatik okuyucu kontrolleri"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ön düğmeleri yönlendir"
 STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Chapter skip"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Orientation change"
+STR_FONT_PREVIEW_TEXT: "Pijamalı hasta yağız şoföre çabucak güvendi"
 STR_FONT_FAMILY: "Okuyucu Yazı Tipi Ailesi"
 STR_FONT_SIZE: "Arayüz Yazı Boyutu"
 STR_LINE_SPACING: "Okuyucu Satır Aralığı"
@@ -129,7 +131,8 @@ STR_SLEEP: "Uyku"
 STR_PAGE_TURN: "Sayfa Çevirme"
 STR_PORTRAIT: "Dikey"
 STR_LANDSCAPE_CW: "Yatay (Saat Yönü)"
-STR_INVERTED: "Ters"
+STR_INVERTED: "Negatif"
+STR_ORIENTATION_INVERTED: "Dikey 180°"
 STR_LANDSCAPE_CCW: "Yatay (Saat Yönü Tersi)"
 STR_PREV_NEXT: "Önceki/Sonraki"
 STR_NEXT_PREV: "Sonraki/Önceki"
@@ -180,6 +183,9 @@ STR_EXIT: "« Çıkış"
 STR_HOME: "« Ana Sayfa"
 STR_SELECT: "Seç"
 STR_TOGGLE: "Değiştir"
+STR_TOGGLE_BOOKMARK: "Yer imini değiştir"
+STR_BOOKMARK_REMOVED: "Yer imi kaldırıldı."
+STR_HOLD_OPEN_TO_DELETE: "Silmek için Aç düğmesini basılı tutun"
 STR_CONFIRM: "Onayla"
 STR_CANCEL: "İptal"
 STR_CONNECT: "Bağlan"

lib/I18n/translations/ukrainian.yaml

@@ -61,6 +61,7 @@ STR_CAT_READER: "Читач"
 STR_CAT_CONTROLS: "Кнопки"
 STR_CAT_SYSTEM: "Система"
 STR_SLEEP_SCREEN: "Екран у режимі сну"
+STR_QUICK_RESUME_TIMEOUT: "Швидке поверн. після таймауту"
 STR_SLEEP_COVER_MODE: "Режим заповнення"
 STR_HIDE_BATTERY: "Приховати % батареї"
 STR_EXTRA_SPACING: "Додатковий інтервал між абзацами"
@@ -72,11 +73,13 @@ STR_IMAGES_SUPPRESS: "Приховати"
 STR_SHORT_PWR_BTN: "Короткий натиск кн. живл."
 STR_ORIENTATION: "Орієнтація читання"
 STR_SIDE_BTN_LAYOUT: "Схема бічних кнопок"
+STR_TOUCH_READER_CONTROLS: "Сенсорне керування читанням"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Орієнтувати передні кнопки"
 STR_LONG_PRESS_BEHAVIOR: "Поведінка при довгому настику"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Немає"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Наступ. розділ (утримув.)"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Зміна орієнтації екрану"
+STR_FONT_PREVIEW_TEXT: "Єхидна, ґава, їжак ще й шиплячі плазуни бігцем форсують Янцзи"
 STR_FONT_FAMILY: "Шрифт"
 STR_FONT_SIZE: "Розмір шрифту"
 STR_LINE_SPACING: "Міжрядковий інтервал"
@@ -85,8 +88,8 @@ STR_PARA_ALIGNMENT: "Вирівнювання тексту"
 STR_HYPHENATION: "Перенесення слів"
 STR_TIME_TO_SLEEP: "Перехід в режим сну"
 STR_SHOW_HIDDEN_FILES: "Показати приховані файли"
-STR_REMOVE_READ_FROM_RECENTS: "Очищати прочитані книги зі списку останніх"
-STR_MOVE_FINISHED_TO_READ: "Переміщати прочитані книги до теки Read"
+STR_REMOVE_READ_FROM_RECENTS: "Приховувати прочитані книги"
+STR_MOVE_FINISHED_TO_READ: "Переміщати прочит. в теку Read"
 STR_REFRESH_FREQ: "Частота оновлення екрану"
 STR_KOREADER_SYNC: "Синхронізація KOReader"
 STR_CHECK_UPDATES: "Перевірити оновлення системи"
@@ -135,10 +138,12 @@ STR_PAGE_TURN: "Наст. сторінка"
 STR_FORCE_REFRESH: "Оновити екран"
 STR_PORTRAIT: "Книжкова"
 STR_LANDSCAPE_CW: "Альбом. за год."
-STR_INVERTED: "Перевернутий"
+STR_INVERTED: "Інверсія"
+STR_ORIENTATION_INVERTED: "Книжкова 180°"
 STR_LANDSCAPE_CCW: "Альбом. проти год."
 STR_PREV_NEXT: "Попер/Наст"
 STR_NEXT_PREV: "Наст/Попер"
+STR_DISABLED: "Вимкнуто"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
 STR_SMALL: "Малий"
@@ -173,6 +178,7 @@ STR_DOWNLOADING: "Завантаження..."
 STR_DOWNLOAD_FAILED: "Завантаження не вдалося"
 STR_ERROR_MSG: "Помилка:"
 STR_UNNAMED: "Без назви"
+STR_HOLD_OPEN_TO_DELETE: "Утримуйте Відкрити, щоб видалити"
 STR_NO_SERVER_URL: "URL сервера не налаштовано"
 STR_FETCH_FEED_FAILED: "Не вдалося отримати стрічку"
 STR_PARSE_FEED_FAILED: "Не вдалося розпарсити стрічку"
@@ -190,6 +196,7 @@ STR_HOME: "« Додому"
 STR_SELECT: "Вибрати"
 STR_SELECTED: "Вибрано"
 STR_TOGGLE: "Обрати"
+STR_TOGGLE_BOOKMARK: "Перемкнути закладку"
 STR_CONFIRM: "Підтвердити"
 STR_CANCEL: "Скасувати"
 STR_CONNECT: "Приєдн."
@@ -228,18 +235,35 @@ STR_BATTERY: "Акумулятор"
 STR_XTC_STATUS_BAR: "XTC Рядок прогресу"
 STR_BOTTOM: "Низ"
 STR_TOP: "Верх"
+STR_CLOCK: "Годинник"
+STR_CLOCK_UTC_OFFSET: "Часовий пояс"
+STR_CLOCK_FORMAT: "Формат Годинника"
+STR_CLOCK_FORMAT_24H: "24-години"
+STR_CLOCK_FORMAT_12H: "12-годин"
+STR_CURRENT_TIME: "Поточний час:"
+STR_NEXT_FIELD: "наступний"
+STR_CLOCK_SYNC: "Синхр. Годинник"
+STR_CLOCK_SYNC_NOW: "Синхр. годин. зараз"
+STR_CLOCK_SYNCING: "Синхр. через NTP..."
+STR_CLOCK_SYNC_OK: "Успішна синхр."
+STR_CLOCK_SYNC_FAIL: "Невдала синхр. "
+STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi не під'єднано"
+STR_CLOCK_SYNC_NO_WIFI_HINT: "Під'єднайтесь спершу до Wi-Fi, тоді спробуйте знову."
+STR_CLOCK_SYNCED: "Годинник синхр."
 STR_UI_THEME: "Тема інтерфейсу"
 STR_THEME_CLASSIC: "Класична"
 STR_THEME_LYRA: "Lyra"
 STR_THEME_ROUNDEDRAFF: "RoundedRaff"
 STR_THEME_LYRA_EXTENDED: "Lyra Extended"
 STR_SUNLIGHT_FADING_FIX: "Виправлення вицвітання на сонці"
-STR_QUICK_RESUME_TIMEOUT: "Швидке продовження після таймауту"
 STR_REMAP_FRONT_BUTTONS: "Налаштувати передні кнопки"
+STR_BOOKMARKS: "Закладки"
+STR_BOOKMARK_ADDED: "Закладку додано"
+STR_BOOKMARK_REMOVED: "Закладку видалено"
 STR_OPDS_BROWSER: "Браузер OPDS"
 STR_SEARCH: "Пошук"
 STR_COVER_CUSTOM: "Обкл. + власне"
-STR_QUICK_RESUME: "Швидке продовження"
+STR_QUICK_RESUME: "Швидке поверн."
 STR_MENU_RECENT_BOOKS: "Останні книги"
 STR_REMOVE_FROM_RECENTS: "Видалити з останніх книг?"
 STR_NO_RECENT_BOOKS: "Немає останніх книг"
@@ -265,6 +289,7 @@ STR_GO_HOME_BUTTON: "На головну"
 STR_SYNC_PROGRESS: "Прогрес синхронізації"
 STR_DELETE_CACHE: "Видалити кеш книги"
 STR_DELETE: "Видалити"
+STR_CONFIRM_DELETE_BOOKMARK: "Видалити цю закладку?"
 STR_DISPLAY_QR: "Показати сторінку як QR-код"
 STR_CHAPTER_PREFIX: "Розділ: "
 STR_PAGES_SEPARATOR: " сторінок  |  "
@@ -297,14 +322,15 @@ STR_BOOK_S_STYLE: "Стиль книги"
 STR_EMBEDDED_STYLE: "Вбудований стиль"
 STR_FOCUS_READING: "Фокусне читання"
 STR_OPDS_SERVER_URL: "URL сервера OPDS"
+STR_PWR_BTN_FOOTNOTE_BACK: "Швидке повернення з приміток"
 STR_SET_SLEEP_COVER: "Як обкл."
 STR_FOOTNOTES: "Примітки"
 STR_NO_FOOTNOTES: "На цій сторінці немає приміток"
 STR_LINK: "[посилання]"
+STR_SCREENSHOT_BUTTON: "Знімок екрана"
 STR_SLEEP_TIMER_VALUE_FORMAT: "%u хв"
 STR_SLEEP_NEVER: "Ніколи"
 STR_SLEEP_TIMER_STEP_HINT: "Вліво/Вправо: 1 хв  Вгору/Вниз: 5 хв"
-STR_SCREENSHOT_BUTTON: "Знімок екрана"
 STR_ADD_SERVER: "Додати сервер"
 STR_SERVER_NAME: "Назва сервера"
 STR_NO_SERVERS: "Не налаштовано жодного сервера OPDS"

lib/I18n/translations/valencian.yaml

@@ -73,11 +73,14 @@ STR_IMAGES_SUPPRESS: "Eliminar"
 STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada"
 STR_ORIENTATION: "Orientació de lectura"
 STR_SIDE_BTN_LAYOUT: "Disposició botons laterals"
+STR_TOUCH_READER_CONTROLS: "Controls tàctils del lector"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals"
 STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Saltar capítols"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Canvi d'orientació"
+STR_LONG_PRESS_MENU: "Funció de pulsació llarga"
+STR_FONT_PREVIEW_TEXT: "Jove xef, porti whisky amb quinze glaçons d'hidrogen, coi!"
 STR_FONT_FAMILY: "Família de fonts"
 STR_FONT_SIZE: "Grandària de la lletra (UI)"
 STR_LINE_SPACING: "Interlineat del lector"
@@ -139,9 +142,12 @@ STR_PAGE_TURN: "Canvi de pàgina"
 STR_PORTRAIT: "Vertical"
 STR_LANDSCAPE_CW: "Horitzontal horari"
 STR_INVERTED: "Invertit"
+STR_ORIENTATION_INVERTED: "Vertical 180°"
 STR_LANDSCAPE_CCW: "Horitzontal antihorari"
 STR_PREV_NEXT: "Anterior/Següent"
 STR_NEXT_PREV: "Següent/Anterior"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Punt de llibre"
 STR_DISABLED: "Desactivats"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -176,8 +182,7 @@ STR_DOWNLOADING: "S'està baixant..."
 STR_DOWNLOAD_FAILED: "Ha fallat la baixada"
 STR_ERROR_MSG: "Error:"
 STR_UNNAMED: "Sense nom"
-STR_HOLD_CONFIRM_TO_DELETE: "Manteniu premut Confirma per esborrar"
-STR_BOOKMARK_INSTRUCTIONS: "Manteniu premut Confirma al lector per crear un punt de llibre."
+STR_HOLD_OPEN_TO_DELETE: "Manteniu premut Obre per esborrar"
 STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor"
 STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed"
 STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed"
@@ -193,6 +198,7 @@ STR_HOME: "« Inici"
 STR_SELECT: "Selecciona"
 STR_SELECTED: "Seleccionat"
 STR_TOGGLE: "Canvia"
+STR_TOGGLE_BOOKMARK: "Canvia punt de llibre"
 STR_CONFIRM: "Confirma"
 STR_CANCEL: "Cancel·la"
 STR_CONNECT: "Connecta"
@@ -236,6 +242,7 @@ STR_SUNLIGHT_FADING_FIX: "Correcció de l'esvaïment pel sol"
 STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals"
 STR_BOOKMARKS: "Punts de llibre"
 STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre."
+STR_BOOKMARK_REMOVED: "S'ha eliminat el punt de llibre."
 STR_OPDS_BROWSER: "Navegador OPDS"
 STR_COVER_CUSTOM: "Portada + Personalitzat"
 STR_QUICK_RESUME: "Represa ràpida"
@@ -297,6 +304,7 @@ STR_BOOK_S_STYLE: "Estil del llibre"
 STR_EMBEDDED_STYLE: "Estil incrustat"
 STR_FOCUS_READING: "Lectura enfocada"
 STR_OPDS_SERVER_URL: "URL del servidor OPDS"
+STR_PWR_BTN_FOOTNOTE_BACK: "Retorn ràpid des de les notes al peu"
 STR_FOOTNOTES: "Notes al peu"
 STR_NO_FOOTNOTES: "No hi ha notes al peu en esta pàgina"
 STR_LINK: "[enllaç]"

lib/I18n/translations/vietnamese.yaml

@@ -73,11 +73,13 @@ STR_IMAGES_SUPPRESS: "Ẩn đi"
 STR_SHORT_PWR_BTN: "Nhấn nhanh nút nguồn"
 STR_ORIENTATION: "Hướng đọc"
 STR_SIDE_BTN_LAYOUT: "Bố trí nút bên (trình đọc)"
+STR_TOUCH_READER_CONTROLS: "Điều khiển cảm ứng (trình đọc)"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Xoay nút trước theo hướng"
 STR_LONG_PRESS_BEHAVIOR: "Hành vi nhấn giữ nút"
 STR_LONG_PRESS_BEHAVIOR_OFF: "TẮT"
 STR_LONG_PRESS_BEHAVIOR_SKIP: "Nhảy chương"
 STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Đổi hướng"
+STR_FONT_PREVIEW_TEXT: "Trường quê em do bố của em xây kĩ nên sạch và đẹp lắm"
 STR_FONT_FAMILY: "Phông chữ trình đọc"
 STR_FONT_SIZE: "Cỡ chữ trình đọc"
 STR_LINE_SPACING: "Giãn dòng trình đọc"
@@ -136,7 +138,8 @@ STR_PAGE_TURN: "Lật trang"
 STR_FORCE_REFRESH: "Làm tươi màn hình"
 STR_PORTRAIT: "Dọc"
 STR_LANDSCAPE_CW: "Ngang (thuận)"
-STR_INVERTED: "Lật ngược"
+STR_INVERTED: "Đảo màu"
+STR_ORIENTATION_INVERTED: "Dọc 180°"
 STR_LANDSCAPE_CCW: "Ngang (ngược)"
 STR_PREV_NEXT: "Trước/Sau"
 STR_NEXT_PREV: "Sau/Trước"
@@ -175,8 +178,7 @@ STR_DOWNLOADING: "Đang tải về..."
 STR_DOWNLOAD_FAILED: "Tải về thất bại"
 STR_ERROR_MSG: "Lỗi:"
 STR_UNNAMED: "Không tên"
-STR_HOLD_CONFIRM_TO_DELETE: "Giữ Xác nhận để xóa"
-STR_BOOKMARK_INSTRUCTIONS: "Giữ Xác nhận trong trình đọc để tạo dấu trang."
+STR_HOLD_OPEN_TO_DELETE: "Giữ Mở để xóa"
 STR_NO_SERVER_URL: "Chưa cấu hình URL máy chủ"
 STR_FETCH_FEED_FAILED: "Không tải được nguồn cấp"
 STR_PARSE_FEED_FAILED: "Không phân tích được nguồn cấp"
@@ -194,6 +196,7 @@ STR_HOME: "« Thư viện"
 STR_SELECT: "Chọn"
 STR_SELECTED: "Đã chọn"
 STR_TOGGLE: "Bật/Tắt"
+STR_TOGGLE_BOOKMARK: "Bật/tắt dấu trang"
 STR_CONFIRM: "Xác nhận"
 STR_CANCEL: "Hủy"
 STR_CONNECT: "Kết nối"
@@ -256,6 +259,7 @@ STR_SUNLIGHT_FADING_FIX: "Khắc phục mờ dưới nắng"
 STR_REMAP_FRONT_BUTTONS: "Gán lại nút mặt trước"
 STR_BOOKMARKS: "Dấu trang"
 STR_BOOKMARK_ADDED: "Đã thêm dấu trang."
+STR_BOOKMARK_REMOVED: "Đã xóa dấu trang."
 STR_OPDS_BROWSER: "Trình duyệt OPDS"
 STR_SEARCH: "Tìm kiếm"
 STR_COVER_CUSTOM: "Ảnh bìa + Tùy chỉnh"

lib/JpegToBmpConverter/JpegToBmpConverter.cpp

@@ -164,6 +164,7 @@ namespace {
 constexpr int MAX_MCU_HEIGHT = 16;
 constexpr size_t JPEG_DECODER_SIZE = 20 * 1024;
 constexpr size_t MIN_FREE_HEAP = JPEG_DECODER_SIZE + 32 * 1024;
+constexpr uint32_t FP_ONE = 1UL << 16;
 
 // Static file pointer for JPEGDEC open callback.
 // Safe in single-threaded embedded context; never accessed concurrently.
@@ -208,6 +209,9 @@ struct BmpConvertCtx {
   bool needsScaling;
   uint32_t scaleX_fp;  // source pixels per output pixel, 16.16 fixed-point
   uint32_t scaleY_fp;
+  bool smoothUpscale;
+  uint32_t smoothScaleX_fp;
+  uint32_t smoothScaleY_fp;
 
   // Accumulates one MCU row (up to MAX_MCU_HEIGHT source rows × srcWidth pixels)
   // Filled column-by-column as JPEGDEC callbacks arrive for the same MCU row
@@ -219,6 +223,13 @@ struct BmpConvertCtx {
   std::unique_ptr<uint32_t[]> rowAccum;
   std::unique_ptr<uint32_t[]> rowCount;
 
+  int smoothNextOutY;
+  int smoothPrevY;
+  std::unique_ptr<uint8_t[]> smoothRows;
+  uint8_t* smoothPrevRow;
+  uint8_t* smoothCurrRow;
+  uint8_t* smoothOutRow;
+
   std::unique_ptr<uint8_t[]> bmpRow;
 
   std::unique_ptr<AtkinsonDitherer> atkinsonDitherer;
@@ -265,6 +276,88 @@ static void writeOutputRow(BmpConvertCtx* ctx, const uint8_t* srcRow, int outY)
   ctx->bmpOut->write(ctx->bmpRow.get(), ctx->bytesPerRow);
 }
 
+// Matches the progressive-JPEG smoothing used by JpegToFramebufferConverter, but stays
+// local because cover generation streams dithered BMP rows instead of framebuffer pixels.
+static uint32_t interpolationStep(const int srcSize, const int outSize) {
+  if (srcSize <= 1 || outSize <= 1) return 0;
+  return (static_cast<uint32_t>(srcSize - 1) << 16) / static_cast<uint32_t>(outSize - 1);
+}
+
+static uint32_t interpolatedSourceFp(const int outIndex, const int outSize, const int srcSize, const uint32_t step) {
+  if (srcSize <= 1 || outSize <= 1) return 0;
+  if (outIndex >= outSize - 1) return static_cast<uint32_t>(srcSize - 1) << 16;
+  return static_cast<uint32_t>(outIndex) * step;
+}
+
+static void scaleRowLinear(BmpConvertCtx* ctx, const uint8_t* srcRow, uint8_t* dstRow) {
+  for (int outX = 0; outX < ctx->outWidth; outX++) {
+    const uint32_t srcX_fp = interpolatedSourceFp(outX, ctx->outWidth, ctx->srcWidth, ctx->smoothScaleX_fp);
+    const int x0 = srcX_fp >> 16;
+    const int x1 = (x0 + 1 < ctx->srcWidth) ? (x0 + 1) : x0;
+    const uint32_t fx = srcX_fp & (FP_ONE - 1);
+    dstRow[outX] = static_cast<uint8_t>((srcRow[x0] * (FP_ONE - fx) + srcRow[x1] * fx) >> 16);
+  }
+}
+
+static void writeBlendedRow(BmpConvertCtx* ctx, const uint8_t* row0, const uint8_t* row1, const uint32_t fy,
+                            const int outY) {
+  const uint32_t invFy = FP_ONE - fy;
+  for (int outX = 0; outX < ctx->outWidth; outX++) {
+    ctx->smoothOutRow[outX] = static_cast<uint8_t>((row0[outX] * invFy + row1[outX] * fy) >> 16);
+  }
+  writeOutputRow(ctx, ctx->smoothOutRow, outY);
+}
+
+static void processSmoothSourceRow(BmpConvertCtx* ctx, const uint8_t* srcRow, const int srcY) {
+  scaleRowLinear(ctx, srcRow, ctx->smoothCurrRow);
+
+  if (ctx->smoothPrevY < 0) {
+    uint8_t* tmp = ctx->smoothPrevRow;
+    ctx->smoothPrevRow = ctx->smoothCurrRow;
+    ctx->smoothCurrRow = tmp;
+    ctx->smoothPrevY = srcY;
+    if (ctx->srcHeight <= 1) {
+      while (ctx->smoothNextOutY < ctx->outHeight) {
+        writeOutputRow(ctx, ctx->smoothPrevRow, ctx->smoothNextOutY);
+        ctx->smoothNextOutY++;
+      }
+      return;
+    }
+    return;
+  }
+
+  while (ctx->smoothNextOutY < ctx->outHeight) {
+    const uint32_t srcY_fp =
+        interpolatedSourceFp(ctx->smoothNextOutY, ctx->outHeight, ctx->srcHeight, ctx->smoothScaleY_fp);
+    const int y0 = srcY_fp >> 16;
+    const int y1 = (y0 + 1 < ctx->srcHeight) ? (y0 + 1) : y0;
+    if (y1 > srcY) break;
+
+    const uint8_t* row0 = (y0 == srcY) ? ctx->smoothCurrRow : ctx->smoothPrevRow;
+    const uint8_t* row1 = (y1 == srcY) ? ctx->smoothCurrRow : ctx->smoothPrevRow;
+    writeBlendedRow(ctx, row0, row1, srcY_fp & (FP_ONE - 1), ctx->smoothNextOutY);
+    ctx->smoothNextOutY++;
+  }
+
+  uint8_t* tmp = ctx->smoothPrevRow;
+  ctx->smoothPrevRow = ctx->smoothCurrRow;
+  ctx->smoothCurrRow = tmp;
+  ctx->smoothPrevY = srcY;
+}
+
+static void finishSmoothUpscale(BmpConvertCtx* ctx) {
+  if (ctx->smoothPrevY < 0) {
+    LOG_ERR("JPG", "No progressive rows decoded for smoothing");
+    ctx->error = true;
+    return;
+  }
+
+  while (ctx->smoothNextOutY < ctx->outHeight) {
+    writeOutputRow(ctx, ctx->smoothPrevRow, ctx->smoothNextOutY);
+    ctx->smoothNextOutY++;
+  }
+}
+
 // Flush one scaled output row from Y-axis accumulators and advance currentOutY
 static void flushScaledRow(BmpConvertCtx* ctx) {
   memset(ctx->bmpRow.get(), 0, ctx->bytesPerRow);
@@ -344,7 +437,9 @@ int bmpDrawCallback(JPEGDRAW* pDraw) {
   for (int y = blockY; y < endRow && y < ctx->srcHeight; y++) {
     const uint8_t* srcRow = ctx->mcuBuf.get() + (y - blockY) * ctx->srcWidth;
 
-    if (!ctx->needsScaling) {
+    if (ctx->smoothUpscale) {
+      processSmoothSourceRow(ctx, srcRow, y);
+    } else if (!ctx->needsScaling) {
       // 1:1 — outWidth == srcWidth, write directly
       writeOutputRow(ctx, srcRow, y);
     } else {
@@ -472,6 +567,9 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
     needsScaling = true;
   }
 
+  const bool smoothUpscale =
+      progressiveDecode && needsScaling && scaleSrcWidth <= outWidth && scaleSrcHeight <= outHeight;
+
   // Write BMP header with output dimensions
   int bytesPerRow;
   if (USE_8BIT_OUTPUT && !oneBit) {
@@ -496,6 +594,11 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
   ctx.needsScaling = needsScaling;
   ctx.scaleX_fp = scaleX_fp;
   ctx.scaleY_fp = scaleY_fp;
+  ctx.smoothUpscale = smoothUpscale;
+  ctx.smoothScaleX_fp = interpolationStep(ctx.srcWidth, outWidth);
+  ctx.smoothScaleY_fp = interpolationStep(ctx.srcHeight, outHeight);
+  ctx.smoothNextOutY = 0;
+  ctx.smoothPrevY = -1;
   ctx.error = false;
 
   // MCU row buffer: MAX_MCU_HEIGHT rows × decoded srcWidth columns of grayscale
@@ -512,7 +615,20 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
     return false;
   }
 
-  if (needsScaling) {
+  if (smoothUpscale) {
+    // One contiguous allocation avoids three heap blocks while keeping smoothing line-buffered.
+    const size_t smoothRowsBytes = static_cast<size_t>(outWidth) * 3;
+    ctx.smoothRows = makeUniqueNoThrow<uint8_t[]>(smoothRowsBytes);
+    if (!ctx.smoothRows) {
+      LOG_ERR("JPG", "OOM: progressive smoothing buffers");
+      return false;
+    }
+    ctx.smoothPrevRow = ctx.smoothRows.get();
+    ctx.smoothCurrRow = ctx.smoothPrevRow + outWidth;
+    ctx.smoothOutRow = ctx.smoothCurrRow + outWidth;
+    LOG_DBG("JPG", "Progressive smoothing: %dx%d -> %dx%d, buffers=%u bytes", ctx.srcWidth, ctx.srcHeight, outWidth,
+            outHeight, static_cast<unsigned>(smoothRowsBytes));
+  } else if (needsScaling) {
     ctx.rowAccum = makeUniqueNoThrow<uint32_t[]>(outWidth);
     ctx.rowCount = makeUniqueNoThrow<uint32_t[]>(outWidth);
     if (!ctx.rowAccum || !ctx.rowCount) {
@@ -549,6 +665,10 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
 
   rc = jpeg->decode(0, 0, 0);
 
+  if (rc == 1 && ctx.smoothUpscale && !ctx.error) {
+    finishSmoothUpscale(&ctx);
+  }
+
   if (rc != 1 || ctx.error) {
     LOG_ERR("JPG", "JPEG decode failed (rc=%d, err=%d)", rc, jpeg->getLastError());
     return false;

lib/KOReaderSync/ProgressMapper.cpp

@@ -30,8 +30,7 @@ int parseIndex(const std::string& xpath, const char* prefix, bool last = false)
 
 int parseCharOffset(const std::string& xpath) {
   const size_t textPos = xpath.rfind("text()");
-  if (textPos == std::string::npos) return 0;
-  const size_t dotPos = xpath.find('.', textPos);
+  const size_t dotPos = (textPos != std::string::npos) ? xpath.find('.', textPos) : xpath.rfind('.');
   if (dotPos == std::string::npos || dotPos + 1 >= xpath.size()) return 0;
   int val = 0;
   for (size_t i = dotPos + 1; i < xpath.size(); i++) {
@@ -104,7 +103,13 @@ bool isChapterStartXPath(const std::string& xpath) {
   if (dotPos == std::string::npos || dotPos <= bodyContentStart || dotPos + 1 >= xpath.size()) {
     return false;
   }
-  if (xpath.find('/', bodyContentStart) != std::string::npos) {
+  size_t terminalEnd = dotPos;
+  static constexpr char kTextNode[] = "/text()";
+  const size_t textNodePos = xpath.rfind(kTextNode, dotPos);
+  if (textNodePos != std::string::npos && textNodePos >= bodyContentStart) {
+    terminalEnd = textNodePos;
+  }
+  if (xpath.find('/', bodyContentStart) < terminalEnd) {
     return false;
   }
 
@@ -122,7 +127,7 @@ struct XPathStep {
 
 static constexpr int MAX_XPATH_DEPTH = 16;
 
-// Parse the XPath segment between /body/DocFragment[N]/body/ and text()[N].offset
+// Parse the XPath segment between /body/DocFragment[N]/body/ and the terminal position
 // into an ordered sequence of steps. Returns step count, 0 on failure.
 // Example input: "/body/DocFragment[1]/body/div[1]/ul/li[4]/text()[1].51"
 // Fills steps with: {div,1}, {ul,1}, {li,4}
@@ -136,13 +141,20 @@ int parseXPathSteps(const std::string& xpath, XPathStep steps[MAX_XPATH_DEPTH])
   if (xpath.compare(afterBracket + 1, strlen(kBody), kBody) != 0) return 0;
   size_t pos = afterBracket + 1 + strlen(kBody);
 
-  const size_t textPos = xpath.rfind("/text()");
-  if (textPos == std::string::npos || textPos <= pos) return 0;
+  size_t stepsEnd = xpath.rfind("/text()");
+  if (stepsEnd == std::string::npos) {
+    stepsEnd = xpath.rfind('.');
+    if (stepsEnd == std::string::npos || stepsEnd <= pos || stepsEnd + 1 >= xpath.size()) return 0;
+    for (size_t i = stepsEnd + 1; i < xpath.size(); i++) {
+      if (xpath[i] < '0' || xpath[i] > '9') return 0;
+    }
+  }
+  if (stepsEnd <= pos) return 0;
 
   int count = 0;
-  while (pos < textPos && count < MAX_XPATH_DEPTH) {
+  while (pos < stepsEnd && count < MAX_XPATH_DEPTH) {
     const size_t slash = xpath.find('/', pos);
-    const size_t segEnd = (slash < textPos) ? slash : textPos;
+    const size_t segEnd = (slash < stepsEnd) ? slash : stepsEnd;
 
     XPathStep& step = steps[count];
     const size_t bracket = xpath.find('[', pos);
@@ -166,7 +178,7 @@ int parseXPathSteps(const std::string& xpath, XPathStep steps[MAX_XPATH_DEPTH])
     }
 
     count++;
-    pos = (slash < textPos) ? slash + 1 : textPos;
+    pos = (slash < stepsEnd) ? slash + 1 : stepsEnd;
   }
   return count;
 }
@@ -223,10 +235,148 @@ class ParagraphStreamer final : public Print {
   char capturedAnchorId[MAX_ANCHOR_ID] = {};
   int capturedAnchorIdLen = 0;
   bool capturingAnchorTag = false;
-  enum IdScanState { ID_SCAN, ID_I, ID_D, ID_EQ, ID_IN_VALUE_D, ID_IN_VALUE_S } idState = ID_SCAN;
+  enum AnchorAttrState {
+    ATTR_FIND_NAME,
+    ATTR_READ_NAME,
+    ATTR_AFTER_NAME,
+    ATTR_BEFORE_VALUE,
+    ATTR_CAPTURE_D,
+    ATTR_CAPTURE_S
+  } attrState = ATTR_FIND_NAME;
+  uint8_t attrNameLen = 0;
+  bool currentAttrIsId = false;
   bool inAttrQuote =
       false;  // true while inside a quoted attribute value (prevents '/' from being treated as self-close)
   char attrQuoteChar = 0;
+  uint8_t nonVisibleDepth = 0;
+
+  bool isNonVisibleTag() const {
+    return strcasecmp(tagName, "head") == 0 || strcasecmp(tagName, "style") == 0 ||
+           strcasecmp(tagName, "script") == 0 || strcasecmp(tagName, "title") == 0;
+  }
+
+  static bool isAttrWhitespace(uint8_t c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }
+
+  static bool isAttrNameChar(uint8_t c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-' ||
+           c == ':' || c == '.';
+  }
+
+  void resetAnchorAttrScan() {
+    attrState = ATTR_FIND_NAME;
+    attrNameLen = 0;
+    currentAttrIsId = false;
+  }
+
+  void finishCapturedAnchorId() {
+    capturedAnchorId[capturedAnchorIdLen] = '\0';
+    capturingAnchorTag = false;
+    resetAnchorAttrScan();
+  }
+
+  void beginAnchorIdScan() {
+    capturingAnchorTag = true;
+    resetAnchorAttrScan();
+  }
+
+  void endAnchorIdScan() {
+    if (capturingAnchorTag) {
+      capturedAnchorIdLen = 0;
+    }
+    capturingAnchorTag = false;
+    resetAnchorAttrScan();
+  }
+
+  void appendCapturedAnchorId(uint8_t c) {
+    if (capturedAnchorIdLen + 1 < MAX_ANCHOR_ID) {
+      capturedAnchorId[capturedAnchorIdLen++] = c;
+    }
+  }
+
+  void scanAnchorAttribute(uint8_t c) {
+    switch (attrState) {
+      case ATTR_FIND_NAME:
+        if (isAttrNameChar(c)) {
+          attrState = ATTR_READ_NAME;
+          attrNameLen = 1;
+          currentAttrIsId = c == 'i';
+        }
+        break;
+      case ATTR_READ_NAME:
+        if (isAttrNameChar(c)) {
+          if (attrNameLen == 1) {
+            currentAttrIsId = currentAttrIsId && c == 'd';
+          } else {
+            currentAttrIsId = false;
+          }
+          attrNameLen++;
+        } else {
+          currentAttrIsId = currentAttrIsId && attrNameLen == 2;
+          if (isAttrWhitespace(c)) {
+            attrState = ATTR_AFTER_NAME;
+          } else if (c == '=') {
+            attrState = ATTR_BEFORE_VALUE;
+          } else {
+            resetAnchorAttrScan();
+          }
+        }
+        break;
+      case ATTR_AFTER_NAME:
+        if (isAttrWhitespace(c)) {
+          break;
+        }
+        if (c == '=') {
+          attrState = ATTR_BEFORE_VALUE;
+        } else if (isAttrNameChar(c)) {
+          attrState = ATTR_READ_NAME;
+          attrNameLen = 1;
+          currentAttrIsId = c == 'i';
+        } else {
+          resetAnchorAttrScan();
+        }
+        break;
+      case ATTR_BEFORE_VALUE:
+        if (isAttrWhitespace(c)) {
+          break;
+        }
+        if (currentAttrIsId && c == '"') {
+          capturedAnchorIdLen = 0;
+          attrState = ATTR_CAPTURE_D;
+        } else if (currentAttrIsId && c == '\'') {
+          capturedAnchorIdLen = 0;
+          attrState = ATTR_CAPTURE_S;
+        } else if (c == '"') {
+          attrState = ATTR_CAPTURE_D;
+        } else if (c == '\'') {
+          attrState = ATTR_CAPTURE_S;
+        } else {
+          resetAnchorAttrScan();
+        }
+        break;
+      case ATTR_CAPTURE_D:
+        if (c == '"') {
+          if (currentAttrIsId) {
+            finishCapturedAnchorId();
+          } else {
+            resetAnchorAttrScan();
+          }
+        } else if (currentAttrIsId) {
+          appendCapturedAnchorId(c);
+        }
+        break;
+      case ATTR_CAPTURE_S:
+        if (c == '\'') {
+          if (currentAttrIsId) {
+            finishCapturedAnchorId();
+          } else {
+            resetAnchorAttrScan();
+          }
+        } else if (currentAttrIsId) {
+          appendCapturedAnchorId(c);
+        }
+        break;
+    }
+  }
 
   void onVisibleCodepoint() {
     totalVisChars++;
@@ -286,15 +436,19 @@ class ParagraphStreamer final : public Print {
   void onOpenTag() {
     htmlDepth++;
 
+    if (nonVisibleDepth > 0 || isNonVisibleTag()) {
+      nonVisibleDepth++;
+      return;
+    }
+
     if (stepCount == 0) {
       if (strcasecmp(tagName, "p") == 0) onLegacyP();
       return;
     }
 
-    // Capture <a id> inside the fully-matched element even after target char is found
+    // Capture a child <a id> inside the fully-matched element even after target char is found.
     if (revPFound && matchedDepth == stepCount && capturedAnchorIdLen == 0 && strcasecmp(tagName, "a") == 0) {
-      capturingAnchorTag = true;
-      idState = ID_SCAN;
+      beginAnchorIdScan();
     }
 
     if (revDone) return;
@@ -315,6 +469,7 @@ class ParagraphStreamer final : public Print {
           stepEnteredAtDepth[matchedDepth] = htmlDepth;
           matchedDepth++;
           if (matchedDepth == stepCount) {
+            beginAnchorIdScan();
             paragraphAtMatch = pCount;
             liCountAtMatch = liCount;
             revPFound = true;
@@ -332,6 +487,12 @@ class ParagraphStreamer final : public Print {
   }
 
   void onCloseTag() {
+    if (nonVisibleDepth > 0) {
+      nonVisibleDepth--;
+      if (htmlDepth > 0) htmlDepth--;
+      return;
+    }
+
     // Legacy mode: each direct child element closing advances the text node index.
     if (stepCount == 0 && revPFound && !revDone && paragraphHtmlDepth >= 0 && htmlDepth == paragraphHtmlDepth + 1) {
       currentTextNode++;
@@ -419,42 +580,12 @@ class ParagraphStreamer final : public Print {
           attrQuoteChar = 0;
         }
         if (capturingAnchorTag) {
-          switch (idState) {
-            case ID_SCAN:
-              idState = (c == 'i' || c == 'I') ? ID_I : ID_SCAN;
-              break;
-            case ID_I:
-              idState = (c == 'd' || c == 'D') ? ID_D : ID_SCAN;
-              break;
-            case ID_D:
-              idState = (c == '=') ? ID_EQ : ID_SCAN;
-              break;
-            case ID_EQ:
-              if (c == '"')
-                idState = ID_IN_VALUE_D;
-              else if (c == '\'')
-                idState = ID_IN_VALUE_S;
-              break;
-            case ID_IN_VALUE_D:
-              if (c == '"') {
-                capturedAnchorId[capturedAnchorIdLen] = '\0';
-                capturingAnchorTag = false;
-              } else if (capturedAnchorIdLen + 1 < MAX_ANCHOR_ID)
-                capturedAnchorId[capturedAnchorIdLen++] = c;
-              break;
-            case ID_IN_VALUE_S:
-              if (c == '\'') {
-                capturedAnchorId[capturedAnchorIdLen] = '\0';
-                capturingAnchorTag = false;
-              } else if (capturedAnchorIdLen + 1 < MAX_ANCHOR_ID)
-                capturedAnchorId[capturedAnchorIdLen++] = c;
-              break;
-          }
+          scanAnchorAttribute(c);
         }
         // Only treat '/' as self-closing when outside a quoted attribute value.
         if (c == '/' && !inAttrQuote) {
+          endAnchorIdScan();
           onCloseTag();
-          capturingAnchorTag = false;
         }
         break;
     }
@@ -512,10 +643,13 @@ class ParagraphStreamer final : public Print {
       tagNameLen = 0;
       tagIsClose = false;
       capturingAnchorTag = false;
-      idState = ID_SCAN;
+      resetAnchorAttrScan();
       inAttrQuote = false;
       attrQuoteChar = 0;
     } else if (c == '>') {
+      if (tagState == TAG_ATTRS) {
+        endAnchorIdScan();
+      }
       globalInTag = false;
       inAttrQuote = false;
       if (tagState == TAG_IN_NAME && tagNameLen > 0) {
@@ -529,6 +663,9 @@ class ParagraphStreamer final : public Print {
       tagState = TAG_IDLE;
     } else if (globalInTag) {
       processByteInTag(c);
+    } else if (nonVisibleDepth > 0) {
+      // Ignore head/style/script/title text. KOReader XPaths are body-relative, and CSS text
+      // should not contribute to intra-spine progress.
     } else {
       if (c == '&') {
         globalInEntity = true;
@@ -762,4 +899,4 @@ std::string ProgressMapper::generateXPath(const std::shared_ptr<Epub>& epub, int
 
   const int p = s.paragraphCount();
   return (p > 0) ? base + "/p[" + std::to_string(p) + "]" : base;
-}
+}

lib/Logging/Logging.cpp

@@ -1,5 +1,8 @@
 #include "Logging.h"
 
+#include <BoardConfig.h>
+#include <esp_rom_sys.h>
+
 #include <string>
 
 #define MAX_ENTRY_LEN 256
@@ -59,9 +62,19 @@ void logPrintf(const char* level, const char* origin, const char* format, ...) {
     }
   }
   va_end(args);
+#if FREEINK_LOG_TRANSPORT == FREEINK_LOG_TRANSPORT_USB_CDC_WRITE
+  // Native USB CDC can report false while PlatformIO monitor is attached on
+  // boards like LilyGo T5 S3, so write directly to the CDC object.
+  logSerial.write(reinterpret_cast<const uint8_t*>(buf), strnlen(buf, sizeof(buf)));
+#elif FREEINK_LOG_TRANSPORT == FREEINK_LOG_TRANSPORT_ROM_PRINTF
+  // IDF/ROM console path for boards whose monitor is attached there during
+  // bring-up, e.g. Sticky.
+  esp_rom_printf("%s", buf);
+#else
   if (logSerial) {
     logSerial.print(buf);
   }
+#endif
   addToLogRingBuffer(buf);
 }
 

lib/Logging/Logging.h

@@ -27,7 +27,10 @@ won't trigger deprecation warnings.
 #define LOG_LEVEL 0
 #endif
 
-static HWCDC& logSerial = Serial;
+// The concrete Serial type differs by MCU: HWCDC (native USB CDC on C3/S3) vs
+// HardwareSerial (UART0 on the classic ESP32 / M5Paper). Bind to whatever the
+// real Serial is here — this is before the `#define Serial` shim below.
+static decltype(Serial)& logSerial = Serial;
 
 void logPrintf(const char* level, const char* origin, const char* format, ...);
 

lib/Utf8/Utf8.cpp

@@ -1,5 +1,73 @@
 #include "Utf8.h"
 
+#include "Utf8ComposeTable.h"
+
+namespace {
+// Look up the canonical composition of (base + combining mark), or 0 if none.
+uint32_t utf8ComposePair(const uint32_t base, const uint32_t mark) {
+  if (base > 0xFFFF || mark > 0xFFFF) return 0;
+  int lo = 0;
+  int hi = kUtf8ComposeTableSize - 1;
+  while (lo <= hi) {
+    const int mid = (lo + hi) / 2;
+    const Utf8ComposeEntry& e = kUtf8ComposeTable[mid];
+    if (e.base < base || (e.base == base && e.mark < mark)) {
+      lo = mid + 1;
+    } else if (e.base > base || (e.base == base && e.mark > mark)) {
+      hi = mid - 1;
+    } else {
+      return e.composed;
+    }
+  }
+  return 0;
+}
+}  // namespace
+
+std::string utf8ComposeNfc(const std::string& in) {
+  // Fast path: NFC composition can only change text that contains a combining
+  // diacritical mark U+0300-036F (UTF-8 lead byte 0xCC or 0xCD). Plain ASCII and
+  // already-precomposed (NFC) text -- the vast majority of words -- have none, so
+  // return them untouched without walking codepoints or allocating. A 0xCD that is
+  // actually a non-combining codepoint just falls through to the full pass below.
+  bool maybeHasMarks = false;
+  for (const unsigned char c : in) {
+    if (c == 0xCC || c == 0xCD) {
+      maybeHasMarks = true;
+      break;
+    }
+  }
+  if (!maybeHasMarks) return in;
+
+  std::string out;
+  out.reserve(in.size());
+  const unsigned char* p = reinterpret_cast<const unsigned char*>(in.c_str());
+  uint32_t base = 0;
+  bool haveBase = false;
+  while (*p) {
+    const uint32_t cp = utf8NextCodepoint(&p);
+    if (cp == 0) break;
+    if (utf8IsCombiningMark(cp)) {
+      const uint32_t composed = haveBase ? utf8ComposePair(base, cp) : 0;
+      if (composed) {
+        base = composed;  // keep accumulating further marks onto the composed char
+        continue;
+      }
+      // No composition: flush the pending base, then emit the mark unchanged.
+      if (haveBase) {
+        utf8AppendCodepoint(base, out);
+        haveBase = false;
+      }
+      utf8AppendCodepoint(cp, out);
+    } else {
+      if (haveBase) utf8AppendCodepoint(base, out);
+      base = cp;
+      haveBase = true;
+    }
+  }
+  if (haveBase) utf8AppendCodepoint(base, out);
+  return out;
+}
+
 int utf8CodepointLen(const unsigned char c) {
   if (c < 0x80) return 1;          // 0xxxxxxx
   if ((c >> 5) == 0x6) return 2;   // 110xxxxx

lib/Utf8/Utf8.h

@@ -12,6 +12,12 @@ size_t utf8RemoveLastChar(std::string& str);
 // Truncate string by removing N UTF-8 codepoints from the end.
 void utf8TruncateChars(std::string& str, size_t numChars);
 
+// Canonical composition (NFC) for the Latin / Vietnamese range: precomposes a
+// base letter followed by combining diacritical mark(s) into a single codepoint.
+// Needed because the device fonts have no combining-mark positioning, so text
+// stored in NFD (e.g. some EPUB chapter titles) otherwise renders broken.
+std::string utf8ComposeNfc(const std::string& in);
+
 // Truncate a raw char buffer to the last complete UTF-8 codepoint boundary.
 // Returns the new length (<= len). If the buffer ends mid-sequence, the
 // incomplete trailing bytes are excluded.
@@ -21,12 +27,15 @@ int utf8SafeTruncateBuffer(const char* buf, int len);
 // Covers CJK Unified Ideographs, Hiragana, Katakana, Hangul Syllables, CJK punctuation,
 // and fullwidth forms — the ranges where word boundaries are implicit per character.
 inline bool utf8IsCjkBreakable(const uint32_t cp) {
-  return (cp >= 0x3000 && cp <= 0x303F)        // CJK Symbols and Punctuation
+  return (cp >= 0x1100 && cp <= 0x11FF)        // Hangul Jamo
+         || (cp >= 0x3000 && cp <= 0x303F)     // CJK Symbols and Punctuation
          || (cp >= 0x3040 && cp <= 0x309F)     // Hiragana
          || (cp >= 0x30A0 && cp <= 0x30FF)     // Katakana
+         || (cp >= 0x3130 && cp <= 0x318F)     // Hangul Compatibility Jamo
          || (cp >= 0x3400 && cp <= 0x4DBF)     // CJK Extension A
          || (cp >= 0x4E00 && cp <= 0x9FFF)     // CJK Unified Ideographs
          || (cp >= 0xAC00 && cp <= 0xD7AF)     // Hangul Syllables
+         || (cp >= 0xD7B0 && cp <= 0xD7FF)     // Hangul Jamo Extended-B
          || (cp >= 0xF900 && cp <= 0xFAFF)     // CJK Compatibility Ideographs
          || (cp >= 0xFE30 && cp <= 0xFE4F)     // CJK Compatibility Forms
          || (cp >= 0xFF01 && cp <= 0xFF60)     // Fullwidth Latin / Punctuation

lib/Utf8/Utf8ComposeTable.h

@@ -0,0 +1,229 @@
+// Auto-generated canonical composition (NFC) table for the Latin / Vietnamese
+// range (combining marks U+0300-U+036F). Generated from Python unicodedata.
+// Used by utf8ComposeNfc() to precompose decomposed (NFD) text so the device
+// fonts (which lack combining-mark positioning) render it correctly.
+#pragma once
+#include <cstdint>
+
+struct Utf8ComposeEntry {
+  uint16_t base;
+  uint16_t mark;
+  uint16_t composed;
+};
+
+// Sorted by (base, mark) for binary search.
+static constexpr Utf8ComposeEntry kUtf8ComposeTable[] = {
+    {0x0041, 0x0300, 0x00C0}, {0x0041, 0x0301, 0x00C1}, {0x0041, 0x0302, 0x00C2}, {0x0041, 0x0303, 0x00C3},
+    {0x0041, 0x0304, 0x0100}, {0x0041, 0x0306, 0x0102}, {0x0041, 0x0307, 0x0226}, {0x0041, 0x0308, 0x00C4},
+    {0x0041, 0x0309, 0x1EA2}, {0x0041, 0x030A, 0x00C5}, {0x0041, 0x030C, 0x01CD}, {0x0041, 0x030F, 0x0200},
+    {0x0041, 0x0311, 0x0202}, {0x0041, 0x0323, 0x1EA0}, {0x0041, 0x0325, 0x1E00}, {0x0041, 0x0328, 0x0104},
+    {0x0041, 0x0340, 0x00C0}, {0x0041, 0x0341, 0x00C1}, {0x0042, 0x0307, 0x1E02}, {0x0042, 0x0323, 0x1E04},
+    {0x0042, 0x0331, 0x1E06}, {0x0043, 0x0301, 0x0106}, {0x0043, 0x0302, 0x0108}, {0x0043, 0x0307, 0x010A},
+    {0x0043, 0x030C, 0x010C}, {0x0043, 0x0327, 0x00C7}, {0x0043, 0x0341, 0x0106}, {0x0044, 0x0307, 0x1E0A},
+    {0x0044, 0x030C, 0x010E}, {0x0044, 0x0323, 0x1E0C}, {0x0044, 0x0327, 0x1E10}, {0x0044, 0x032D, 0x1E12},
+    {0x0044, 0x0331, 0x1E0E}, {0x0045, 0x0300, 0x00C8}, {0x0045, 0x0301, 0x00C9}, {0x0045, 0x0302, 0x00CA},
+    {0x0045, 0x0303, 0x1EBC}, {0x0045, 0x0304, 0x0112}, {0x0045, 0x0306, 0x0114}, {0x0045, 0x0307, 0x0116},
+    {0x0045, 0x0308, 0x00CB}, {0x0045, 0x0309, 0x1EBA}, {0x0045, 0x030C, 0x011A}, {0x0045, 0x030F, 0x0204},
+    {0x0045, 0x0311, 0x0206}, {0x0045, 0x0323, 0x1EB8}, {0x0045, 0x0327, 0x0228}, {0x0045, 0x0328, 0x0118},
+    {0x0045, 0x032D, 0x1E18}, {0x0045, 0x0330, 0x1E1A}, {0x0045, 0x0340, 0x00C8}, {0x0045, 0x0341, 0x00C9},
+    {0x0046, 0x0307, 0x1E1E}, {0x0047, 0x0301, 0x01F4}, {0x0047, 0x0302, 0x011C}, {0x0047, 0x0304, 0x1E20},
+    {0x0047, 0x0306, 0x011E}, {0x0047, 0x0307, 0x0120}, {0x0047, 0x030C, 0x01E6}, {0x0047, 0x0327, 0x0122},
+    {0x0047, 0x0341, 0x01F4}, {0x0048, 0x0302, 0x0124}, {0x0048, 0x0307, 0x1E22}, {0x0048, 0x0308, 0x1E26},
+    {0x0048, 0x030C, 0x021E}, {0x0048, 0x0323, 0x1E24}, {0x0048, 0x0327, 0x1E28}, {0x0048, 0x032E, 0x1E2A},
+    {0x0049, 0x0300, 0x00CC}, {0x0049, 0x0301, 0x00CD}, {0x0049, 0x0302, 0x00CE}, {0x0049, 0x0303, 0x0128},
+    {0x0049, 0x0304, 0x012A}, {0x0049, 0x0306, 0x012C}, {0x0049, 0x0307, 0x0130}, {0x0049, 0x0308, 0x00CF},
+    {0x0049, 0x0309, 0x1EC8}, {0x0049, 0x030C, 0x01CF}, {0x0049, 0x030F, 0x0208}, {0x0049, 0x0311, 0x020A},
+    {0x0049, 0x0323, 0x1ECA}, {0x0049, 0x0328, 0x012E}, {0x0049, 0x0330, 0x1E2C}, {0x0049, 0x0340, 0x00CC},
+    {0x0049, 0x0341, 0x00CD}, {0x0049, 0x0344, 0x1E2E}, {0x004A, 0x0302, 0x0134}, {0x004B, 0x0301, 0x1E30},
+    {0x004B, 0x030C, 0x01E8}, {0x004B, 0x0323, 0x1E32}, {0x004B, 0x0327, 0x0136}, {0x004B, 0x0331, 0x1E34},
+    {0x004B, 0x0341, 0x1E30}, {0x004C, 0x0301, 0x0139}, {0x004C, 0x030C, 0x013D}, {0x004C, 0x0323, 0x1E36},
+    {0x004C, 0x0327, 0x013B}, {0x004C, 0x032D, 0x1E3C}, {0x004C, 0x0331, 0x1E3A}, {0x004C, 0x0341, 0x0139},
+    {0x004D, 0x0301, 0x1E3E}, {0x004D, 0x0307, 0x1E40}, {0x004D, 0x0323, 0x1E42}, {0x004D, 0x0341, 0x1E3E},
+    {0x004E, 0x0300, 0x01F8}, {0x004E, 0x0301, 0x0143}, {0x004E, 0x0303, 0x00D1}, {0x004E, 0x0307, 0x1E44},
+    {0x004E, 0x030C, 0x0147}, {0x004E, 0x0323, 0x1E46}, {0x004E, 0x0327, 0x0145}, {0x004E, 0x032D, 0x1E4A},
+    {0x004E, 0x0331, 0x1E48}, {0x004E, 0x0340, 0x01F8}, {0x004E, 0x0341, 0x0143}, {0x004F, 0x0300, 0x00D2},
+    {0x004F, 0x0301, 0x00D3}, {0x004F, 0x0302, 0x00D4}, {0x004F, 0x0303, 0x00D5}, {0x004F, 0x0304, 0x014C},
+    {0x004F, 0x0306, 0x014E}, {0x004F, 0x0307, 0x022E}, {0x004F, 0x0308, 0x00D6}, {0x004F, 0x0309, 0x1ECE},
+    {0x004F, 0x030B, 0x0150}, {0x004F, 0x030C, 0x01D1}, {0x004F, 0x030F, 0x020C}, {0x004F, 0x0311, 0x020E},
+    {0x004F, 0x031B, 0x01A0}, {0x004F, 0x0323, 0x1ECC}, {0x004F, 0x0328, 0x01EA}, {0x004F, 0x0340, 0x00D2},
+    {0x004F, 0x0341, 0x00D3}, {0x0050, 0x0301, 0x1E54}, {0x0050, 0x0307, 0x1E56}, {0x0050, 0x0341, 0x1E54},
+    {0x0052, 0x0301, 0x0154}, {0x0052, 0x0307, 0x1E58}, {0x0052, 0x030C, 0x0158}, {0x0052, 0x030F, 0x0210},
+    {0x0052, 0x0311, 0x0212}, {0x0052, 0x0323, 0x1E5A}, {0x0052, 0x0327, 0x0156}, {0x0052, 0x0331, 0x1E5E},
+    {0x0052, 0x0341, 0x0154}, {0x0053, 0x0301, 0x015A}, {0x0053, 0x0302, 0x015C}, {0x0053, 0x0307, 0x1E60},
+    {0x0053, 0x030C, 0x0160}, {0x0053, 0x0323, 0x1E62}, {0x0053, 0x0326, 0x0218}, {0x0053, 0x0327, 0x015E},
+    {0x0053, 0x0341, 0x015A}, {0x0054, 0x0307, 0x1E6A}, {0x0054, 0x030C, 0x0164}, {0x0054, 0x0323, 0x1E6C},
+    {0x0054, 0x0326, 0x021A}, {0x0054, 0x0327, 0x0162}, {0x0054, 0x032D, 0x1E70}, {0x0054, 0x0331, 0x1E6E},
+    {0x0055, 0x0300, 0x00D9}, {0x0055, 0x0301, 0x00DA}, {0x0055, 0x0302, 0x00DB}, {0x0055, 0x0303, 0x0168},
+    {0x0055, 0x0304, 0x016A}, {0x0055, 0x0306, 0x016C}, {0x0055, 0x0308, 0x00DC}, {0x0055, 0x0309, 0x1EE6},
+    {0x0055, 0x030A, 0x016E}, {0x0055, 0x030B, 0x0170}, {0x0055, 0x030C, 0x01D3}, {0x0055, 0x030F, 0x0214},
+    {0x0055, 0x0311, 0x0216}, {0x0055, 0x031B, 0x01AF}, {0x0055, 0x0323, 0x1EE4}, {0x0055, 0x0324, 0x1E72},
+    {0x0055, 0x0328, 0x0172}, {0x0055, 0x032D, 0x1E76}, {0x0055, 0x0330, 0x1E74}, {0x0055, 0x0340, 0x00D9},
+    {0x0055, 0x0341, 0x00DA}, {0x0055, 0x0344, 0x01D7}, {0x0056, 0x0303, 0x1E7C}, {0x0056, 0x0323, 0x1E7E},
+    {0x0057, 0x0300, 0x1E80}, {0x0057, 0x0301, 0x1E82}, {0x0057, 0x0302, 0x0174}, {0x0057, 0x0307, 0x1E86},
+    {0x0057, 0x0308, 0x1E84}, {0x0057, 0x0323, 0x1E88}, {0x0057, 0x0340, 0x1E80}, {0x0057, 0x0341, 0x1E82},
+    {0x0058, 0x0307, 0x1E8A}, {0x0058, 0x0308, 0x1E8C}, {0x0059, 0x0300, 0x1EF2}, {0x0059, 0x0301, 0x00DD},
+    {0x0059, 0x0302, 0x0176}, {0x0059, 0x0303, 0x1EF8}, {0x0059, 0x0304, 0x0232}, {0x0059, 0x0307, 0x1E8E},
+    {0x0059, 0x0308, 0x0178}, {0x0059, 0x0309, 0x1EF6}, {0x0059, 0x0323, 0x1EF4}, {0x0059, 0x0340, 0x1EF2},
+    {0x0059, 0x0341, 0x00DD}, {0x005A, 0x0301, 0x0179}, {0x005A, 0x0302, 0x1E90}, {0x005A, 0x0307, 0x017B},
+    {0x005A, 0x030C, 0x017D}, {0x005A, 0x0323, 0x1E92}, {0x005A, 0x0331, 0x1E94}, {0x005A, 0x0341, 0x0179},
+    {0x0061, 0x0300, 0x00E0}, {0x0061, 0x0301, 0x00E1}, {0x0061, 0x0302, 0x00E2}, {0x0061, 0x0303, 0x00E3},
+    {0x0061, 0x0304, 0x0101}, {0x0061, 0x0306, 0x0103}, {0x0061, 0x0307, 0x0227}, {0x0061, 0x0308, 0x00E4},
+    {0x0061, 0x0309, 0x1EA3}, {0x0061, 0x030A, 0x00E5}, {0x0061, 0x030C, 0x01CE}, {0x0061, 0x030F, 0x0201},
+    {0x0061, 0x0311, 0x0203}, {0x0061, 0x0323, 0x1EA1}, {0x0061, 0x0325, 0x1E01}, {0x0061, 0x0328, 0x0105},
+    {0x0061, 0x0340, 0x00E0}, {0x0061, 0x0341, 0x00E1}, {0x0062, 0x0307, 0x1E03}, {0x0062, 0x0323, 0x1E05},
+    {0x0062, 0x0331, 0x1E07}, {0x0063, 0x0301, 0x0107}, {0x0063, 0x0302, 0x0109}, {0x0063, 0x0307, 0x010B},
+    {0x0063, 0x030C, 0x010D}, {0x0063, 0x0327, 0x00E7}, {0x0063, 0x0341, 0x0107}, {0x0064, 0x0307, 0x1E0B},
+    {0x0064, 0x030C, 0x010F}, {0x0064, 0x0323, 0x1E0D}, {0x0064, 0x0327, 0x1E11}, {0x0064, 0x032D, 0x1E13},
+    {0x0064, 0x0331, 0x1E0F}, {0x0065, 0x0300, 0x00E8}, {0x0065, 0x0301, 0x00E9}, {0x0065, 0x0302, 0x00EA},
+    {0x0065, 0x0303, 0x1EBD}, {0x0065, 0x0304, 0x0113}, {0x0065, 0x0306, 0x0115}, {0x0065, 0x0307, 0x0117},
+    {0x0065, 0x0308, 0x00EB}, {0x0065, 0x0309, 0x1EBB}, {0x0065, 0x030C, 0x011B}, {0x0065, 0x030F, 0x0205},
+    {0x0065, 0x0311, 0x0207}, {0x0065, 0x0323, 0x1EB9}, {0x0065, 0x0327, 0x0229}, {0x0065, 0x0328, 0x0119},
+    {0x0065, 0x032D, 0x1E19}, {0x0065, 0x0330, 0x1E1B}, {0x0065, 0x0340, 0x00E8}, {0x0065, 0x0341, 0x00E9},
+    {0x0066, 0x0307, 0x1E1F}, {0x0067, 0x0301, 0x01F5}, {0x0067, 0x0302, 0x011D}, {0x0067, 0x0304, 0x1E21},
+    {0x0067, 0x0306, 0x011F}, {0x0067, 0x0307, 0x0121}, {0x0067, 0x030C, 0x01E7}, {0x0067, 0x0327, 0x0123},
+    {0x0067, 0x0341, 0x01F5}, {0x0068, 0x0302, 0x0125}, {0x0068, 0x0307, 0x1E23}, {0x0068, 0x0308, 0x1E27},
+    {0x0068, 0x030C, 0x021F}, {0x0068, 0x0323, 0x1E25}, {0x0068, 0x0327, 0x1E29}, {0x0068, 0x032E, 0x1E2B},
+    {0x0068, 0x0331, 0x1E96}, {0x0069, 0x0300, 0x00EC}, {0x0069, 0x0301, 0x00ED}, {0x0069, 0x0302, 0x00EE},
+    {0x0069, 0x0303, 0x0129}, {0x0069, 0x0304, 0x012B}, {0x0069, 0x0306, 0x012D}, {0x0069, 0x0308, 0x00EF},
+    {0x0069, 0x0309, 0x1EC9}, {0x0069, 0x030C, 0x01D0}, {0x0069, 0x030F, 0x0209}, {0x0069, 0x0311, 0x020B},
+    {0x0069, 0x0323, 0x1ECB}, {0x0069, 0x0328, 0x012F}, {0x0069, 0x0330, 0x1E2D}, {0x0069, 0x0340, 0x00EC},
+    {0x0069, 0x0341, 0x00ED}, {0x0069, 0x0344, 0x1E2F}, {0x006A, 0x0302, 0x0135}, {0x006A, 0x030C, 0x01F0},
+    {0x006B, 0x0301, 0x1E31}, {0x006B, 0x030C, 0x01E9}, {0x006B, 0x0323, 0x1E33}, {0x006B, 0x0327, 0x0137},
+    {0x006B, 0x0331, 0x1E35}, {0x006B, 0x0341, 0x1E31}, {0x006C, 0x0301, 0x013A}, {0x006C, 0x030C, 0x013E},
+    {0x006C, 0x0323, 0x1E37}, {0x006C, 0x0327, 0x013C}, {0x006C, 0x032D, 0x1E3D}, {0x006C, 0x0331, 0x1E3B},
+    {0x006C, 0x0341, 0x013A}, {0x006D, 0x0301, 0x1E3F}, {0x006D, 0x0307, 0x1E41}, {0x006D, 0x0323, 0x1E43},
+    {0x006D, 0x0341, 0x1E3F}, {0x006E, 0x0300, 0x01F9}, {0x006E, 0x0301, 0x0144}, {0x006E, 0x0303, 0x00F1},
+    {0x006E, 0x0307, 0x1E45}, {0x006E, 0x030C, 0x0148}, {0x006E, 0x0323, 0x1E47}, {0x006E, 0x0327, 0x0146},
+    {0x006E, 0x032D, 0x1E4B}, {0x006E, 0x0331, 0x1E49}, {0x006E, 0x0340, 0x01F9}, {0x006E, 0x0341, 0x0144},
+    {0x006F, 0x0300, 0x00F2}, {0x006F, 0x0301, 0x00F3}, {0x006F, 0x0302, 0x00F4}, {0x006F, 0x0303, 0x00F5},
+    {0x006F, 0x0304, 0x014D}, {0x006F, 0x0306, 0x014F}, {0x006F, 0x0307, 0x022F}, {0x006F, 0x0308, 0x00F6},
+    {0x006F, 0x0309, 0x1ECF}, {0x006F, 0x030B, 0x0151}, {0x006F, 0x030C, 0x01D2}, {0x006F, 0x030F, 0x020D},
+    {0x006F, 0x0311, 0x020F}, {0x006F, 0x031B, 0x01A1}, {0x006F, 0x0323, 0x1ECD}, {0x006F, 0x0328, 0x01EB},
+    {0x006F, 0x0340, 0x00F2}, {0x006F, 0x0341, 0x00F3}, {0x0070, 0x0301, 0x1E55}, {0x0070, 0x0307, 0x1E57},
+    {0x0070, 0x0341, 0x1E55}, {0x0072, 0x0301, 0x0155}, {0x0072, 0x0307, 0x1E59}, {0x0072, 0x030C, 0x0159},
+    {0x0072, 0x030F, 0x0211}, {0x0072, 0x0311, 0x0213}, {0x0072, 0x0323, 0x1E5B}, {0x0072, 0x0327, 0x0157},
+    {0x0072, 0x0331, 0x1E5F}, {0x0072, 0x0341, 0x0155}, {0x0073, 0x0301, 0x015B}, {0x0073, 0x0302, 0x015D},
+    {0x0073, 0x0307, 0x1E61}, {0x0073, 0x030C, 0x0161}, {0x0073, 0x0323, 0x1E63}, {0x0073, 0x0326, 0x0219},
+    {0x0073, 0x0327, 0x015F}, {0x0073, 0x0341, 0x015B}, {0x0074, 0x0307, 0x1E6B}, {0x0074, 0x0308, 0x1E97},
+    {0x0074, 0x030C, 0x0165}, {0x0074, 0x0323, 0x1E6D}, {0x0074, 0x0326, 0x021B}, {0x0074, 0x0327, 0x0163},
+    {0x0074, 0x032D, 0x1E71}, {0x0074, 0x0331, 0x1E6F}, {0x0075, 0x0300, 0x00F9}, {0x0075, 0x0301, 0x00FA},
+    {0x0075, 0x0302, 0x00FB}, {0x0075, 0x0303, 0x0169}, {0x0075, 0x0304, 0x016B}, {0x0075, 0x0306, 0x016D},
+    {0x0075, 0x0308, 0x00FC}, {0x0075, 0x0309, 0x1EE7}, {0x0075, 0x030A, 0x016F}, {0x0075, 0x030B, 0x0171},
+    {0x0075, 0x030C, 0x01D4}, {0x0075, 0x030F, 0x0215}, {0x0075, 0x0311, 0x0217}, {0x0075, 0x031B, 0x01B0},
+    {0x0075, 0x0323, 0x1EE5}, {0x0075, 0x0324, 0x1E73}, {0x0075, 0x0328, 0x0173}, {0x0075, 0x032D, 0x1E77},
+    {0x0075, 0x0330, 0x1E75}, {0x0075, 0x0340, 0x00F9}, {0x0075, 0x0341, 0x00FA}, {0x0075, 0x0344, 0x01D8},
+    {0x0076, 0x0303, 0x1E7D}, {0x0076, 0x0323, 0x1E7F}, {0x0077, 0x0300, 0x1E81}, {0x0077, 0x0301, 0x1E83},
+    {0x0077, 0x0302, 0x0175}, {0x0077, 0x0307, 0x1E87}, {0x0077, 0x0308, 0x1E85}, {0x0077, 0x030A, 0x1E98},
+    {0x0077, 0x0323, 0x1E89}, {0x0077, 0x0340, 0x1E81}, {0x0077, 0x0341, 0x1E83}, {0x0078, 0x0307, 0x1E8B},
+    {0x0078, 0x0308, 0x1E8D}, {0x0079, 0x0300, 0x1EF3}, {0x0079, 0x0301, 0x00FD}, {0x0079, 0x0302, 0x0177},
+    {0x0079, 0x0303, 0x1EF9}, {0x0079, 0x0304, 0x0233}, {0x0079, 0x0307, 0x1E8F}, {0x0079, 0x0308, 0x00FF},
+    {0x0079, 0x0309, 0x1EF7}, {0x0079, 0x030A, 0x1E99}, {0x0079, 0x0323, 0x1EF5}, {0x0079, 0x0340, 0x1EF3},
+    {0x0079, 0x0341, 0x00FD}, {0x007A, 0x0301, 0x017A}, {0x007A, 0x0302, 0x1E91}, {0x007A, 0x0307, 0x017C},
+    {0x007A, 0x030C, 0x017E}, {0x007A, 0x0323, 0x1E93}, {0x007A, 0x0331, 0x1E95}, {0x007A, 0x0341, 0x017A},
+    {0x00A8, 0x0300, 0x1FED}, {0x00A8, 0x0301, 0x0385}, {0x00A8, 0x0340, 0x1FED}, {0x00A8, 0x0341, 0x0385},
+    {0x00A8, 0x0342, 0x1FC1}, {0x00C2, 0x0300, 0x1EA6}, {0x00C2, 0x0301, 0x1EA4}, {0x00C2, 0x0303, 0x1EAA},
+    {0x00C2, 0x0309, 0x1EA8}, {0x00C2, 0x0323, 0x1EAC}, {0x00C2, 0x0340, 0x1EA6}, {0x00C2, 0x0341, 0x1EA4},
+    {0x00C4, 0x0304, 0x01DE}, {0x00C5, 0x0301, 0x01FA}, {0x00C5, 0x0341, 0x01FA}, {0x00C6, 0x0301, 0x01FC},
+    {0x00C6, 0x0304, 0x01E2}, {0x00C6, 0x0341, 0x01FC}, {0x00C7, 0x0301, 0x1E08}, {0x00C7, 0x0341, 0x1E08},
+    {0x00CA, 0x0300, 0x1EC0}, {0x00CA, 0x0301, 0x1EBE}, {0x00CA, 0x0303, 0x1EC4}, {0x00CA, 0x0309, 0x1EC2},
+    {0x00CA, 0x0323, 0x1EC6}, {0x00CA, 0x0340, 0x1EC0}, {0x00CA, 0x0341, 0x1EBE}, {0x00CF, 0x0301, 0x1E2E},
+    {0x00CF, 0x0341, 0x1E2E}, {0x00D2, 0x031B, 0x1EDC}, {0x00D3, 0x031B, 0x1EDA}, {0x00D4, 0x0300, 0x1ED2},
+    {0x00D4, 0x0301, 0x1ED0}, {0x00D4, 0x0303, 0x1ED6}, {0x00D4, 0x0309, 0x1ED4}, {0x00D4, 0x0323, 0x1ED8},
+    {0x00D4, 0x0340, 0x1ED2}, {0x00D4, 0x0341, 0x1ED0}, {0x00D5, 0x0301, 0x1E4C}, {0x00D5, 0x0304, 0x022C},
+    {0x00D5, 0x0308, 0x1E4E}, {0x00D5, 0x031B, 0x1EE0}, {0x00D5, 0x0341, 0x1E4C}, {0x00D6, 0x0304, 0x022A},
+    {0x00D8, 0x0301, 0x01FE}, {0x00D8, 0x0341, 0x01FE}, {0x00D9, 0x031B, 0x1EEA}, {0x00DA, 0x031B, 0x1EE8},
+    {0x00DC, 0x0300, 0x01DB}, {0x00DC, 0x0301, 0x01D7}, {0x00DC, 0x0304, 0x01D5}, {0x00DC, 0x030C, 0x01D9},
+    {0x00DC, 0x0340, 0x01DB}, {0x00DC, 0x0341, 0x01D7}, {0x00E2, 0x0300, 0x1EA7}, {0x00E2, 0x0301, 0x1EA5},
+    {0x00E2, 0x0303, 0x1EAB}, {0x00E2, 0x0309, 0x1EA9}, {0x00E2, 0x0323, 0x1EAD}, {0x00E2, 0x0340, 0x1EA7},
+    {0x00E2, 0x0341, 0x1EA5}, {0x00E4, 0x0304, 0x01DF}, {0x00E5, 0x0301, 0x01FB}, {0x00E5, 0x0341, 0x01FB},
+    {0x00E6, 0x0301, 0x01FD}, {0x00E6, 0x0304, 0x01E3}, {0x00E6, 0x0341, 0x01FD}, {0x00E7, 0x0301, 0x1E09},
+    {0x00E7, 0x0341, 0x1E09}, {0x00EA, 0x0300, 0x1EC1}, {0x00EA, 0x0301, 0x1EBF}, {0x00EA, 0x0303, 0x1EC5},
+    {0x00EA, 0x0309, 0x1EC3}, {0x00EA, 0x0323, 0x1EC7}, {0x00EA, 0x0340, 0x1EC1}, {0x00EA, 0x0341, 0x1EBF},
+    {0x00EF, 0x0301, 0x1E2F}, {0x00EF, 0x0341, 0x1E2F}, {0x00F2, 0x031B, 0x1EDD}, {0x00F3, 0x031B, 0x1EDB},
+    {0x00F4, 0x0300, 0x1ED3}, {0x00F4, 0x0301, 0x1ED1}, {0x00F4, 0x0303, 0x1ED7}, {0x00F4, 0x0309, 0x1ED5},
+    {0x00F4, 0x0323, 0x1ED9}, {0x00F4, 0x0340, 0x1ED3}, {0x00F4, 0x0341, 0x1ED1}, {0x00F5, 0x0301, 0x1E4D},
+    {0x00F5, 0x0304, 0x022D}, {0x00F5, 0x0308, 0x1E4F}, {0x00F5, 0x031B, 0x1EE1}, {0x00F5, 0x0341, 0x1E4D},
+    {0x00F6, 0x0304, 0x022B}, {0x00F8, 0x0301, 0x01FF}, {0x00F8, 0x0341, 0x01FF}, {0x00F9, 0x031B, 0x1EEB},
+    {0x00FA, 0x031B, 0x1EE9}, {0x00FC, 0x0300, 0x01DC}, {0x00FC, 0x0301, 0x01D8}, {0x00FC, 0x0304, 0x01D6},
+    {0x00FC, 0x030C, 0x01DA}, {0x00FC, 0x0340, 0x01DC}, {0x00FC, 0x0341, 0x01D8}, {0x0102, 0x0300, 0x1EB0},
+    {0x0102, 0x0301, 0x1EAE}, {0x0102, 0x0303, 0x1EB4}, {0x0102, 0x0309, 0x1EB2}, {0x0102, 0x0323, 0x1EB6},
+    {0x0102, 0x0340, 0x1EB0}, {0x0102, 0x0341, 0x1EAE}, {0x0103, 0x0300, 0x1EB1}, {0x0103, 0x0301, 0x1EAF},
+    {0x0103, 0x0303, 0x1EB5}, {0x0103, 0x0309, 0x1EB3}, {0x0103, 0x0323, 0x1EB7}, {0x0103, 0x0340, 0x1EB1},
+    {0x0103, 0x0341, 0x1EAF}, {0x0106, 0x0327, 0x1E08}, {0x0107, 0x0327, 0x1E09}, {0x0112, 0x0300, 0x1E14},
+    {0x0112, 0x0301, 0x1E16}, {0x0112, 0x0340, 0x1E14}, {0x0112, 0x0341, 0x1E16}, {0x0113, 0x0300, 0x1E15},
+    {0x0113, 0x0301, 0x1E17}, {0x0113, 0x0340, 0x1E15}, {0x0113, 0x0341, 0x1E17}, {0x0114, 0x0327, 0x1E1C},
+    {0x0115, 0x0327, 0x1E1D}, {0x014C, 0x0300, 0x1E50}, {0x014C, 0x0301, 0x1E52}, {0x014C, 0x0328, 0x01EC},
+    {0x014C, 0x0340, 0x1E50}, {0x014C, 0x0341, 0x1E52}, {0x014D, 0x0300, 0x1E51}, {0x014D, 0x0301, 0x1E53},
+    {0x014D, 0x0328, 0x01ED}, {0x014D, 0x0340, 0x1E51}, {0x014D, 0x0341, 0x1E53}, {0x015A, 0x0307, 0x1E64},
+    {0x015B, 0x0307, 0x1E65}, {0x0160, 0x0307, 0x1E66}, {0x0161, 0x0307, 0x1E67}, {0x0168, 0x0301, 0x1E78},
+    {0x0168, 0x031B, 0x1EEE}, {0x0168, 0x0341, 0x1E78}, {0x0169, 0x0301, 0x1E79}, {0x0169, 0x031B, 0x1EEF},
+    {0x0169, 0x0341, 0x1E79}, {0x016A, 0x0308, 0x1E7A}, {0x016B, 0x0308, 0x1E7B}, {0x017F, 0x0307, 0x1E9B},
+    {0x01A0, 0x0300, 0x1EDC}, {0x01A0, 0x0301, 0x1EDA}, {0x01A0, 0x0303, 0x1EE0}, {0x01A0, 0x0309, 0x1EDE},
+    {0x01A0, 0x0323, 0x1EE2}, {0x01A0, 0x0340, 0x1EDC}, {0x01A0, 0x0341, 0x1EDA}, {0x01A1, 0x0300, 0x1EDD},
+    {0x01A1, 0x0301, 0x1EDB}, {0x01A1, 0x0303, 0x1EE1}, {0x01A1, 0x0309, 0x1EDF}, {0x01A1, 0x0323, 0x1EE3},
+    {0x01A1, 0x0340, 0x1EDD}, {0x01A1, 0x0341, 0x1EDB}, {0x01AF, 0x0300, 0x1EEA}, {0x01AF, 0x0301, 0x1EE8},
+    {0x01AF, 0x0303, 0x1EEE}, {0x01AF, 0x0309, 0x1EEC}, {0x01AF, 0x0323, 0x1EF0}, {0x01AF, 0x0340, 0x1EEA},
+    {0x01AF, 0x0341, 0x1EE8}, {0x01B0, 0x0300, 0x1EEB}, {0x01B0, 0x0301, 0x1EE9}, {0x01B0, 0x0303, 0x1EEF},
+    {0x01B0, 0x0309, 0x1EED}, {0x01B0, 0x0323, 0x1EF1}, {0x01B0, 0x0340, 0x1EEB}, {0x01B0, 0x0341, 0x1EE9},
+    {0x01B7, 0x030C, 0x01EE}, {0x01EA, 0x0304, 0x01EC}, {0x01EB, 0x0304, 0x01ED}, {0x0226, 0x0304, 0x01E0},
+    {0x0227, 0x0304, 0x01E1}, {0x0228, 0x0306, 0x1E1C}, {0x0229, 0x0306, 0x1E1D}, {0x022E, 0x0304, 0x0230},
+    {0x022F, 0x0304, 0x0231}, {0x0292, 0x030C, 0x01EF}, {0x0391, 0x0300, 0x1FBA}, {0x0391, 0x0301, 0x0386},
+    {0x0391, 0x0304, 0x1FB9}, {0x0391, 0x0306, 0x1FB8}, {0x0391, 0x0313, 0x1F08}, {0x0391, 0x0314, 0x1F09},
+    {0x0391, 0x0340, 0x1FBA}, {0x0391, 0x0341, 0x0386}, {0x0391, 0x0343, 0x1F08}, {0x0391, 0x0345, 0x1FBC},
+    {0x0395, 0x0300, 0x1FC8}, {0x0395, 0x0301, 0x0388}, {0x0395, 0x0313, 0x1F18}, {0x0395, 0x0314, 0x1F19},
+    {0x0395, 0x0340, 0x1FC8}, {0x0395, 0x0341, 0x0388}, {0x0395, 0x0343, 0x1F18}, {0x0397, 0x0300, 0x1FCA},
+    {0x0397, 0x0301, 0x0389}, {0x0397, 0x0313, 0x1F28}, {0x0397, 0x0314, 0x1F29}, {0x0397, 0x0340, 0x1FCA},
+    {0x0397, 0x0341, 0x0389}, {0x0397, 0x0343, 0x1F28}, {0x0397, 0x0345, 0x1FCC}, {0x0399, 0x0300, 0x1FDA},
+    {0x0399, 0x0301, 0x038A}, {0x0399, 0x0304, 0x1FD9}, {0x0399, 0x0306, 0x1FD8}, {0x0399, 0x0308, 0x03AA},
+    {0x0399, 0x0313, 0x1F38}, {0x0399, 0x0314, 0x1F39}, {0x0399, 0x0340, 0x1FDA}, {0x0399, 0x0341, 0x038A},
+    {0x0399, 0x0343, 0x1F38}, {0x039F, 0x0300, 0x1FF8}, {0x039F, 0x0301, 0x038C}, {0x039F, 0x0313, 0x1F48},
+    {0x039F, 0x0314, 0x1F49}, {0x039F, 0x0340, 0x1FF8}, {0x039F, 0x0341, 0x038C}, {0x039F, 0x0343, 0x1F48},
+    {0x03A1, 0x0314, 0x1FEC}, {0x03A5, 0x0300, 0x1FEA}, {0x03A5, 0x0301, 0x038E}, {0x03A5, 0x0304, 0x1FE9},
+    {0x03A5, 0x0306, 0x1FE8}, {0x03A5, 0x0308, 0x03AB}, {0x03A5, 0x0314, 0x1F59}, {0x03A5, 0x0340, 0x1FEA},
+    {0x03A5, 0x0341, 0x038E}, {0x03A9, 0x0300, 0x1FFA}, {0x03A9, 0x0301, 0x038F}, {0x03A9, 0x0313, 0x1F68},
+    {0x03A9, 0x0314, 0x1F69}, {0x03A9, 0x0340, 0x1FFA}, {0x03A9, 0x0341, 0x038F}, {0x03A9, 0x0343, 0x1F68},
+    {0x03A9, 0x0345, 0x1FFC}, {0x03AC, 0x0345, 0x1FB4}, {0x03AE, 0x0345, 0x1FC4}, {0x03B1, 0x0300, 0x1F70},
+    {0x03B1, 0x0301, 0x03AC}, {0x03B1, 0x0304, 0x1FB1}, {0x03B1, 0x0306, 0x1FB0}, {0x03B1, 0x0313, 0x1F00},
+    {0x03B1, 0x0314, 0x1F01}, {0x03B1, 0x0340, 0x1F70}, {0x03B1, 0x0341, 0x03AC}, {0x03B1, 0x0342, 0x1FB6},
+    {0x03B1, 0x0343, 0x1F00}, {0x03B1, 0x0345, 0x1FB3}, {0x03B5, 0x0300, 0x1F72}, {0x03B5, 0x0301, 0x03AD},
+    {0x03B5, 0x0313, 0x1F10}, {0x03B5, 0x0314, 0x1F11}, {0x03B5, 0x0340, 0x1F72}, {0x03B5, 0x0341, 0x03AD},
+    {0x03B5, 0x0343, 0x1F10}, {0x03B7, 0x0300, 0x1F74}, {0x03B7, 0x0301, 0x03AE}, {0x03B7, 0x0313, 0x1F20},
+    {0x03B7, 0x0314, 0x1F21}, {0x03B7, 0x0340, 0x1F74}, {0x03B7, 0x0341, 0x03AE}, {0x03B7, 0x0342, 0x1FC6},
+    {0x03B7, 0x0343, 0x1F20}, {0x03B7, 0x0345, 0x1FC3}, {0x03B9, 0x0300, 0x1F76}, {0x03B9, 0x0301, 0x03AF},
+    {0x03B9, 0x0304, 0x1FD1}, {0x03B9, 0x0306, 0x1FD0}, {0x03B9, 0x0308, 0x03CA}, {0x03B9, 0x0313, 0x1F30},
+    {0x03B9, 0x0314, 0x1F31}, {0x03B9, 0x0340, 0x1F76}, {0x03B9, 0x0341, 0x03AF}, {0x03B9, 0x0342, 0x1FD6},
+    {0x03B9, 0x0343, 0x1F30}, {0x03B9, 0x0344, 0x0390}, {0x03BF, 0x0300, 0x1F78}, {0x03BF, 0x0301, 0x03CC},
+    {0x03BF, 0x0313, 0x1F40}, {0x03BF, 0x0314, 0x1F41}, {0x03BF, 0x0340, 0x1F78}, {0x03BF, 0x0341, 0x03CC},
+    {0x03BF, 0x0343, 0x1F40}, {0x03C1, 0x0313, 0x1FE4}, {0x03C1, 0x0314, 0x1FE5}, {0x03C1, 0x0343, 0x1FE4},
+    {0x03C5, 0x0300, 0x1F7A}, {0x03C5, 0x0301, 0x03CD}, {0x03C5, 0x0304, 0x1FE1}, {0x03C5, 0x0306, 0x1FE0},
+    {0x03C5, 0x0308, 0x03CB}, {0x03C5, 0x0313, 0x1F50}, {0x03C5, 0x0314, 0x1F51}, {0x03C5, 0x0340, 0x1F7A},
+    {0x03C5, 0x0341, 0x03CD}, {0x03C5, 0x0342, 0x1FE6}, {0x03C5, 0x0343, 0x1F50}, {0x03C5, 0x0344, 0x03B0},
+    {0x03C9, 0x0300, 0x1F7C}, {0x03C9, 0x0301, 0x03CE}, {0x03C9, 0x0313, 0x1F60}, {0x03C9, 0x0314, 0x1F61},
+    {0x03C9, 0x0340, 0x1F7C}, {0x03C9, 0x0341, 0x03CE}, {0x03C9, 0x0342, 0x1FF6}, {0x03C9, 0x0343, 0x1F60},
+    {0x03C9, 0x0345, 0x1FF3}, {0x03CA, 0x0300, 0x1FD2}, {0x03CA, 0x0301, 0x0390}, {0x03CA, 0x0340, 0x1FD2},
+    {0x03CA, 0x0341, 0x0390}, {0x03CA, 0x0342, 0x1FD7}, {0x03CB, 0x0300, 0x1FE2}, {0x03CB, 0x0301, 0x03B0},
+    {0x03CB, 0x0340, 0x1FE2}, {0x03CB, 0x0341, 0x03B0}, {0x03CB, 0x0342, 0x1FE7}, {0x03CE, 0x0345, 0x1FF4},
+    {0x03D2, 0x0301, 0x03D3}, {0x03D2, 0x0308, 0x03D4}, {0x03D2, 0x0341, 0x03D3}, {0x0406, 0x0308, 0x0407},
+    {0x0410, 0x0306, 0x04D0}, {0x0410, 0x0308, 0x04D2}, {0x0413, 0x0301, 0x0403}, {0x0413, 0x0341, 0x0403},
+    {0x0415, 0x0300, 0x0400}, {0x0415, 0x0306, 0x04D6}, {0x0415, 0x0308, 0x0401}, {0x0415, 0x0340, 0x0400},
+    {0x0416, 0x0306, 0x04C1}, {0x0416, 0x0308, 0x04DC}, {0x0417, 0x0308, 0x04DE}, {0x0418, 0x0300, 0x040D},
+    {0x0418, 0x0304, 0x04E2}, {0x0418, 0x0306, 0x0419}, {0x0418, 0x0308, 0x04E4}, {0x0418, 0x0340, 0x040D},
+    {0x041A, 0x0301, 0x040C}, {0x041A, 0x0341, 0x040C}, {0x041E, 0x0308, 0x04E6}, {0x0423, 0x0304, 0x04EE},
+    {0x0423, 0x0306, 0x040E}, {0x0423, 0x0308, 0x04F0}, {0x0423, 0x030B, 0x04F2}, {0x0427, 0x0308, 0x04F4},
+    {0x042B, 0x0308, 0x04F8}, {0x042D, 0x0308, 0x04EC}, {0x0430, 0x0306, 0x04D1}, {0x0430, 0x0308, 0x04D3},
+    {0x0433, 0x0301, 0x0453}, {0x0433, 0x0341, 0x0453}, {0x0435, 0x0300, 0x0450}, {0x0435, 0x0306, 0x04D7},
+    {0x0435, 0x0308, 0x0451}, {0x0435, 0x0340, 0x0450}, {0x0436, 0x0306, 0x04C2}, {0x0436, 0x0308, 0x04DD},
+    {0x0437, 0x0308, 0x04DF}, {0x0438, 0x0300, 0x045D}, {0x0438, 0x0304, 0x04E3}, {0x0438, 0x0306, 0x0439},
+    {0x0438, 0x0308, 0x04E5}, {0x0438, 0x0340, 0x045D}, {0x043A, 0x0301, 0x045C}, {0x043A, 0x0341, 0x045C},
+    {0x043E, 0x0308, 0x04E7}, {0x0443, 0x0304, 0x04EF}, {0x0443, 0x0306, 0x045E}, {0x0443, 0x0308, 0x04F1},
+    {0x0443, 0x030B, 0x04F3}, {0x0447, 0x0308, 0x04F5}, {0x044B, 0x0308, 0x04F9}, {0x044D, 0x0308, 0x04ED},
+    {0x0456, 0x0308, 0x0457}, {0x0474, 0x030F, 0x0476}, {0x0475, 0x030F, 0x0477}, {0x04D8, 0x0308, 0x04DA},
+    {0x04D9, 0x0308, 0x04DB}, {0x04E8, 0x0308, 0x04EA}, {0x04E9, 0x0308, 0x04EB}, {0x1E36, 0x0304, 0x1E38},
+    {0x1E37, 0x0304, 0x1E39}, {0x1E5A, 0x0304, 0x1E5C}, {0x1E5B, 0x0304, 0x1E5D}, {0x1E60, 0x0323, 0x1E68},
+    {0x1E61, 0x0323, 0x1E69}, {0x1E62, 0x0307, 0x1E68}, {0x1E63, 0x0307, 0x1E69}, {0x1EA0, 0x0302, 0x1EAC},
+    {0x1EA0, 0x0306, 0x1EB6}, {0x1EA1, 0x0302, 0x1EAD}, {0x1EA1, 0x0306, 0x1EB7}, {0x1EB8, 0x0302, 0x1EC6},
+    {0x1EB9, 0x0302, 0x1EC7}, {0x1ECC, 0x0302, 0x1ED8}, {0x1ECC, 0x031B, 0x1EE2}, {0x1ECD, 0x0302, 0x1ED9},
+    {0x1ECD, 0x031B, 0x1EE3}, {0x1ECE, 0x031B, 0x1EDE}, {0x1ECF, 0x031B, 0x1EDF}, {0x1EE4, 0x031B, 0x1EF0},
+    {0x1EE5, 0x031B, 0x1EF1}, {0x1EE6, 0x031B, 0x1EEC}, {0x1EE7, 0x031B, 0x1EED},
+};
+static constexpr int kUtf8ComposeTableSize = sizeof(kUtf8ComposeTable) / sizeof(kUtf8ComposeTable[0]);

lib/Xtc/Xtc.cpp

@@ -173,53 +173,37 @@ bool Xtc::generateCoverBmp() const {
     return false;
   }
 
+  // Write 1-bit BMP header (top-down row order)
+  BmpHeader bmpHeader;
+  createBmpHeader(&bmpHeader, pageInfo.width, pageInfo.height, BmpRowOrder::TopDown);
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&bmpHeader), sizeof(bmpHeader));
+
+  const uint32_t rowSize = ((pageInfo.width + 31) / 32) * 4;
+
+  // Write bitmap data
+  // BMP requires 4-byte row alignment
+  const size_t dstRowSize = (pageInfo.width + 7) / 8;  // 1-bit destination row size
+
   if (bitDepth == 2) {
-    // XTH 2-bit mode: preserve all 4 gray levels in a 2-bit BMP so the sleep
-    // screen's grayscale pass can render them (a 1-bit cover would silently
-    // disable it). Source is two bit planes, column-major order:
+    // XTH 2-bit mode: Two bit planes, column-major order
     // - Columns scanned right to left (x = width-1 down to 0)
     // - 8 vertical pixels per byte (MSB = topmost pixel in group)
     // - First plane: Bit1, Second plane: Bit2
-    // - Pixel value = (bit1 << 1) | bit2: 0=white, 1=dark gray,
-    //   2=light gray, 3=black
-    // 70-byte 2-bit BMP header (14 file + 40 DIB + 4-entry gray palette),
-    // top-down rows. Only the size and dimension fields vary; patch them in.
-    // clang-format off
-    uint8_t hdr[70] = {
-        'B', 'M', 0, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0,            // file header
-        40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0,          // DIB: w/h patched
-        0, 0, 0, 0, 0, 0, 0, 0, 0x13, 0x0B, 0, 0, 0x13, 0x0B, 0, 0,  // 0, 2835 DPI
-        4, 0, 0, 0, 4, 0, 0, 0,                                   // 4 palette colors
-        0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x55, 0x00,           // black, dark gray
-        0xAA, 0xAA, 0xAA, 0x00, 0xFF, 0xFF, 0xFF, 0x00};          // light gray, white
-    // clang-format on
-    const uint32_t rowSize2 = ((static_cast<uint32_t>(pageInfo.width) * 2 + 31) / 32) * 4;
-    const uint32_t imageSize = rowSize2 * pageInfo.height;
-    const uint32_t fileSize = sizeof(hdr) + imageSize;
-    const int32_t topDownHeight = -static_cast<int32_t>(pageInfo.height);
-    memcpy(hdr + 2, &fileSize, 4);
-    memcpy(hdr + 18, &pageInfo.width, 2);  // biWidth (upper bytes stay 0)
-    memcpy(hdr + 22, &topDownHeight, 4);   // negative biHeight = top-down
-    memcpy(hdr + 34, &imageSize, 4);
-    coverBmp.write(hdr, sizeof(hdr));
-
+    // - Pixel value = (bit1 << 1) | bit2
     const size_t planeSize = (static_cast<size_t>(pageInfo.width) * pageInfo.height + 7) / 8;
     const uint8_t* plane1 = pageBuffer;                 // Bit1 plane
     const uint8_t* plane2 = pageBuffer + planeSize;     // Bit2 plane
     const size_t colBytes = (pageInfo.height + 7) / 8;  // Bytes per column
 
-    // 2 bits per pixel, MSB first, rows padded to 4 bytes
-    uint8_t* rowBuffer = static_cast<uint8_t*>(malloc(rowSize2));
+    // Allocate a row buffer for 1-bit output
+    uint8_t* rowBuffer = static_cast<uint8_t*>(malloc(dstRowSize));
     if (!rowBuffer) {
       free(pageBuffer);
       return false;
     }
 
-    // XTH value -> BMP palette index (palette: 0=black, 1=dark, 2=light, 3=white)
-    static constexpr uint8_t kXthToBmp[4] = {3, 1, 2, 0};
-
     for (uint16_t y = 0; y < pageInfo.height; y++) {
-      memset(rowBuffer, 0x00, rowSize2);
+      memset(rowBuffer, 0xFF, dstRowSize);  // Start with all white
 
       for (uint16_t x = 0; x < pageInfo.width; x++) {
         // Column-major, right to left: column index = (width - 1 - x)
@@ -232,22 +216,28 @@ bool Xtc::generateCoverBmp() const {
         const uint8_t bit2 = (plane2[byteOffset] >> bitInByte) & 1;
         const uint8_t pixelValue = (bit1 << 1) | bit2;
 
-        const uint8_t bmpVal = kXthToBmp[pixelValue];
-        rowBuffer[(x * 2) / 8] |= bmpVal << (6 - ((x * 2) % 8));
+        // Threshold: 0=white (1); 1,2,3=black (0)
+        if (pixelValue >= 1) {
+          // Set bit to 0 (black) in BMP format
+          const size_t dstByte = x / 8;
+          const size_t dstBit = 7 - (x % 8);
+          rowBuffer[dstByte] &= ~(1 << dstBit);
+        }
       }
 
-      // Row buffer is rowSize2 bytes and zero-padded, write it whole
-      coverBmp.write(rowBuffer, rowSize2);
+      // Write converted row
+      coverBmp.write(rowBuffer, dstRowSize);
+
+      // Pad to 4-byte boundary
+      uint8_t padding[4] = {0, 0, 0, 0};
+      size_t paddingSize = rowSize - dstRowSize;
+      if (paddingSize > 0) {
+        coverBmp.write(padding, paddingSize);
+      }
     }
 
     free(rowBuffer);
   } else {
-    // Write 1-bit BMP header (top-down row order)
-    BmpHeader bmpHeader;
-    createBmpHeader(&bmpHeader, pageInfo.width, pageInfo.height, BmpRowOrder::TopDown);
-    coverBmp.write(reinterpret_cast<const uint8_t*>(&bmpHeader), sizeof(bmpHeader));
-
-    const uint32_t rowSize = ((pageInfo.width + 31) / 32) * 4;
     // 1-bit source: write directly with proper padding
     const size_t srcRowSize = (pageInfo.width + 7) / 8;
 
@@ -432,10 +422,9 @@ bool Xtc::generateThumbBmp(int height) const {
                 const uint8_t bit1 = (plane1[byteOffset] >> bitInByte) & 1;
                 const uint8_t bit2 = (plane2[byteOffset] >> bitInByte) & 1;
                 const uint8_t pixelValue = (bit1 << 1) | bit2;
-                // pixelValue: 0=white, 1=dark gray, 2=light gray, 3=black —
-                // same semantics as the cover's kXthToBmp mapping above
-                static constexpr uint8_t kXthToGray[4] = {255, 85, 170, 0};
-                grayValue = kXthToGray[pixelValue];
+                // Convert 2-bit (0-3) to grayscale: 0=black, 3=white
+                // pixelValue: 0=white, 1=light gray, 2=dark gray, 3=black (XTC polarity)
+                grayValue = (3 - pixelValue) * 85;  // 0->255, 1->170, 2->85, 3->0
               }
             }
           } else {

lib/ZipFile/ZipFile.cpp

@@ -397,37 +397,34 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
 
     // Continue out of block with data set
   } else if (fileStat.method == ZIP_METHOD_DEFLATED) {
-    // Read out deflated content from file
-    const auto deflatedData = static_cast<uint8_t*>(malloc(deflatedDataSize));
-    if (deflatedData == nullptr) {
-      LOG_ERR("ZIP", "Failed to allocate memory for decompression buffer");
+    auto* fileReadBuffer = static_cast<uint8_t*>(malloc(1024));
+    if (!fileReadBuffer) {
+      LOG_ERR("ZIP", "Failed to allocate memory for zip file read buffer");
       free(data);
       return nullptr;
     }
 
-    const size_t dataRead = file.read(deflatedData, deflatedDataSize);
+    ZipInflateCtx ctx;
+    ctx.file = &file;
+    ctx.fileRemaining = deflatedDataSize;
+    ctx.readBuf = fileReadBuffer;
+    ctx.readBufSize = 1024;
 
-    if (dataRead != deflatedDataSize) {
-      LOG_ERR("ZIP", "Failed to read data, expected %d got %d", deflatedDataSize, dataRead);
-      free(deflatedData);
+    if (!ctx.reader.init(true)) {
+      LOG_ERR("ZIP", "Failed to init inflate reader");
+      free(fileReadBuffer);
       free(data);
       return nullptr;
     }
+    ctx.reader.setReadCallback(zipReadCallback);
 
-    bool success = false;
-    {
-      InflateReader r;
-      r.init(false);
-      r.setSource(deflatedData, deflatedDataSize);
-      success = r.read(data, inflatedDataSize);
-    }
-    free(deflatedData);
-
-    if (!success) {
+    if (!ctx.reader.read(data, inflatedDataSize)) {
       LOG_ERR("ZIP", "Failed to inflate file");
+      free(fileReadBuffer);
       free(data);
       return nullptr;
     }
+    free(fileReadBuffer);
 
     // Continue out of block with data set
   } else {

lib/hal/HalClock.cpp

@@ -18,8 +18,11 @@ static uint8_t bcdToDec(uint8_t bcd) { return ((bcd >> 4) * 10) + (bcd & 0x0F);
 static uint8_t decToBcd(uint8_t dec) { return ((dec / 10) << 4) | (dec % 10); }
 
 void HalClock::begin() {
+  _usesSdkRtc = false;
   if (!gpio.deviceIsX3()) {
-    _available = false;
+    _available = _sdkRtc.begin();
+    _usesSdkRtc = _available;
+    LOG_INF("CLK", _available ? "SDK RTC found" : "RTC not found");
     return;
   }
 
@@ -57,6 +60,24 @@ bool HalClock::getTime(uint8_t& hour, uint8_t& minute) const {
     return true;
   }
 
+  if (_usesSdkRtc) {
+    Rtc::DateTime dt;
+    if (!_sdkRtc.now(dt)) {
+      if (!_hasCachedTime) return false;
+      _lastPollMs = now;
+      hour = _cachedHour;
+      minute = _cachedMinute;
+      return true;
+    }
+    _cachedHour = dt.hour;
+    _cachedMinute = dt.minute;
+    _lastPollMs = now;
+    _hasCachedTime = true;
+    hour = _cachedHour;
+    minute = _cachedMinute;
+    return true;
+  }
+
   // Read 3 bytes starting at register 0x00: seconds, minutes, hours
   Wire.beginTransmission(I2C_ADDR_DS3231);
   Wire.write(DS3231_SEC_REG);
@@ -131,6 +152,25 @@ bool HalClock::writeTimeToRTC(uint8_t hour, uint8_t minute, uint8_t second) {
   assert(hour < 24);
   assert(minute < 60);
   assert(second < 60);
+  if (_usesSdkRtc) {
+    Rtc::DateTime dt;
+    dt.hour = hour;
+    dt.minute = minute;
+    dt.second = second;
+    dt.year = 2000;
+    dt.month = 1;
+    dt.day = 1;
+    if (!_sdkRtc.set(dt)) {
+      LOG_ERR("CLK", "Failed to write time to SDK RTC");
+      return false;
+    }
+    _lastPollMs = 0;
+    _cachedHour = hour;
+    _cachedMinute = minute;
+    _hasCachedTime = true;
+    return true;
+  }
+
   Wire.beginTransmission(I2C_ADDR_DS3231);
   Wire.write(DS3231_SEC_REG);    // Start at register 0x00
   Wire.write(decToBcd(second));  // 0x00: Seconds
@@ -168,6 +208,27 @@ bool HalClock::syncFromNTP() {
       struct tm timeinfo;
       gmtime_r(&now, &timeinfo);
 
+      if (_usesSdkRtc) {
+        Rtc::DateTime dt;
+        dt.year = static_cast<uint16_t>(timeinfo.tm_year + 1900);
+        dt.month = static_cast<uint8_t>(timeinfo.tm_mon + 1);
+        dt.day = static_cast<uint8_t>(timeinfo.tm_mday);
+        dt.hour = static_cast<uint8_t>(timeinfo.tm_hour);
+        dt.minute = static_cast<uint8_t>(timeinfo.tm_min);
+        dt.second = static_cast<uint8_t>(timeinfo.tm_sec);
+        dt.weekday = static_cast<uint8_t>(timeinfo.tm_wday);
+        if (_sdkRtc.set(dt)) {
+          _lastPollMs = 0;
+          _cachedHour = dt.hour;
+          _cachedMinute = dt.minute;
+          _hasCachedTime = true;
+          LOG_INF("CLK", "RTC set to %04u-%02u-%02u %02u:%02u:%02u UTC", dt.year, dt.month, dt.day, dt.hour, dt.minute,
+                  dt.second);
+          return true;
+        }
+        return false;
+      }
+
       if (writeTimeToRTC(timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec)) {
         LOG_INF("CLK", "RTC set to %02d:%02d:%02d UTC", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
         return true;

lib/hal/HalClock.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Arduino.h>
+#include <Rtc.h>
 #include <Wire.h>
 
 #include "HalGPIO.h"
@@ -10,6 +11,8 @@ extern HalClock halClock;  // Singleton
 
 class HalClock {
   bool _available = false;
+  bool _usesSdkRtc = false;
+  mutable Rtc _sdkRtc;
   mutable uint8_t _cachedHour = 0;
   mutable uint8_t _cachedMinute = 0;
   mutable bool _hasCachedTime = false;

lib/hal/HalDisplay.cpp

@@ -81,6 +81,27 @@ void HalDisplay::copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* m
   einkDisplay.copyGrayscaleBuffers(lsbBuffer, msbBuffer);
 }
 
+void HalDisplay::displayGrayscaleBase(RefreshMode fallback, bool turnOffScreen) {
+  // X3: a HALF fallback means the caller wants a clean base (e.g. the sleep
+  // cover, a full-screen swap from arbitrary prior content). Without this, the
+  // X3 grayscale base takes its gentle differential happy path and the prior
+  // home/reader frame ghosts through the soft aa_pre_bw_mid waveform. Forcing a
+  // resync makes displayGrayscaleBase clear first, matching displayBuffer(HALF).
+  // The reader's FAST path is deliberately left on the differential path so
+  // per-page grayscale stays cheap.
+  if (gpio.deviceIsX3() && fallback == RefreshMode::HALF_REFRESH) {
+    einkDisplay.requestResync(1);
+  }
+
+  einkDisplay.displayGrayscaleBase(convertRefreshMode(fallback), turnOffScreen);
+}
+
+void HalDisplay::preconditionGrayscale() { einkDisplay.preconditionGrayscale(); }
+
+void HalDisplay::preconditionGrayscale(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
+  einkDisplay.preconditionGrayscale(x, y, w, h);
+}
+
 void HalDisplay::copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer) { einkDisplay.copyGrayscaleLsbBuffers(lsbBuffer); }
 
 void HalDisplay::copyGrayscaleMsbBuffers(const uint8_t* msbBuffer) { einkDisplay.copyGrayscaleMsbBuffers(msbBuffer); }

lib/hal/HalDisplay.h

@@ -47,6 +47,19 @@ class HalDisplay {
   // Access to frame buffer
   uint8_t* getFrameBuffer() const;
 
+  // X3 grayscale preconditioning (OEM "AA-pre-BW(mid)" settle pass), windowed
+  // to the gray region in physical panel coordinates (no-arg = full frame).
+  // Call after the BW base frame is displayed and before the grayscale planes
+  // are written; no-op on X4. See EInkDisplay::preconditionGrayscale.
+  void preconditionGrayscale();
+  void preconditionGrayscale(uint16_t x, uint16_t y, uint16_t w, uint16_t h);
+
+  // Display the framebuffer as the base frame for a grayscale overlay that
+  // follows. On X3, HALF fallback first requests a resync to match
+  // displayBuffer(HALF); FAST fallback keeps the OEM differential base waveform
+  // ("AA-pre-BW(mid)"). Other panels display normally with `fallback` mode.
+  void displayGrayscaleBase(RefreshMode fallback = HALF_REFRESH, bool turnOffScreen = false);
+
   void copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer);
   void copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer);
   void copyGrayscaleMsbBuffers(const uint8_t* msbBuffer);

lib/hal/HalGPIO.cpp

@@ -1,5 +1,6 @@
 #include <HalGPIO.h>
 #include <Logging.h>
+#include <PowerManager.h>
 #include <Preferences.h>
 #include <SPI.h>
 #include <Wire.h>
@@ -192,14 +193,44 @@ HalGPIO::DeviceType detectDeviceTypeWithFingerprint() {
 
 void HalGPIO::begin() {
   inputMgr.begin();
+#if FREEINK_MCU_C3
+  // Claim the shared SPI bus with the X4/X3 display+SD pins. These EPD_* pin
+  // macros are hardcoded C3/Xteink values, so this pre-claim is only valid on the
+  // C3 family. On other boards (M5Paper's IT8951, Sticky's SSD1677, ...) the SDK
+  // driver and SDCardManager bring up SPI from BoardConfig::ACTIVE pins; pre-
+  // claiming here would stick (SPIClass::begin early-returns once the bus is
+  // started) and leave the display/SD on the wrong pins.
   SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS);
+#endif
 
+#if FREEINK_MCU_C3
   _deviceType = detectDeviceTypeWithFingerprint();
 
+  // Sync the runtime board profile to the detected device NOW, before any I2C
+  // consumer begins. powerManager/clock/tilt begin() run immediately after this
+  // in setup() and rely on BoardConfig::ACTIVE: HalPowerManager only calls
+  // Wire.begin() when the active profile has an I2C gauge (gaugeAddr != 0), and
+  // the X3 clock/tilt raw-Wire paths assume that begin happened. The dual X3+X4
+  // binary boots as X4 (gaugeAddr 0), so without this the X4 profile stays active
+  // through those begins, Wire is never (re)initialised after the detection probe
+  // end()s it, and every X3 read fails with lock==NULL ("could not acquire lock"
+  // / "NULL TX buffer pointer"). FreeInkDisplay also calls selectDevice() later,
+  // but that is after the I2C consumers — too late. selectDevice() is idempotent.
+  BoardConfig::selectDevice(deviceIsX3() ? BoardConfig::Board::XteinkX3 : BoardConfig::Board::XteinkX4);
+
   if (deviceIsX4()) {
     pinMode(BAT_GPIO0, INPUT);
     pinMode(UART0_RXD, INPUT);
   }
+#else
+  // Non-C3 boards (S3/ESP32) are single-device builds; their pins, panel, and
+  // battery backend all come from BoardConfig::ACTIVE. The X3/X4 fingerprint probe
+  // targets Xteink C3 hardware and drives Wire on X3_I2C_SDA/SCL (GPIO20/0) — which
+  // collides with this board's own I2C (e.g. Sticky's BQ27220 gauge shares GPIO0)
+  // and reconfigures strapping pins. Skip it; _deviceType stays X4 ("not X3"),
+  // the correct non-X3 branch for every deviceIsX3() consumer.
+  _deviceType = DeviceType::X4;
+#endif
 }
 
 void HalGPIO::update() {
@@ -225,30 +256,55 @@ unsigned long HalGPIO::getHeldTime() const { return inputMgr.getHeldTime(); }
 
 unsigned long HalGPIO::getPowerButtonHeldTime() const { return inputMgr.getPowerButtonHeldTime(); }
 
+bool HalGPIO::wasTouchTap(float& nx, float& ny) const { return inputMgr.wasTouchTap(nx, ny); }
+
+bool HalGPIO::wasTouchDown(float& nx, float& ny) const { return inputMgr.wasTouchPressedAt(nx, ny); }
+
+bool HalGPIO::isTouchTapCandidate(float& nx, float& ny, unsigned long& heldMs) const {
+  return inputMgr.isTouchTapCandidate(nx, ny, heldMs);
+}
+
+unsigned long HalGPIO::lastTouchHeldMs() const { return inputMgr.lastTouchHeldMs(); }
+
+bool HalGPIO::wasSwipe(float& nxStart, float& nyStart, float& nxEnd, float& nyEnd) const {
+  return inputMgr.wasSwipe(nxStart, nyStart, nxEnd, nyEnd);
+}
+
+bool HalGPIO::hasTouch() const { return inputMgr.hasTouch(); }
+
+bool HalGPIO::wasTouchActivity() const { return inputMgr.wasTouchActivity(); }
+
+bool HalGPIO::isXteinkDevice() const {
+  const auto board = BoardConfig::ACTIVE.board;
+  return board == BoardConfig::Board::XteinkX3 || board == BoardConfig::Board::XteinkX4;
+}
+
 void HalGPIO::startDeepSleep() {
   // Ensure that the power button has been released to avoid immediately turning back on if you're holding it
   while (inputMgr.isPressed(BTN_POWER)) {
     delay(50);
     inputMgr.update();
   }
-  // Arm the wakeup trigger *after* the button is released
-  esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
-  // Enter Deep Sleep
-  esp_deep_sleep_start();
+  freeink::PowerManager::armPowerButtonWakeup();
+  freeink::PowerManager::deepSleep();
 }
 
 void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed) {
+  if (BoardConfig::ACTIVE.input.power < 0) {
+    // No readable power-button input pin: can't verify a hold, so don't sleep.
+    return;
+  }
+#if defined(FREEINK_DEVICE_M5PAPER) && FREEINK_DEVICE_M5PAPER
+  // M5Paper: power-on is a hardware latch and the "power button" is the rotary
+  // push (G38), shared with Confirm. A USB/flash cold boot is indistinguishable
+  // from an intentional power-on hold here, so skip the X4-style anti-accidental-
+  // wake check and always boot. G38 still serves as the deep-sleep wake source.
+  return;
+#endif
   if (shortPressAllowed) {
     // Fast path - no duration check needed
     return;
   }
-  // TODO: Intermittent edge case remains: a single tap followed by another single tap
-  // can still power on the device. Tighten wake debounce/state handling here.
-
-  // Calibrate: subtract boot time already elapsed, assuming button held since boot
-  const uint16_t calibration = millis();
-  const uint16_t calibratedDuration = (calibration < requiredDurationMs) ? (requiredDurationMs - calibration) : 1;
-
   const auto start = millis();
   inputMgr.update();
   // inputMgr.isPressed() may take up to ~500ms to return correct state
@@ -257,11 +313,12 @@ void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPre
     inputMgr.update();
   }
   if (inputMgr.isPressed(BTN_POWER)) {
+    const auto holdStart = millis();
     do {
       delay(10);
       inputMgr.update();
-    } while (inputMgr.isPressed(BTN_POWER) && inputMgr.getPowerButtonHeldTime() < calibratedDuration);
-    if (inputMgr.getPowerButtonHeldTime() < calibratedDuration) {
+    } while (inputMgr.isPressed(BTN_POWER) && millis() - holdStart < requiredDurationMs);
+    if (millis() - holdStart < requiredDurationMs) {
       startDeepSleep();
     }
   } else {
@@ -282,8 +339,10 @@ bool HalGPIO::isUsbConnected() const {
     }
     return false;
   }
-  // U0RXD/GPIO20 reads HIGH when USB is connected
-  return digitalRead(UART0_RXD) == HIGH;
+  if (BoardConfig::ACTIVE.usbDetect < 0) {
+    return false;
+  }
+  return digitalRead(BoardConfig::ACTIVE.usbDetect) == HIGH;
 }
 
 HalGPIO::WakeupReason HalGPIO::getWakeupReason() const {
@@ -292,8 +351,11 @@ HalGPIO::WakeupReason HalGPIO::getWakeupReason() const {
 
   const bool usbConnected = isUsbConnected();
 
-  if ((wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_POWERON && !usbConnected) ||
-      (wakeupCause == ESP_SLEEP_WAKEUP_GPIO && resetReason == ESP_RST_DEEPSLEEP && usbConnected)) {
+  if (resetReason == ESP_RST_DEEPSLEEP &&
+      (wakeupCause == ESP_SLEEP_WAKEUP_GPIO || wakeupCause == ESP_SLEEP_WAKEUP_EXT1)) {
+    return WakeupReason::PowerButton;
+  }
+  if (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_POWERON && !usbConnected) {
     return WakeupReason::PowerButton;
   }
   if (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_UNKNOWN && usbConnected) {

lib/hal/HalGPIO.h

@@ -59,6 +59,11 @@ class HalGPIO {
   inline bool deviceIsX3() const { return _deviceType == DeviceType::X3; }
   inline bool deviceIsX4() const { return _deviceType == DeviceType::X4; }
 
+  // True on the Xteink X3/X4 boards. Unlike deviceIsX3/X4 (which both stay "X4"
+  // on non-C3 boards), this keys off BoardConfig::ACTIVE.board, so it reliably
+  // gates Xteink-only features (sunlight fix) and non-Xteink-only ones (touch).
+  bool isXteinkDevice() const;
+
   // Start button GPIO and setup SPI for screen and SD card
   void begin();
 
@@ -72,6 +77,34 @@ class HalGPIO {
   unsigned long getHeldTime() const;
   unsigned long getPowerButtonHeldTime() const;
 
+  // Touch: one-shot tap with the release position normalized 0..1 in the panel's
+  // native orientation. Returns false on non-touch devices. (Reusable gesture
+  // primitive; see MappedInputManager for the top-left = Back mapping.)
+  bool wasTouchTap(float& nx, float& ny) const;
+
+  // Press-edge of a touch: true on touch-down with the down position normalized
+  // 0..1 (panel native). For showing the pressed/selected element before release.
+  bool wasTouchDown(float& nx, float& ny) const;
+
+  // True while a touch remains within tap slop; writes touch-down position and held time.
+  bool isTouchTapCandidate(float& nx, float& ny, unsigned long& heldMs) const;
+
+  // Duration (ms) of the last touch contact, latched on release. Valid on the
+  // release frame (alongside wasTouchTap). For tap-vs-long-press decisions.
+  unsigned long lastTouchHeldMs() const;
+
+  // Swipe (flick) gesture on the release frame: writes the start/end positions
+  // normalized 0..1 in the panel's native frame (map via GfxRenderer::tapToLogical).
+  // A swipe also raises wasTouchTap(), so check this first. False on non-touch.
+  bool wasSwipe(float& nxStart, float& nyStart, float& nxEnd, float& nyEnd) const;
+
+  // True if a touch controller is present/active (runtime gate; false on the C3).
+  bool hasTouch() const;
+
+  // True if a touch press or release happened this frame (the touch analogue of
+  // wasAnyPressed/Released), for resetting idle/sleep timers and CPU frequency.
+  bool wasTouchActivity() const;
+
   // Setup wake up GPIO and enter deep sleep
   void startDeepSleep();
 

lib/hal/HalPowerManager.cpp

@@ -1,6 +1,7 @@
 #include "HalPowerManager.h"
 
 #include <Logging.h>
+#include <PowerManager.h>
 #include <WiFi.h>
 #include <esp_sleep.h>
 
@@ -10,15 +11,32 @@
 
 HalPowerManager powerManager;  // Singleton instance
 
+namespace {
+// The fuel gauge's I2C controller (Wire or Wire1) per the active board profile.
+// On single-bus SoCs (ESP32-C3, SOC_I2C_NUM == 1) Wire1 doesn't exist, so always
+// use Wire. On Sticky the gauge is on Wire1 so it doesn't fight the GT911 touch,
+// which owns Wire.
+TwoWire& gaugeWire() {
+#if SOC_I2C_NUM > 1
+  if (BoardConfig::ACTIVE.batteryGauge.i2cBus == 1) return Wire1;
+#endif
+  return Wire;
+}
+}  // namespace
+
 void HalPowerManager::begin() {
-  if (gpio.deviceIsX3()) {
-    // X3 uses an I2C fuel gauge for battery monitoring.
-    // I2C init must come AFTER gpio.begin() so early hardware detection/probes are finished.
-    Wire.begin(X3_I2C_SDA, X3_I2C_SCL, X3_I2C_FREQ);
-    Wire.setTimeOut(4);
+  const auto& gauge = BoardConfig::ACTIVE.batteryGauge;
+  if (gauge.gaugeAddr != 0) {
+    // Board has an I2C fuel gauge (X3, LilyGo, Sticky, ...). Pins/freq come from
+    // the active board profile, not hardcoded X3 values. I2C init must come AFTER
+    // gpio.begin() so early hardware detection/probes are finished.
+    gaugeWire().begin(gauge.i2cSda, gauge.i2cScl, gauge.i2cHz);
+    gaugeWire().setTimeOut(4);
     _batteryUseI2C = true;
-  } else {
-    pinMode(BAT_GPIO0, INPUT);
+  } else if (BoardConfig::ACTIVE.batteryAdc >= 0) {
+    // ADC-sensed board (X4: GPIO0, M5Paper: GPIO35). Skip when the profile leaves
+    // batteryAdc unassigned (PIN_UNASSIGNED) — pinMode(255) faults the GPIO mux.
+    pinMode(BoardConfig::ACTIVE.batteryAdc, INPUT);
   }
   normalFreq = getCpuFrequencyMhz();
   modeMutex = xSemaphoreCreateMutex();
@@ -76,22 +94,19 @@ void HalPowerManager::startDeepSleep(HalGPIO& gpio) const {
 #endif
 
   // Pre-sleep routines from the original firmware
+#if !SOC_PM_SUPPORT_EXT1_WAKEUP  // RISC-V (C3 / X4)
   // GPIO13 is connected to battery latch MOSFET, we need to make sure it's low during sleep
   // Note that this means the MCU will be completely powered off during sleep, including RTC
+  // (X4-specific: on classic ESP32/M5Paper GPIO13 is SD MISO, so this is skipped.)
   constexpr gpio_num_t GPIO_SPIWP = GPIO_NUM_13;
   gpio_set_direction(GPIO_SPIWP, GPIO_MODE_OUTPUT);
   gpio_set_level(GPIO_SPIWP, 0);
   esp_sleep_config_gpio_isolate();
   gpio_deep_sleep_hold_en();
   gpio_hold_en(GPIO_SPIWP);
-  pinMode(InputManager::POWER_BUTTON_PIN, INPUT_PULLUP);
-  // Arm the wakeup trigger *after* the button is released
-  // Note: this is only useful for waking up on USB power. On battery, the MCU will be completely powered off, so the
-  // power button is hard-wired to briefly provide power to the MCU, waking it up regardless of the wakeup source
-  // configuration
-  esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
-  // Enter Deep Sleep
-  esp_deep_sleep_start();
+#endif
+  freeink::PowerManager::armPowerButtonWakeup();
+  freeink::PowerManager::deepSleep();
 }
 
 uint16_t HalPowerManager::getBatteryPercentage() const {
@@ -101,27 +116,32 @@ uint16_t HalPowerManager::getBatteryPercentage() const {
       return _batteryCachedPercent;
     }
 
-    // Read SOC directly from I2C fuel gauge (16-bit LE register).
-    // On I2C error, keep last known value to avoid UI jitter/slowdowns.
-    Wire.beginTransmission(I2C_ADDR_BQ27220);
-    Wire.write(BQ27220_SOC_REG);
-    if (Wire.endTransmission(false) != 0) {
+    // Read SOC directly from the I2C fuel gauge (16-bit LE register). Gauge
+    // address comes from the active board profile (all current gauges are
+    // BQ27220-class, SOC at 0x2C). On I2C error, keep last known value to avoid
+    // UI jitter/slowdowns.
+    const uint8_t gaugeAddr = BoardConfig::ACTIVE.batteryGauge.gaugeAddr;
+    TwoWire& w = gaugeWire();
+    w.beginTransmission(gaugeAddr);
+    w.write(BQ27220_SOC_REG);
+    if (w.endTransmission(false) != 0) {
       _batteryLastPollMs = now;
       return _batteryCachedPercent;
     }
-    Wire.requestFrom(I2C_ADDR_BQ27220, (uint8_t)2);
-    if (Wire.available() < 2) {
+    w.requestFrom(gaugeAddr, (uint8_t)2);
+    if (w.available() < 2) {
       _batteryLastPollMs = now;
       return _batteryCachedPercent;
     }
-    const uint8_t lo = Wire.read();
-    const uint8_t hi = Wire.read();
+    const uint8_t lo = w.read();
+    const uint8_t hi = w.read();
     const uint16_t soc = (hi << 8) | lo;
     _batteryCachedPercent = soc > 100 ? 100 : soc;
     _batteryLastPollMs = now;
     return _batteryCachedPercent;
   }
-  static const BatteryMonitor battery = BatteryMonitor(BAT_GPIO0);
+  // ADC pin from the active profile (X4 GPIO0 / M5Paper GPIO35); default 2:1 divider.
+  static const BatteryMonitor battery = BatteryMonitor(BoardConfig::ACTIVE.batteryAdc);
 
   // smooth the battery %.
   if (_batteryCachedPercent == 0) {

lib/hal/HalPowerManager.h

@@ -28,7 +28,16 @@ class HalPowerManager {
   SemaphoreHandle_t modeMutex = nullptr;  // Protect access to currentLockMode
 
  public:
-  static constexpr int LOW_POWER_FREQ = 10;                    // MHz
+  // On PSRAM boards (classic ESP32 / M5Paper) the APB clock follows the CPU below
+  // 80 MHz, and APB clocks both the SD SPI bus and the 80 MHz PSRAM (which holds
+  // the framebuffer). Dropping to 10 MHz breaks SD writes and PSRAM, so floor the
+  // low-power CPU at 80 MHz (APB stays pinned at 80 for CPU 80/160/240, so power
+  // still drops from the 240 MHz default while SD/PSRAM stay stable).
+#if defined(BOARD_HAS_PSRAM)
+  static constexpr int LOW_POWER_FREQ = 80;  // MHz (APB-safe floor for PSRAM/SD)
+#else
+  static constexpr int LOW_POWER_FREQ = 10;  // MHz
+#endif
   static constexpr unsigned long IDLE_POWER_SAVING_MS = 3000;  // ms
   static constexpr unsigned long BATTERY_POLL_MS = 1500;       // ms
 

lib/hal/HalSystem.cpp

@@ -38,6 +38,13 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
     __real_panic_print_backtrace(frame, core);
     return;
   }
+#if !__riscv
+  // RvExcFrame and the flat SP scan below are RISC-V-only (C3). On Xtensa
+  // (classic ESP32 / S3) the exception frame is XtExcFrame with windowed-register
+  // unwinding, so fall back to the default backtrace.
+  __real_panic_print_backtrace(frame, core);
+  return;
+#else
   for (size_t i = 0; i < MAX_PANIC_STACK_DEPTH; i++) {
     panicStack[i].sp = 0;
   }
@@ -65,6 +72,7 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
   }
 
   __real_panic_print_backtrace(frame, core);
+#endif  // __riscv
 }
 }
 

lib/hal/HalTiltSensor.cpp

@@ -26,6 +26,15 @@ bool HalTiltSensor::readReg(uint8_t reg, uint8_t* val) const {
 }
 
 bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const {
+  if (_backend == Backend::SdkImu) {
+    Imu::Sample sample;
+    if (!_sdkImu.read(sample)) return false;
+    gx = sample.gx;
+    gy = sample.gy;
+    gz = sample.gz;
+    return true;
+  }
+
   Wire.beginTransmission(_i2cAddr);
   Wire.write(REG_GX_L);  // Start reading at Gyro X Low
   if (Wire.endTransmission(false) != 0) {
@@ -52,11 +61,22 @@ bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const {
 }
 
 void HalTiltSensor::begin() {
+  _backend = Backend::None;
   if (!gpio.deviceIsX3()) {
-    _available = false;
+    _available = _sdkImu.begin();
+    if (!_available) {
+      LOG_ERR("GYR", "SDK IMU not found");
+      return;
+    }
+    _backend = Backend::SdkImu;
+    _initMs = millis();
+    _lastPollMs = millis();
+    LOG_INF("GYR", "SDK IMU initialized");
     return;
   }
 
+  _backend = Backend::Qmi8658;
+
   // Try primary address, then alternate
   uint8_t whoami = 0;
   _i2cAddr = I2C_ADDR_QMI8658;
@@ -89,6 +109,14 @@ bool HalTiltSensor::wake() {
     return false;
   }
 
+  if (_backend == Backend::SdkImu) {
+    _lastPollMs = millis();
+    _lastTiltMs = millis();
+    _wakeMs = millis();
+    _isAwake = true;
+    return true;
+  }
+
   // Wait for init to complete before waking
   if ((millis() - _initMs) < SLEEP_STABILIZE_MS) {
     return false;
@@ -111,6 +139,13 @@ bool HalTiltSensor::deepSleep() {
     return false;
   }
 
+  if (_backend == Backend::SdkImu) {
+    clearPendingEvents();
+    _inTilt = false;
+    _isAwake = false;
+    return true;
+  }
+
   if ((millis() - _wakeMs) < SLEEP_STABILIZE_MS) {
     return false;
   }

lib/hal/HalTiltSensor.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Arduino.h>
+#include <Imu.h>
 #include <Wire.h>
 
 #include "HalGPIO.h"
@@ -18,8 +19,12 @@ class HalTiltSensor;
 extern HalTiltSensor halTiltSensor;  // Singleton
 
 class HalTiltSensor {
+  enum class Backend : uint8_t { None, Qmi8658, SdkImu };
+
   bool _available = false;
+  Backend _backend = Backend::None;
   uint8_t _i2cAddr = 0;
+  mutable Imu _sdkImu;
 
   // Tilt gesture state machine
   bool _tiltForwardEvent = false;  // Consumed by wasTiltedForward()

platformio.ini

@@ -4,7 +4,7 @@ build_cache_dir = .cache
 extra_configs = platformio.local.ini
 
 [crosspoint]
-version = 1.3.0
+version = 1.4.1
 
 [base]
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
@@ -55,47 +55,121 @@ extra_scripts =
   pre:scripts/patch_jpegdec.py
   post:scripts/register_unit_tests_target.py
 
-; Libraries
+; Libraries — FreeInk SDK (git submodule at ./freeink-sdk). The left-hand names
+; are the include paths the firmware already uses (<EInkDisplay.h>, etc.); FreeInk's
+; compat shim preserves them. BoardConfig + PowerManager are FreeInk-only and
+; required (device profiles + the SoC-correct deep-sleep wakeup the HAL relies on).
 lib_deps =
-  BatteryMonitor=symlink://open-x4-sdk/libs/hardware/BatteryMonitor
-  InputManager=symlink://open-x4-sdk/libs/hardware/InputManager
-  EInkDisplay=symlink://open-x4-sdk/libs/display/EInkDisplay
-  SDCardManager=symlink://open-x4-sdk/libs/hardware/SDCardManager
+  BatteryMonitor=symlink://freeink-sdk/libs/hardware/BatteryMonitor
+  InputManager=symlink://freeink-sdk/libs/hardware/InputManager
+  EInkDisplay=symlink://freeink-sdk/libs/display/FreeInkDisplay
+  SDCardManager=symlink://freeink-sdk/libs/hardware/SDCardManager
+  BoardConfig=symlink://freeink-sdk/libs/hardware/BoardConfig
+  PowerManager=symlink://freeink-sdk/libs/hardware/PowerManager
+  Rtc=symlink://freeink-sdk/libs/hardware/Rtc
+  Imu=symlink://freeink-sdk/libs/hardware/Imu
+  FreeInkUI=symlink://freeink-sdk/libs/ui/FreeInkUI
+  Icons=symlink://freeink-sdk/libs/assets/Icons
   bblanchon/ArduinoJson @ 7.4.2
   ricmoo/QRCode @ 0.0.1
   bitbank2/PNGdec @ 1.1.6
   https://github.com/bitbank2/JPEGDEC.git#86282979224c8a32fd51e091ed5a35b0c699a52b
   links2004/WebSockets @ 2.7.3
 
-[env:default]
+; ESP32-C3 device set: X3 + X4 compiled into one binary, runtime-selected after
+; the I2C fingerprint. FreeInk requires an explicit device selection, so the C3
+; envs extend this instead of [base] directly. (M5Paper is a different MCU family
+; and selects its own device below.)
+[c3]
 extends = base
 build_flags =
   ${base.build_flags}
+  -DFREEINK_DEVICE_X3=1
+  -DFREEINK_DEVICE_X4=1
+
+[env:default]
+extends = c3
+build_flags =
+  ${c3.build_flags}
   ; CROSSPOINT_VERSION is set by scripts/git_branch.py (includes branch + short SHA)
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=2 ; Set log level to debug for development builds
 
 
 [env:gh_release]
-extends = base
+extends = c3
 build_flags =
-  ${base.build_flags}
+  ${c3.build_flags}
   -DCROSSPOINT_VERSION=\"${crosspoint.version}\"
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=1 ; Set log level to info for release builds
 
 [env:gh_release_rc]
-extends = base
+extends = c3
 build_flags =
-  ${base.build_flags}
+  ${c3.build_flags}
   -DCROSSPOINT_VERSION=\"${crosspoint.version}-rc+${sysenv.CROSSPOINT_RC_HASH}\"
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=1 ; Set log level to info for release candidate builds
 
 [env:slim]
-extends = base
+extends = c3
 build_flags =
-  ${base.build_flags}
+  ${c3.build_flags}
   -DCROSSPOINT_VERSION=\"${crosspoint.version}-slim\"
   ; serial output is disabled in slim builds to save space
   -UENABLE_SERIAL_LOG
+
+; --- LilyGo T5 S3 (ESP32-S3 N16R8, 4.7" ED047TC1 / raw-parallel EPD) ---------
+; Uses FreeInk's LilyGo board-support library for the PCA9535/TPS65185 display
+; power hooks and expander button.
+;   pio run -e lilygo_t5s3 -t upload --upload-port /dev/tty.usbmodemXXXX
+[env:lilygo_t5s3]
+extends = base
+board = esp32-s3-devkitc1-n16r8
+board_build.mcu = esp32s3
+board_build.flash_mode = qio
+board_build.arduino.memory_type = qio_opi
+build_flags =
+  ${base.build_flags}
+  -DBOARD_HAS_PSRAM
+  -DFREEINK_DEVICE_LILYGO=1
+  -DCROSSPOINT_VERSION=\"${crosspoint.version}-lilygo_t5s3\"
+  -DCROSSPOINT_SHOW_BUTTON_HINTS=0
+  -DENABLE_SERIAL_LOG
+  -DLOG_LEVEL=2
+  -DTOUCH_PROBE_DEBUG=1
+lib_deps =
+  ${base.lib_deps}
+  BoardT5S3=symlink://freeink-sdk/libs/hardware/BoardT5S3
+  m5stack/M5GFX @ 0.2.20
+
+; --- M5Paper v1.1 (classic ESP32-D0WDQ6, 4.7" 540x960 / IT8951E) -------------
+; Different MCU family than the C3 base: override board/mcu/flash, disable the
+; C3-only native-USB CDC (logs over UART0), and select the M5Paper device.
+;   pio run -e m5paper_v11 -t upload --upload-port /dev/tty.usbserial-XXXX
+[env:m5paper_v11]
+extends = base
+board = esp32dev
+board_build.mcu = esp32
+board_build.flash_mode = qio
+; CP2104 bridge: 460800 is ~4x the 115200 fallback and reliable; drop if a flash
+; stalls. (921600 usually works too.)
+upload_speed = 460800
+build_flags =
+  ${base.build_flags}
+  -UARDUINO_USB_MODE
+  -UARDUINO_USB_CDC_ON_BOOT
+  -DBOARD_HAS_PSRAM
+  -DFREEINK_DEVICE_M5PAPER=1
+  ; git_branch.py only injects CROSSPOINT_VERSION for the default env; set it here.
+  -DCROSSPOINT_VERSION=\"${crosspoint.version}-m5paper_v11\"
+  -DENABLE_SERIAL_LOG
+  -DLOG_LEVEL=2
+  ; Touch + rotary: no physical button row, so hide on-screen button hints.
+  -DCROSSPOINT_SHOW_BUTTON_HINTS=0
+  ; Archive-order workarounds for the classic-ESP32 link (see freeink-sdk
+  ; platformio.crosspoint.sample.ini): force Arduino startup + the I2C HAL members.
+  -Wl,.pio/build/m5paper_v11/FrameworkArduino/main.cpp.o
+  -Wl,-u,i2cInit
+  -Wl,-u,i2cSlaveInit

scripts/gen_icons.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Regenerate src/components/icons/generated_icons.h from icons.manifest, using the
+# FreeInk SDK icon generator and its vendored Lucide submodule. generated_icons.h is
+# a committed build product of these inputs — re-run this after editing the manifest.
+#
+# Requires: rsvg-convert (librsvg) + Pillow, and the Lucide submodule fetched
+# (git submodule update --init in the SDK).
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+SDK="$ROOT/freeink-sdk"
+SVGDIR="$SDK/libs/assets/Icons/lucide/icons"
+
+if [ ! -d "$SVGDIR" ]; then
+  echo "Lucide SVGs not found at $SVGDIR" >&2
+  echo "Fetch the submodule:  git -C \"$SDK\" submodule update --init libs/assets/Icons/lucide" >&2
+  exit 1
+fi
+
+python3 "$SDK/libs/assets/Icons/tools/gen_icons.py" \
+  --manifest "$ROOT/src/components/icons/icons.manifest" \
+  --svgdir   "$SVGDIR" \
+  --sizes    16,24,32,40,48 \
+  --out      "$ROOT/src/components/icons/generated_icons.h"
+
+echo "Regenerated src/components/icons/generated_icons.h"

src/CrossPointSettings.h

@@ -65,6 +65,8 @@ class CrossPointSettings {
     XTC_STATUS_BAR_MODE_COUNT
   };
 
+  enum STATUS_BAR_CLOCK_MODE { STATUS_BAR_CLOCK_HIDE = 0, STATUS_BAR_CLOCK_RIGHT = 1, STATUS_BAR_CLOCK_LEFT = 2 };
+
   enum ORIENTATION {
     PORTRAIT = 0,       // 480x800 logical coordinates (current default)
     LANDSCAPE_CW = 1,   // 800x480 logical coordinates, rotated 180° (swap top/bottom)
@@ -136,6 +138,17 @@ class CrossPointSettings {
   // Short power button press actions
   enum SHORT_PWRBTN { IGNORE = 0, SLEEP = 1, PAGE_TURN = 2, FORCE_REFRESH = 3, FOOTNOTES = 4, SHORT_PWRBTN_COUNT };
 
+  // Long-press Confirm action while reading an EPUB. The setting cycles through these values.
+  // Persisted in settings.json by index: any new function (e.g. dictionary, bookmark) MUST use a
+  // value >= 2 and be appended at the END of the enumValues array in SettingsList.h, otherwise the
+  // stored indices shift and existing saves are silently misinterpreted.
+  enum LONG_PRESS_MENU_FUNCTION {
+    LP_MENU_KOSYNC = 0,
+    LP_MENU_DISABLED = 1,
+    LP_MENU_BOOKMARK = 2,
+    LONG_PRESS_MENU_FUNCTION_COUNT
+  };
+
   // Hide battery percentage
   enum HIDE_BATTERY_PERCENTAGE { HIDE_NEVER = 0, HIDE_READER = 1, HIDE_ALWAYS = 2, HIDE_BATTERY_PERCENTAGE_COUNT };
 
@@ -177,7 +190,7 @@ class CrossPointSettings {
   uint8_t statusBarBattery = 1;
   uint8_t xtcStatusBarMode = XTC_STATUS_BAR_HIDE;
   // Clock display in status bar (X3 only, requires DS3231 RTC)
-  uint8_t statusBarClock = 0;
+  uint8_t statusBarClock = STATUS_BAR_CLOCK_HIDE;
   // Clock UTC offset in quarter-hour steps, biased by 48 so it fits in uint8_t.
   // Value 48 = UTC+0, 0 = UTC-12:00, 104 = UTC+14:00.
   // Quarter-hour granularity supports oddball zones like Nepal (+5:45) and Chatham (+12:45).
@@ -226,10 +239,16 @@ class CrossPointSettings {
   uint8_t hideBatteryPercentage = HIDE_NEVER;
   // Long-press page turn button behavior
   uint8_t longPressButtonBehavior = OFF;
+  // Long-press Confirm function in EPUB reader (cycles through LONG_PRESS_MENU_FUNCTION values).
+  // Defaults to Disabled so shortcut-based bookmark toggling remains opt-in.
+  uint8_t longPressMenuFunction = LP_MENU_DISABLED;
   // UI Theme
   uint8_t uiTheme = LYRA;
   // Sunlight fading compensation
   uint8_t fadingFix = 0;
+  // Touch reader controls: tap zones for page back/forward + press-and-hold,
+  // mirroring the physical buttons. Touch devices only (hidden elsewhere).
+  uint8_t touchReaderControls = 1;
   // Power button return from footnotes (1 = enabled, 0 = disabled)
   uint8_t pwrBtnFootnoteBack = 1;
   // Use book's embedded CSS styles for EPUB rendering (1 = enabled, 0 = disabled)

src/JsonSettingsIO.cpp

@@ -423,6 +423,9 @@ bool JsonSettingsIO::saveBookmarks(const std::vector<BookmarkEntry>& bookmarks,
     obj["xpath"] = bookmark.xpath;
     obj["percentage"] = bookmark.percentage;
     obj["summary"] = bookmark.summary;
+    obj["si"] = bookmark.computedSpineIndex;
+    obj["pc"] = bookmark.computedChapterPageCount;
+    obj["pp"] = bookmark.computedChapterProgress;
   }
 
   String json;
@@ -447,6 +450,9 @@ bool JsonSettingsIO::loadBookmarks(std::vector<BookmarkEntry>& bookmarks, const
     bookmark.xpath = obj["xpath"] | std::string("");
     bookmark.percentage = obj["percentage"] | static_cast<float>(0);
     bookmark.summary = obj["summary"] | std::string("");
+    bookmark.computedSpineIndex = obj["si"] | static_cast<uint16_t>(0);
+    bookmark.computedChapterPageCount = obj["pc"] | static_cast<uint16_t>(0);
+    bookmark.computedChapterProgress = obj["pp"] | static_cast<uint16_t>(0);
   }
 
   LOG_DBG("BKM", "Loaded %zu bookmarks from file", bookmarks.size());

src/MappedInputManager.cpp

@@ -1,6 +1,21 @@
 #include "MappedInputManager.h"
 
+#include <FreeInkUI.h>
+#include <GfxRenderer.h>
+
+#include <cstdlib>
+
 #include "CrossPointSettings.h"
+#include "components/TouchRegistry.h"
+
+bool MappedInputManager::isNavDirectionSwapped() const {
+  // Key the swap on the orientation the screen is *actually* rendered at, not the persisted reader
+  // setting. The reader (and its modal menus) render rotated, so navigation/labels flip there; the
+  // home and settings UI render in portrait, so they never flip even when a rotated reader is configured.
+  const auto orientation = renderer.getOrientation();
+  return SETTINGS.frontButtonFollowOrientation &&
+         (orientation == GfxRenderer::PortraitInverted || orientation == GfxRenderer::LandscapeCounterClockwise);
+}
 
 bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint8_t) const) const {
   const auto sideLayout = SETTINGS.sideButtonLayout;
@@ -49,14 +64,196 @@ bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint
         default:
           return false;
       }
+    case Button::NavNext:
+      // Logical "next item" navigation: side Down + front Right, with the control axis flipped in
+      // INVERTED / LANDSCAPE_CCW (frontButtonFollowOrientation) so it matches the rotated hint labels.
+      return isNavDirectionSwapped() ? (mapButton(Button::Up, fn) || mapButton(Button::Left, fn))
+                                     : (mapButton(Button::Down, fn) || mapButton(Button::Right, fn));
+    case Button::NavPrevious:
+      // Logical "previous item" navigation: side Up + front Left, axis-flipped in the same orientations.
+      return isNavDirectionSwapped() ? (mapButton(Button::Down, fn) || mapButton(Button::Right, fn))
+                                     : (mapButton(Button::Up, fn) || mapButton(Button::Left, fn));
   }
 
   return false;
 }
 
-bool MappedInputManager::wasPressed(const Button button) const { return mapButton(button, &HalGPIO::wasPressed); }
+// Top-left corner fallback, as a fraction of the logical screen. Generous to hit.
+static constexpr float BACK_GESTURE_FRAC_X = 0.22f;
+static constexpr float BACK_GESTURE_FRAC_Y = 0.12f;
+static constexpr float BOTTOM_EDGE_BACK_GESTURE_FRAC_Y = 0.14f;
+static constexpr unsigned long TOUCH_DOWN_SELECT_DELAY_MS = 90;
+static constexpr unsigned long TOUCH_HELD_OVERRIDE_WINDOW_MS = 250;
 
-bool MappedInputManager::wasReleased(const Button button) const { return mapButton(button, &HalGPIO::wasReleased); }
+void MappedInputManager::rememberTouchHeldTime() const {
+  touchHeldOverrideValid = true;
+  touchHeldOverrideMs = gpio.lastTouchHeldMs();
+  touchHeldOverrideAt = millis();
+}
+
+bool MappedInputManager::wasBottomEdgeSwipeUp() const {
+  float nxs = 0.0f, nys = 0.0f, nxe = 0.0f, nye = 0.0f;
+  if (!gpio.wasSwipe(nxs, nys, nxe, nye)) return false;
+
+  int sx = 0, sy = 0, ex = 0, ey = 0;
+  renderer.tapToLogical(nxs, nys, sx, sy);
+  renderer.tapToLogical(nxe, nye, ex, ey);
+
+  const int screenHeight = renderer.getScreenHeight();
+  const int bottomEdgeTop = screenHeight - static_cast<int>(screenHeight * BOTTOM_EDGE_BACK_GESTURE_FRAC_Y);
+  const bool isBackSwipe = sy >= bottomEdgeTop && ey < sy && std::abs(ey - sy) > std::abs(ex - sx);
+  if (isBackSwipe) rememberTouchHeldTime();
+  return isBackSwipe;
+}
+
+bool MappedInputManager::wasBackGesture() const {
+  if (wasBottomEdgeSwipeUp()) return true;
+
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  int lx = 0, ly = 0;
+  renderer.tapToLogical(nx, ny, lx, ly);
+  // A tap on the theme's header Back target acts as Back.
+  int id = 0;
+  if (TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Back, id)) {
+    rememberTouchHeldTime();
+    return true;
+  }
+  // Else the top-left corner, for screens with no Back target (e.g. the reader).
+  const bool isTopLeftBack =
+      lx <= renderer.getScreenWidth() * BACK_GESTURE_FRAC_X && ly <= renderer.getScreenHeight() * BACK_GESTURE_FRAC_Y;
+  if (isTopLeftBack) rememberTouchHeldTime();
+  return isTopLeftBack;
+}
+
+bool MappedInputManager::wasItemTapped(int& id) const {
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  int lx = 0, ly = 0;
+  renderer.tapToLogical(nx, ny, lx, ly);
+  const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, id);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasItemTouchedDown(int& id) const {
+  float nx = 0.0f, ny = 0.0f;
+  unsigned long heldMs = 0;
+  if (!gpio.isTouchTapCandidate(nx, ny, heldMs)) {
+    touchSelectTracking = false;
+    touchSelectEmitted = false;
+    touchSelectId = -1;
+    return false;
+  }
+
+  if (!touchSelectTracking) {
+    float downNx = 0.0f, downNy = 0.0f;
+    if (!gpio.wasTouchDown(downNx, downNy)) return false;
+
+    int lx = 0, ly = 0;
+    renderer.tapToLogical(downNx, downNy, lx, ly);
+    int candidateId = -1;
+    if (!TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, candidateId)) {
+      touchSelectTracking = false;
+      touchSelectEmitted = false;
+      touchSelectId = -1;
+      return false;
+    }
+    touchSelectTracking = true;
+    touchSelectEmitted = false;
+    touchSelectId = candidateId;
+  }
+
+  if (touchSelectEmitted || heldMs < TOUCH_DOWN_SELECT_DELAY_MS) return false;
+  touchSelectEmitted = true;
+  id = touchSelectId;
+  return true;
+}
+
+bool MappedInputManager::wasItemLongPressed(int& id) const {
+  static constexpr unsigned long TOUCH_LONG_PRESS_MS = 500;
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;  // release frame
+  if (gpio.lastTouchHeldMs() < TOUCH_LONG_PRESS_MS) return false;
+  int lx = 0, ly = 0;
+  renderer.tapToLogical(nx, ny, lx, ly);
+  const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, id);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasTabTapped(int& id) const {
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  int lx = 0, ly = 0;
+  renderer.tapToLogical(nx, ny, lx, ly);
+  const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Tab, id);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasCoverTapped(int& id) const {
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  int lx = 0, ly = 0;
+  renderer.tapToLogical(nx, ny, lx, ly);
+  const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Cover, id);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasScreenTapped(int& x, int& y) const {
+  float nx = 0.0f, ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  renderer.tapToLogical(nx, ny, x, y);
+  rememberTouchHeldTime();
+  return true;
+}
+
+bool MappedInputManager::wasListScroll(int& index, int count, int pageItems) const {
+  if (count <= 0) return false;
+  if (pageItems < 1) pageItems = 1;
+  if (wasBottomEdgeSwipeUp()) return false;
+  const SwipeDir swipe = wasSwipe();
+  if (swipe == SwipeDir::Up) {
+    return freeink::ui::listPageIndex(index, +1, count, pageItems);
+  }
+  if (swipe == SwipeDir::Down) {
+    return freeink::ui::listPageIndex(index, -1, count, pageItems);
+  }
+  return false;
+}
+
+MappedInputManager::SwipeDir MappedInputManager::wasSwipe() const {
+  if (wasBottomEdgeSwipeUp()) return SwipeDir::None;
+
+  float nxs = 0.0f, nys = 0.0f, nxe = 0.0f, nye = 0.0f;
+  if (!gpio.wasSwipe(nxs, nys, nxe, nye)) return SwipeDir::None;
+  // Map both endpoints into the logical frame so the direction follows what the
+  // user sees regardless of panel mount/orientation.
+  int sx = 0, sy = 0, ex = 0, ey = 0;
+  renderer.tapToLogical(nxs, nys, sx, sy);
+  renderer.tapToLogical(nxe, nye, ex, ey);
+  const int dx = ex - sx;
+  const int dy = ey - sy;
+  if (std::abs(dx) >= std::abs(dy)) {
+    return dx < 0 ? SwipeDir::Left : SwipeDir::Right;
+  }
+  return dy < 0 ? SwipeDir::Up : SwipeDir::Down;
+}
+
+bool MappedInputManager::wasPressed(const Button button) const {
+  // A top-left tap fires on the release frame; expose it on Back's press edge too
+  // so menus that act on wasPressed(Back) also respond. Deliberately NOT folded
+  // into isPressed, so a quick tap never satisfies the readers' long-press-home.
+  if (button == Button::Back && wasBackGesture()) return true;
+  return mapButton(button, &HalGPIO::wasPressed);
+}
+
+bool MappedInputManager::wasReleased(const Button button) const {
+  if (button == Button::Back && wasBackGesture()) return true;
+  return mapButton(button, &HalGPIO::wasReleased);
+}
 
 bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &HalGPIO::isPressed); }
 
@@ -64,14 +261,19 @@ bool MappedInputManager::wasAnyPressed() const { return gpio.wasAnyPressed(); }
 
 bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); }
 
-unsigned long MappedInputManager::getHeldTime() const { return gpio.getHeldTime(); }
+unsigned long MappedInputManager::getHeldTime() const {
+  if (!gpio.wasAnyPressed() && !gpio.wasAnyReleased() && touchHeldOverrideValid &&
+      millis() - touchHeldOverrideAt <= TOUCH_HELD_OVERRIDE_WINDOW_MS) {
+    return touchHeldOverrideMs;
+  }
+  touchHeldOverrideValid = false;
+  return gpio.getHeldTime();
+}
 
 MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const char* confirm, const char* previous,
                                                          const char* next) const {
   // Swap previous/next labels to match the page turn direction swap in INVERTED and LANDSCAPE_CCW.
-  const bool swapLabels =
-      SETTINGS.frontButtonFollowOrientation && (SETTINGS.orientation == CrossPointSettings::INVERTED ||
-                                                SETTINGS.orientation == CrossPointSettings::LANDSCAPE_CCW);
+  const bool swapLabels = isNavDirectionSwapped();
   const char* leftLabel = swapLabels ? next : previous;
   const char* rightLabel = swapLabels ? previous : next;
 

src/MappedInputManager.h

@@ -2,9 +2,12 @@
 
 #include <HalGPIO.h>
 
+class GfxRenderer;
+
 class MappedInputManager {
  public:
-  enum class Button { Back, Confirm, Left, Right, Up, Down, Power, PageBack, PageForward };
+  enum class Button { Back, Confirm, Left, Right, Up, Down, Power, PageBack, PageForward, NavNext, NavPrevious };
+  enum class SwipeDir { None, Left, Right, Up, Down };
 
   struct Labels {
     const char* btn1;
@@ -13,12 +16,39 @@ class MappedInputManager {
     const char* btn4;
   };
 
-  explicit MappedInputManager(HalGPIO& gpio) : gpio(gpio) {}
+  MappedInputManager(HalGPIO& gpio, const GfxRenderer& renderer) : gpio(gpio), renderer(renderer) {}
 
   void update() const { gpio.update(); }
   bool wasPressed(Button button) const;
   bool wasReleased(Button button) const;
   bool isPressed(Button button) const;
+  // Touch "back" gesture: a tap on the theme's header Back target, or in the
+  // top-left corner, or a swipe up from the visible bottom edge. Folded into
+  // Back's edges, so every screen gets it for free.
+  bool wasBackGesture() const;
+  // True (and writes the id) if a tap this frame hit a TouchRegistry item.
+  // Activities treat the id as "select + activate". False on non-touch devices.
+  bool wasItemTapped(int& id) const;
+  // Stable touch-down candidate: fires once when a touch remains over an item
+  // briefly without crossing tap slop, so swipes do not show row selection.
+  bool wasItemTouchedDown(int& id) const;
+  // Subset of wasItemTapped's releases held past the long-press threshold (check
+  // this first). Distinguishes tap vs press-and-hold.
+  bool wasItemLongPressed(int& id) const;
+  // wasItemTapped for tab-bar tabs (id = tab index) and cover/card targets
+  // (id = item index). Distinct kinds so a screen with both doesn't confuse them.
+  bool wasTabTapped(int& id) const;
+  bool wasCoverTapped(int& id) const;
+  // True on a touch release anywhere on screen, with logical/oriented coords.
+  bool wasScreenTapped(int& x, int& y) const;
+  // Swipe direction in the current logical (oriented) frame, or None. A swipe also
+  // raises the tap helpers above, so check this first and consume it.
+  SwipeDir wasSwipe() const;
+  // Page-scroll a list selection by a vertical swipe (touch nav without buttons):
+  // swipe up advances down the list, swipe down moves up, by pageItems, clamped to
+  // [0, count-1]. Updates index and returns true when a vertical swipe occurred, so
+  // callers can requestUpdate() and return before the tap handlers run.
+  bool wasListScroll(int& index, int count, int pageItems) const;
   bool wasAnyPressed() const;
   bool wasAnyReleased() const;
   unsigned long getHeldTime() const;
@@ -26,8 +56,29 @@ class MappedInputManager {
   // Returns the raw front button index that was pressed this frame (or -1 if none).
   int getPressedFrontButton() const;
 
+  // True when the control axis is flipped relative to the physical buttons: the user opted into
+  // orientation-following front buttons AND the screen is *currently rendered* rotated (INVERTED /
+  // LANDSCAPE_CCW). Keyed on the live renderer orientation rather than the persisted reader setting,
+  // so portrait UI (home, settings) never swaps while the reader and its menus do.
+  [[nodiscard]] bool isNavDirectionSwapped() const;
+
  private:
   HalGPIO& gpio;
+  // Logical-to-physical button mapping depends on what the user is actually looking at: when the
+  // screen is rendered rotated, the directional buttons must flip to match. The renderer is the only
+  // authority on the *live* orientation (the reader rotates it and restores portrait on exit), so we
+  // read it here instead of CrossPointSettings.orientation, which is just the persisted reader
+  // preference and stays "rotated" even while portrait UI like home/settings is on screen.
+  const GfxRenderer& renderer;
 
   bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const;
+  void rememberTouchHeldTime() const;
+  bool wasBottomEdgeSwipeUp() const;
+
+  mutable bool touchSelectTracking = false;
+  mutable bool touchSelectEmitted = false;
+  mutable int touchSelectId = -1;
+  mutable bool touchHeldOverrideValid = false;
+  mutable unsigned long touchHeldOverrideMs = 0;
+  mutable unsigned long touchHeldOverrideAt = 0;
 };

src/SdCardFontSystem.cpp

@@ -5,12 +5,16 @@
 
 #include "CrossPointSettings.h"
 
+namespace {
+
 static uint8_t fontSizeEnumFromSettings() {
   uint8_t e = SETTINGS.fontSize;
   if (e >= CrossPointSettings::FONT_SIZE_COUNT) e = 1;  // default to MEDIUM
   return e;
 }
 
+}  // namespace
+
 void SdCardFontSystem::begin(GfxRenderer& renderer) {
   registry_.discover();
 
@@ -74,10 +78,8 @@ void SdCardFontSystem::ensureLoaded(GfxRenderer& renderer) {
       SETTINGS.sdFontFamilyName[0] = '\0';
       return;
     }
-    auto sizes = family->availableSizes();
-    uint8_t idx = sizeEnum;
-    if (idx >= sizes.size()) idx = sizes.size() - 1;
-    uint8_t wantedPt = sizes.empty() ? 0 : sizes[idx];
+    const auto* selected = family->findClosestReaderSize(sizeEnum);
+    const uint8_t wantedPt = selected ? selected->pointSize : 0;
     if (!registryWasDirty && wantedPt == manager_.currentPointSize()) return;
     LOG_DBG("SDFS", "Reloading %s: size %u -> %u (enum %u)%s", wantedFamily, manager_.currentPointSize(), wantedPt,
             sizeEnum, registryWasDirty ? " [registry dirty]" : "");

src/SettingsList.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <BoardConfig.h>
 #include <HalClock.h>
+#include <HalGPIO.h>
 #include <HalTiltSensor.h>
 #include <I18n.h>
 #include <SdCardFontRegistry.h>
@@ -151,9 +153,10 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
                             StrId::STR_CAT_READER),
         SettingInfo::Toggle(StrId::STR_HYPHENATION, &CrossPointSettings::hyphenationEnabled, "hyphenationEnabled",
                             StrId::STR_CAT_READER),
-        SettingInfo::Enum(StrId::STR_ORIENTATION, &CrossPointSettings::orientation,
-                          {StrId::STR_PORTRAIT, StrId::STR_LANDSCAPE_CW, StrId::STR_INVERTED, StrId::STR_LANDSCAPE_CCW},
-                          "orientation", StrId::STR_CAT_READER),
+        SettingInfo::Enum(
+            StrId::STR_ORIENTATION, &CrossPointSettings::orientation,
+            {StrId::STR_PORTRAIT, StrId::STR_LANDSCAPE_CW, StrId::STR_ORIENTATION_INVERTED, StrId::STR_LANDSCAPE_CCW},
+            "orientation", StrId::STR_CAT_READER),
         SettingInfo::Toggle(StrId::STR_EXTRA_SPACING, &CrossPointSettings::extraParagraphSpacing,
                             "extraParagraphSpacing", StrId::STR_CAT_READER),
         SettingInfo::Toggle(StrId::STR_TEXT_AA, &CrossPointSettings::textAntiAliasing, "textAntiAliasing",
@@ -171,12 +174,16 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
                           {StrId::STR_LONG_PRESS_BEHAVIOR_OFF, StrId::STR_LONG_PRESS_BEHAVIOR_SKIP,
                            StrId::STR_LONG_PRESS_BEHAVIOR_ORIENTATION},
                           "longPressButtonBehavior", StrId::STR_CAT_CONTROLS),
+        SettingInfo::Enum(StrId::STR_LONG_PRESS_MENU, &CrossPointSettings::longPressMenuFunction,
+                          {StrId::STR_KOSYNC, StrId::STR_DISABLED, StrId::STR_BOOKMARK_OPTION}, "longPressMenuFunction",
+                          StrId::STR_CAT_CONTROLS),
         SettingInfo::Enum(
             StrId::STR_SHORT_PWR_BTN, &CrossPointSettings::shortPwrBtn,
             {StrId::STR_IGNORE, StrId::STR_SLEEP, StrId::STR_PAGE_TURN, StrId::STR_FORCE_REFRESH, StrId::STR_FOOTNOTES},
             "shortPwrBtn", StrId::STR_CAT_CONTROLS),
         SettingInfo::Toggle(StrId::STR_PWR_BTN_FOOTNOTE_BACK, &CrossPointSettings::pwrBtnFootnoteBack,
                             "pwrBtnFootnoteBack", StrId::STR_CAT_CONTROLS),
+
         // --- System ---
         SettingInfo::Value(
             StrId::STR_TIME_TO_SLEEP, &CrossPointSettings::sleepTimeoutMinutes,
@@ -240,8 +247,9 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
                           StrId::STR_CUSTOMISE_STATUS_BAR),
         // Clock entries (web settings only; device UI uses ClockOffsetActivity for the offset).
         // Range 0..104 = quarter-hour steps from UTC-12:00 to UTC+14:00, biased by 48.
-        SettingInfo::Toggle(StrId::STR_CLOCK, &CrossPointSettings::statusBarClock, "statusBarClock",
-                            StrId::STR_CUSTOMISE_STATUS_BAR),
+        SettingInfo::Enum(StrId::STR_CLOCK, &CrossPointSettings::statusBarClock,
+                          {StrId::STR_HIDE, StrId::STR_DIR_LEFT, StrId::STR_DIR_RIGHT}, "statusBarClock",
+                          StrId::STR_CUSTOMISE_STATUS_BAR),
         SettingInfo::Value(StrId::STR_CLOCK_UTC_OFFSET, &CrossPointSettings::clockUtcOffsetQ, {0, 104, 1},
                            "clockUtcOffsetQ", StrId::STR_CUSTOMISE_STATUS_BAR),
         SettingInfo::Enum(StrId::STR_CLOCK_FORMAT, &CrossPointSettings::clockFormat,
@@ -252,6 +260,26 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
         SettingInfo::Toggle(StrId::STR_CLOCK_SYNCED, &CrossPointSettings::clockHasBeenSynced, "clockHasBeenSynced",
                             StrId::STR_CUSTOMISE_STATUS_BAR),
     };
+    // Sunlight fading fix is Xteink-only (transflective panel); other devices get
+    // the touch reader controls toggle instead. Same gate as the reader runtime.
+    if (!gpio.isXteinkDevice()) {
+      v.erase(std::remove_if(v.begin(), v.end(),
+                             [](const SettingInfo& s) { return s.nameId == StrId::STR_SUNLIGHT_FADING_FIX; }),
+              v.end());
+      for (auto it = v.begin(); it != v.end(); ++it) {
+        if (it->nameId == StrId::STR_SIDE_BTN_LAYOUT) {
+          v.insert(it, SettingInfo::Toggle(StrId::STR_TOUCH_READER_CONTROLS, &CrossPointSettings::touchReaderControls,
+                                           "touchReaderControls", StrId::STR_CAT_CONTROLS));
+          break;
+        }
+      }
+    }
+    if (BoardConfig::hasTouch()) {
+      v.erase(std::remove_if(v.begin(), v.end(),
+                             [](const SettingInfo& s) { return s.nameId == StrId::STR_FRONT_BTN_FOLLOW_ORIENTATION; }),
+              v.end());
+    }
+
     // Only show tilt page turn setting when the QMI8658 IMU is present (X3)
     if (halTiltSensor.isAvailable()) {
       // Insert after the short power button setting (end of Controls section)

src/activities/Activity.h

@@ -56,8 +56,7 @@ class Activity {
   // Finish this activity and return to the previous one on the stack (if any)
   void finish();
 
-  // Convenience method to facilitate API transition to ActivityManager
-  // TODO: remove this in near future
+  // Convenience method to facilitate API transition to ActivityManager.
   void onGoHome(HomeMenuItem item = HomeMenuItem::NONE);
   void onSelectBook(const std::string& path);
 };

src/activities/ActivityManager.cpp

@@ -1,5 +1,6 @@
 #include "ActivityManager.h"
 
+#include <FontCacheManager.h>
 #include <HalPowerManager.h>
 
 #include <algorithm>
@@ -8,6 +9,7 @@
 #include "boot_sleep/BootActivity.h"
 #include "boot_sleep/SleepActivity.h"
 #include "browser/OpdsBookBrowserActivity.h"
+#include "components/TouchRegistry.h"
 #include "home/CrashActivity.h"
 #include "home/FileBrowserActivity.h"
 #include "home/HomeActivity.h"
@@ -18,6 +20,13 @@
 #include "settings/SettingsActivity.h"
 #include "util/FullScreenMessageActivity.h"
 
+// taskENTER_CRITICAL needs a real spinlock on dual-core targets (classic ESP32,
+// e.g. M5Paper). On the single-core ESP32-C3 a nullptr mux was tolerated, but
+// the dual-core port acquires an inter-core spinlock and asserts on a null
+// pointer (spinlock_acquire, spinlock.h:84). One shared spinlock guards the
+// short waitingTaskHandle critical sections below.
+static portMUX_TYPE activityMux = portMUX_INITIALIZER_UNLOCKED;
+
 void ActivityManager::begin() {
   xTaskCreate(&renderTaskTrampoline, "ActivityManagerRender",
               8192,              // Stack size
@@ -41,14 +50,18 @@ void ActivityManager::renderTaskLoop() {
     RenderLock lock;
     if (currentActivity) {
       HalPowerManager::Lock powerLock;  // Ensure we don't go into low-power mode while rendering
+      // Touch targets are rebuilt every frame: clear before the activity draws, then
+      // publish so the next loop() hit-tests against exactly what's on screen.
+      TouchRegistry::getInstance().beginFrame();
       currentActivity->render(std::move(lock));
+      TouchRegistry::getInstance().publish();
     }
     // Notify any task blocked in requestUpdateAndWait() that the render is done.
     TaskHandle_t waiter = nullptr;
-    taskENTER_CRITICAL(nullptr);
+    taskENTER_CRITICAL(&activityMux);
     waiter = waitingTaskHandle;
     waitingTaskHandle = nullptr;
-    taskEXIT_CRITICAL(nullptr);
+    taskEXIT_CRITICAL(&activityMux);
     if (waiter) {
       xTaskNotify(waiter, 1, eIncrement);
     }
@@ -279,7 +292,7 @@ void ActivityManager::requestUpdateAndWait() {
   }
 
   // Atomic section to perform checks
-  taskENTER_CRITICAL(nullptr);
+  taskENTER_CRITICAL(&activityMux);
   auto currTaskHandler = xTaskGetCurrentTaskHandle();
   auto mutexHolder = xSemaphoreGetMutexHolder(renderingMutex);
   bool isRenderTask = (currTaskHandler == renderTaskHandle);
@@ -288,7 +301,7 @@ void ActivityManager::requestUpdateAndWait() {
   if (!alreadyWaiting && !isRenderTask && !holdingRenderLock) {
     waitingTaskHandle = currTaskHandler;
   }
-  taskEXIT_CRITICAL(nullptr);
+  taskEXIT_CRITICAL(&activityMux);
 
   // Render task cannot call requestUpdateAndWait() or it will cause a deadlock
   assert(!isRenderTask && "Render task cannot call requestUpdateAndWait()");

src/activities/boot_sleep/SleepActivity.cpp

@@ -218,7 +218,15 @@ void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
     renderer.invertScreen();
   }
 
-  renderer.displayBuffer(HalDisplay::HALF_REFRESH);
+  if (hasGreyscale) {
+    // OEM grayscale pipeline base: on X3 this displays the frame with the
+    // dedicated "AA-pre-BW(mid)" differential waveform, leaving every pixel
+    // in the calibrated state the gray nudge refresh expects; on X4 it is a
+    // plain HALF refresh (previous behavior).
+    renderer.displayGrayscaleBase(HalDisplay::HALF_REFRESH);
+  } else {
+    renderer.displayBuffer(HalDisplay::HALF_REFRESH);
+  }
 
   if (hasGreyscale) {
     bitmap.rewindToData();

src/activities/browser/OpdsBookBrowserActivity.cpp

@@ -1,5 +1,6 @@
 #include "OpdsBookBrowserActivity.h"
 
+#include <FreeInkUI.h>
 #include <GfxRenderer.h>
 #include <I18n.h>
 #include <Logging.h>
@@ -10,6 +11,7 @@
 #include "SilentRestart.h"
 #include "activities/network/WifiSelectionActivity.h"
 #include "activities/util/KeyboardEntryActivity.h"
+#include "components/TouchRegistry.h"
 #include "components/UITheme.h"
 #include "fontIds.h"
 #include "network/HttpDownloader.h"
@@ -31,7 +33,6 @@ void OpdsBookBrowserActivity::onEnter() {
   currentPath = "";
   selectorIndex = 0;
   consumeConfirm = false;
-  consumeBack = false;
   errorMessage.clear();
   statusMessage = tr(STR_CHECKING_WIFI);
   requestUpdate();
@@ -60,10 +61,6 @@ void OpdsBookBrowserActivity::loop() {
     consumeConfirm = false;
     return;
   }
-  if (consumeBack && mappedInput.wasReleased(MappedInputManager::Button::Back)) {
-    consumeBack = false;
-    return;
-  }
 
   if (state == BrowserState::ERROR) {
     if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
@@ -91,11 +88,28 @@ void OpdsBookBrowserActivity::loop() {
   if (state == BrowserState::DOWNLOADING) return;
 
   if (state == BrowserState::BROWSING) {
-    if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-      if (!entries.empty()) {
-        const auto& entry = entries[selectorIndex];
-        entry.type == OpdsEntryType::BOOK ? downloadBook(entry) : navigateToEntry(entry);
+    if (!entries.empty()) {
+      if (mappedInput.wasListScroll(selectorIndex, static_cast<int>(entries.size()), PAGE_ITEMS)) {
+        requestUpdate();
+        return;
       }
+
+      int downId = -1;
+      if (mappedInput.wasItemTouchedDown(downId) &&
+          freeink::ui::listSelectIndex(selectorIndex, downId, static_cast<int>(entries.size()))) {
+        requestUpdate();
+      }
+
+      int tappedId = -1;
+      if (mappedInput.wasItemTapped(tappedId) && tappedId >= 0 && tappedId < static_cast<int>(entries.size())) {
+        selectorIndex = tappedId;
+        activateSelectedEntry();
+        return;
+      }
+    }
+
+    if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+      activateSelectedEntry();
     } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
       navigateBack();
     } else if (mappedInput.wasReleased(MappedInputManager::Button::Left)) {
@@ -178,13 +192,20 @@ void OpdsBookBrowserActivity::render(RenderLock&&) {
       std::string displayText = (entry.type == OpdsEntryType::NAVIGATION) ? "> " + entry.title : entry.title;
       if (entry.type == OpdsEntryType::BOOK && !entry.author.empty()) displayText += " - " + entry.author;
       auto item = renderer.truncatedText(UI_10_FONT_ID, displayText.c_str(), pageWidth - 40);
-      renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, item.c_str(),
-                        i != static_cast<size_t>(selectorIndex));
+      const int itemY = 60 + (i % PAGE_ITEMS) * 30;
+      renderer.drawText(UI_10_FONT_ID, 20, itemY, item.c_str(), i != static_cast<size_t>(selectorIndex));
+      TouchRegistry::getInstance().add(Rect{0, itemY - 2, pageWidth, 30}, static_cast<int>(i), TouchRegistry::Item);
     }
   }
   renderer.displayBuffer();
 }
 
+void OpdsBookBrowserActivity::activateSelectedEntry() {
+  if (entries.empty() || selectorIndex < 0 || selectorIndex >= static_cast<int>(entries.size())) return;
+  const auto& entry = entries[selectorIndex];
+  entry.type == OpdsEntryType::BOOK ? downloadBook(entry) : navigateToEntry(entry);
+}
+
 void OpdsBookBrowserActivity::fetchFeed(const std::string& path) {
   if (server.url.empty()) {
     state = BrowserState::ERROR;

src/activities/browser/OpdsBookBrowserActivity.h

@@ -33,7 +33,6 @@ class OpdsBookBrowserActivity final : public Activity {
   std::string currentPath;
   std::string searchTemplate;
   bool consumeConfirm = false;
-  bool consumeBack = false;  // Added missing member
   int selectorIndex = 0;
   std::string errorMessage;
   std::string statusMessage;
@@ -51,5 +50,6 @@ class OpdsBookBrowserActivity final : public Activity {
   void downloadBook(const OpdsEntry& book);
   void launchSearch();
   void performSearch(const std::string& query);
+  void activateSelectedEntry();
   bool preventAutoSleep() override { return true; }
 };

src/activities/home/CrashActivity.cpp

@@ -20,7 +20,9 @@ void CrashActivity::onEnter() {
 }
 
 void CrashActivity::loop() {
-  if (mappedInput.isPressed(MappedInputManager::Button::Back)) {
+  int tapX = 0;
+  int tapY = 0;
+  if (mappedInput.isPressed(MappedInputManager::Button::Back) || mappedInput.wasScreenTapped(tapX, tapY)) {
     finish();
   }
 }

src/activities/home/FileBrowserActivity.cpp

@@ -206,7 +206,29 @@ void FileBrowserActivity::loop() {
   const int pathReserved = renderer.getLineHeight(SMALL_FONT_ID) + UITheme::getInstance().getMetrics().verticalSpacing;
   const int pageItems = UITheme::getNumberOfItemsPerPage(renderer, true, false, true, false, pathReserved);
 
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+  // Vertical swipe page-scrolls the list (touch nav without the side buttons).
+  int scrollIdx = static_cast<int>(selectorIndex);
+  if (mappedInput.wasListScroll(scrollIdx, static_cast<int>(files.size()), pageItems)) {
+    selectorIndex = scrollIdx;
+    requestUpdate();
+    return;
+  }
+
+  int downId = -1;
+  if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(files.size())) {
+    selectorIndex = downId;
+    requestUpdate();
+  }
+
+  // A tap opens the tapped entry (held-time is 0 on a tap, so it takes the short-press
+  // open path below, never the long-press delete).
+  int tappedId = -1;
+  const bool tapped = mappedInput.wasItemTapped(tappedId);
+  if (tapped && tappedId >= 0 && tappedId < static_cast<int>(files.size())) {
+    selectorIndex = tappedId;
+  }
+
+  if (tapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
     if (lockNextConfirmRelease) {
       lockNextConfirmRelease = false;
       return;

src/activities/home/HomeActivity.cpp

@@ -179,7 +179,29 @@ void HomeActivity::loop() {
     requestUpdate();
   });
 
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+  // Tap a menu button to select + activate it. The button menu registers
+  // menu-local ids (drawn with selectorIndex offset by recentBooks.size()), so map
+  // back into the global selector space.
+  int downId = -1;
+  if (mappedInput.wasItemTouchedDown(downId)) {
+    selectorIndex = static_cast<int>(recentBooks.size()) + downId;
+    requestUpdate();
+  }
+
+  int tappedId = -1;
+  const bool tapped = mappedInput.wasItemTapped(tappedId);
+  if (tapped) {
+    selectorIndex = static_cast<int>(recentBooks.size()) + tappedId;
+  }
+
+  // A tap on the continue-reading cover selects that book (home selector index).
+  int coverId = -1;
+  const bool coverTapped = mappedInput.wasCoverTapped(coverId);
+  if (coverTapped && coverId >= 0 && coverId < static_cast<int>(recentBooks.size())) {
+    selectorIndex = coverId;
+  }
+
+  if (tapped || coverTapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
     if (selectorIndex < recentBooks.size()) {
       onSelectBook(recentBooks[selectorIndex].path);
     } else {
@@ -233,7 +255,7 @@ void HomeActivity::render(RenderLock&&) {
   // Build menu items dynamically
   std::vector<const char*> menuItems = {tr(STR_BROWSE_FILES), tr(STR_MENU_RECENT_BOOKS), tr(STR_FILE_TRANSFER),
                                         tr(STR_SETTINGS_TITLE)};
-  std::vector<UIIcon> menuIcons = {Folder, Recent, Transfer, Settings};
+  std::vector<UIIcon> menuIcons = {Folder, Book, Transfer, Settings};
 
   if (hasOpdsServers) {
     menuItems.insert(menuItems.begin() + 2, tr(STR_OPDS_BROWSER));
@@ -246,12 +268,13 @@ void HomeActivity::render(RenderLock&&) {
     menuIcons.insert(menuIcons.begin(), Book);
   }
 
+  // Menu fills the space between the cover and the bottom reserve (button hints
+  // when shown, else a margin). Sizing it to the real remaining height lets
+  // drawButtonMenu fit the items, so a scaled-up menu never runs off the bottom.
+  const int menuY = metrics.homeTopPadding + metrics.homeCoverTileHeight + metrics.homeMenuTopOffset;
+  const int bottomReserve = (BaseTheme::showButtonHints() ? metrics.buttonHintsHeight : 0) + metrics.verticalSpacing;
   GUI.drawButtonMenu(
-      renderer,
-      Rect{0, metrics.homeTopPadding + metrics.homeCoverTileHeight + metrics.homeMenuTopOffset, pageWidth,
-           pageHeight - (metrics.headerHeight + metrics.homeTopPadding + metrics.verticalSpacing +
-                         metrics.homeMenuTopOffset + metrics.buttonHintsHeight)},
-      static_cast<int>(menuItems.size()),
+      renderer, Rect{0, menuY, pageWidth, pageHeight - menuY - bottomReserve}, static_cast<int>(menuItems.size()),
       metrics.homeContinueReadingInMenu ? selectorIndex : selectorIndex - recentBooks.size(),
       [&menuItems](int index) { return std::string(menuItems[index]); },
       [&menuIcons](int index) { return menuIcons[index]; });

src/activities/home/RecentBooksActivity.cpp

@@ -44,6 +44,14 @@ void RecentBooksActivity::onExit() {
 void RecentBooksActivity::loop() {
   const int pageItems = UITheme::getInstance().getNumberOfItemsPerPage(renderer, true, false, true, true);
 
+  // Vertical swipe page-scrolls the list (touch nav without the side buttons).
+  int scrollIdx = static_cast<int>(selectorIndex);
+  if (mappedInput.wasListScroll(scrollIdx, static_cast<int>(recentBooks.size()), pageItems)) {
+    selectorIndex = scrollIdx;
+    requestUpdate();
+    return;
+  }
+
   // After a long-press has fired, swallow input until Confirm is physically released
   // (so the release doesn't also open the book; re-arm only once the button is up).
   if (longPressFired) {
@@ -63,7 +71,16 @@ void RecentBooksActivity::loop() {
     return;
   }
 
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+  int downId = -1;
+  if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(recentBooks.size())) {
+    selectorIndex = downId;
+    requestUpdate();
+  }
+
+  int tappedId = -1;
+  const bool tapped = mappedInput.wasItemTapped(tappedId);
+  if (tapped && tappedId >= 0 && tappedId < static_cast<int>(recentBooks.size())) selectorIndex = tappedId;
+  if (tapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
     if (!recentBooks.empty() && selectorIndex < static_cast<int>(recentBooks.size())) {
       LOG_DBG("RBA", "Selected recent book: %s", recentBooks[selectorIndex].path.c_str());
       onSelectBook(recentBooks[selectorIndex].path);

src/activities/network/CalibreConnectActivity.cpp

@@ -4,13 +4,13 @@
 #include <GfxRenderer.h>
 #include <I18n.h>
 #include <WiFi.h>
-#include <esp_task_wdt.h>
 
 #include "MappedInputManager.h"
 #include "SilentRestart.h"
 #include "WifiSelectionActivity.h"
 #include "components/UITheme.h"
 #include "fontIds.h"
+#include "network/TaskWatchdog.h"
 
 namespace {
 constexpr const char* HOSTNAME = "crosspoint";
@@ -110,12 +110,12 @@ void CalibreConnectActivity::loop() {
       LOG_DBG("CAL", "WARNING: %lu ms gap since last handleClient", timeSinceLastHandleClient);
     }
 
-    esp_task_wdt_reset();
+    feedTaskWatchdog();
     constexpr int MAX_ITERATIONS = 80;
     for (int i = 0; i < MAX_ITERATIONS && webServer->isRunning(); i++) {
       webServer->handleClient();
       if ((i & 0x07) == 0x07) {
-        esp_task_wdt_reset();
+        feedTaskWatchdog();
       }
       if ((i & 0x0F) == 0x0F) {
         yield();