fix: duplicate User-Agent header on wolfSSL requests breaks strict servers (aiohttp 400) (#2661)

Updated SCOPE.md to remove unnecessary line breaks and improve readability.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,13 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Scope or Roadmap Question (start here if unsure)
+    url: https://github.com/crosspoint-reader/crosspoint-reader/discussions
+    about: |
+      Not sure if your idea fits CrossPoint's scope? Start a Discussion before filing an issue.
+      See SCOPE.md and ROADMAP.md for what is in, out, and currently paused.
+  - name: Read the Scope document
+    url: https://github.com/crosspoint-reader/crosspoint-reader/blob/master/SCOPE.md
+    about: The authoritative list of what CrossPoint will and will not accept.
+  - name: Read the Roadmap
+    url: https://github.com/crosspoint-reader/crosspoint-reader/blob/master/ROADMAP.md
+    about: Current phase, what is being closed out, and what comes next.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,80 @@
+name: Feature Request
+description: Propose a new feature, enhancement, or change to CrossPoint
+title: "Short, descriptive title of the request"
+labels: ["enhancement", "needs-scope-review"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to propose a change to CrossPoint!
+
+        **Before you continue, please read [SCOPE.md](../blob/master/SCOPE.md) and [ROADMAP.md](../blob/master/ROADMAP.md).**
+
+        CrossPoint is intentionally narrow. Most rejected proposals are rejected for scope reasons that are already
+        documented. The checklist below exists to save both of us time.
+
+        If you are not sure whether your idea fits, open a [Discussion](../../discussions) first instead of filing
+        this issue.
+
+  - type: checkboxes
+    id: scope-check
+    attributes:
+      label: Scope Self-Check (required)
+      description: Please confirm each of the following. If any are unchecked, your issue will likely be closed.
+      options:
+        - label: I have read SCOPE.md and ROADMAP.md.
+          required: true
+        - label: This is **not** a new theme or theming change (themes are temporarily closed pending the move to SD-loaded themes).
+          required: true
+        - label: This is **not** a new external network connector (sync engine, cloud storage, remote file access, OPDS extensions beyond what exists, or any new "talk to a server" feature).
+          required: true
+        - label: This is **not** an interactive app (game, calculator, notepad), writing/authoring tool, RSS/news/browser feature, media playback feature, or PDF rendering.
+          required: true
+        - label: The stock firmware does **not** already handle this well.
+          required: true
+        - label: No other popular CrossPoint fork already handles this well (or, if one does, I explain below why CrossPoint still needs it).
+          required: true
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem this solves
+      description: What user-facing problem or reading-experience gap does this address? Be concrete.
+      placeholder: e.g., "When reading in landscape, paragraph breaks are inconsistent because..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: stock-gap
+    attributes:
+      label: Why the stock firmware (and other forks) do not already solve this
+      description: Explain which existing solutions you checked and why they fall short. This is the core scope filter.
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed change
+      description: A short description of what you would build or change. Focus on user impact; implementation details can come later.
+    validations:
+      required: true
+
+  - type: textarea
+    id: tradeoffs
+    attributes:
+      label: Memory / flash / complexity cost
+      description: |
+        CrossPoint runs on 380KB of RAM. Roughly how much DRAM, flash, or code complexity does this add?
+        "Don't know" is a valid answer, but please attempt an estimate.
+      placeholder: e.g., "Adds ~2KB flash for the new font tables, no DRAM impact at runtime."
+    validations:
+      required: false
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Anything else relevant (links, screenshots, related discussions).
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -3,16 +3,34 @@
 * **What is the goal of this PR?** (e.g., Implements the new feature for file uploading.)
 * **What changes are included?**
 
+## Scope Check
+
+CrossPoint is intentionally narrow. See [SCOPE.md](../blob/master/SCOPE.md) and [ROADMAP.md](../blob/master/ROADMAP.md).
+Please confirm:
+
+- [ ] I have read SCOPE.md and ROADMAP.md.
+- [ ] This PR is **not** a new built-in theme (themes are temporarily closed pending the move to SD-loaded themes).
+- [ ] This PR is **not** a new external network connector (sync engine, cloud storage, remote file access, etc.).
+- [ ] This PR is **not** an interactive app, writing tool, RSS/news/browser, media playback, or PDF feature.
+- [ ] The stock firmware does not already handle this well, **and** no other popular CrossPoint fork already does
+      (or, if one does, I explain why CrossPoint still needs it below).
+- [ ] If this PR touches `freeink-sdk/`, `lib/hal/`, the bootloader, OTA, or recovery code, I have coordinated with
+      the relevant maintainer.
+
+**If this PR was opened against the previous (broader) scope and was already in flight under Phase 0, link the
+relevant Discussion or issue so reviewers can see the history.**
+
 ## Additional Context
 
-* Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks, 
+* Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks,
   specific areas to focus on).
+* Memory / flash impact, if known.
 
 ---
 
 ### AI Usage
 
-While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it 
+While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it
 helps set the right context for reviewers.
 
 Did you use AI tools to help write this code? _**< YES | PARTIALLY | NO >**_

.github/workflows/ci.yml

@@ -91,9 +91,13 @@ jobs:
           restore-keys: pio-${{ runner.os }}-
 
       - name: Build CrossPoint
+        # Both envs in ONE pio invocation: a second `pio run` can wipe the whole
+        # .pio/build tree (project-checksum mismatch after the S3 toolchain
+        # installs into the restored cache), deleting the default firmware.bin
+        # before the artifact upload.
         run: |
           set -euo pipefail
-          pio run | tee pio.log
+          pio run -e default -e sticky | tee pio.log
 
       - name: Extract firmware stats
 

.gitignore

@@ -2,6 +2,8 @@
 .idea
 .DS_Store
 .vscode
+open-x4-sdk
+fs_
 lib/EpdFont/fontsrc
 lib/I18n/I18nKeys.h
 lib/I18n/I18nStrings.h
@@ -23,9 +25,3 @@ lib/EpdFont/scripts/output/
 # (worktrees, scheduled-task locks, settings.local, scout CLEANUP.md) out.
 .claude/*
 !.claude/skills/
-/managed_components
-/.dummy
-dependencies.lock
-sdkconfig.default
-sdkconfig.defaults
-CMakeLists.txt

README.md

@@ -12,7 +12,7 @@ CrossPoint is open-source e-reader firmware - community-built, fully hackable, f
 
 ## What can CrossPoint do?
 
-- **Reader engine**: EPUB 2/3 rendering with embedded-style option, image handling, hyphenation, kerning, chapter navigation, footnotes, bookmarks, go-to-percent, auto page turn, orientation control, focus reading, KOReader progress sync and more. 
+- **Reader engine**: EPUB 2/3 rendering with embedded-style option, image handling, hyphenation, kerning, chapter navigation, footnotes, bookmarks, dictionary lookups ([StarDict](docs/dictionary.md)), go-to-percent, auto page turn, orientation control, focus reading, KOReader progress sync and more. 
 
 - **Various formats**: native handling for `.epub`, `.xtc/.xtch`, `.txt`, and `.bmp`.
 
@@ -42,8 +42,6 @@ CrossPoint is open-source e-reader firmware - community-built, fully hackable, f
 
 ### Coming soon:
 
-- Dictionary lookup — inline word lookup without leaving the reader.
-
 - More themes.
 
 - Much more! stay tuned.
@@ -138,6 +136,7 @@ Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py`
 - [Web server endpoints](./docs/webserver-endpoints.md)
 - [Project scope](./SCOPE.md)
 - [Contributing docs](./docs/contributing/README.md)
+- [Touch and UI development](./docs/contributing/touch-and-ui.md) - FreeInkUI components for new screens, the touch bridge for existing ones, and build envs for the non-Xteink touch devices
 
 ---
 
@@ -160,6 +159,24 @@ cd crosspoint-reader
 git submodule update --init --recursive
 ```
 
+### Nix/NixOS
+
+Nix/NixOS users can enter the development shell with either `nix develop` (flakes) or `nix-shell`:
+
+```bash
+nix develop -f nix
+# or
+nix-shell nix
+```
+
+To flash a connected ESP32-C3 device, enable PlatformIO's udev rules in your NixOS configuration:
+
+```nix
+services.udev.packages = with pkgs; [ platformio-core.udev ];
+```
+
+After rebuilding the system configuration, reconnect the device or reload udev rules.
+
 ### Build / flash / monitor
 
 ```bash

ROADMAP.md

@@ -0,0 +1,88 @@
+# CrossPoint Reader Roadmap
+
+This roadmap describes how CrossPoint is moving through the tighter scope defined in [SCOPE.md](SCOPE.md). It is
+intentionally phased: Phase 0 closed out the commitments already in flight before locking down to the stricter
+"fill gaps the stock firmware leaves" delineator.
+
+Phases are sequential. We do not start the next phase until the prior one is wrapped or explicitly carried over.
+
+---
+
+## Phase 0 - Close Out Legacy Scope Items — **COMPLETE**
+
+**Goal:** Land the work that was already in motion under the prior, broader scope so contributors are not left
+hanging, and so we enter the stricter phases with a clean slate.
+
+**Landed in Phase 0:**
+
+* **RTL support PRs.** The in-flight right-to-left work was reviewed, iterated, and merged.
+* **Dictionary PR.** The offline dictionary lookup work was reviewed and merged.
+* **Bookmarks** feature. First-class navigation markers in EPUBs.
+* ~~**Transparent sleep screens.**~~ Shelved; not picked back up under the stricter phases.
+
+Phase 0 is closed. The tighter scope in [SCOPE.md](SCOPE.md) is now fully enforced. "But it was on the old roadmap"
+is not a valid argument for accepting a PR.
+
+---
+
+## Phase 1 - Consolidation, Footprint, and Multi-Device Support — **IN PROGRESS**
+
+**Goal:** Reduce memory and flash usage, clean up the codebase, and land the SDK / HAL generalization work so
+CrossPoint runs cleanly on ESP32-based e-reader hardware beyond Xteink (X3 / X4), including ESP32-S3 class devices.
+
+**Focus areas:**
+
+* DRAM and heap fragmentation reduction across the reader core.
+* Flash footprint reduction (dead code, redundant strings, oversized tables).
+* Refactors that tighten the HAL / SDK boundary.
+* Pluggable per-device SDK layers (display, input, storage, battery) and per-device build configuration without
+  forking the reader core.
+* Documentation for adding a new ESP32 e-reader target.
+* E-ink driver refinement (ghosting, partial update behavior).
+
+**Closed during this phase:** new themes built into firmware, new external network connectors (sync engines, cloud
+storage, remote file access).
+
+---
+
+## Phase 2 - Languages, Fonts, and Themes
+
+**Goal:** With the codebase smaller and portable, make reading great in every language: multi-language support,
+better font support with custom fonts, UI translations, and themes loaded from the SD card instead of consuming
+flash.
+
+**Focus areas:**
+
+* Multi-language reading support (underserved languages, complex script support where realistic on ESP32 hardware).
+* Better font support and custom fonts.
+* UI languages and localization.
+* Moving themes off-firmware to SD-loaded assets (see SCOPE.md Section 6).
+* **Moving hyphenation files off-firmware.** Hyphenation rules vary per language and the files are large (German
+  alone is ~200KB). Today these eat flash budget that should be available for the reader core. The plan is to build
+  a downloader analogous to the existing font downloader and store the dictionaries on SD / SPIFFS, loading on
+  demand. This unlocks better hyphenation for long-word languages (German, Finnish, Norwegian, etc.) without paying
+  the flash cost up front.
+
+This phase depends on Phase 1 cleanup landing first; otherwise we generalize a moving target.
+
+---
+
+## Out of Roadmap
+
+The following are explicitly *not* on the roadmap. They may live in other CrossPoint forks; they will not be picked
+up here:
+
+* Interactive apps (games, calculators, notepads).
+* Writing / authoring tools.
+* Active connectivity features (RSS, news, browsers).
+* PDF rendering as a first-class format.
+
+See [SCOPE.md](SCOPE.md) for the full rationale.
+
+---
+
+## How This Roadmap Changes
+
+* Phase boundaries are decided by maintainers, not by individual PRs.
+* If a phase needs to be extended or an item carried over, that is documented here with a short note.
+* Proposals for new phases or reordering should go through a Discussion first.

SCOPE.md

@@ -1,62 +1,100 @@
 # Project Vision & Scope: CrossPoint Reader
 
-The goal of CrossPoint Reader is to create an efficient, open-source reading experience for the Xteink X4. We believe a
-dedicated e-reader should do one thing exceptionally well: **facilitate focused reading.**
+The goal of CrossPoint Reader is to create an efficient, open-source reading experience for ESP32-based e-reader devices. Xteink hardware (X3, X4) is where the project started and remains a primary target, but CrossPoint is explicitly broadening to support the wider ecosystem of small ESP32 e-ink readers. We believe a dedicated e-reader should do one thing exceptionally well: **facilitate focused reading.**
 
 ## 1. Core Mission
 
-To provide a lightweight, high-performance firmware that maximizes the potential of the X4, prioritizing legibility and
-usability over "swiss-army-knife" functionality.
+To provide a lightweight, high-performance firmware that maximizes the potential of ESP32-based e-reader hardware, prioritizing legibility, performance, and usability over "swiss-army-knife" functionality.
 
-## 2. Scope
+CrossPoint is **not** a kitchen-sink firmware, and it is **not** Xteink-only. We want clean, maintainable code that the community can build on, and that runs across the range of ESP32 e-reader devices (ESP32-C3, ESP32-S3, and adjacent variants). Every accepted change should make that goal easier, not harder. Device-specific code should live behind the HAL / SDK boundary so the reader core stays portable.
+
+## 2. Guiding Principle: Fill Gaps the Stock Firmware Leaves
+
+CrossPoint exists to do the things the stock firmware does poorly or not at all. New work is evaluated against that delineator:
+
+* **Does the stock firmware already do this well?** We should hit that bar or surpass it 
+* **Is another popular CrossPoint fork already solving this well?** If yes, we generally defer to that fork if it's not part of the core reading experience. e.g. stats
+* **Does this directly improve the reading experience or the firmware's long-term maintainability?** If no, it is out of scope.
+
+## 3. Current Focus
+
+We are intentionally narrowing scope to consolidate the codebase as we open it up to more ESP32 e-reader devices.
+
+During this period, the priorities are:
+
+* **Memory footprint:** Reducing DRAM usage and heap fragmentation. The ESP32-C3 is the tightest target and sets the ceiling, but the gains benefit every ESP32 variant we run on. 
+* **Flash footprint:** Trimming binary size to leave room for additional device targets and features. 
+* **Code cleanup:** Refactoring, removing dead code, tightening abstractions, and improving readability. 
+* **Reading experience:** EPUB parsing and rendering, typography, hyphenation, line spacing, font handling, and legibility improvements.
+
+### Temporarily Closed Areas
+
+PRs in the following areas will be closed until this notice is lifted. Adding these now makes the cleanup and multi-device work materially harder:
+
+* **New themes.** The existing theming surface is frozen. 
+* **New external network connectors.** This includes sync engines, cloud storage clients, OPDS extensions beyond what exists, remote file access, and any new "talk to a server" feature. We now have our own CrossPoint KOSync server which gives us a way to sync to 3rd party systems like Hardcover at an API level instead of bloating the firmware. If you're interested in helping here, the sync server is also open source.
+
+If you are unsure whether your idea falls into one of these categories, open a Discussion first.
+
+## 4. Scope
 
 ### In-Scope
 
-*These are features that directly improve the primary purpose of the device.*
+*Features that directly improve the core reading experience or the firmware's maintainability.*
 
-* **User Experience:** E.g. User-friendly interfaces, and interactions, both inside the reader and navigating the
-  firmware. This includes things like button mapping, book loading, and book navigation like bookmarks.
-* **Document Rendering:** E.g. Support for rendering documents (primarily EPUB) and improvements to the rendering
-  engine.
-* **Format Optimization:** E.g. Efficiently parsing EPUB (CSS/Images) and other documents within the device's
-  capabilities.
-* **Typography & Legibility:** E.g. Custom font support, hyphenation engines, and adjustable line spacing.
-* **E-Ink Driver Refinement:** E.g. Reducing full-screen flashes (ghosting management) and improving general rendering.
-* **Library Management:** E.g. Simple, intuitive ways to organize and navigate a collection of books.
-* **Local Transfer:** E.g. Simple, "pull" based book loading via a basic web-server or public and widely-used standards.
-* **Language Support:** E.g. Support for multiple languages both in the reader and in the interfaces.
-* **Reference Tools:** E.g. Local dictionary lookup. Providing quick, offline definitions to enhance comprehension 
-  without breaking focus.
-* **Clock Display (device dependent):** 
-
-| Device | Scope |
-| -- | -- |
-| X3 | The X3 uses a dedicated DS3231 RTC, which maintains accurate time across sleep cycles and can be treated as a reliable wall clock. |
-| X4 | The X4 relies on the ESP32-C3's internal RTC, which drifts significantly during deep sleep. NTP sync could correct this, with an appropriate user experience around connecting to the internet on wake or on demand. This causes some tension with the **Active Connectivity** section below, so please open a discussion about this UX if it's a feature you would find useful. |
+* **EPUB Rendering & Optimization:** Improvements to the rendering engine, CSS/image handling, and parsing performance. 
+* **Typography & Legibility:** Custom font support, hyphenation, line and paragraph spacing, margins. 
+* **E-Ink Driver Refinement:** Reducing full-screen flashes (ghosting management) and improving general rendering. 
+* **Reading UX:** Bookmarks, progress tracking, button mapping, page navigation, and other in-reader interactions. 
+* **Library Management:** Simple, intuitive ways to organize and navigate a local book collection. 
+* **Memory, Flash, and Code Quality:** Refactors and cleanups that reduce resource use or improve maintainability, even without a user-visible feature.
 
 ### Out-of-Scope
 
-*These items are rejected because they compromise the device's stability or mission.*
+*Rejected because they compromise the device's stability, maintainability, or core mission.*
 
-* **Interactive Apps:** No Notepads, Calculators, or Games. This is a reader, not a PDA.
-* **Active Connectivity:** No RSS readers, News aggregators, or Web browsers. Background Wi-Fi tasks drain the battery
-  and complicate the single-core CPU's execution.
-* **Media Playback:** No Audio players or Audio-books.
-* **Complex Annotation:** No typed out notes. These features are better suited for devices with better input
-  capabilities and more powerful chips.
+* **Interactive Apps:** No notepads, calculators, or games. These belong in other forks and are not part of CrossPoint's focus. 
+* **Writing / Authoring Tools:** No typed notes, journals, or editors. Input hardware and RAM are wrong for this, and other forks already explore this space. 
+* **Active Connectivity:** No RSS readers, news aggregators, or web browsers. Background Wi-Fi drains the battery and complicates the single-core CPU. 
+* **PDF Rendering:** PDFs are fixed-layout documents, so rendering them requires displaying pages as images rather than reflowable text, resulting in constant panning and zooming that makes for a poor reading experience on e-ink. Out of scope on the current hardware class.
 
-### In-scope — Technically Unsupported
+## 5. Calls to Action
 
-*These features align with CrossPoint's goals but are impractical on the current hardware or produce poor UX.*
+These are the areas where contributor help is most valuable right now. If you want to take one of these on, open a Discussion or issue first so we can coordinate.
 
-* **PDF Rendering:** PDFs are fixed-layout documents, so rendering them requires displaying pages as images rather than reflowable text — resulting in constant panning and zooming that makes for a poor reading experience on e-ink.
+### Theme System: Move Themes Off-Firmware
 
-## 3. Idea Evaluation
+We want to abstract themes out of the firmware entirely so they no longer consume flash, and instead load from the SD card. This directly supports the current focus on flash footprint and code cleanup.
 
-While I appreciate the desire to add new and exciting features to CrossPoint Reader, CrossPoint Reader is designed to be
-a lightweight, reliable, and performant e-reader. Things which distract or compromise the device's core mission will not
-be accepted. As a guiding question, consider if your idea improve the "core reading experience" for the average user,
-and, critically, not distract from that reading experience.
+* **Status:** [@itsthisjustin](https://github.com/itsthisjustin) plans to take this on eventually but is very open to someone else claiming it sooner. 
+* **Why it matters:** Every built-in theme costs flash that we would rather spend on rendering, fonts, or future device support. SD-loaded themes also let users customize without rebuilding firmware. It also leads to SD font loading for better language support in the UI. 
+* **How to claim:** Comment on the relevant Discussion (or open one) before starting.
 
-> **Note to Contributors:** If you are unsure if your idea fits the scope, please open a **Discussion** before you start
-> coding!
+### Identifying Other Stock-Firmware Gaps
+
+We want help cataloguing things the stock firmware (and other popular CrossPoint forks) handle poorly or not at all, so future work has a clear target list. Particularly interested in:
+
+* **RTL (right-to-left) text support:** Arabic, Hebrew, Persian, and similar scripts. 
+* **Languages with poor stock and fork coverage:** Especially those that need shaping, complex layout, or non-Latin font work that nobody is handling well today. 
+* **Other gaps:** Rendering edge cases, accessibility issues, input quirks, anything stock does badly and existing forks have not fixed.
+
+If you can read or use the device in one of these languages, your feedback (even without code) is genuinely useful. Open a Discussion with concrete examples (screenshots, sample EPUBs, expected vs actual behavior) and we will prioritize from there.
+
+## 6. Funding and Contributor Sustainability
+
+CrossPoint uses [Royalty.dev](https://royalty.dev) (yes, a product built by [@itsthisjustin](https://github.com/itsthisjustin)) to fund contributors. There has been some tension in the community around this, so the intent is being clarified here directly.
+
+**Why we do this:**
+
+* To maintain long-term interest from contributors and maintainers, in direct response to substantial community requests for a way to give back. 
+* To motivate contributors to invest in the *core* project rather than spinning up competing forks. 
+* To help pay for new ESP32 devices so we can port CrossPoint to additional hardware. 
+* To give the project a credible long-term path to sustainability.
+
+**How it works:**
+
+* Funds are distributed automatically to contributors based on impact to the codebase and tenure on the project. 
+* Over **$600** was raised in the first few hours after opening up funding, which is a signal the demand is real. 
+* The exact scoring methodology is published at <https://app.royalty.dev/transparency>.
+
+**This is not fixed in stone.** The weighting, eligibility, and distribution rules can be tweaked as we learn what works for this project. If you have concerns or suggestions about how funds are allocated, open a Discussion. The goal is a system that fairly recognizes the people doing the work, not a perfect one on day one.

USER_GUIDE.md

@@ -28,8 +28,10 @@ Welcome to the **CrossPoint** firmware. This guide outlines the hardware control
       - [3.6.5 OPDS Servers (Multiple Libraries)](#365-opds-servers-multiple-libraries)
       - [3.6.6 Web Settings (Wi-Fi + OPDS)](#366-web-settings-wi-fi--opds)
       - [3.6.7 KOReader Sync Quick Setup](#367-koreader-sync-quick-setup)
-        - [Option A: Free Public Server (`sync.koreader.rocks`)](#option-a-free-public-server-synckoreaderrocks)
-        - [Option B: Self-Hosted Server (Docker Compose)](#option-b-self-hosted-server-docker-compose)
+        - [Option A: CrossPoint Sync Server (`sync.crosspointreader.com`, default)](#option-a-crosspoint-sync-server-synccrosspointreadercom-default)
+        - [Option B: Legacy Public KOReader Server (`sync.koreader.rocks`)](#option-b-legacy-public-koreader-server-synckoreaderrocks)
+        - [Option C: Self-Hosted Server (Docker Compose)](#option-c-self-hosted-server-docker-compose)
+        - [Syncing While Reading](#syncing-while-reading)
     - [3.7 Sleep Screen](#37-sleep-screen)
       - [Cover settings](#cover-settings)
       - [Custom images](#custom-images)
@@ -261,6 +263,8 @@ The Settings screen allows you to configure the device's behavior. There are a f
   - "ON" - Vertical space will be added between paragraphs in Reading Mode
   - "OFF" - Paragraphs will not have vertical space added, but will have first-line indentation
 
+- **Dictionary**: Select the StarDict dictionary used for word lookups while reading, or "None" to disable lookups. *(Only shown when at least one dictionary folder exists under `/dictionaries/` on the SD card — see [docs/dictionary.md](docs/dictionary.md) for setup and usage.)*
+
 - **Text Anti-Aliasing**: Whether to show smooth grey edges (anti-aliasing) on text in reading mode. Note this slows down page turns slightly.
 
 - **Images**: Whether to display embedded images (JPG/PNG) found in EPUB files; options are "ON" (default) or "OFF".
@@ -280,6 +284,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
 - **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.
+  - "Dictionary" - Hold Confirm (~0.4 second) to start dictionary word selection on the current page (see [docs/dictionary.md](docs/dictionary.md)).
   - "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:
@@ -297,7 +302,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
 
 - **Wi-Fi Networks**: Connect to Wi-Fi networks for file transfers and firmware updates.
 
-- **KOReader Sync**: Options for setting up KOReader for syncing book progress.
+- **KOReader Sync**: Options for setting up KOReader for syncing book progress. **Smart sync** is the default for new configurations and auto-resolves simple push/pull decisions. Existing credential files retain **Ask every time** when migrated; you can switch Sync Behavior at any time if you prefer manual confirmation.
 
 - **OPDS Servers**: Manage one or more OPDS [(Open Publication Distribution System)](https://en.wikipedia.org/wiki/Open_Publication_Distribution_System) libraries for browsing and downloading books. See [OPDS Servers (Multiple Libraries)](#365-opds-servers-multiple-libraries) below.
 
@@ -360,9 +365,37 @@ Behavior notes:
 CrossPoint can sync reading progress with KOReader-compatible sync servers.
 It also interoperates with KOReader apps/devices when they use the same server and credentials.
 
-##### Option A: Free Public Server (`sync.koreader.rocks`)
+##### Option A: CrossPoint Sync Server (`sync.crosspointreader.com`, default)
 
-1. Register a user once (only if needed):
+When **Sync Server URL** is left empty, CrossPoint uses the free CrossPoint sync server at `https://sync.crosspointreader.com`. It speaks the standard KOReader sync protocol (so KOReader apps can use it too) and additionally stores an exact spine/page position for lossless CrossPoint-to-CrossPoint sync.
+
+1. On each CrossPoint device:
+
+   - Go to **Settings -> System -> KOReader Sync**.
+
+   - Set **Username** and **Password** (enter the plain password; CrossPoint computes MD5 internally, and use the same values on all devices).
+
+   - Leave **Sync Server URL** empty (or set it to `https://sync.crosspointreader.com`).
+
+   - On the first device, run **Sign Up** once to create the account directly from the device. On every other device, just run **Authenticate**.
+
+Accounts are per server. Existing `sync.koreader.rocks` credentials do not exist on the CrossPoint server; either sign up again with the same username/password or use Option B to keep using the legacy server.
+
+##### Option B: Legacy Public KOReader Server (`sync.koreader.rocks`)
+
+Use this if you already sync KOReader devices against the official public server.
+
+1. On each CrossPoint device:
+
+   - Go to **Settings -> System -> KOReader Sync**.
+
+   - Set **Sync Server URL** to `https://sync.koreader.rocks` (required; an empty URL now points at the CrossPoint server instead).
+
+   - Set **Username** and **Password** to your existing KOReader Sync credentials.
+
+   - Run **Authenticate**.
+
+2. If you do not have an account yet, run **Sign Up** on the device, or register once with curl:
 
 ```bash
 USERNAME="user"
@@ -375,27 +408,9 @@ curl -i "https://sync.koreader.rocks/users/create" \
   --data "{\"username\":\"$USERNAME\",\"password\":\"$PASSWORD_MD5\"}"
 ```
 
-Already have KOReader Sync credentials? Skip registration; basic sync only requires using the same existing username/password on all devices.
-
 When this returns `HTTP 402` with `{"code":2002,"message":"Username is already registered."}`, pick a different username or use that existing account.
 
-2. On each CrossPoint device:
-   
-   - Go to **Settings -> System -> KOReader Sync**.
-   
-   - Set **Username** and **Password** (enter the plain password; CrossPoint computes MD5 internally, and use the same values on all devices).
-   
-   - Set **Sync Server URL** to `https://sync.koreader.rocks`, or leave it empty (both use the same default KOReader sync server).
-   
-   - Run **Authenticate**.
-
-3. While reading, press **Confirm** to open the reader menu, then select **Sync Progress**.
-   
-   - Choose **Apply Remote** to jump to remote progress.
-   
-   - Choose **Upload Local** to push current progress.
-
-##### Option B: Self-Hosted Server (Docker Compose)
+##### Option C: Self-Hosted Server (Docker Compose)
 
 1. Start a sync server:
 
@@ -468,11 +483,12 @@ If this returns `HTTP 402` with `{"code":2002,"message":"Username is already reg
 
 If you use the HTTPS listener, use `https://<server-ip>:7200` (`curl -k` only for self-signed certificate testing).
 
-5. While reading, press **Confirm** to open the reader menu, then select **Sync Progress**.
-   
-   - Choose **Apply Remote** to jump to remote progress.
-   
-   - Choose **Upload Local** to push current progress.
+##### Syncing While Reading
+
+Once any of the options above is set up, press **Confirm** while reading to open the reader menu, then select **Sync Progress**. Alternatively, set **Settings -> Controls -> Long-press Menu** to **KOSync** and hold Confirm to launch sync directly.
+
+- With **Sync Behavior** set to **Ask every time**, choose **Apply Remote** to jump to remote progress or **Upload Local** to push current progress.
+- With **Sync Behavior** set to **Smart sync**, CrossPoint auto-resolves simple cases: upload when no remote progress exists, confirm and leave both unchanged when local and remote progress are already synchronized, upload when local progress is further ahead, or apply remote when remote progress is further ahead.
 
 ### 3.7 Sleep Screen
 
@@ -570,7 +586,7 @@ If the device goes to sleep or you close the book while viewing a footnote, the
 * **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.
+* **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, "Dictionary" starts a word lookup, "Disabled" does nothing. A short press always opens the Reader Menu.
 
 ### Supported Languages
 
@@ -592,6 +608,7 @@ Available options include:
 
 - **Select Chapter** – Open the table of contents to jump to a specific chapter (see [Chapter Selection](#51-chapter-selection) below).
 - **Footnotes** – Navigate to the footnotes for the current section *(only shown in books that contain footnotes)*.
+- **Look Up** – Select a word on the current page and show its dictionary definition (see [docs/dictionary.md](docs/dictionary.md)). Requires a dictionary to be selected in **Settings → Reader → Dictionary**.
 - **Reading Orientation** – Cycle through screen orientations without leaving the reader.
 - **Auto Turn (Pages Per Minute)** – Cycle through automatic page turn speed options for hands-free reading.
 - **Go to %** – Jump to a specific position in the book by percentage.

docs/contributing/README.md

@@ -7,5 +7,6 @@ It is written for software developers who may be new to embedded development.
 - [Architecture Overview](./architecture.md)
 - [Development Workflow](./development-workflow.md)
 - [Testing and Debugging](./testing-debugging.md)
+- [Touch and UI Development](./touch-and-ui.md)
 
 If you are new, start with [Getting Started](./getting-started.md).

docs/contributing/touch-and-ui.md

@@ -0,0 +1,221 @@
+# Touch and UI Development
+
+CrossPoint now runs on touch devices (Seeed Sticky, M5Paper, LilyGo T5) alongside the button-only Xteink X3/X4. Every screen must work with both input styles. There are two supported ways to get there:
+
+1. **New screens: build them with FreeInkUI components.** Touch hit-testing, tap highlighting, long-press, and button focus navigation come with the component; you never hand-roll coordinate math.
+2. **Existing screens and in-flight features: use the MappedInputManager touch bridge.** A small set of helpers adds tap/hold/swipe support to hand-rolled rendering without restructuring the activity.
+
+If you are starting a new activity, use FreeInkUI. If you have a feature branch with a hand-rolled screen already working on buttons, use the bridge; do not rewrite mid-flight.
+
+---
+
+## Path 1: New screens with FreeInkUI
+
+FreeInkUI (`freeink-sdk/libs/ui/FreeInkUI`, namespace `freeink::ui`) is an immediate-mode component library. The core idea:
+
+- While a component renders, it registers its tappable areas ("hit rects") into the frame's interaction buffer via `Frame::hit(rect, action, value, inputMask, state)`.
+- Each loop you build an `InputSnapshot` from the input manager and route it against that buffer. If a tap (or mapped button press) lands in a registered rect, the routed `ActionEvent` tells you which action fired and with what value.
+- Components query `frame.stateFor(action, value)` while painting, so touch-down highlight and focus states render correctly without any per-activity code.
+
+You get touch, hold highlighting, long-press, minimum touch-target sizing, and orientation-aware coordinates for free. The same action IDs fire from physical buttons, so one code path serves both input styles.
+
+### Component inventory
+
+All under `freeink-sdk/libs/ui/FreeInkUI/include/components/`:
+
+| Category | Components |
+|---|---|
+| Controls | `button`, `checkbox`, `slider`, `progress-bar`, `header` |
+| Lists | `list` (virtualized), `table`, `dropdown`, `radio-group`, `setting-row`, `toggle-row`, `stepper-row` |
+| Keyboard | `keyboard` (QWERTY/AZERTY/QWERTZ/ES layouts), `key-grid` |
+| Overlays | `popup`, `option-dialog`, `context-menu`, `message-panel`, `toast` |
+| Bars | `status-bar`, `tab-bar`, `reader-chrome`, `battery-indicator`, `gesture-bar`, `tap-zones` |
+| Media | `book-card`, `cover-grid`, `cover-carousel`, `metric-card` |
+| Text | `text-field`, `text-area` |
+
+### Integration skeleton
+
+The in-tree reference is [`src/activities/util/KeyboardEntryActivity.cpp`](../../src/activities/util/KeyboardEntryActivity.cpp); it drives the FreeInkUI keyboard component inside a normal Activity. The shape:
+
+```cpp
+#include <FreeInkUIGfxRenderer.h>
+namespace fui = freeink::ui;
+
+// Render step: draw the component and (re)register its hit rects.
+fui::GfxRendererTarget target(renderer);           // adapts GfxRenderer to FreeInkUI's DrawTarget
+target.setFont(fui::GfxRendererTarget::FONT_BODY, UI_12_FONT_ID);
+const fui::DeviceContext device = target.deviceContext();  // orientation, safe area, touch sizing
+
+fui::Frame<48> frame(target, device, fui::InputSnapshot{}, interactions);  // 48 = max hit rects
+fui::KeyboardProps props;
+props.layout = &currentLayout();
+props.keyAction = ACTION_KEY;                      // one action id; the key is the event value
+props.inputMask = fui::InputTouch | fui::InputLongPress;
+fui::keyboard(frame, kbRect, props);               // draws AND registers hit rects
+```
+
+```cpp
+// Input step (each loop): feed touch state, act on routed events.
+int tx, ty, tapX, tapY, hx, hy;
+const bool pressedDown = mappedInput.wasScreenTouchDown(tx, ty);
+const bool tapped      = mappedInput.wasScreenTapped(tapX, tapY);
+const bool inContact   = mappedInput.isScreenTouchHeld(hx, hy);
+
+const auto result = touchRouter.update(interactions, pressedDown, tx, ty,
+                                       tapped, tapX, tapY, inContact, millis());
+if (result.event) {
+  activateValue(result.event.value, result.event.longPress);
+  requestUpdate();
+} else if (result.activeChanged) {
+  requestUpdate();  // repaint touch-down highlight
+}
+```
+
+Notes:
+
+- `Frame<N>` is templated on the max number of hit rects; the buffer is stack/static, no heap.
+- `fui::TouchHoldRouter` (see `components/keyboard/keyboard.h`) synthesizes long-press while the finger is still down and swallows the eventual release. Use it whenever a component distinguishes tap from long-press.
+- For simpler screens without long-press, `FreeInkApp` / `Screen<N>` (`FreeInkApp.h`) is the ergonomic layer: it owns the interaction buffer, offers a top-to-bottom builder (`takeTop`, footer helpers, etc.), and its `render(input)` call routes the snapshot and dispatches registered action callbacks in one step. `snapshotFrom(input, device)` in `FreeInkUIInputManager.h` builds the `InputSnapshot` with orientation-aware touch mapping.
+- Everything stays allocation-free and works on the button-only devices unchanged: physical buttons route through the same interaction table via each hit rect's `inputMask`.
+
+---
+
+## Path 2: Adding touch to existing hand-rolled screens
+
+For activities that draw their own rows, menus, and buttons, `MappedInputManager` ([src/MappedInputManager.h](../../src/MappedInputManager.h)) exposes bridge helpers. They all return **logical screen coordinates** (orientation already applied via `GfxRenderer::tapToLogical`); never touch raw normalized panel coordinates or the SDK `InputManager` directly.
+
+| Helper | Use for |
+|---|---|
+| `wasScreenTapped(x, y)` | A completed tap (press + release), with logical coords |
+| `wasScreenTouchDown(x, y)` | Touch-down (held > 90 ms, not yet released): draw selection highlight |
+| `isScreenTouchHeld(x, y)` | Live contact position while the finger is down (drag tracking) |
+| `wasTapInRect(x, y, w, h)` | One-off hit test on a rectangle (a single button, a banner) |
+| `wasListItemTapped(index, count, selected, listTop, listHeight, hasSubtitle)` | Taps on a standard UITheme list; does the row/paging math for you |
+| `wasListItemTouchedDown(...)` | Same geometry, touch-down phase (highlight before activate) |
+| `rowTouch(row, top, rowStep, rowCount, xStart, xEnd, rowHeight)` | Any custom band of equal-height rows; returns `RowTouch::None/Down/Tap` |
+| `colTouch(col, left, colStep, colCount, yStart, yEnd, colWidth)` | Horizontal button bands (dialogs, prompts) |
+| `wasSwipe()` | Raw swipe direction if you need one beyond the global gestures |
+| `hasTouch()` | True when the device has a touch panel (rarely needed; helpers simply never fire without one) |
+
+### Pattern A: standard themed list
+
+One call per loop; UITheme owns the row geometry ([EpubReaderBookmarksActivity.cpp:123](../../src/activities/reader/EpubReaderBookmarksActivity.cpp)):
+
+```cpp
+int tapped = -1;
+if (mappedInput.wasListItemTapped(tapped, bookmarks.size(), selectorIndex, listY, listHeight, true)) {
+  selectorIndex = tapped;
+  openBookmark();
+  return;
+}
+```
+
+### Pattern B: custom rows with hold highlight
+
+For non-theme row layouts, use `rowTouch` and distinguish `Down` (highlight) from `Tap` (activate), as in [EpubReaderFootnotesActivity.cpp](../../src/activities/reader/EpubReaderFootnotesActivity.cpp):
+
+```cpp
+int row = -1;
+const auto touch = mappedInput.rowTouch(row, listTop, lineHeight, visibleCount,
+                                        contentX, contentX + contentWidth);
+if (touch != MappedInputManager::RowTouch::None) {
+  const int touched = scrollOffset + row;
+  if (touch == MappedInputManager::RowTouch::Down) {
+    if (selectedIndex != touched) { selectedIndex = touched; requestUpdate(); }
+  } else {  // RowTouch::Tap
+    selectedIndex = touched;
+    activateSelection();
+  }
+  return;
+}
+```
+
+The `Down` state exists because e-ink repaints are slow: highlight on touch-down gives immediate feedback, activation happens on release.
+
+### Global gestures: do not reimplement these
+
+Three gestures are handled once, for every screen. Activities must not add their own edge-swipe handling:
+
+| Gesture | Trigger | Where it is handled |
+|---|---|---|
+| Back | Right-swipe starting in the left 25% of the screen | Folded into `Button::Back`, so the existing `wasPressed(Button::Back)` in your activity already fires |
+| Home | Up-swipe starting in the bottom 14% | `ActivityManager::loop()`; pops to Home (activities can override via `handleHomeGesture()`) |
+| Menu | Down-swipe starting in the top 14% | Activities that have a menu check `wasMenuGesture()` themselves (the reader does this) |
+
+Because the back gesture arrives as `Button::Back`, most button-era activities gain back-swipe support with zero changes. That is the bar to aim for: bridge helpers should make touch an additive layer over the button flow, not a second input state machine.
+
+### Bridge rules
+
+- Handle touch in `loop()` next to the existing button handling, one helper call per interaction zone, and `return` after consuming an event (mirrors the button pattern).
+- Never call the SDK `InputManager` or read GPIO directly; the HAL rule from the main guide applies to touch too.
+- Coordinates from the helpers are logical and orientation-correct on all four rotations; test at least Portrait and one Landscape mode before PR.
+- Nothing to clean up in `onExit()`; the helpers are stateless from the activity's point of view.
+
+---
+
+## Building and testing on non-Xteink devices
+
+Each MCU family is its own binary: X3/X4 are ESP32-C3, Sticky and LilyGo T5 are ESP32-S3, M5Paper v1.1 is a classic ESP32. The Sticky env ships in `platformio.ini` (`pio run -e sticky`). Envs for other devices go in **`platformio.local.ini`**, a gitignored file that PlatformIO merges over `platformio.ini` (see `extra_configs`). Create it next to `platformio.ini`; personal envs, ports, and debug flags live there and never get committed.
+
+Both envs below extend the repo's `[base]`, so they build against the `freeink-sdk` submodule with all the normal deps and scripts.
+
+### M5Paper v1.1 (classic ESP32, IT8951 panel)
+
+```ini
+[env:m5paper_v11]
+extends = base
+board = esp32dev
+board_build.mcu = esp32
+board_build.flash_mode = qio
+; CP2104 UART bridge: 921600 drops out on macOS after the stub baud switch
+upload_speed = 460800
+build_unflags =
+  ${base.build_unflags}
+  ; classic ESP32 has UART serial, not USB CDC; Logging.h keys off these
+  -DARDUINO_USB_MODE=1
+  -DARDUINO_USB_CDC_ON_BOOT=1
+build_flags =
+  ${base.build_flags}
+  -DFREEINK_DEVICE_M5PAPER=1
+  ; the 63KB 540x960 framebuffer lives in PSRAM (FREEINK_FB_PSRAM auto-on)
+  -DBOARD_HAS_PSRAM
+  -DCROSSPOINT_VERSION=\"${crosspoint.version}-m5paper\"
+  -DENABLE_SERIAL_LOG
+  -DLOG_LEVEL=2
+  ; touch-first device: hide front-button hint labels
+  -DCROSSPOINT_SHOW_BUTTON_HINTS=0
+  ; archive-scan-order workaround: without these a full relink drops Wire's i2c symbols
+  -Wl,-u,i2cInit
+  -Wl,-u,i2cSlaveInit
+```
+
+### LilyGo T5 S3 (ESP32-S3, controller-less panel via LovyanGFX)
+
+```ini
+[env:lilygo_t5s3]
+extends = base
+board = esp32-s3-devkitc1-n16r8
+board_build.mcu = esp32s3
+build_flags =
+  ${base.build_flags}
+  -DFREEINK_DEVICE_LILYGO=1
+  ; board injects the parallel-bus pins + PMIC power hooks (BoardT5S3)
+  -DFREEINK_LGFX_EPD_CONFIG=lilygoT5S3LgfxConfig
+  -DCROSSPOINT_VERSION=\"${crosspoint.version}-lilygo\"
+  -DENABLE_SERIAL_LOG
+  -DLOG_LEVEL=2
+  -DCROSSPOINT_SHOW_BUTTON_HINTS=0
+lib_deps =
+  ${base.lib_deps}
+  ; LgfxEpdConfig for the T5 S3 (pins, PCA9535/TPS65185 power sequence)
+  BoardT5S3=symlink://freeink-sdk/libs/hardware/BoardT5S3
+  ; LovyanGFX Panel_EPD drives the controller-less ED047TC1 panel
+  m5stack/M5GFX @ 0.2.20
+```
+
+Then `pio run -e m5paper_v11 -t upload` (or `-e lilygo_t5s3`). Gotchas worth knowing:
+
+- **Flash mode matters.** The M5Paper is `qio`; the X4-family standalone envs need `dio`. A wrong flash-mode header boots into a `partition 0 invalid magic number 0xffff` loop even though esptool verified the write.
+- **One `FREEINK_DEVICE_*` flag per env** selects the board profile (pins, panel, touch controller) from the SDK's `BoardConfig`. See `freeink-sdk/platformio.sample.ini` for reference envs of every supported device.
+- **Serial logs:** `[base]` does not enable logging; without `-DENABLE_SERIAL_LOG` a non-default env prints nothing.
+- No touch hardware on your desk? The X4 build still exercises the same code paths through buttons; touch-specific behavior (tap zones, gestures) needs a real device.

docs/dictionary.md

@@ -0,0 +1,51 @@
+# Dictionary
+
+Look up words while reading an EPUB using an offline StarDict dictionary stored on the SD card.
+
+## Supported Format
+
+The reader supports **StarDict** dictionaries. When searching for dictionaries online, look for "StarDict format" or files with `.dict`, `.idx`, and `.ifo` extensions.
+
+A dictionary folder must contain:
+
+- `.idx` — word index (required, **must be uncompressed** — a `.idx.gz` will not work; decompress it on your computer with `gzip -d` first)
+- `.dict` or `.dict.dz` — definition data (`.dict.dz` is supported as-is; entries are decompressed on the fly during lookup)
+- `.ifo` — metadata (optional)
+
+Not supported: `.syn` synonym files (ignored), dictionaries with 64-bit index offsets (`idxoffsetbits=64` in the `.ifo` — rare, and rejected with an error), and HTML-formatted definitions render as raw markup rather than styled text.
+
+## Setting Up a Dictionary
+
+1. Copy your dictionary folder(s) to `/dictionaries/` on the SD card — one dictionary per folder, e.g. `/dictionaries/webster/webster.idx` + `webster.dict.dz`. A hidden `/.dictionaries/` folder (dot-prefixed) works the same way, for keeping it out of the file browser.
+2. Open **Settings → Reader → Dictionary** on the device.
+3. Select a dictionary from the list, or **None** to disable lookups.
+
+The Dictionary setting only appears when at least one usable dictionary folder exists. Folders containing more than one dictionary (multiple `.idx` stems) are skipped as ambiguous.
+
+## Looking Up a Word
+
+Two ways to start a lookup while reading:
+
+- Open the reader menu (**Confirm**) and choose **Look Up**.
+- Or set **Settings → Controls → Long-press Menu** to "Dictionary", then hold **Confirm** (~0.4s) on the reading page.
+
+One word on the page becomes highlighted:
+
+1. Use **Left/Right** to move between words in reading order, and the side **Up/Down** buttons to jump between lines.
+2. Press **Confirm** to look up the highlighted word.
+3. Press **Back** to return to the reader.
+
+On the very first lookup with a dictionary (and again if the dictionary file changes), the reader shows *"Indexing dictionary…"* while it builds a small `.qidx` sidecar file next to the `.idx`. This takes a few seconds for large dictionaries and makes all subsequent lookups fast. The sidecar can be deleted safely at any time — it will simply be rebuilt.
+
+### How Lookup Works
+
+1. **Direct match** — the word is found as-is (case-insensitive) in the dictionary index. Surrounding punctuation is ignored.
+2. **Stemming** — on a miss, common English word forms are retried automatically: possessives and plurals (`dogs` → `dog`, `stories` → `story`) and verb endings (`walked` → `walk`, `running` → `run`, `making` → `make`).
+3. **Not found** — a short popup appears and you return to word selection.
+
+## The Definition Screen
+
+When a word is found, the definition screen shows the matched headword at the top and the definition text below, with a page counter for long definitions.
+
+- **Left/Right** or side **Up/Down** — previous / next page
+- **Back** — return to word selection

lib/EpdFont/FontDecompressor.cpp

@@ -369,11 +369,6 @@ int FontDecompressor::prewarmCache(const EpdFontData* fontData, const char* utf8
   }
   stats.pageBufferBytes += totalBytes;
   stats.pageGlyphsBytes += glyphCount * sizeof(PageGlyphEntry);
-  // MEMFIX-PORT: page-slot address landmark for the heap map; portable
-  // Landmark for the heap block map: page slots are the largest flash-font
-  // allocations and otherwise show up as anonymous ~4-20 KB used blocks.
-  LOG_DBG("FDC", "page slot buffer=%p bytes=%u glyphs=%u", static_cast<void*>(slot.buffer), (unsigned)totalBytes,
-          (unsigned)glyphCount);
 
   slot.fontData = fontData;
   slot.glyphCount = glyphCount;

lib/EpdFont/SdCardFont.cpp

@@ -68,22 +68,6 @@ bool collectUniqueCodepoints(const char* text, uint32_t* codepoints, uint32_t& c
 const char* asCStr(const std::string& s) { return s.c_str(); }
 const char* asCStr(const char* s) { return s; }
 
-// Keep-if-fits buffer reuse: only reallocate when the needed size exceeds the
-// current capacity. Freeing + reallocating slightly different sizes every page
-// turn punches non-coalescing holes in the heap (the freed block rarely fits the
-// next page's need), eroding the largest contiguous block all session. With
-// reuse, capacities converge on the book's max page after a few turns and page
-// turns stop touching the allocator. Only three small instantiations exist
-// (interval/glyph/byte arrays), so template bloat is negligible.
-template <typename T, typename CapT>
-bool ensureArrayCapacity(T*& buf, CapT& capacity, const uint32_t needed) {
-  if (buf && capacity >= needed) return true;
-  delete[] buf;
-  buf = new (std::nothrow) T[needed > 0 ? needed : 1];
-  capacity = buf ? static_cast<CapT>(needed) : 0;
-  return buf != nullptr;
-}
-
 }  // namespace
 
 SdCardFont::~SdCardFont() { freeAll(); }
@@ -99,9 +83,6 @@ void SdCardFont::freeStyleMiniData(PerStyle& s) {
   s.miniBitmap = nullptr;
   s.miniIntervalCount = 0;
   s.miniGlyphCount = 0;
-  s.miniIntervalCapacity = 0;
-  s.miniGlyphCapacity = 0;
-  s.miniBitmapCapacity = 0;
   freeStyleMiniKern(s);
   memset(&s.miniData, 0, sizeof(s.miniData));
   s.epdFont.data = &s.stubData;
@@ -128,9 +109,6 @@ void SdCardFont::freeStyleMiniKern(PerStyle& s) {
   s.miniKernRightEntryCount = 0;
   s.miniKernLeftClassCount = 0;
   s.miniKernRightClassCount = 0;
-  s.miniKernLeftCapacity = 0;
-  s.miniKernRightCapacity = 0;
-  s.miniKernMatrixCapacity = 0;
 }
 
 void SdCardFont::freeStyleAll(PerStyle& s) {
@@ -333,13 +311,13 @@ bool SdCardFont::buildMiniKernMatrix(PerStyle& s, const uint32_t* codepoints, ui
     if (miniLookupKernClass(s.kernRightClasses, s.header.kernRightEntryCount, codepoints[i]) != 0) miniRightCount++;
   }
 
-  // Step 4: size the three mini buffers (reused across pages when they fit; the
-  // per-page sizes vary by a few entries, which as free+realloc churn was punching
-  // non-coalescing holes in the heap every page turn).
+  // Step 4: allocate the three mini buffers. The matrix is <1KB in practice
+  // (<30 × <30 × 1 byte) so fragmentation is a non-issue.
   const uint32_t matrixBytes = static_cast<uint32_t>(numLeft) * numRight;
-  if (!ensureArrayCapacity(s.miniKernLeftClasses, s.miniKernLeftCapacity, miniLeftCount) ||
-      !ensureArrayCapacity(s.miniKernRightClasses, s.miniKernRightCapacity, miniRightCount) ||
-      !ensureArrayCapacity(s.miniKernMatrix, s.miniKernMatrixCapacity, matrixBytes)) {
+  s.miniKernLeftClasses = new (std::nothrow) EpdKernClassEntry[miniLeftCount];
+  s.miniKernRightClasses = new (std::nothrow) EpdKernClassEntry[miniRightCount];
+  s.miniKernMatrix = new (std::nothrow) int8_t[matrixBytes];
+  if (!s.miniKernLeftClasses || !s.miniKernRightClasses || !s.miniKernMatrix) {
     LOG_ERR("SDCF", "Failed to allocate mini kern (%u+%u+%u bytes)", miniLeftCount * 3u, miniRightCount * 3u,
             matrixBytes);
     freeStyleMiniKern(s);
@@ -815,19 +793,12 @@ int SdCardFont::prewarmStyle(uint8_t styleIdx, const uint32_t* codepoints, uint3
     return missed;
   }
 
-  // Build mini intervals from sorted codepoints. Reset counts and fall back to the
-  // stub until the rebuild completes, but KEEP the existing buffers (keep-if-fits
-  // reuse) — the free-and-realloc-per-page pattern here was a primary fragmenter.
-  s.miniIntervalCount = 0;
-  s.miniGlyphCount = 0;
-  s.miniKernLeftEntryCount = 0;
-  s.miniKernRightEntryCount = 0;
-  s.miniKernLeftClassCount = 0;
-  s.miniKernRightClassCount = 0;
-  memset(&s.miniData, 0, sizeof(s.miniData));
-  s.epdFont.data = &s.stubData;
+  // Build mini intervals from sorted codepoints
+  freeStyleMiniData(s);
 
-  if (!ensureArrayCapacity(s.miniIntervals, s.miniIntervalCapacity, validCount)) {
+  uint32_t intervalCapacity = validCount;
+  s.miniIntervals = new (std::nothrow) EpdUnicodeInterval[intervalCapacity];
+  if (!s.miniIntervals) {
     LOG_ERR("SDCF", "Failed to allocate mini intervals for style %u", styleIdx);
     delete[] mappings;
     return static_cast<int>(cpCount);
@@ -845,14 +816,15 @@ int SdCardFont::prewarmStyle(uint8_t styleIdx, const uint32_t* codepoints, uint3
     }
   }
 
-  // Mini glyph array (reused across pages when it fits)
-  if (!ensureArrayCapacity(s.miniGlyphs, s.miniGlyphCapacity, validCount)) {
+  // Allocate mini glyph array
+  s.miniGlyphCount = validCount;
+  s.miniGlyphs = new (std::nothrow) EpdGlyph[s.miniGlyphCount];
+  if (!s.miniGlyphs) {
     LOG_ERR("SDCF", "Failed to allocate mini glyphs for style %u", styleIdx);
     delete[] mappings;
     freeStyleMiniData(s);
     return static_cast<int>(cpCount);
   }
-  s.miniGlyphCount = validCount;
 
   // Build sorted read order for sequential I/O
   uint32_t* readOrder = new (std::nothrow) uint32_t[validCount];
@@ -919,7 +891,8 @@ int SdCardFont::prewarmStyle(uint8_t styleIdx, const uint32_t* codepoints, uint3
       totalBitmapSize += s.miniGlyphs[i].dataLength;
     }
 
-    if (!ensureArrayCapacity(s.miniBitmap, s.miniBitmapCapacity, totalBitmapSize)) {
+    s.miniBitmap = new (std::nothrow) uint8_t[totalBitmapSize > 0 ? totalBitmapSize : 1];
+    if (!s.miniBitmap) {
       LOG_ERR("SDCF", "Failed to allocate mini bitmap (%u bytes) for style %u", totalBitmapSize, styleIdx);
       delete[] readOrder;
       delete[] mappings;
@@ -1406,33 +1379,6 @@ const EpdGlyph* SdCardFont::onGlyphMiss(void* ctx, uint32_t codepoint) {
   return &self->overflow_[slot].glyph;
 }
 
-size_t SdCardFont::reportMemory() const {
-  size_t total = 0;
-  for (uint8_t si = 0; si < MAX_STYLES; ++si) {
-    const auto& s = styles_[si];
-    if (!s.present) continue;
-    size_t fixed = 0;  // loaded once per family: interval/kern/lig tables
-    if (s.fullIntervals) fixed += s.header.intervalCount * sizeof(EpdUnicodeInterval);
-    if (s.bmpIntervals) fixed += s.header.intervalCount * sizeof(PerStyle::BmpInterval16);
-    if (s.kernLeftClasses) fixed += s.header.kernLeftEntryCount * sizeof(EpdKernClassEntry);
-    if (s.kernRightClasses) fixed += s.header.kernRightEntryCount * sizeof(EpdKernClassEntry);
-    if (s.ligaturePairs) fixed += s.header.ligaturePairCount * sizeof(EpdLigaturePair);
-    // kept-if-fits mini arenas: capacity (not count) is what stays resident
-    size_t mini = s.miniIntervalCapacity * sizeof(EpdUnicodeInterval) + s.miniGlyphCapacity * sizeof(EpdGlyph) +
-                  s.miniBitmapCapacity + s.miniKernLeftCapacity * sizeof(EpdKernClassEntry) +
-                  s.miniKernRightCapacity * sizeof(EpdKernClassEntry) + s.miniKernMatrixCapacity;
-    const size_t adv = advanceTableSize_[si] * sizeof(AdvanceEntry);
-    LOG_DBG("SDCF", "mem style%u: fixed=%u mini=%u adv=%u", si, (unsigned)fixed, (unsigned)mini, (unsigned)adv);
-    total += fixed + mini + adv;
-  }
-  size_t overflowBytes = 0;
-  for (uint32_t i = 0; i < overflowCount_; ++i) {
-    if (overflow_[i].bitmap) overflowBytes += overflow_[i].glyph.dataLength;
-  }
-  total += overflowBytes + overflowCount_ * sizeof(OverflowEntry);
-  return total;
-}
-
 bool SdCardFont::isOverflowGlyph(const EpdGlyph* glyph) const {
   for (uint32_t i = 0; i < overflowCount_; i++) {
     if (&overflow_[i].glyph == glyph) return true;

lib/EpdFont/SdCardFont.h

@@ -104,11 +104,6 @@ class SdCardFont {
     uint32_t uniqueGlyphs = 0;
     uint32_t bitmapBytes = 0;
   };
-  // MEMFIX-PORT: SD font resident-bytes audit; portable
-  // Log per-style resident heap (full tables + kept-if-fits mini arenas +
-  // advance tables + overflow bitmaps) and return the total in bytes. Pure
-  // accounting — no allocation, no state change.
-  size_t reportMemory() const;
   void logStats(const char* label = "SDCF");
   void resetStats();
   const Stats& getStats() const { return stats_; }
@@ -173,22 +168,13 @@ class SdCardFont {
     // Stub EpdFontData returned when not prewarmed
     EpdFontData stubData{};
 
-    // Mini EpdFontData built during prewarm. Buffers are kept-if-fits across pages
-    // (capacities below track allocated sizes): freeing and reallocating slightly
-    // different sizes on every page turn was a primary heap fragmenter — each page's
-    // freed hole rarely fit the next page's need, so maxAlloc eroded all session.
-    // After a few pages the capacities converge on the book's max and page turns
-    // stop allocating entirely. freeStyleMiniData() still releases everything (and
-    // zeroes capacities) for style eviction / font unload.
+    // Mini EpdFontData built during prewarm
     EpdFontData miniData{};
     EpdUnicodeInterval* miniIntervals = nullptr;
     EpdGlyph* miniGlyphs = nullptr;
     uint8_t* miniBitmap = nullptr;
     uint32_t miniIntervalCount = 0;
     uint32_t miniGlyphCount = 0;
-    uint32_t miniIntervalCapacity = 0;
-    uint32_t miniGlyphCapacity = 0;
-    uint32_t miniBitmapCapacity = 0;
 
     // Per-page mini kern matrix (built by buildMiniKernMatrix on each full
     // prewarm). miniKernLeftClasses/miniKernRightClasses map ONLY the codepoints
@@ -203,10 +189,6 @@ class SdCardFont {
     uint8_t miniKernLeftClassCount = 0;
     uint8_t miniKernRightClassCount = 0;
     int8_t* miniKernMatrix = nullptr;
-    // Kept-if-fits capacities, same rationale as the mini glyph buffers above.
-    uint16_t miniKernLeftCapacity = 0;
-    uint16_t miniKernRightCapacity = 0;
-    uint32_t miniKernMatrixCapacity = 0;
 
     // The EpdFont whose data pointer we manage
     EpdFont epdFont{&stubData};

lib/EpdFont/SdCardFontManager.cpp

@@ -88,14 +88,6 @@ void SdCardFontManager::unloadAll(GfxRenderer& renderer) {
   loadedPointSize_ = 0;
 }
 
-size_t SdCardFontManager::reportMemory() const {
-  size_t total = 0;
-  for (const auto& lf : loaded_) {
-    if (lf.font) total += lf.font->reportMemory();
-  }
-  return total;
-}
-
 int SdCardFontManager::getFontId(const std::string& familyName) const {
   if (familyName != loadedFamilyName_ || loaded_.empty()) return 0;
   return loaded_.front().fontId;

lib/EpdFont/SdCardFontManager.h

@@ -32,10 +32,6 @@ class SdCardFontManager {
   // Get name of currently loaded family (empty if none).
   const std::string& currentFamilyName() const { return loadedFamilyName_; };
 
-  // MEMFIX-PORT: font manager audit passthrough; portable
-  // Sum of loaded fonts' resident heap (see SdCardFont::reportMemory).
-  size_t reportMemory() const;
-
   // Point size that was actually loaded.
   // 0 if nothing loaded.
   uint8_t currentPointSize() const { return loadedPointSize_; };

lib/Epub/Epub.h

@@ -44,18 +44,6 @@ class Epub {
   }
   ~Epub() = default;
   std::string& getBasePath() { return contentBasePath; }
-  // MEMFIX-PORT: epub resident-bytes audit accessor; portable
-  // Approximate resident heap of the open book (audit): path strings, the CSS
-  // file list, and the parsed stylesheet. BookMetadataCache is file-backed
-  // (counts + HalFile handles) and contributes little.
-  size_t residentBytes() const {
-    size_t total = sizeof(Epub) + tocNcxItem.capacity() + tocNavItem.capacity() + filepath.capacity() +
-                   contentBasePath.capacity() + cachePath.capacity();
-    for (const auto& f : cssFiles) total += sizeof(f) + (f.capacity() > 15 ? f.capacity() : 0);
-    if (cssParser) total += cssParser->residentBytes();
-    return total;
-  }
-  size_t cssRuleCount() const { return cssParser ? cssParser->ruleCount() : 0; }
   bool load(bool buildIfMissing = true, bool skipLoadingCss = false);
   bool clearCache() const;
   void setupCacheDir() const;

lib/Epub/Epub/Page.cpp

@@ -173,10 +173,6 @@ std::unique_ptr<Page> Page::deserialize(HalFile& file) {
 
   uint16_t count;
   serialization::readPod(file, count);
-  // Reserve up front: growth-by-doubling needs old + new capacity live at once and
-  // reallocates repeatedly — a field crash (bad_alloc -> abort under -fno-exceptions)
-  // hit exactly this append path on a heavily fragmented heap.
-  page->elements.reserve(count);
 
   for (uint16_t i = 0; i < count; i++) {
     uint8_t tag;

lib/Epub/Epub/ParsedText.cpp

@@ -287,7 +287,30 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
     effectiveNoSpaceBefore = true;
   }
 
+  const auto ensureTokenCapacity = [&](const size_t additionalTokens) {
+    if (additionalTokens == 0) return;
+    const size_t requiredSize = words.size() + additionalTokens;
+    if (words.capacity() >= requiredSize) return;
+
+    size_t newCapacity = words.capacity();
+    if (newCapacity < 16) {
+      newCapacity = 16;
+    }
+    while (newCapacity < requiredSize) {
+      newCapacity *= 2;
+    }
+
+    words.reserve(newCapacity);
+    wordStyles.reserve(newCapacity);
+    wordContinues.reserve(newCapacity);
+    wordNoSpaceBefore.reserve(newCapacity);
+    wordIsFocusSuffix.reserve(newCapacity);
+  };
+
   if (auto breakOffsets = cjkCharacterBreakByteOffsets(word); !breakOffsets.empty()) {
+    // CJK-heavy paragraphs can push hundreds of tiny tokens quickly when CSS toggles
+    // inline styles. Reserve once up front to avoid repeated vector growth reallocations.
+    ensureTokenCapacity(breakOffsets.size() + 1);
     bool firstToken = true;
     size_t tokenStart = 0;
     for (const size_t breakOffset : breakOffsets) {
@@ -326,29 +349,8 @@ void ParsedText::addWord(std::string word, const EpdFontFamily::Style fontStyle,
 
   // --- FOCUS READING LOGIC BELOW ---
 
-  // Pre-reserve capacity to prevent mid-word heap reallocations.
-  size_t maxPossibleNewTokens = word.length();
-  size_t requiredSize = words.size() + maxPossibleNewTokens;
-
-  if (words.capacity() < requiredSize) {
-    // Emulate standard geometric growth (doubling) to ensure we don't reallocate on every word.
-    size_t newCapacity = words.capacity() * 2;
-
-    // Ensure the doubled capacity is actually enough for this specific word
-    if (newCapacity < requiredSize) {
-      newCapacity = requiredSize;
-    }
-    // Set a sensible minimum starting size so the first few words don't trigger tiny reallocations
-    if (newCapacity < 16) {
-      newCapacity = 16;
-    }
-
-    words.reserve(newCapacity);
-    wordStyles.reserve(newCapacity);
-    wordContinues.reserve(newCapacity);
-    wordNoSpaceBefore.reserve(newCapacity);
-    wordIsFocusSuffix.reserve(newCapacity);
-  }
+  // Worst case: a segment boundary on each byte (highly punctuated UTF-8 text).
+  ensureTokenCapacity(word.length());
 
   // Lambda helper to process and push individual sub-segments of the string
   // Use std::string_view to avoid heap allocations when slicing

lib/Epub/Epub/Section.cpp

@@ -17,7 +17,7 @@ namespace {
 // v30: Arabic shaping changed both drawing and measurement (getTextAdvanceX now
 //      measures the shaped visual text); cached word positions from v29 no longer
 //      match what drawText renders.
-constexpr uint8_t SECTION_FILE_VERSION = 30;
+constexpr uint8_t SECTION_FILE_VERSION = 31;
 // Written into the version field while a build is in progress; patched to
 // SECTION_FILE_VERSION only when the build is finalized. An abandoned /
 // crash-interrupted .bin therefore carries version 0, which loadSectionFile rejects

lib/Epub/Epub/Section.h

@@ -72,7 +72,6 @@ class Section {
   // Builds write here and are swapped over filePath only on commit, so a prior
   // partial/finalized file stays readable while a rebuild is in progress.
   std::string binTmpPath() const { return filePath + ".part"; }
-
   std::unique_ptr<Page> loadPageAt(int page) const;
   // Read a page already laid out by the in-progress build (page < build LUT size), from
   // the partially-written tmp .bin without disturbing the build's write cursor.
@@ -132,20 +131,6 @@ class Section {
   // (covers finalized sections and partials from a previous session).
   std::optional<uint16_t> findAnchor(const std::string& anchor) const;
 
-  // MEMFIX-PORT: section resident-bytes audit accessor; portable
-  // Approximate resident heap for the audit log. Steady state (no build) a
-  // Section holds little beyond itself; during a build the page LUT and path
-  // strings dominate (the parser's internal footprint is not walked here).
-  size_t residentBytes() const {
-    size_t total = sizeof(Section) + filePath.capacity();
-    if (build_) {
-      total += sizeof(BuildContext) + build_->lut.capacity() * sizeof(PageLutEntry) +
-               build_->parsePath.capacity() + build_->contentBase.capacity() + build_->imageBasePath.capacity() +
-               build_->htmlPath.capacity() + build_->tmpHtmlPath.capacity();
-    }
-    return total;
-  }
-
   // True if this spine's unzipped HTML is already cached, so a build won't pay the (multi-second on a
   // giant spine) zip inflation. Lets the reader skip the indexing popup on a fast reopen/rebuild.
   bool hasHtmlCache() const;

lib/Epub/Epub/css/CssParser.cpp

@@ -431,6 +431,11 @@ CssStyle CssParser::parseDeclarations(std::string_view declBlock) {
 // Rule processing
 
 void CssParser::processRuleBlockWithStyle(std::string_view selectorGroup, const CssStyle& style) {
+  // Skip rules that don't define any supported properties to save RAM.
+  if (!style.defined.anySet()) {
+    return;
+  }
+
   // Check if we've reached the rule limit before processing
   if (rulesBySelector_.size() >= MAX_RULES) {
     LOG_DBG("CSS", "Reached max rules limit (%zu), stopping CSS parsing", MAX_RULES);

lib/Epub/Epub/css/CssParser.h

@@ -33,7 +33,7 @@
 class CssParser {
  public:
   // Bump when CSS cache format or rules change; section caches are invalidated when this changes
-  static constexpr uint8_t CSS_CACHE_VERSION = 7;
+  static constexpr uint8_t CSS_CACHE_VERSION = 8;
 
   explicit CssParser(std::string cachePath) : cachePath(std::move(cachePath)) {}
   ~CssParser() = default;
@@ -67,20 +67,6 @@ class CssParser {
    */
   [[nodiscard]] static CssStyle parseInlineStyle(std::string_view styleValue);
 
-  // MEMFIX-PORT: stylesheet resident-bytes audit accessor; portable
-  // Approximate resident heap of the parsed stylesheet, for the audit log.
-  // unordered_map cost model: bucket array + one node per rule (libstdc++ node
-  // overhead ~= 2 pointers + hash) + key string capacity when it exceeds SSO.
-  size_t residentBytes() const {
-    size_t total = rulesBySelector_.bucket_count() * sizeof(void*);
-    for (const auto& kv : rulesBySelector_) {
-      total += sizeof(void*) * 2 + sizeof(size_t);  // node overhead
-      total += sizeof(kv);
-      if (kv.first.capacity() > 15) total += kv.first.capacity();  // beyond SSO
-    }
-    return total;
-  }
-
   /**
    * Check if any rules have been loaded
    */

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp

@@ -22,6 +22,17 @@
 constexpr size_t MIN_SIZE_FOR_POPUP = 10 * 1024;  // 10KB
 constexpr size_t PARSE_BUFFER_SIZE = 1024;
 
+// This number comes from PR #73
+// If we have > 750 words buffered up, perform the layout and consume out all but the last line
+// There should be enough here to build out 1-2 full pages and doing this will free up a lot of
+// memory.
+// Spotted when reading Intermezzo, there are some really long text blocks in there.
+constexpr size_t TEXT_BLOCK_SOFT_FLUSH_WORDS = 750;
+
+// When CSS is enabled, flush earlier to save RAM. 320 is still more than enough to build a CJK
+// page at font size 14
+constexpr size_t TEXT_BLOCK_SOFT_FLUSH_WORDS_WITH_CSS = 320;
+
 // Hard cap on the number of anchor IDs recorded per chapter. Legitimate navigation
 // anchors (TOC entries, footnotes, cross-references) rarely exceed a few hundred per
 // chapter. A runaway count usually means a converter injected machine-generated IDs on
@@ -1143,24 +1154,28 @@ void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char
         }
         self->partWordBufferIndex = safeLen;
         self->flushPartWordBuffer();
+        self->nextWordContinues = true;
         for (int j = 0; j < overflow; j++) {
           self->partWordBuffer[j] = saved[j];
         }
         self->partWordBufferIndex = overflow;
       } else {
         self->flushPartWordBuffer();
+        self->nextWordContinues = true;
       }
     }
 
     self->partWordBuffer[self->partWordBufferIndex++] = s[i];
   }
 
-  // If we have > 750 words buffered up, perform the layout and consume out all but the last line
-  // There should be enough here to build out 1-2 full pages and doing this will free up a lot of
-  // memory.
-  // Spotted when reading Intermezzo, there are some really long text blocks in there.
-  if (self->currentTextBlock->size() > 750) {
-    LOG_DBG("EHP", "Text block too long, splitting into multiple pages");
+  // Keep token growth bounded: CSS-heavy spans can fragment text into many tiny
+  // words, so flush earlier when embedded CSS is active. We still keep the
+  // "exclude last line" behavior to preserve paragraph flow across chunks.
+  const size_t blockWordCount = self->currentTextBlock->size();
+  const size_t softFlushThreshold =
+      self->embeddedStyle ? TEXT_BLOCK_SOFT_FLUSH_WORDS_WITH_CSS : TEXT_BLOCK_SOFT_FLUSH_WORDS;
+  if (blockWordCount > softFlushThreshold) {
+    LOG_DBG("EHP", "Text block soft flush (%u words)", static_cast<unsigned>(blockWordCount));
     const int horizontalInset = self->currentTextBlock->getBlockStyle().totalHorizontalInset();
     const uint16_t effectiveWidth = (horizontalInset < self->viewportWidth)
                                         ? static_cast<uint16_t>(self->viewportWidth - horizontalInset)

lib/GfxRenderer/FontCacheManager.cpp

@@ -62,14 +62,7 @@ void FontCacheManager::resetStats() {
 bool FontCacheManager::isScanning() const { return scanMode_ == ScanMode::Scanning; }
 
 void FontCacheManager::recordText(const char* text, int fontId, EpdFontFamily::Style style) {
-  if (!text) return;
-  const size_t remaining = (scanTextLen_ < SCAN_TEXT_CAPACITY - 1) ? (SCAN_TEXT_CAPACITY - 1 - scanTextLen_) : 0;
-  if (remaining > 0) {
-    const size_t textLen = strnlen(text, remaining);
-    memcpy(scanText_ + scanTextLen_, text, textLen);
-    scanTextLen_ += textLen;
-    scanText_[scanTextLen_] = '\0';
-  }
+  scanText_ += text;
   if (scanFontId_ < 0) scanFontId_ = fontId;
   const uint8_t baseStyle = static_cast<uint8_t>(style) & 0x03;
   const unsigned char* p = reinterpret_cast<const unsigned char*>(text);
@@ -87,15 +80,15 @@ FontCacheManager::PrewarmScope::PrewarmScope(FontCacheManager& manager) : manage
   manager_->scanMode_ = ScanMode::Scanning;
   manager_->clearCache();
   manager_->resetStats();
-  manager_->scanTextLen_ = 0;
-  manager_->scanText_[0] = '\0';
+  manager_->scanText_.clear();
+  manager_->scanText_.reserve(2048);  // Pre-allocate to avoid heap fragmentation from repeated concat
   memset(manager_->scanStyleCounts_, 0, sizeof(manager_->scanStyleCounts_));
   manager_->scanFontId_ = -1;
 }
 
 void FontCacheManager::PrewarmScope::endScanAndPrewarm() {
   manager_->scanMode_ = ScanMode::None;
-  if (manager_->scanTextLen_ == 0) return;
+  if (manager_->scanText_.empty()) return;
 
   // Build style bitmask from all styles that appeared during the scan
   uint8_t styleMask = 0;
@@ -104,10 +97,11 @@ void FontCacheManager::PrewarmScope::endScanAndPrewarm() {
   }
   if (styleMask == 0) styleMask = 1;  // default to regular
 
-  manager_->prewarmCache(manager_->scanFontId_, manager_->scanText_, styleMask);
+  manager_->prewarmCache(manager_->scanFontId_, manager_->scanText_.c_str(), styleMask);
 
-  manager_->scanTextLen_ = 0;
-  manager_->scanText_[0] = '\0';
+  // Free scan string memory
+  manager_->scanText_.clear();
+  manager_->scanText_.shrink_to_fit();
 }
 
 FontCacheManager::PrewarmScope::~PrewarmScope() {

lib/GfxRenderer/FontCacheManager.h

@@ -2,9 +2,9 @@
 
 #include <EpdFontFamily.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <map>
+#include <string>
 
 class FontDecompressor;
 class SdCardFont;
@@ -51,9 +51,7 @@ class FontCacheManager {
 
   enum class ScanMode : uint8_t { None, Scanning };
   ScanMode scanMode_ = ScanMode::None;
-  static constexpr size_t SCAN_TEXT_CAPACITY = 2048;
-  char scanText_[SCAN_TEXT_CAPACITY] = {};
-  size_t scanTextLen_ = 0;
+  std::string scanText_;
   uint32_t scanStyleCounts_[4] = {};
   int scanFontId_ = -1;
 };

lib/GfxRenderer/GfxRenderer.cpp

@@ -213,6 +213,61 @@ static inline void rotateCoordinates(const GfxRenderer::Orientation orientation,
   }
 }
 
+// Output of screenRectToAlignedMemRect: a rectangle in panel-memory
+// coordinates whose x and width are guaranteed to be multiples of 8 (the
+// SDK's EInkDisplay::displayWindow alignment requirement). `valid == false`
+// means the input was empty or fully outside the panel.
+struct AlignedMemRect {
+  uint16_t x = 0;
+  uint16_t y = 0;
+  uint16_t w = 0;
+  uint16_t h = 0;
+  bool valid = false;
+};
+
+// Translate a screen-coordinate rectangle (the coordinate system used by
+// fillRect / drawText / the rest of the renderer's public API) into a
+// panel-memory rectangle suitable for direct framebuffer indexing. Rotates
+// the rectangle's two opposite corners with rotateCoordinates(), takes the
+// bounding box (which naturally swaps width/height in Portrait /
+// PortraitInverted), then snaps the x extent outward to multiples of 8 and
+// clamps to panel bounds. Precondition: panel dims are multiples of 8 (true
+// for the 800x480 panel), so clamping cannot re-break alignment.
+static AlignedMemRect screenRectToAlignedMemRect(GfxRenderer::Orientation orientation, int sx, int sy, int sw, int sh,
+                                                 uint16_t panelWidth, uint16_t panelHeight) {
+  AlignedMemRect out;
+  if (sw <= 0 || sh <= 0) return out;
+
+  int x0, y0, x1, y1;
+  rotateCoordinates(orientation, sx, sy, &x0, &y0, panelWidth, panelHeight);
+  rotateCoordinates(orientation, sx + sw - 1, sy + sh - 1, &x1, &y1, panelWidth, panelHeight);
+
+  const int memXLo = std::min(x0, x1);
+  const int memYLo = std::min(y0, y1);
+  const int memXHi = std::max(x0, x1) + 1;  // exclusive upper bound
+  const int memYHi = std::max(y0, y1) + 1;
+
+  // Snap x outward to multiples of 8.
+  int alignedXLo = memXLo & ~0x7;        // round down
+  int alignedXHi = (memXHi + 7) & ~0x7;  // round up
+
+  if (alignedXLo < 0) alignedXLo = 0;
+  if (alignedXHi > panelWidth) alignedXHi = panelWidth;
+  int clampedYLo = memYLo;
+  int clampedYHi = memYHi;
+  if (clampedYLo < 0) clampedYLo = 0;
+  if (clampedYHi > panelHeight) clampedYHi = panelHeight;
+
+  if (alignedXHi <= alignedXLo || clampedYHi <= clampedYLo) return out;
+
+  out.x = static_cast<uint16_t>(alignedXLo);
+  out.y = static_cast<uint16_t>(clampedYLo);
+  out.w = static_cast<uint16_t>(alignedXHi - alignedXLo);
+  out.h = static_cast<uint16_t>(clampedYHi - clampedYLo);
+  out.valid = true;
+  return out;
+}
+
 enum class TextRotation { None, Rotated90CW };
 
 // Shared glyph rendering logic for normal and rotated text.
@@ -1465,6 +1520,39 @@ void GfxRenderer::waitRefreshComplete() const { display.waitRefreshComplete(); }
 
 bool GfxRenderer::supportsAsyncRefresh() const { return !fadingFix && display.supportsAsyncRefresh(); }
 
+size_t GfxRenderer::readFramebufferRegion(int x, int y, int w, int h, uint8_t* dst, size_t dstCapacity) const {
+  if (dst == nullptr || w <= 0 || h <= 0) return 0;
+
+  const AlignedMemRect mem = screenRectToAlignedMemRect(orientation, x, y, w, h, panelWidth, panelHeight);
+  if (!mem.valid) return 0;
+
+  const size_t rowBytes = mem.w / 8;  // exact: mem.w is a multiple of 8
+  const size_t needed = rowBytes * mem.h;
+  if (needed > dstCapacity) return 0;
+
+  for (uint16_t row = 0; row < mem.h; ++row) {
+    const uint8_t* srcRow = frameBuffer + (static_cast<uint32_t>(mem.y + row) * panelWidthBytes) + (mem.x / 8);
+    uint8_t* dstRow = dst + (static_cast<size_t>(row) * rowBytes);
+    memcpy(dstRow, srcRow, rowBytes);
+  }
+  return needed;
+}
+
+void GfxRenderer::writeFramebufferRegion(int x, int y, int w, int h, const uint8_t* src) {
+  if (src == nullptr || w <= 0 || h <= 0) return;
+
+  const AlignedMemRect mem = screenRectToAlignedMemRect(orientation, x, y, w, h, panelWidth, panelHeight);
+  if (!mem.valid) return;
+
+  const size_t rowBytes = mem.w / 8;  // exact: mem.w is a multiple of 8
+
+  for (uint16_t row = 0; row < mem.h; ++row) {
+    const uint8_t* srcRow = src + (static_cast<size_t>(row) * rowBytes);
+    uint8_t* dstRow = frameBuffer + (static_cast<uint32_t>(mem.y + row) * panelWidthBytes) + (mem.x / 8);
+    memcpy(dstRow, srcRow, rowBytes);
+  }
+}
+
 std::string GfxRenderer::truncatedText(const int fontId, const char* text, const int maxWidth,
                                        const EpdFontFamily::Style style) const {
   if (!text || maxWidth <= 0) return "";
@@ -1578,6 +1666,35 @@ int GfxRenderer::getScreenHeight() const {
   return panelWidth;
 }
 
+void GfxRenderer::tapToLogical(float nx, float ny, int& outX, int& outY) const {
+  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;
+
+  switch (orientation) {
+    case Portrait:
+      outX = panelHeight - 1 - phyY;
+      outY = phyX;
+      break;
+    case PortraitInverted:
+      outX = phyY;
+      outY = panelWidth - 1 - phyX;
+      break;
+    case LandscapeClockwise:
+      outX = panelWidth - 1 - phyX;
+      outY = panelHeight - 1 - phyY;
+      break;
+    case LandscapeCounterClockwise:
+    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.

lib/GfxRenderer/GfxRenderer.h

@@ -134,6 +134,7 @@ class GfxRenderer {
   // Screen ops
   int getScreenWidth() const;
   int getScreenHeight() const;
+  void tapToLogical(float nx, float ny, int& outX, int& outY) const;
   void displayBuffer(HalDisplay::RefreshMode refreshMode = HalDisplay::FAST_REFRESH) const;
   // Non-blocking refresh: starts the waveform and returns so CPU work (e.g.
   // grayscale strip rendering) can overlap the panel's refresh time. The
@@ -200,6 +201,15 @@ class GfxRenderer {
   void drawBitmap1Bit(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight) const;
   void fillPolygon(const int* xPoints, const int* yPoints, int numPoints, bool state = true) const;
 
+  // Snapshot / restore a screen-coordinate framebuffer region (byte-aligned in
+  // panel memory). readFramebufferRegion returns the bytes written to dst, or
+  // 0 when the region is empty, offscreen, or exceeds dstCapacity. Pass the
+  // same rectangle to writeFramebufferRegion to restore the saved pixels.
+  // Enables partial-repaint patterns (e.g. moving a selection highlight)
+  // without re-rendering the whole page.
+  size_t readFramebufferRegion(int x, int y, int w, int h, uint8_t* dst, size_t dstCapacity) const;
+  void writeFramebufferRegion(int x, int y, int w, int h, const uint8_t* src);
+
   // Text
   int getTextWidth(int fontId, const char* text, EpdFontFamily::Style style = EpdFontFamily::REGULAR,
                    BidiUtils::BidiBaseDir baseDir = BidiUtils::BidiBaseDir::AUTO) const;

lib/I18n/translations/arabic.yaml

@@ -0,0 +1,394 @@
+_language_name: "العربية"
+_language_code: "AR"
+_order: "28"
+
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "جاري بدء التشغيل"
+STR_SLEEPING: "وضع السكون"
+STR_ENTERING_SLEEP: "جاري الدخول في وضع السكون"
+STR_BROWSE_FILES: "تصفح الملفات"
+STR_FILE_TRANSFER: "نقل الملفات"
+STR_SETTINGS_TITLE: "الإعدادات"
+STR_CONTINUE_READING: "متابعة القراءة"
+STR_NO_OPEN_BOOK: "لا يوجد كتاب مفتوح"
+STR_START_READING: "ابدأ القراءة أدناه"
+STR_NO_FILES_FOUND: "لم يتم العثور على ملفات"
+STR_SELECT_CHAPTER: "اختر الفصل"
+STR_NO_CHAPTERS: "لا توجد فصول"
+STR_END_OF_BOOK: "نهاية الكتاب"
+STR_EMPTY_CHAPTER: "فصل فارغ"
+STR_INDEXING: "جاري الفهرسة"
+STR_INDEX_FAILED: "فشلت الفهرسة - كتاب غير صالح"
+STR_MEMORY_ERROR: "خطأ في الذاكرة"
+STR_PAGE_LOAD_ERROR: "خطأ في تحميل الصفحة"
+STR_EMPTY_FILE: "ملف فارغ"
+STR_OUT_OF_BOUNDS: "خارج النطاق"
+STR_LOADING: "جاري التحميل..."
+STR_LOADING_POPUP: "جاري التحميل"
+STR_WIFI_NETWORKS: "شبكات Wi-Fi"
+STR_NO_NETWORKS: "لم يتم العثور على شبكات"
+STR_NETWORKS_FOUND: "تم العثور على %zu شبكة"
+STR_SCANNING: "جاري البحث..."
+STR_FINDING_SAVED_WIFI: "جاري البحث عن شبكة Wi-Fi محفوظة..."
+STR_CONNECTING: "جاري الاتصال..."
+STR_CONNECTING_SAVED_WIFI: "جاري الاتصال بشبكة Wi-Fi محفوظة..."
+STR_SHOW_NETWORKS: "عرض"
+STR_CONNECTED: "تم الاتصال!"
+STR_CONNECTION_FAILED: "فشل الاتصال"
+STR_FORGET_NETWORK: "نسيان هذه الشبكة؟"
+STR_SAVE_PASSWORD: "حفظ كلمة المرور للمرة القادمة؟"
+STR_PRESS_OK_SCAN: "اضغط موافق لإعادة البحث"
+STR_JOIN_NETWORK: "الانضمام إلى شبكة"
+STR_CREATE_HOTSPOT: "إنشاء نقطة اتصال"
+STR_JOIN_DESC: "الاتصال بشبكة Wi-Fi موجودة"
+STR_HOTSPOT_DESC: "إنشاء شبكة Wi-Fi يمكن للآخرين الانضمام إليها"
+STR_STARTING_HOTSPOT: "جاري تشغيل نقطة الاتصال..."
+STR_HOTSPOT_MODE: "وضع نقطة الاتصال"
+STR_CONNECT_WIFI_HINT: "قم بتوصيل جهازك بشبكة Wi-Fi هذه"
+STR_OPEN_URL_HINT: "افتح هذا العنوان في المتصفح"
+STR_OR_HTTP_PREFIX: "أو http://"
+STR_SCAN_QR_HINT: "أو امسح رمز QR بهاتفك:"
+STR_CALIBRE_WIRELESS: "اتصال Calibre اللاسلكي"
+STR_NETWORK_LEGEND: "* = مشفرة | + = محفوظة"
+STR_MAC_ADDRESS: "عنوان MAC:"
+STR_CHECKING_WIFI: "جاري فحص Wi-Fi..."
+STR_ENTER_WIFI_PASSWORD: "أدخل كلمة مرور الشبكة"
+STR_ADD_HIDDEN_NETWORK: "إضافة شبكة مخفية..."
+STR_ENTER_WIFI_SSID: "أدخل اسم الشبكة (SSID)"
+STR_TO_PREFIX: "إلى "
+STR_CALIBRE_RECEIVING: "جاري الاستلام: "
+STR_CALIBRE_RECEIVED: "تم الاستلام: "
+STR_CALIBRE_INSTRUCTION_1: "1) قم بتثبيت إضافة CrossPoint Reader"
+STR_CALIBRE_INSTRUCTION_2: "2) اتصل بنفس شبكة Wi-Fi"
+STR_CALIBRE_INSTRUCTION_3: "3) في Calibre: اختر \"إرسال إلى الجهاز\""
+STR_CALIBRE_INSTRUCTION_4: "اترك هذه الشاشة مفتوحة أثناء الإرسال"
+STR_CAT_DISPLAY: "الشاشة"
+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: "تباعد إضافي بين الفقرات"
+STR_TEXT_AA: "تنعيم حواف النص"
+STR_IMAGES: "الصور"
+STR_IMAGES_DISPLAY: "عرض"
+STR_IMAGES_PLACEHOLDER: "عنصر نائب"
+STR_IMAGES_SUPPRESS: "إخفاء"
+STR_EOB_HOME: "الرئيسية"
+STR_EOB_CONTINUE_WITH: "المتابعة إلى"
+STR_SHORT_PWR_BTN: "ضغطة قصيرة على زر التشغيل"
+STR_ORIENTATION: "اتجاه القراءة"
+STR_SIDE_BTN_LAYOUT: "تخطيط الأزرار الجانبية (أثناء القراءة)"
+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: "تباعد الأسطر"
+STR_SCREEN_MARGIN: "هوامش شاشة القراءة"
+STR_PARA_ALIGNMENT: "محاذاة الفقرات"
+STR_HYPHENATION: "تقسيم الكلمات"
+STR_TIME_TO_SLEEP: "مهلة الدخول في السكون"
+STR_SHOW_HIDDEN_FILES: "عرض الملفات المخفية"
+STR_REMOVE_READ_FROM_RECENTS: "إزالة الكتب المقروءة من قائمة الكتب الأخيرة"
+STR_MOVE_FINISHED_TO_READ: "نقل الكتب المنتهية إلى مجلد المقروءة"
+STR_REFRESH_FREQ: "معدل تحديث الشاشة"
+STR_KOREADER_SYNC: "مزامنة KOReader"
+STR_CHECK_UPDATES: "التحقق من التحديثات"
+STR_LANGUAGE: "اللغة"
+STR_CLEAR_READING_CACHE: "مسح ذاكرة القراءة المؤقتة"
+STR_USERNAME: "اسم المستخدم"
+STR_PASSWORD: "كلمة المرور"
+STR_SYNC_SERVER_URL: "عنوان خادم المزامنة"
+STR_DOCUMENT_MATCHING: "مطابقة المستندات"
+STR_SEND_METADATA: "إرسال البيانات الوصفية للمستند"
+STR_AUTHENTICATE: "تسجيل الدخول"
+STR_KOREADER_USERNAME: "اسم مستخدم KOReader"
+STR_KOREADER_PASSWORD: "كلمة مرور KOReader"
+STR_FILENAME: "اسم الملف"
+STR_BINARY: "ثنائي"
+STR_SET_CREDENTIALS_FIRST: "أدخل بيانات الاعتماد أولا"
+STR_WIFI_CONN_FAILED: "فشل الاتصال بالشبكة"
+STR_AUTHENTICATING: "جاري التحقق..."
+STR_AUTH_SUCCESS: "تم تسجيل الدخول بنجاح!"
+STR_KOREADER_AUTH: "تسجيل الدخول إلى KOReader"
+STR_SYNC_READY: "مزامنة KOReader جاهزة للاستخدام"
+STR_AUTH_FAILED: "فشل تسجيل الدخول"
+STR_DONE: "تم"
+STR_CLEAR_CACHE_WARNING_1: "سيؤدي هذا إلى مسح جميع بيانات الكتب المخزنة."
+STR_CLEAR_CACHE_WARNING_2: "سيتم فقدان كل تقدم القراءة!"
+STR_CLEAR_CACHE_WARNING_3: "ستحتاج الكتب إلى إعادة فهرسة"
+STR_CLEAR_CACHE_WARNING_4: "عند فتحها مرة أخرى."
+STR_CLEARING_CACHE: "جاري مسح الذاكرة المؤقتة..."
+STR_CACHE_CLEARED: "تم مسح الذاكرة المؤقتة"
+STR_ITEMS_REMOVED: "عناصر تمت إزالتها"
+STR_FAILED_LOWER: "فشل"
+STR_CLEAR_CACHE_FAILED: "فشل مسح الذاكرة المؤقتة"
+STR_CHECK_SERIAL_OUTPUT: "راجع مخرجات المنفذ التسلسلي للتفاصيل"
+STR_DARK: "داكن"
+STR_LIGHT: "فاتح"
+STR_CUSTOM: "مخصص"
+STR_COVER: "الغلاف"
+STR_NONE_OPT: "بدون"
+STR_FIT: "ملاءمة"
+STR_CROP: "قص"
+STR_NEVER: "أبدا"
+STR_IN_READER: "أثناء القراءة"
+STR_ALWAYS: "دائما"
+STR_IGNORE: "تجاهل"
+STR_SLEEP: "سكون"
+STR_PAGE_TURN: "تقليب الصفحة"
+STR_FORCE_REFRESH: "تحديث الشاشة"
+STR_PORTRAIT: "عمودي"
+STR_LANDSCAPE_CW: "أفقي (يمين)"
+STR_INVERTED: "عكس الألوان"
+STR_ORIENTATION_INVERTED: "عمودي 180°"
+STR_LANDSCAPE_CCW: "أفقي (يسار)"
+STR_PREV_NEXT: "السابق/التالي"
+STR_NEXT_PREV: "التالي/السابق"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "إشارة مرجعية"
+STR_DISABLED: "معطل"
+STR_NOTO_SERIF: "Noto Serif"
+STR_NOTO_SANS: "Noto Sans"
+STR_SMALL: "صغير"
+STR_MEDIUM: "متوسط"
+STR_LARGE: "كبير"
+STR_X_LARGE: "كبير جدا"
+STR_TIGHT: "ضيق"
+STR_NORMAL: "عادي"
+STR_WIDE: "واسع"
+STR_JUSTIFY: "ضبط الطرفين"
+STR_ALIGN_LEFT: "يسار"
+STR_CENTER: "وسط"
+STR_ALIGN_RIGHT: "يمين"
+STR_PAGES_1: "صفحة واحدة"
+STR_PAGES_5: "5 صفحات"
+STR_PAGES_10: "10 صفحات"
+STR_PAGES_15: "15 صفحة"
+STR_PAGES_30: "30 صفحة"
+STR_UPDATE: "تحديث"
+STR_CHECKING_UPDATE: "جاري التحقق من التحديثات..."
+STR_NEW_UPDATE: "يتوفر تحديث جديد!"
+STR_CURRENT_VERSION: "الإصدار الحالي: "
+STR_NEW_VERSION: "الإصدار الجديد: "
+STR_UPDATING: "جاري التحديث..."
+STR_NO_UPDATE: "لا يتوفر تحديث"
+STR_UPDATE_FAILED: "فشل التحديث"
+STR_UPDATE_COMPLETE: "اكتمل التحديث"
+STR_POWER_ON_HINT: "اضغط مطولا على زر التشغيل لتشغيل الجهاز من جديد"
+STR_RESTARTING_HINT: "جاري إعادة التشغيل... إذا لم يعمل الجهاز، اضغط مطولا على زر التشغيل لعدة ثوان."
+STR_NO_ENTRIES: "لم يتم العثور على عناصر"
+STR_DOWNLOADING: "جاري التنزيل..."
+STR_DOWNLOAD_FAILED: "فشل التنزيل"
+STR_ERROR_MSG: "خطأ:"
+STR_UNNAMED: "بدون اسم"
+STR_HOLD_OPEN_TO_DELETE: "اضغط مطولا على فتح للحذف"
+STR_NO_SERVER_URL: "لم يتم تحديد عنوان الخادم"
+STR_FETCH_FEED_FAILED: "فشل جلب القائمة"
+STR_PARSE_FEED_FAILED: "فشل تحليل القائمة"
+STR_NEXT_PAGE: "الصفحة التالية"
+STR_PREV_PAGE: "الصفحة السابقة"
+STR_NETWORK_PREFIX: "الشبكة: "
+STR_IP_ADDRESS_PREFIX: "عنوان IP: "
+STR_ERROR_GENERAL_FAILURE: "خطأ: فشل عام"
+STR_ERROR_NETWORK_NOT_FOUND: "خطأ: الشبكة غير موجودة"
+STR_ERROR_CONNECTION_TIMEOUT: "خطأ: انتهت مهلة الاتصال"
+STR_SD_CARD: "بطاقة SD"
+STR_BACK: "رجوع »"
+STR_EXIT: "خروج »"
+STR_HOME: "الرئيسية »"
+STR_SELECT: "اختيار"
+STR_SELECTED: "محدد"
+STR_TOGGLE: "تبديل"
+STR_TOGGLE_BOOKMARK: "إضافة/إزالة إشارة مرجعية"
+STR_CONFIRM: "تأكيد"
+STR_CANCEL: "إلغاء"
+STR_CONNECT: "اتصال"
+STR_OPEN: "فتح"
+STR_DOWNLOAD: "تنزيل"
+STR_RETRY: "إعادة المحاولة"
+STR_YES: "نعم"
+STR_NO: "لا"
+STR_SHOW: "عرض"
+STR_HIDE: "إخفاء"
+STR_STATE_ON: "تشغيل"
+STR_STATE_OFF: "إيقاف"
+STR_NOT_SET: "غير محدد"
+STR_DIR_LEFT: "يسار"
+STR_DIR_RIGHT: "يمين"
+STR_DIR_UP: "أعلى"
+STR_DIR_DOWN: "أسفل"
+STR_OK_BUTTON: "موافق"
+STR_SLEEP_COVER_FILTER: "مرشح غلاف شاشة السكون"
+STR_FILTER_CONTRAST: "التباين"
+STR_CUSTOMISE_STATUS_BAR: "تخصيص شريط الحالة"
+STR_CHAPTER_PAGE_COUNT: "عدد صفحات الفصل"
+STR_BOOK_PROGRESS_PERCENTAGE: "نسبة التقدم في الكتاب"
+STR_PROGRESS_BAR: "شريط التقدم"
+STR_PROGRESS_BAR_THICKNESS: "سمك شريط التقدم"
+STR_PROGRESS_BAR_THIN: "رفيع"
+STR_PROGRESS_BAR_MEDIUM: "متوسط"
+STR_PROGRESS_BAR_THICK: "سميك"
+STR_BOOK: "الكتاب"
+STR_CHAPTER: "الفصل"
+STR_EXAMPLE_CHAPTER: "الفصل 21"
+STR_EXAMPLE_BOOK: "عنوان الكتاب"
+STR_PREVIEW: "معاينة"
+STR_TITLE: "العنوان"
+STR_BATTERY: "البطارية"
+STR_XTC_STATUS_BAR: "شريط حالة XTC"
+STR_BOTTOM: "أسفل"
+STR_TOP: "أعلى"
+STR_CLOCK: "الساعة"
+STR_CLOCK_UTC_OFFSET: "فرق التوقيت عن UTC"
+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 موسع"
+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: "الغلاف + مخصص"
+STR_QUICK_RESUME: "استئناف سريع"
+STR_MENU_RECENT_BOOKS: "الكتب الأخيرة"
+STR_REMOVE_FROM_RECENTS: "إزالة من الكتب الأخيرة؟"
+STR_NO_RECENT_BOOKS: "لا توجد كتب أخيرة"
+STR_CALIBRE_DESC: "استخدم النقل اللاسلكي من Calibre"
+STR_FORGET_AND_REMOVE: "نسيان الشبكة وحذف كلمة المرور المحفوظة؟"
+STR_FORGET_BUTTON: "نسيان"
+STR_CALIBRE_STARTING: "جاري تشغيل Calibre..."
+STR_CALIBRE_SETUP: "الإعداد"
+STR_CALIBRE_STATUS: "الحالة"
+STR_CLEAR_BUTTON: "مسح"
+STR_DEFAULT_VALUE: "افتراضي"
+STR_REMAP_PROMPT: "اضغط زرا أماميا لكل وظيفة"
+STR_UNASSIGNED: "غير معين"
+STR_ALREADY_ASSIGNED: "معين مسبقا"
+STR_REMAP_RESET_HINT: "الزر الجانبي العلوي: استعادة التخطيط الافتراضي"
+STR_REMAP_CANCEL_HINT: "الزر الجانبي السفلي: إلغاء التغيير"
+STR_HW_BACK_LABEL: "رجوع (الزر 1)"
+STR_HW_CONFIRM_LABEL: "تأكيد (الزر 2)"
+STR_HW_LEFT_LABEL: "يسار (الزر 3)"
+STR_HW_RIGHT_LABEL: "يمين (الزر 4)"
+STR_GO_TO_PERCENT: "الانتقال إلى نسبة %"
+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: " صفحات  |  "
+STR_BOOK_PREFIX: "الكتاب: "
+STR_CALIBRE_URL_HINT: "في Calibre، أضف /opds إلى العنوان"
+STR_SYNCING_TIME: "جاري مزامنة الوقت..."
+STR_CALC_HASH: "جاري حساب بصمة المستند..."
+STR_HASH_FAILED: "فشل حساب بصمة المستند"
+STR_FETCH_PROGRESS: "جاري جلب التقدم من الخادم..."
+STR_UPLOAD_PROGRESS: "جاري رفع التقدم..."
+STR_NO_CREDENTIALS_MSG: "لم يتم إعداد بيانات الاعتماد"
+STR_KOREADER_SETUP_HINT: "قم بإعداد حساب KOReader في الإعدادات"
+STR_PROGRESS_FOUND: "تم العثور على تقدم سابق!"
+STR_REMOTE_LABEL: "الخادم:"
+STR_LOCAL_LABEL: "الجهاز:"
+STR_PAGE_OVERALL_FORMAT: "صفحة %d، %.2f%% إجمالا"
+STR_PAGE_TOTAL_OVERALL_FORMAT: "صفحة %d من %d، %.2f%% إجمالا"
+STR_DEVICE_FROM_FORMAT: "  من: %s"
+STR_APPLY_REMOTE: "استخدام تقدم الخادم"
+STR_UPLOAD_LOCAL: "رفع التقدم المحلي"
+STR_NO_REMOTE_MSG: "لا يوجد تقدم على الخادم"
+STR_UPLOAD_PROMPT: "رفع الموضع الحالي؟"
+STR_UPLOAD_SUCCESS: "تم رفع التقدم!"
+STR_SYNC_FAILED_MSG: "فشلت المزامنة"
+STR_SAVE_PROGRESS_FAILED: "تعذر حفظ التقدم"
+STR_SECTION_PREFIX: "القسم "
+STR_UPLOAD: "رفع"
+STR_BOOK_S_STYLE: "تنسيق الكتاب الأصلي"
+STR_EMBEDDED_STYLE: "التنسيق المضمن"
+STR_FOCUS_READING: "قراءة مركزة"
+STR_OPDS_SERVER_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_STEP_HINT_FRONT: "الأزرار الأمامية:"
+STR_STEP_HINT_SIDE: "الأزرار الجانبية:"
+STR_ADD_SERVER: "إضافة خادم"
+STR_SERVER_NAME: "اسم الخادم"
+STR_NO_SERVERS: "لم يتم إعداد خوادم OPDS"
+STR_DELETE_SERVER: "حذف الخادم"
+STR_OPDS_SERVERS: "خوادم OPDS"
+STR_AUTO_TURN_ENABLED: "التقليب التلقائي مفعل: "
+STR_AUTO_TURN_PAGES_PER_MIN: "التقليب التلقائي (صفحات في الدقيقة)"
+STR_MANAGE_FONTS: "إدارة الخطوط"
+STR_FONT_BROWSER: "متصفح الخطوط"
+STR_LOADING_FONT_LIST: "جاري تحميل قائمة الخطوط..."
+STR_NO_FONTS_AVAILABLE: "لا تتوفر خطوط"
+STR_FONT_INSTALLED: "تم تثبيت الخط!"
+STR_FONT_INSTALL_FAILED: "فشل تثبيت الخط"
+STR_INSTALLED: "مثبت"
+STR_DOWNLOAD_ALL: "تنزيل الكل"
+STR_UPDATE_ALL: "تحديث الكل"
+STR_UPDATE_AVAILABLE: "تحديث"
+STR_CRASH_TITLE: "تعطل النظام"
+STR_CRASH_DESCRIPTION: "تم حفظ تقرير مفصل في الملف crash_report.txt. يرجى إرفاق هذا الملف عند الإبلاغ عن المشكلة."
+STR_CRASH_REASON: "سبب التعطل:"
+STR_CRASH_NO_REASON: "(لم يتم تسجيل سبب)"
+STR_TILT_PAGE_TURN: "تقليب الصفحة بالإمالة"
+STR_KB_HINT_MOVE_CURSOR: "اضغط زر اليمين أو اليسار لتحريك المؤشر"
+STR_KB_HINT_RETURN_CURSOR: "اضغط زر اليسار للعودة إلى موضع المؤشر"
+STR_KB_HINT_HIDE_PASSWORD: "اضغط مطولا على زر اليمين ثم اضغط [***] لإخفاء كلمة المرور"
+STR_KB_HINT_SHOW_PASSWORD: "اضغط مطولا على زر اليمين ثم اضغط [abc] لإظهار كلمة المرور"
+STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "اضغط [***] لإخفاء كلمة المرور"
+STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "اضغط [abc] لإظهار كلمة المرور"
+STR_KB_HINT_EDIT_ENTRY: "اضغط مطولا على زر الأعلى للتعديل"
+STR_KB_TIPS: "نصائح:"
+STR_KB_HINT_RETURN_KEYBOARD: "اضغط زر الأسفل للعودة إلى لوحة المفاتيح"
+STR_KB_HINT_EXIT_URL_MODE: "اضغط ABC للخروج من وضع URL"
+STR_KB_HINT_CLEAR_TEXT: "اضغط مطولا على DEL لمسح كل النص"
+STR_KB_HINT_SECONDARY_CHAR: "اضغط مطولا على زر الاختيار للحرف الثانوي"
+STR_KB_HINT_UPPER_SECONDARY: "اضغط مطولا على زر الاختيار للحرف الكبير أو الثانوي"
+STR_KB_HINT_LOWER_SECONDARY: "اضغط مطولا على زر الاختيار للحرف الصغير أو الثانوي"
+STR_KB_HINT_URL_SNIPPETS: "اضغط URL للاختصارات"
+STR_SD_FIRMWARE_UPDATE: "تحديث البرنامج الثابت من بطاقة SD"
+STR_SELECT_FIRMWARE_FILE: "اختر ملف البرنامج الثابت (.bin)"
+STR_NO_BIN_FILES: "لم يتم العثور على ملفات .bin"
+STR_VALIDATING_FIRMWARE: "جاري التحقق من البرنامج الثابت..."
+STR_INVALID_FIRMWARE: "ملف برنامج ثابت غير صالح"
+STR_FIRMWARE_TOO_LARGE: "البرنامج الثابت أكبر من القسم المخصص له"
+STR_FIRMWARE_TOO_SMALL: "ملف البرنامج الثابت صغير جدا"
+STR_FIRMWARE_UPDATE_PROMPT: "تحديث البرنامج الثابت؟"
+STR_FIRMWARE_FILE_OPEN_FAILED: "تعذر فتح الملف"
+STR_FIRMWARE_WRITE_FAILED: "فشلت كتابة البرنامج الثابت"
+STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "لا تطفئ الجهاز!"
+STR_RECOVERY_MODE: "وضع الاستعادة"
+STR_RECOVERY_MODE_HINT: "ضع الملف firmware.bin في المجلد الرئيسي لبطاقة SD ثم اختره"

lib/I18n/translations/belarusian.yaml

@@ -68,6 +68,7 @@ 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: "У Іўі худы жвавы чорт у зялёнай камізэльцы пабег пад'есці фаршу з юшкай"
@@ -298,6 +299,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u хв"
 STR_SLEEP_NEVER: "Ніколі"
 STR_STEP_HINT_FRONT: "Пярэднія кнопкі:"
 STR_STEP_HINT_SIDE: "Бакавыя кнопкі:"
+STR_OPDS_DOWNLOAD_FOLDER: "Папка для спампоўкі"
+STR_OPDS_FILENAME_FORMAT: "Фармат назвы файла"
+STR_FMT_AUTHOR_TITLE: "Аўтар - Назва"
+STR_FMT_TITLE_AUTHOR: "Назва - Аўтар"
+STR_FMT_TITLE: "Назва"
 STR_AUTO_TURN_ENABLED: "Аўтаперагортванне: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Аўтаперагортванне (старонак за хвіліну)"
 STR_TILT_PAGE_TURN: "Перагортванне нахілам"

lib/I18n/translations/bosnian.yaml

@@ -0,0 +1,393 @@
+_language_name: "Bosanski"
+_language_code: "BS"
+_order: "29"
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "POKRETANJE"
+STR_SLEEPING: "REŽIM MIROVANJA"
+STR_ENTERING_SLEEP: "Prelazak u režim mirovanja"
+STR_BROWSE_FILES: "Pregled datoteka"
+STR_FILE_TRANSFER: "Prijenos datoteka"
+STR_SETTINGS_TITLE: "Postavke"
+STR_CONTINUE_READING: "Nastavi čitanje"
+STR_NO_OPEN_BOOK: "Nema otvorene knjige"
+STR_START_READING: "Počni čitati ispod"
+STR_NO_FILES_FOUND: "Nema pronađenih datoteka"
+STR_SELECT_CHAPTER: "Odaberi poglavlje"
+STR_NO_CHAPTERS: "Nema poglavlja"
+STR_END_OF_BOOK: "Kraj knjige"
+STR_EMPTY_CHAPTER: "Prazno poglavlje"
+STR_INDEXING: "Indeksiranje"
+STR_INDEX_FAILED: "Indeksiranje nije uspjelo - nevažeća knjiga"
+STR_MEMORY_ERROR: "Greška memorije"
+STR_PAGE_LOAD_ERROR: "Greška pri učitavanju stranice"
+STR_EMPTY_FILE: "Prazna datoteka"
+STR_OUT_OF_BOUNDS: "Izvan granica"
+STR_LOADING: "Učitavanje..."
+STR_LOADING_POPUP: "Učitavanje"
+STR_WIFI_NETWORKS: "Wi-Fi mreže"
+STR_NO_NETWORKS: "Nema pronađenih mreža"
+STR_NETWORKS_FOUND: "%zu pronađenih mreža"
+STR_SCANNING: "Skeniranje..."
+STR_FINDING_SAVED_WIFI: "Traženje sačuvanog Wi-Fi-a..."
+STR_CONNECTING: "Povezivanje..."
+STR_CONNECTING_SAVED_WIFI: "Povezivanje na sačuvani Wi-Fi..."
+STR_SHOW_NETWORKS: "Prikaži"
+STR_CONNECTED: "Povezano!"
+STR_CONNECTION_FAILED: "Povezivanje nije uspjelo"
+STR_FORGET_NETWORK: "Zaboraviti mrežu?"
+STR_SAVE_PASSWORD: "Sačuvati lozinku za sljedeći put?"
+STR_PRESS_OK_SCAN: "Pritisni OK za ponovno skeniranje"
+STR_JOIN_NETWORK: "Pridruži se mreži"
+STR_CREATE_HOTSPOT: "Kreiraj hotspot"
+STR_JOIN_DESC: "Poveži se na postojeću Wi-Fi mrežu"
+STR_HOTSPOT_DESC: "Kreiraj Wi-Fi mrežu kojoj se drugi mogu pridružiti"
+STR_STARTING_HOTSPOT: "Pokretanje hotspota..."
+STR_HOTSPOT_MODE: "Hotspot način rada"
+STR_CONNECT_WIFI_HINT: "Poveži svoj uređaj na ovu Wi-Fi mrežu"
+STR_OPEN_URL_HINT: "Otvori ovaj URL u svom pregledniku"
+STR_OR_HTTP_PREFIX: "ili http://"
+STR_SCAN_QR_HINT: "ili skeniraj QR kod svojim telefonom:"
+STR_CALIBRE_WIRELESS: "Calibre bežično"
+STR_NETWORK_LEGEND: "* = Šifrovano | + = Sačuvano"
+STR_MAC_ADDRESS: "MAC adresa:"
+STR_CHECKING_WIFI: "Provjera Wi-Fi-a..."
+STR_ENTER_WIFI_PASSWORD: "Unesi Wi-Fi lozinku"
+STR_ADD_HIDDEN_NETWORK: "Dodaj skrivenu mrežu..."
+STR_ENTER_WIFI_SSID: "Unesi naziv mreže (SSID)"
+STR_TO_PREFIX: "na "
+STR_CALIBRE_RECEIVING: "Primanje: "
+STR_CALIBRE_RECEIVED: "Primljeno: "
+STR_CALIBRE_INSTRUCTION_1: "1) Instaliraj CrossPoint Reader dodatak"
+STR_CALIBRE_INSTRUCTION_2: "2) Budi na istoj Wi-Fi mreži"
+STR_CALIBRE_INSTRUCTION_3: "3) U Calibreu: \"Pošalji na uređaj\""
+STR_CALIBRE_INSTRUCTION_4: "\"Drži ovaj ekran otvorenim tokom slanja\""
+STR_CAT_DISPLAY: "Ekran"
+STR_CAT_READER: "Čitač"
+STR_CAT_CONTROLS: "Kontrole"
+STR_CAT_SYSTEM: "Sistem"
+STR_SLEEP_SCREEN: "Ekran mirovanja"
+STR_QUICK_RESUME_TIMEOUT: "Brzi nastavak nakon isteka vremena"
+STR_SLEEP_COVER_MODE: "Način prikaza korica na ekranu mirovanja"
+STR_HIDE_BATTERY: "Sakrij % baterije"
+STR_EXTRA_SPACING: "Dodatni razmak između paragrafa"
+STR_TEXT_AA: "Zaglađivanje teksta"
+STR_IMAGES: "Slike"
+STR_IMAGES_DISPLAY: "Prikaz"
+STR_IMAGES_PLACEHOLDER: "Rezervisano mjesto"
+STR_IMAGES_SUPPRESS: "Sakrij"
+STR_EOB_HOME: "Početna"
+STR_EOB_CONTINUE_WITH: "Nastavi sa"
+STR_SHORT_PWR_BTN: "Kratak klik dugmeta napajanja"
+STR_ORIENTATION: "Orijentacija čitanja"
+STR_SIDE_BTN_LAYOUT: "Raspored bočnih dugmadi (čitač)"
+STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orijentiši prednja dugmad"
+STR_LONG_PRESS_BEHAVIOR: "Ponašanje dugog pritiska dugmeta"
+STR_LONG_PRESS_BEHAVIOR_OFF: "ISKLJUČENO"
+STR_LONG_PRESS_BEHAVIOR_SKIP: "Preskakanje poglavlja"
+STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Promjena orijentacije"
+STR_LONG_PRESS_MENU: "Meni dugog pritiska"
+STR_FONT_PREVIEW_TEXT: "Brza smeđa lisica preskače lijenog psa"
+STR_FONT_FAMILY: "Porodica fonta čitača"
+STR_FONT_SIZE: "Veličina fonta čitača"
+STR_LINE_SPACING: "Razmak između redova čitača"
+STR_SCREEN_MARGIN: "Margina ekrana čitača"
+STR_PARA_ALIGNMENT: "Poravnanje paragrafa čitača"
+STR_HYPHENATION: "Rastavljanje riječi"
+STR_TIME_TO_SLEEP: "Vrijeme do mirovanja"
+STR_SHOW_HIDDEN_FILES: "Prikaži skrivene datoteke"
+STR_REMOVE_READ_FROM_RECENTS: "Ukloni pročitane knjige sa liste nedavnih"
+STR_MOVE_FINISHED_TO_READ: "Premjesti završene knjige u fasciklu Read"
+STR_REFRESH_FREQ: "Učestalost osvježavanja"
+STR_KOREADER_SYNC: "KOReader sinhronizacija"
+STR_CHECK_UPDATES: "Provjeri ažuriranja"
+STR_LANGUAGE: "Jezik"
+STR_CLEAR_READING_CACHE: "Očisti keš čitanja"
+STR_USERNAME: "Korisničko ime"
+STR_PASSWORD: "Lozinka"
+STR_SYNC_SERVER_URL: "URL servera za sinhronizaciju"
+STR_DOCUMENT_MATCHING: "Podudaranje dokumenata"
+STR_SEND_METADATA: "Pošalji metapodatke dokumenta"
+STR_AUTHENTICATE: "Autentifikuj"
+STR_KOREADER_USERNAME: "KOReader korisničko ime"
+STR_KOREADER_PASSWORD: "KOReader lozinka"
+STR_FILENAME: "Naziv datoteke"
+STR_BINARY: "Binarno"
+STR_SET_CREDENTIALS_FIRST: "Prvo postavi vjerodajnice"
+STR_WIFI_CONN_FAILED: "Wi-Fi povezivanje nije uspjelo"
+STR_AUTHENTICATING: "Autentifikacija..."
+STR_AUTH_SUCCESS: "Uspješno autentifikovano!"
+STR_KOREADER_AUTH: "KOReader autentifikacija"
+STR_SYNC_READY: "KOReader sinhronizacija je spremna za upotrebu"
+STR_AUTH_FAILED: "Autentifikacija nije uspjela"
+STR_DONE: "Gotovo"
+STR_CLEAR_CACHE_WARNING_1: "Ovo će očistiti sve keširane podatke knjiga."
+STR_CLEAR_CACHE_WARNING_2: "Sav napredak čitanja će biti izgubljen!"
+STR_CLEAR_CACHE_WARNING_3: "Knjige će morati biti ponovo indeksirane"
+STR_CLEAR_CACHE_WARNING_4: "kada se ponovo otvore."
+STR_CLEARING_CACHE: "Čišćenje keša..."
+STR_CACHE_CLEARED: "Keš očišćen"
+STR_ITEMS_REMOVED: "stavki uklonjeno"
+STR_FAILED_LOWER: "nije uspjelo"
+STR_CLEAR_CACHE_FAILED: "Čišćenje keša nije uspjelo"
+STR_CHECK_SERIAL_OUTPUT: "Provjeri serijski izlaz za detalje"
+STR_DARK: "Tamno"
+STR_LIGHT: "Svijetlo"
+STR_CUSTOM: "Prilagođeno"
+STR_COVER: "Korice"
+STR_NONE_OPT: "Ništa"
+STR_FIT: "Prilagodi"
+STR_CROP: "Isjeci"
+STR_NEVER: "Nikad"
+STR_IN_READER: "U čitaču"
+STR_ALWAYS: "Uvijek"
+STR_IGNORE: "Ignoriši"
+STR_SLEEP: "Mirovanje"
+STR_PAGE_TURN: "Okretanje stranice"
+STR_FORCE_REFRESH: "Osvježi ekran"
+STR_PORTRAIT: "Uspravno"
+STR_LANDSCAPE_CW: "Položeno (u smjeru kazaljke na satu)"
+STR_INVERTED: "Obrnuto"
+STR_ORIENTATION_INVERTED: "Uspravno 180°"
+STR_LANDSCAPE_CCW: "Položeno (suprotno smjeru kazaljke na satu)"
+STR_PREV_NEXT: "Prethodno/Sljedeće"
+STR_NEXT_PREV: "Sljedeće/Prethodno"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Obilježivač"
+STR_DISABLED: "Onemogućeno"
+STR_NOTO_SERIF: "Noto Serif"
+STR_NOTO_SANS: "Noto Sans"
+STR_SMALL: "Malo"
+STR_MEDIUM: "Srednje"
+STR_LARGE: "Veliko"
+STR_X_LARGE: "Vrlo veliko"
+STR_TIGHT: "Usko"
+STR_NORMAL: "Normalno"
+STR_WIDE: "Široko"
+STR_JUSTIFY: "Poravnaj obostrano"
+STR_ALIGN_LEFT: "Lijevo"
+STR_CENTER: "Centrirano"
+STR_ALIGN_RIGHT: "Desno"
+STR_PAGES_1: "1 stranica"
+STR_PAGES_5: "5 stranica"
+STR_PAGES_10: "10 stranica"
+STR_PAGES_15: "15 stranica"
+STR_PAGES_30: "30 stranica"
+STR_UPDATE: "Ažuriraj"
+STR_CHECKING_UPDATE: "Provjera ažuriranja..."
+STR_NEW_UPDATE: "Dostupno je novo ažuriranje!"
+STR_CURRENT_VERSION: "Trenutna verzija: "
+STR_NEW_VERSION: "Nova verzija: "
+STR_UPDATING: "Ažuriranje..."
+STR_NO_UPDATE: "Nema dostupnih ažuriranja"
+STR_UPDATE_FAILED: "Ažuriranje nije uspjelo"
+STR_UPDATE_COMPLETE: "Ažuriranje završeno"
+STR_POWER_ON_HINT: "Pritisni i drži dugme napajanja da ponovo uključiš"
+STR_RESTARTING_HINT: "Ponovno pokretanje... Ako se uređaj ne pokrene ponovo, drži dugme napajanja nekoliko sekundi."
+STR_NO_ENTRIES: "Nema pronađenih unosa"
+STR_DOWNLOADING: "Preuzimanje..."
+STR_DOWNLOAD_FAILED: "Preuzimanje nije uspjelo"
+STR_ERROR_MSG: "Greška:"
+STR_UNNAMED: "Neimenovano"
+STR_HOLD_OPEN_TO_DELETE: "Drži Otvori za brisanje"
+STR_NO_SERVER_URL: "Nije podešen URL servera"
+STR_FETCH_FEED_FAILED: "Dohvatanje feeda nije uspjelo"
+STR_PARSE_FEED_FAILED: "Obrada feeda nije uspjela"
+STR_NEXT_PAGE: "Sljedeća stranica »"
+STR_PREV_PAGE: "« Prethodna stranica"
+STR_NETWORK_PREFIX: "Mreža: "
+STR_IP_ADDRESS_PREFIX: "IP adresa: "
+STR_ERROR_GENERAL_FAILURE: "Greška: Opšta greška"
+STR_ERROR_NETWORK_NOT_FOUND: "Greška: Mreža nije pronađena"
+STR_ERROR_CONNECTION_TIMEOUT: "Greška: Isteklo vrijeme veze"
+STR_SD_CARD: "SD kartica"
+STR_BACK: "« Nazad"
+STR_EXIT: "« Izlaz"
+STR_HOME: "« Početna"
+STR_SELECT: "Odaberi"
+STR_SELECTED: "Odabrano"
+STR_TOGGLE: "Promijeni"
+STR_TOGGLE_BOOKMARK: "Promijeni obilježivač"
+STR_CONFIRM: "Potvrdi"
+STR_CANCEL: "Otkaži"
+STR_CONNECT: "Poveži"
+STR_OPEN: "Otvori"
+STR_DOWNLOAD: "Preuzmi"
+STR_RETRY: "Pokušaj ponovo"
+STR_YES: "Da"
+STR_NO: "Ne"
+STR_SHOW: "Prikaži"
+STR_HIDE: "Sakrij"
+STR_STATE_ON: "UKLJUČENO"
+STR_STATE_OFF: "ISKLJUČENO"
+STR_NOT_SET: "Nije postavljeno"
+STR_DIR_LEFT: "Lijevo"
+STR_DIR_RIGHT: "Desno"
+STR_DIR_UP: "Gore"
+STR_DIR_DOWN: "Dolje"
+STR_OK_BUTTON: "OK"
+STR_SLEEP_COVER_FILTER: "Filter korica ekrana mirovanja"
+STR_FILTER_CONTRAST: "Kontrast"
+STR_CUSTOMISE_STATUS_BAR: "Prilagodi statusnu traku"
+STR_CHAPTER_PAGE_COUNT: "Broj stranica poglavlja"
+STR_BOOK_PROGRESS_PERCENTAGE: "Procenat napretka knjige"
+STR_PROGRESS_BAR: "Traka napretka"
+STR_PROGRESS_BAR_THICKNESS: "Debljina trake napretka"
+STR_PROGRESS_BAR_THIN: "Tanka"
+STR_PROGRESS_BAR_MEDIUM: "Srednja"
+STR_PROGRESS_BAR_THICK: "Debela"
+STR_BOOK: "Knjiga"
+STR_CHAPTER: "Poglavlje"
+STR_EXAMPLE_CHAPTER: "Poglavlje 21"
+STR_EXAMPLE_BOOK: "Naslov knjige"
+STR_PREVIEW: "Pregled"
+STR_TITLE: "Naslov"
+STR_BATTERY: "Baterija"
+STR_XTC_STATUS_BAR: "XTC statusna traka"
+STR_BOTTOM: "Dolje"
+STR_TOP: "Gore"
+STR_CLOCK: "Sat"
+STR_CLOCK_UTC_OFFSET: "UTC odstupanje sata"
+STR_CLOCK_FORMAT: "Format sata"
+STR_CLOCK_FORMAT_24H: "24-časovni"
+STR_CLOCK_FORMAT_12H: "12-časovni"
+STR_CURRENT_TIME: "Trenutno vrijeme:"
+STR_NEXT_FIELD: "Sljedeće"
+STR_CLOCK_SYNC: "Sinhronizuj sat"
+STR_CLOCK_SYNC_NOW: "Sinhronizuj sat sada"
+STR_CLOCK_SYNCING: "Sinhronizacija sa NTP-a..."
+STR_CLOCK_SYNC_OK: "Sat sinhronizovan"
+STR_CLOCK_SYNC_FAIL: "Sinhronizacija nije uspjela"
+STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi nije povezan"
+STR_CLOCK_SYNC_NO_WIFI_HINT: "Prvo se poveži na Wi-Fi, pa pokušaj ponovo."
+STR_CLOCK_SYNCED: "Sat sinhronizovan"
+STR_UI_THEME: "Tema korisničkog interfejsa"
+STR_THEME_CLASSIC: "Klasična"
+STR_THEME_LYRA: "Lyra"
+STR_THEME_ROUNDEDRAFF: "RoundedRaff"
+STR_THEME_LYRA_EXTENDED: "Lyra proširena"
+STR_SUNLIGHT_FADING_FIX: "Ispravka blijeđenja na suncu"
+STR_REMAP_FRONT_BUTTONS: "Premapiraj prednja dugmad"
+STR_BOOKMARKS: "Obilježivači"
+STR_BOOKMARK_ADDED: "Obilježivač dodan."
+STR_BOOKMARK_REMOVED: "Obilježivač uklonjen."
+STR_OPDS_BROWSER: "OPDS pregledač"
+STR_SEARCH: "Pretraga"
+STR_COVER_CUSTOM: "Korice + Prilagođeno"
+STR_QUICK_RESUME: "Brzi nastavak"
+STR_MENU_RECENT_BOOKS: "Nedavne knjige"
+STR_REMOVE_FROM_RECENTS: "Ukloniti iz nedavnih knjiga?"
+STR_NO_RECENT_BOOKS: "Nema nedavnih knjiga"
+STR_CALIBRE_DESC: "Koristi Calibre bežični prijenos uređaja"
+STR_FORGET_AND_REMOVE: "Zaboraviti mrežu i ukloniti sačuvanu lozinku?"
+STR_FORGET_BUTTON: "Zaboravi"
+STR_CALIBRE_STARTING: "Pokretanje Calibrea..."
+STR_CALIBRE_SETUP: "Podešavanje"
+STR_CALIBRE_STATUS: "Status"
+STR_CLEAR_BUTTON: "Očisti"
+STR_DEFAULT_VALUE: "Zadano"
+STR_REMAP_PROMPT: "Pritisni prednje dugme za svaku ulogu"
+STR_UNASSIGNED: "Nedodijeljeno"
+STR_ALREADY_ASSIGNED: "Već dodijeljeno"
+STR_REMAP_RESET_HINT: "Bočno dugme Gore: Vrati na zadani raspored"
+STR_REMAP_CANCEL_HINT: "Bočno dugme Dolje: Otkaži premapiranje"
+STR_HW_BACK_LABEL: "Nazad (1. dugme)"
+STR_HW_CONFIRM_LABEL: "Potvrdi (2. dugme)"
+STR_HW_LEFT_LABEL: "Lijevo (3. dugme)"
+STR_HW_RIGHT_LABEL: "Desno (4. dugme)"
+STR_GO_TO_PERCENT: "Idi na %"
+STR_GO_HOME_BUTTON: "Idi na početnu"
+STR_SYNC_PROGRESS: "Sinhronizuj napredak"
+STR_DELETE_CACHE: "Obriši keš knjige"
+STR_DELETE: "Obriši"
+STR_CONFIRM_DELETE_BOOKMARK: "Obrisati ovaj obilježivač?"
+STR_DISPLAY_QR: "Prikaži stranicu kao QR"
+STR_CHAPTER_PREFIX: "Poglavlje: "
+STR_PAGES_SEPARATOR: " stranica  |  "
+STR_BOOK_PREFIX: "Knjiga: "
+STR_CALIBRE_URL_HINT: "Za Calibre, dodaj /opds na svoj URL"
+STR_SYNCING_TIME: "Sinhronizacija vremena..."
+STR_CALC_HASH: "Izračunavanje heša dokumenta..."
+STR_HASH_FAILED: "Izračunavanje heša dokumenta nije uspjelo"
+STR_FETCH_PROGRESS: "Dohvatanje udaljenog napretka..."
+STR_UPLOAD_PROGRESS: "Slanje napretka..."
+STR_NO_CREDENTIALS_MSG: "Nisu podešene vjerodajnice"
+STR_KOREADER_SETUP_HINT: "Podesi KOReader nalog u Postavkama"
+STR_PROGRESS_FOUND: "Napredak pronađen!"
+STR_REMOTE_LABEL: "Udaljeno:"
+STR_LOCAL_LABEL: "Lokalno:"
+STR_PAGE_OVERALL_FORMAT: "Stranica %d, %.2f%% ukupno"
+STR_PAGE_TOTAL_OVERALL_FORMAT: "Stranica %d/%d, %.2f%% ukupno"
+STR_DEVICE_FROM_FORMAT: "  Sa: %s"
+STR_APPLY_REMOTE: "Primijeni udaljeni napredak"
+STR_UPLOAD_LOCAL: "Pošalji lokalni napredak"
+STR_NO_REMOTE_MSG: "Nije pronađen udaljeni napredak"
+STR_UPLOAD_PROMPT: "Poslati trenutnu poziciju?"
+STR_UPLOAD_SUCCESS: "Napredak poslan!"
+STR_SYNC_FAILED_MSG: "Sinhronizacija nije uspjela"
+STR_SAVE_PROGRESS_FAILED: "Napredak nije mogao biti sačuvan"
+STR_SECTION_PREFIX: "Sekcija "
+STR_UPLOAD: "Pošalji"
+STR_BOOK_S_STYLE: "Stil knjige"
+STR_EMBEDDED_STYLE: "Ugrađeni stil"
+STR_FOCUS_READING: "Fokusirano čitanje"
+STR_OPDS_SERVER_URL: "URL OPDS servera"
+STR_PWR_BTN_FOOTNOTE_BACK: "Brzi povratak iz fusnota"
+STR_SET_SLEEP_COVER: "Postavi korice"
+STR_FOOTNOTES: "Fusnote"
+STR_NO_FOOTNOTES: "Nema fusnota na ovoj stranici"
+STR_LINK: "[link]"
+STR_SCREENSHOT_BUTTON: "Snimi ekran"
+STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
+STR_SLEEP_NEVER: "Nikad"
+STR_STEP_HINT_FRONT: "Prednja dugmad:"
+STR_STEP_HINT_SIDE: "Bočna dugmad:"
+STR_ADD_SERVER: "Dodaj server"
+STR_SERVER_NAME: "Naziv servera"
+STR_NO_SERVERS: "Nema podešenih OPDS servera"
+STR_DELETE_SERVER: "Obriši server"
+STR_OPDS_SERVERS: "OPDS serveri"
+STR_AUTO_TURN_ENABLED: "Automatsko okretanje omogućeno: "
+STR_AUTO_TURN_PAGES_PER_MIN: "Automatsko okretanje (stranica po minuti)"
+STR_MANAGE_FONTS: "Upravljaj fontovima"
+STR_FONT_BROWSER: "Pregledač fontova"
+STR_LOADING_FONT_LIST: "Učitavanje liste fontova..."
+STR_NO_FONTS_AVAILABLE: "Nema dostupnih fontova"
+STR_FONT_INSTALLED: "Font instaliran!"
+STR_FONT_INSTALL_FAILED: "Instalacija fonta nije uspjela"
+STR_INSTALLED: "Instalirano"
+STR_DOWNLOAD_ALL: "Preuzmi sve"
+STR_UPDATE_ALL: "Ažuriraj sve"
+STR_UPDATE_AVAILABLE: "Ažuriranje"
+STR_CRASH_TITLE: "Sistemski pad"
+STR_CRASH_DESCRIPTION: "Detaljan izvještaj je sačuvan u crash_report.txt. Molimo priloži ovu datoteku u svoj izvještaj o grešci."
+STR_CRASH_REASON: "Razlog pada:"
+STR_CRASH_NO_REASON: "(Razlog nije zabilježen)"
+STR_TILT_PAGE_TURN: "Okretanje stranice naginjanjem"
+STR_KB_HINT_MOVE_CURSOR: "Pritisni LIJEVO ili DESNO za pomjeranje kursora"
+STR_KB_HINT_RETURN_CURSOR: "Pritisni LIJEVO za povratak na poziciju kursora"
+STR_KB_HINT_HIDE_PASSWORD: "Drži DESNO pa pritisni [***] za skrivanje lozinke"
+STR_KB_HINT_SHOW_PASSWORD: "Drži DESNO pa pritisni [abc] za prikaz lozinke"
+STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "Pritisni [***] za skrivanje lozinke"
+STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "Pritisni [abc] za prikaz lozinke"
+STR_KB_HINT_EDIT_ENTRY: "Drži GORE za uređivanje unosa"
+STR_KB_TIPS: "Savjeti:"
+STR_KB_HINT_RETURN_KEYBOARD: "Pritisni DOLJE za povratak na tastaturu"
+STR_KB_HINT_EXIT_URL_MODE: "Pritisni ABC za izlazak iz URL načina"
+STR_KB_HINT_CLEAR_TEXT: "Drži DEL za brisanje cijelog teksta"
+STR_KB_HINT_SECONDARY_CHAR: "Drži SELECT za sekundarni znak"
+STR_KB_HINT_UPPER_SECONDARY: "Drži SELECT za VELIKA SLOVA ili sekundarni znak"
+STR_KB_HINT_LOWER_SECONDARY: "Drži SELECT za mala slova ili sekundarni znak"
+STR_KB_HINT_URL_SNIPPETS: "Pritisni URL za isječke"
+STR_SD_FIRMWARE_UPDATE: "Ažuriranje firmvera sa SD kartice"
+STR_SELECT_FIRMWARE_FILE: "Odaberi datoteku firmvera (.bin)"
+STR_NO_BIN_FILES: "Nema pronađenih .bin datoteka"
+STR_VALIDATING_FIRMWARE: "Provjera firmvera..."
+STR_INVALID_FIRMWARE: "Nevažeća datoteka firmvera"
+STR_FIRMWARE_TOO_LARGE: "Firmver je prevelik za particiju"
+STR_FIRMWARE_TOO_SMALL: "Datoteka firmvera je premala"
+STR_FIRMWARE_UPDATE_PROMPT: "Ažurirati firmver?"
+STR_FIRMWARE_FILE_OPEN_FAILED: "Datoteka se ne može otvoriti"
+STR_FIRMWARE_WRITE_FAILED: "Upisivanje firmvera nije uspjelo"
+STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Ne isključuj napajanje!"
+STR_RECOVERY_MODE: "Način oporavka"
+STR_RECOVERY_MODE_HINT: "Stavi firmware.bin u korijenski direktorij SD kartice i odaberi ga"

lib/I18n/translations/catalan.yaml

@@ -78,6 +78,7 @@ STR_EOB_CONTINUE_WITH: "Continua amb"
 STR_SHORT_PWR_BTN: "Pulsació curta 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: "Acció en mantenir premut un botó"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
@@ -347,6 +348,11 @@ STR_SERVER_NAME: "Nom del servidor"
 STR_NO_SERVERS: "No hi ha servidors OPDS configurats"
 STR_DELETE_SERVER: "Suprimeix el servidor"
 STR_OPDS_SERVERS: "Servidors OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Carpeta de baixades"
+STR_OPDS_FILENAME_FORMAT: "Format del nom de fitxer"
+STR_FMT_AUTHOR_TITLE: "Autor - Títol"
+STR_FMT_TITLE_AUTHOR: "Títol - Autor"
+STR_FMT_TITLE: "Títol"
 STR_MANAGE_FONTS: "Gestiona les fonts"
 STR_FONT_BROWSER: "Navegador de fonts"
 STR_LOADING_FONT_LIST: "S'està carregant la llista de fonts..."

lib/I18n/translations/czech.yaml

@@ -68,6 +68,7 @@ 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"
@@ -270,6 +271,11 @@ STR_BOOK_S_STYLE: "Styl knihy"
 STR_EMBEDDED_STYLE: "Vložený styl"
 STR_FOCUS_READING: "Soustředěné čtení"
 STR_OPDS_SERVER_URL: "URL serveru OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Složka pro stahování"
+STR_OPDS_FILENAME_FORMAT: "Formát názvu souboru"
+STR_FMT_AUTHOR_TITLE: "Autor - Název"
+STR_FMT_TITLE_AUTHOR: "Název - Autor"
+STR_FMT_TITLE: "Název"
 STR_SCREENSHOT_BUTTON: "Udělat snímek obrazovky"
 STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Nikdy"

lib/I18n/translations/danish.yaml

@@ -72,6 +72,7 @@ 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: "Touchkontroller i 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"
@@ -300,6 +301,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Aldrig"
 STR_STEP_HINT_FRONT: "Frontknapper:"
 STR_STEP_HINT_SIDE: "Sideknapper:"
+STR_OPDS_DOWNLOAD_FOLDER: "Downloadmappe"
+STR_OPDS_FILENAME_FORMAT: "Filnavnsformat"
+STR_FMT_AUTHOR_TITLE: "Forfatter - Titel"
+STR_FMT_TITLE_AUTHOR: "Titel - Forfatter"
+STR_FMT_TITLE: "Titel"
 STR_SCREENSHOT_BUTTON: "Tag skærmbillede"
 STR_AUTO_TURN_ENABLED: "Automatisk sidevendning aktiveret: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Automatisk vending (sider per minut)"

lib/I18n/translations/dutch.yaml

@@ -72,6 +72,7 @@ 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"
@@ -300,6 +301,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Nooit"
 STR_STEP_HINT_FRONT: "Voorknoppen:"
 STR_STEP_HINT_SIDE: "Zijknoppen:"
+STR_OPDS_DOWNLOAD_FOLDER: "Downloadmap"
+STR_OPDS_FILENAME_FORMAT: "Bestandsnaamformaat"
+STR_FMT_AUTHOR_TITLE: "Auteur - Titel"
+STR_FMT_TITLE_AUTHOR: "Titel - Auteur"
+STR_FMT_TITLE: "Titel"
 STR_SCREENSHOT_BUTTON: "Screenshot maken"
 STR_AUTO_TURN_ENABLED: "Automatisch omslaan ingeschakeld: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Autom. omslaan (pagina's per minuut)"

lib/I18n/translations/english.yaml

@@ -10,6 +10,7 @@ STR_BROWSE_FILES: "Browse Files"
 STR_FILE_TRANSFER: "File Transfer"
 STR_SETTINGS_TITLE: "Settings"
 STR_CONTINUE_READING: "Continue Reading"
+STR_RESUME: "Resume"
 STR_NO_OPEN_BOOK: "No open book"
 STR_START_READING: "Start reading below"
 STR_NO_FILES_FOUND: "No files found"
@@ -25,6 +26,12 @@ STR_EMPTY_FILE: "Empty file"
 STR_OUT_OF_BOUNDS: "Out of bounds"
 STR_LOADING: "Loading..."
 STR_LOADING_POPUP: "Loading"
+STR_LOOKUP: "Look Up"
+STR_DICT_LOOKING_UP: "Looking up..."
+STR_DICT_INDEXING: "Indexing dictionary..."
+STR_DICT_NOT_FOUND: "Not found"
+STR_DICT_NO_DICT_SET: "No dictionary set"
+STR_DICT_ERROR: "Dictionary error"
 STR_WIFI_NETWORKS: "Wi-Fi Networks"
 STR_NO_NETWORKS: "No networks found"
 STR_NETWORKS_FOUND: "%zu networks found"
@@ -81,6 +88,7 @@ STR_EOB_CONTINUE_WITH: "Continue with"
 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"
@@ -108,7 +116,15 @@ STR_PASSWORD: "Password"
 STR_SYNC_SERVER_URL: "Sync Server URL"
 STR_DOCUMENT_MATCHING: "Document Matching"
 STR_SEND_METADATA: "Send Document Metadata"
+STR_SYNC_BEHAVIOR: "Sync Behavior"
+STR_ASK_EVERY_TIME: "Ask every time"
+STR_SMART_SYNC: "Smart sync"
 STR_AUTHENTICATE: "Authenticate"
+STR_SIGN_UP: "Sign Up"
+STR_CREATING_ACCOUNT: "Creating account..."
+STR_ACCOUNT_CREATED: "Account created"
+STR_SIGNUP_FAILED: "Sign up failed"
+STR_USERNAME_TAKEN: "Username is already registered"
 STR_KOREADER_USERNAME: "KOReader Username"
 STR_KOREADER_PASSWORD: "KOReader Password"
 STR_FILENAME: "Filename"
@@ -154,6 +170,7 @@ STR_PREV_NEXT: "Prev/Next"
 STR_NEXT_PREV: "Next/Prev"
 STR_KOSYNC: "KOSync"
 STR_BOOKMARK_OPTION: "Bookmark"
+STR_DICTIONARY: "Dictionary"
 STR_DISABLED: "Disabled"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -214,6 +231,7 @@ STR_CONNECT: "Connect"
 STR_OPEN: "Open"
 STR_DOWNLOAD: "Download"
 STR_RETRY: "Retry"
+STR_TAP_TO_RETRY: "Tap to retry"
 STR_YES: "Yes"
 STR_NO: "No"
 STR_SHOW: "Show"
@@ -226,6 +244,9 @@ STR_DIR_RIGHT: "Right"
 STR_DIR_UP: "Up"
 STR_DIR_DOWN: "Down"
 STR_OK_BUTTON: "OK"
+STR_KEY_SHIFT: "Shift"
+STR_KEY_MODE_SYMBOLS: "?123"
+STR_KEY_MODE_ABC: "abc"
 STR_SLEEP_COVER_FILTER: "Sleep Screen Cover Filter"
 STR_FILTER_CONTRAST: "Contrast"
 STR_CUSTOMISE_STATUS_BAR: "Customise Status Bar"
@@ -295,25 +316,6 @@ STR_HW_BACK_LABEL: "Back (1st button)"
 STR_HW_CONFIRM_LABEL: "Confirm (2nd button)"
 STR_HW_LEFT_LABEL: "Left (3rd button)"
 STR_HW_RIGHT_LABEL: "Right (4th button)"
-STR_BLUETOOTH: "Bluetooth"
-STR_TOGGLE_BLUETOOTH: "Toggle Bluetooth"
-STR_BT_SCAN_PAIR: "Scan & Pair"
-STR_BT_NO_DEVICES: "No devices found"
-STR_BT_FREE_HINT1: "Set Free2/3 to Reader Mode and"
-STR_BT_FREE_HINT2: "Volume Function to pair"
-STR_BT_DISCONNECT: "Disconnect"
-STR_BT_CONNECTED_TO: "Connected: %s"
-STR_BT_NOT_CONNECTED: "Not connected"
-STR_BT_PAIRED_DEVICES: "Paired Devices"
-STR_BT_NO_PAIRED: "No paired devices"
-STR_BT_MAP_BUTTONS: "Map Remote Buttons"
-STR_BT_PRESS_REMOTE: "Press a button on your remote"
-STR_BT_CONNECTING_POPUP: "BT Connecting..."
-STR_BT_PAUSED_LOW_MEM_POPUP: "BT paused (low memory)"
-STR_STATE_PAUSED: "PAUSED"
-STR_BT_PAGE_FORWARD: "Page Forward"
-STR_BT_PAGE_BACK: "Page Back"
-STR_BT_FORGET_PROMPT: "Hold Confirm to forget"
 STR_GO_TO_PERCENT: "Go to %"
 STR_GO_HOME_BUTTON: "Go Home"
 STR_SYNC_PROGRESS: "Sync Progress"
@@ -343,6 +345,7 @@ STR_UPLOAD_LOCAL: "Upload local progress"
 STR_NO_REMOTE_MSG: "No remote progress found"
 STR_UPLOAD_PROMPT: "Upload current position?"
 STR_UPLOAD_SUCCESS: "Progress uploaded!"
+STR_ALREADY_SYNCED: "Already synced"
 STR_SYNC_FAILED_MSG: "Sync failed"
 STR_SAVE_PROGRESS_FAILED: "Could not save progress"
 STR_SECTION_PREFIX: "Section "
@@ -352,6 +355,7 @@ STR_EMBEDDED_STYLE: "Embedded Style"
 STR_FOCUS_READING: "Focus Reading"
 STR_OPDS_SERVER_URL: "OPDS Server URL"
 STR_PWR_BTN_FOOTNOTE_BACK: "Quick-return from footnotes"
+STR_BACK_SHORT_TO_FILE_BROWSER: "Short Back to File Browser"
 STR_SET_SLEEP_COVER: "Set Cover"
 STR_FOOTNOTES: "Footnotes"
 STR_NO_FOOTNOTES: "No footnotes on this page"
@@ -366,6 +370,12 @@ STR_SERVER_NAME: "Server Name"
 STR_NO_SERVERS: "No OPDS servers configured"
 STR_DELETE_SERVER: "Delete Server"
 STR_OPDS_SERVERS: "OPDS Servers"
+STR_OPDS_DOWNLOAD_FOLDER: "Download folder"
+STR_OPDS_FILENAME_FORMAT: "Filename format"
+STR_FMT_AUTHOR_TITLE: "Author - Title"
+STR_FMT_TITLE_AUTHOR: "Title - Author"
+STR_FMT_TITLE: "Title"
+STR_OPDS_SD_ROOT: "SD root"
 STR_AUTO_TURN_ENABLED: "Auto Turn Enabled: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Auto Turn (Pages Per Minute)"
 STR_MANAGE_FONTS: "Manage Fonts"

lib/I18n/translations/finnish.yaml

@@ -68,6 +68,7 @@ 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: "Lukijan kosketusohjaus"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Suuntaa etupainikkeet"
 STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
 STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -268,6 +269,11 @@ STR_BOOK_S_STYLE: "Kirjan tyyli"
 STR_EMBEDDED_STYLE: "Upotettu tyyli"
 STR_FOCUS_READING: "Keskittynyt lukeminen"
 STR_OPDS_SERVER_URL: "OPDS-palvelimen osoite"
+STR_OPDS_DOWNLOAD_FOLDER: "Latauskansio"
+STR_OPDS_FILENAME_FORMAT: "Tiedostonimen muoto"
+STR_FMT_AUTHOR_TITLE: "Tekijä - Nimi"
+STR_FMT_TITLE_AUTHOR: "Nimi - Tekijä"
+STR_FMT_TITLE: "Nimi"
 STR_SCREENSHOT_BUTTON: "Ota kuvakaappaus"
 STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Ei koskaan"

lib/I18n/translations/french.yaml

@@ -72,6 +72,7 @@ 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é"
@@ -301,6 +302,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Jamais"
 STR_STEP_HINT_FRONT: "Boutons avant :"
 STR_STEP_HINT_SIDE: "Boutons latéraux :"
+STR_OPDS_DOWNLOAD_FOLDER: "Dossier de téléchargement"
+STR_OPDS_FILENAME_FORMAT: "Format du nom de fichier"
+STR_FMT_AUTHOR_TITLE: "Auteur - Titre"
+STR_FMT_TITLE_AUTHOR: "Titre - Auteur"
+STR_FMT_TITLE: "Titre"
 STR_SCREENSHOT_BUTTON: "Capture d'écran"
 STR_AUTO_TURN_ENABLED: "Tourne-page auto : "
 STR_AUTO_TURN_PAGES_PER_MIN: "Tourne-page auto (pages par minute)"

lib/I18n/translations/german.yaml

@@ -68,6 +68,7 @@ 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 beim Lesen"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Vordere Tasten ausrichten"
 STR_LONG_PRESS_BEHAVIOR: "Verhalten bei langem Tastendruck"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Aus"
@@ -315,6 +316,7 @@ STR_BOOK_S_STYLE: "Buch-Stil"
 STR_EMBEDDED_STYLE: "Eingebetteter Stil"
 STR_FOCUS_READING: "Fokus-Lesen"
 STR_OPDS_SERVER_URL: "OPDS-Server-URL"
+STR_BACK_SHORT_TO_FILE_BROWSER: "Kurz zurück drücken zum Datei-Browser"
 STR_SET_SLEEP_COVER: "Wähle Cover"
 STR_SCREENSHOT_BUTTON: "Screenshot aufnehmen"
 STR_FOOTNOTES: "Fußnoten"
@@ -329,6 +331,11 @@ STR_SERVER_NAME: "Servername"
 STR_NO_SERVERS: "Keine OPDS-Server konfiguriert"
 STR_DELETE_SERVER: "Server entfernen"
 STR_OPDS_SERVERS: "OPDS-Server"
+STR_OPDS_DOWNLOAD_FOLDER: "Download-Ordner"
+STR_OPDS_FILENAME_FORMAT: "Dateinamenformat"
+STR_FMT_AUTHOR_TITLE: "Autor - Titel"
+STR_FMT_TITLE_AUTHOR: "Titel - Autor"
+STR_FMT_TITLE: "Titel"
 STR_AUTO_TURN_ENABLED: "Auto-Umblättern aktiv: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Auto-Umblättern (Seiten/Min.)"
 STR_IMAGES: "Bilder"

lib/I18n/translations/hebrew.yaml

@@ -73,6 +73,7 @@ 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: "דלג פרק"
@@ -306,6 +307,11 @@ STR_NO_SERVERS: "לא הוגדרו שרתי OPDS"
 STR_DELETE_SERVER: "מחק שרת"
 STR_DELETE_CONFIRM: "למחוק שרת זה?"
 STR_OPDS_SERVERS: "שרתי OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "תיקיית הורדות"
+STR_OPDS_FILENAME_FORMAT: "תבנית שם קובץ"
+STR_FMT_AUTHOR_TITLE: "מחבר - כותרת"
+STR_FMT_TITLE_AUTHOR: "כותרת - מחבר"
+STR_FMT_TITLE: "כותרת"
 STR_AUTO_TURN_ENABLED: "דפדוף אוטומטי פועל: "
 STR_AUTO_TURN_PAGES_PER_MIN: "דפדוף אוטומטי (דפים בדקה)"
 STR_MANAGE_FONTS: "ניהול גופנים"

lib/I18n/translations/hungarian.yaml

@@ -74,6 +74,7 @@ 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ős olvasóvezérlés"
 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"
@@ -299,6 +300,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u perc"
 STR_SLEEP_NEVER: "Soha"
 STR_STEP_HINT_FRONT: "Elülső gombok:"
 STR_STEP_HINT_SIDE: "Oldalsó gombok:"
+STR_OPDS_DOWNLOAD_FOLDER: "Letöltési mappa"
+STR_OPDS_FILENAME_FORMAT: "Fájlnév formátuma"
+STR_FMT_AUTHOR_TITLE: "Szerző - Cím"
+STR_FMT_TITLE_AUTHOR: "Cím - Szerző"
+STR_FMT_TITLE: "Cím"
 STR_SCREENSHOT_BUTTON: "Képernyőkép készítése"
 STR_AUTO_TURN_ENABLED: "Automatikus lapozás bekapcsolva: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Automatikus lapozás (oldal/perc)"

lib/I18n/translations/italian.yaml

@@ -72,6 +72,7 @@ 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"
@@ -315,6 +316,11 @@ STR_SERVER_NAME: "Nome server"
 STR_NO_SERVERS: "Nessun server OPDS configurato"
 STR_DELETE_SERVER: "Elimina server"
 STR_OPDS_SERVERS: "Server OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Cartella download"
+STR_OPDS_FILENAME_FORMAT: "Formato nome file"
+STR_FMT_AUTHOR_TITLE: "Autore - Titolo"
+STR_FMT_TITLE_AUTHOR: "Titolo - Autore"
+STR_FMT_TITLE: "Titolo"
 STR_AUTO_TURN_ENABLED: "Volta pagina automatico: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Volta pagina automatico (pag/min)"
 STR_MANAGE_FONTS: "Gestisci font"

lib/I18n/translations/kazakh.yaml

@@ -67,6 +67,7 @@ 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: "Канагаттандырылмагандыктарыныздан"
@@ -296,6 +297,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u мин"
 STR_SLEEP_NEVER: "Ешқашан"
 STR_STEP_HINT_FRONT: "Алдыңғы түймелер:"
 STR_STEP_HINT_SIDE: "Бүйір түймелері:"
+STR_OPDS_DOWNLOAD_FOLDER: "Жүктеп алу қалтасы"
+STR_OPDS_FILENAME_FORMAT: "Файл атауының пішімі"
+STR_FMT_AUTHOR_TITLE: "Автор - Атауы"
+STR_FMT_TITLE_AUTHOR: "Атауы - Автор"
+STR_FMT_TITLE: "Атауы"
 STR_SCREENSHOT_BUTTON: "Скриншот түсіру"
 STR_AUTO_TURN_ENABLED: "Автоматты бет аудару қосулы: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Автоматты бет аудару (минутына бет саны)"

lib/I18n/translations/lithuanian.yaml

@@ -72,6 +72,7 @@ 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: "Lietimo valdikliai skaityklėje"
 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ą"
@@ -297,6 +298,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min."
 STR_SLEEP_NEVER: "Niekada"
 STR_STEP_HINT_FRONT: "Priekiniai mygtukai:"
 STR_STEP_HINT_SIDE: "Šoniniai mygtukai:"
+STR_OPDS_DOWNLOAD_FOLDER: "Atsisiuntimų aplankas"
+STR_OPDS_FILENAME_FORMAT: "Failo pavadinimo formatas"
+STR_FMT_AUTHOR_TITLE: "Autorius - Pavadinimas"
+STR_FMT_TITLE_AUTHOR: "Pavadinimas - Autorius"
+STR_FMT_TITLE: "Pavadinimas"
 STR_SCREENSHOT_BUTTON: "Ekrano nuotrauka"
 STR_AUTO_TURN_ENABLED: "Auto-vertimas: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Auto-vertimas (psl/min)"

lib/I18n/translations/norwegian.yaml

@@ -0,0 +1,385 @@
+_language_name: "Norsk bokmål"
+_language_code: "NB"
+_order: "26"
+
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "STARTER"
+STR_SLEEPING: "HVILER"
+STR_ENTERING_SLEEP: "Går i hvilemodus"
+STR_BROWSE_FILES: "Bla i filer"
+STR_FILE_TRANSFER: "Filoverføring"
+STR_SETTINGS_TITLE: "Innstillinger"
+STR_CONTINUE_READING: "Fortsett å lese"
+STR_NO_OPEN_BOOK: "Ingen åpen bok"
+STR_START_READING: "Start å lese nedenfor"
+STR_NO_FILES_FOUND: "Ingen filer funnet"
+STR_SELECT_CHAPTER: "Velg kapittel"
+STR_NO_CHAPTERS: "Ingen kapitler"
+STR_END_OF_BOOK: "Slutten av boken"
+STR_EMPTY_CHAPTER: "Tomt kapittel"
+STR_INDEXING: "Indekserer"
+STR_MEMORY_ERROR: "Minnefeil"
+STR_PAGE_LOAD_ERROR: "Feil ved sidelasting"
+STR_EMPTY_FILE: "Tom fil"
+STR_OUT_OF_BOUNDS: "Utenfor område"
+STR_LOADING: "Laster..."
+STR_LOADING_POPUP: "Laster"
+STR_WIFI_NETWORKS: "WiFi-nettverk"
+STR_NO_NETWORKS: "Ingen nettverk funnet"
+STR_NETWORKS_FOUND: "%zu nettverk funnet"
+STR_SCANNING: "Skanner..."
+STR_CONNECTING: "Kobler til..."
+STR_CONNECTED: "Tilkoblet!"
+STR_CONNECTION_FAILED: "Tilkobling mislyktes"
+STR_FORGET_NETWORK: "Glem nettverk?"
+STR_SAVE_PASSWORD: "Lagre passord til neste gang?"
+STR_PRESS_OK_SCAN: "Trykk OK for å skanne på nytt"
+STR_JOIN_NETWORK: "Koble til et nettverk"
+STR_CREATE_HOTSPOT: "Opprett hotspot"
+STR_JOIN_DESC: "Koble til et eksisterende WiFi-nettverk"
+STR_HOTSPOT_DESC: "Opprett et WiFi-nettverk andre kan koble seg til"
+STR_STARTING_HOTSPOT: "Starter hotspot..."
+STR_HOTSPOT_MODE: "Hotspot-modus"
+STR_CONNECT_WIFI_HINT: "Koble enheten din til dette WiFi-nettverket"
+STR_OPEN_URL_HINT: "Åpne denne URL-en i nettleseren din"
+STR_OR_HTTP_PREFIX: "eller http://"
+STR_SCAN_QR_HINT: "eller skann QR-kode med telefonen din:"
+STR_CALIBRE_WIRELESS: "Calibre Wireless"
+STR_NETWORK_LEGEND: "* = Kryptert | + = Lagret"
+STR_MAC_ADDRESS: "MAC-adresse:"
+STR_CHECKING_WIFI: "Sjekker WiFi..."
+STR_ENTER_WIFI_PASSWORD: "Skriv inn WiFi-passord"
+STR_TO_PREFIX: "til "
+STR_CALIBRE_RECEIVING: "Mottar: "
+STR_CALIBRE_RECEIVED: "Mottatt: "
+STR_CALIBRE_INSTRUCTION_1: "1) Installer CrossPoint Reader-plugin"
+STR_CALIBRE_INSTRUCTION_2: "2) Vær på samme WiFi-nettverk"
+STR_CALIBRE_INSTRUCTION_3: "3) I Calibre: \"Send til enhet\""
+STR_CALIBRE_INSTRUCTION_4: "\"Hold denne skjermen åpen mens du sender\""
+STR_CAT_DISPLAY: "Skjerm"
+STR_CAT_READER: "Leser"
+STR_CAT_CONTROLS: "Betjening"
+STR_CAT_SYSTEM: "System"
+STR_SLEEP_SCREEN: "Hvileskjerm"
+STR_QUICK_RESUME_TIMEOUT: "Hurtig gjenopptak ved tidsavbrudd"
+STR_SLEEP_COVER_MODE: "Omslagsmodus for hvileskjerm"
+STR_HIDE_BATTERY: "Skjul batteri %"
+STR_EXTRA_SPACING: "Ekstra avsnittsavstand"
+STR_TEXT_AA: "Tekstutjevning"
+STR_IMAGES: "Bilder"
+STR_IMAGES_DISPLAY: "Vis"
+STR_IMAGES_PLACEHOLDER: "Plassholder"
+STR_IMAGES_SUPPRESS: "Skjul"
+STR_SHORT_PWR_BTN: "Kort trykk på av/på-knapp"
+STR_ORIENTATION: "Leseretning"
+STR_SIDE_BTN_LAYOUT: "Sideknapp-oppsett (leser)"
+STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienter frontknapper"
+STR_LONG_PRESS_BEHAVIOR: "Atferd ved langt trykk"
+STR_LONG_PRESS_BEHAVIOR_OFF: "AV"
+STR_LONG_PRESS_BEHAVIOR_SKIP: "Kapittelhopp"
+STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Endre orientering"
+STR_LONG_PRESS_MENU: "Langt trykk på Meny"
+STR_FONT_PREVIEW_TEXT: "Høvdingens kjære squaw får litt pizza i Mexico by"
+STR_FONT_FAMILY: "Skrifttype i leser"
+STR_FONT_SIZE: "Skriftstørrelse i leser"
+STR_LINE_SPACING: "Linjeavstand i leser"
+STR_SCREEN_MARGIN: "Skjermmarg i leser"
+STR_PARA_ALIGNMENT: "Avsnittsjustering i leser"
+STR_HYPHENATION: "Orddeling"
+STR_TIME_TO_SLEEP: "Tid før hvile"
+STR_SHOW_HIDDEN_FILES: "Vis skjulte filer"
+STR_REMOVE_READ_FROM_RECENTS: "Fjern leste bøker fra Nylig-listen"
+STR_MOVE_FINISHED_TO_READ: "Flytt fullførte bøker til Read-mappen"
+STR_REFRESH_FREQ: "Oppdateringsfrekvens"
+STR_KOREADER_SYNC: "KOReader Sync"
+STR_CHECK_UPDATES: "Se etter oppdateringer"
+STR_LANGUAGE: "Språk"
+STR_CLEAR_READING_CACHE: "Tøm lesebuffer"
+STR_USERNAME: "Brukernavn"
+STR_PASSWORD: "Passord"
+STR_SYNC_SERVER_URL: "URL til synk-server"
+STR_DOCUMENT_MATCHING: "Dokumentgjenkjenning"
+STR_AUTHENTICATE: "Godkjenn"
+STR_KOREADER_USERNAME: "KOReader-brukernavn"
+STR_KOREADER_PASSWORD: "KOReader-passord"
+STR_FILENAME: "Filnavn"
+STR_BINARY: "Binær"
+STR_SET_CREDENTIALS_FIRST: "Angi påloggingsinfo først"
+STR_WIFI_CONN_FAILED: "WiFi-tilkobling mislyktes"
+STR_AUTHENTICATING: "Godkjenner..."
+STR_AUTH_SUCCESS: "Godkjenning vellykket!"
+STR_KOREADER_AUTH: "KOReader-godkjenning"
+STR_SYNC_READY: "KOReader-synk er klar til bruk"
+STR_AUTH_FAILED: "Godkjenning mislyktes"
+STR_DONE: "Ferdig"
+STR_CLEAR_CACHE_WARNING_1: "Dette tømmer alle bufrede bokdata."
+STR_CLEAR_CACHE_WARNING_2: "All lesefremdrift går tapt!"
+STR_CLEAR_CACHE_WARNING_3: "Bøker må indekseres på nytt"
+STR_CLEAR_CACHE_WARNING_4: "når de åpnes igjen."
+STR_CLEARING_CACHE: "Tømmer buffer..."
+STR_CACHE_CLEARED: "Buffer tømt"
+STR_ITEMS_REMOVED: "elementer fjernet"
+STR_FAILED_LOWER: "mislyktes"
+STR_CLEAR_CACHE_FAILED: "Kunne ikke tømme buffer"
+STR_CHECK_SERIAL_OUTPUT: "Sjekk seriell utdata for detaljer"
+STR_DARK: "Mørk"
+STR_LIGHT: "Lys"
+STR_CUSTOM: "Egendefinert"
+STR_COVER: "Omslag"
+STR_NONE_OPT: "Ingen"
+STR_FIT: "Tilpass"
+STR_CROP: "Beskjær"
+STR_NEVER: "Aldri"
+STR_IN_READER: "I leseren"
+STR_ALWAYS: "Alltid"
+STR_IGNORE: "Ignorer"
+STR_SLEEP: "Hvile"
+STR_PAGE_TURN: "Bla om"
+STR_FORCE_REFRESH: "Oppdater skjerm"
+STR_PORTRAIT: "Stående"
+STR_LANDSCAPE_CW: "Liggende med klokken"
+STR_INVERTED: "Opp ned"
+STR_ORIENTATION_INVERTED: "Portrett 180°"
+STR_LANDSCAPE_CCW: "Liggende mot klokken"
+STR_PREV_NEXT: "Forrige/Neste"
+STR_NEXT_PREV: "Neste/Forrige"
+STR_KOSYNC: "KOSync"
+STR_BOOKMARK_OPTION: "Bokmerke"
+STR_DISABLED: "Deaktivert"
+STR_NOTO_SERIF: "Noto Serif"
+STR_NOTO_SANS: "Noto Sans"
+STR_SMALL: "Liten"
+STR_MEDIUM: "Middels"
+STR_LARGE: "Stor"
+STR_X_LARGE: "Ekstra stor"
+STR_TIGHT: "Tett"
+STR_NORMAL: "Normal"
+STR_WIDE: "Bred"
+STR_JUSTIFY: "Blokkjustert"
+STR_ALIGN_LEFT: "Venstre"
+STR_CENTER: "Midtstilt"
+STR_ALIGN_RIGHT: "Høyre"
+STR_PAGES_1: "1 side"
+STR_PAGES_5: "5 sider"
+STR_PAGES_10: "10 sider"
+STR_PAGES_15: "15 sider"
+STR_PAGES_30: "30 sider"
+STR_UPDATE: "Oppdater"
+STR_CHECKING_UPDATE: "Ser etter oppdatering..."
+STR_NEW_UPDATE: "Ny oppdatering tilgjengelig!"
+STR_CURRENT_VERSION: "Nåværende versjon: "
+STR_NEW_VERSION: "Ny versjon: "
+STR_UPDATING: "Oppdaterer..."
+STR_NO_UPDATE: "Ingen oppdatering tilgjengelig"
+STR_UPDATE_FAILED: "Oppdatering mislyktes"
+STR_UPDATE_COMPLETE: "Oppdatering fullført"
+STR_POWER_ON_HINT: "Trykk og hold av/på-knappen for å slå på igjen"
+STR_RESTARTING_HINT: "Starter på nytt... Hvis enheten ikke starter, hold av/på-knappen i noen sekunder."
+STR_NO_ENTRIES: "Ingen oppføringer funnet"
+STR_DOWNLOADING: "Laster ned..."
+STR_DOWNLOAD_FAILED: "Nedlasting mislyktes"
+STR_ERROR_MSG: "Feil:"
+STR_UNNAMED: "Uten navn"
+STR_HOLD_OPEN_TO_DELETE: "Hold Åpne for å slette"
+STR_NO_SERVER_URL: "Ingen server-URL konfigurert"
+STR_FETCH_FEED_FAILED: "Kunne ikke hente feed"
+STR_PARSE_FEED_FAILED: "Kunne ikke tolke feed"
+STR_NEXT_PAGE: "Neste side »"
+STR_PREV_PAGE: "« Forrige side"
+STR_NETWORK_PREFIX: "Nettverk: "
+STR_IP_ADDRESS_PREFIX: "IP-adresse: "
+STR_ERROR_GENERAL_FAILURE: "Feil: Generell feil"
+STR_ERROR_NETWORK_NOT_FOUND: "Feil: Nettverk ikke funnet"
+STR_ERROR_CONNECTION_TIMEOUT: "Feil: Tidsavbrudd for tilkobling"
+STR_SD_CARD: "SD-kort"
+STR_BACK: "« Tilbake"
+STR_EXIT: "« Avslutt"
+STR_HOME: "« Hjem"
+STR_SELECT: "Velg"
+STR_SELECTED: "Valgt"
+STR_TOGGLE: "Veksle"
+STR_TOGGLE_BOOKMARK: "Veksle bokmerke"
+STR_CONFIRM: "Bekreft"
+STR_CANCEL: "Avbryt"
+STR_CONNECT: "Koble til"
+STR_OPEN: "Åpne"
+STR_DOWNLOAD: "Last ned"
+STR_RETRY: "Prøv igjen"
+STR_YES: "Ja"
+STR_NO: "Nei"
+STR_SHOW: "Vis"
+STR_HIDE: "Skjul"
+STR_STATE_ON: "PÅ"
+STR_STATE_OFF: "AV"
+STR_NOT_SET: "Ikke angitt"
+STR_DIR_LEFT: "Venstre"
+STR_DIR_RIGHT: "Høyre"
+STR_DIR_UP: "Opp"
+STR_DIR_DOWN: "Ned"
+STR_OK_BUTTON: "OK"
+STR_SLEEP_COVER_FILTER: "Omslagsfilter for hvileskjerm"
+STR_FILTER_CONTRAST: "Kontrast"
+STR_CUSTOMISE_STATUS_BAR: "Tilpass statuslinje"
+STR_CHAPTER_PAGE_COUNT: "Sideantall i kapittel"
+STR_BOOK_PROGRESS_PERCENTAGE: "Bokfremdrift i prosent"
+STR_PROGRESS_BAR: "Fremdriftslinje"
+STR_PROGRESS_BAR_THICKNESS: "Tykkelse på fremdriftslinje"
+STR_PROGRESS_BAR_THIN: "Tynn"
+STR_PROGRESS_BAR_MEDIUM: "Middels"
+STR_PROGRESS_BAR_THICK: "Tykk"
+STR_BOOK: "Bok"
+STR_CHAPTER: "Kapittel"
+STR_EXAMPLE_CHAPTER: "Kapittel 21"
+STR_EXAMPLE_BOOK: "Boktittel"
+STR_PREVIEW: "Forhåndsvisning"
+STR_TITLE: "Tittel"
+STR_BATTERY: "Batteri"
+STR_XTC_STATUS_BAR: "XTC-statuslinje"
+STR_BOTTOM: "Nederst"
+STR_TOP: "Øverst"
+STR_CLOCK: "Klokke"
+STR_CLOCK_UTC_OFFSET: "UTC-forskyvning for klokke"
+STR_CLOCK_FORMAT: "Klokkeformat"
+STR_CLOCK_FORMAT_24H: "24-timers"
+STR_CLOCK_FORMAT_12H: "12-timers"
+STR_CURRENT_TIME: "Nåværende tid:"
+STR_NEXT_FIELD: "Neste"
+STR_CLOCK_SYNC: "Synkroniser klokke"
+STR_CLOCK_SYNC_NOW: "Synkroniser klokke nå"
+STR_CLOCK_SYNCING: "Synkroniserer fra NTP..."
+STR_CLOCK_SYNC_OK: "Klokke synkronisert"
+STR_CLOCK_SYNC_FAIL: "Synkronisering mislyktes"
+STR_CLOCK_SYNC_NO_WIFI: "WiFi ikke tilkoblet"
+STR_CLOCK_SYNC_NO_WIFI_HINT: "Koble til WiFi først, og prøv igjen."
+STR_CLOCK_SYNCED: "Klokke synkronisert"
+STR_UI_THEME: "Grensesnittstema"
+STR_THEME_CLASSIC: "Klassisk"
+STR_THEME_LYRA: "Lyra"
+STR_THEME_ROUNDEDRAFF: "RoundedRaff"
+STR_THEME_LYRA_EXTENDED: "Lyra Extended"
+STR_SUNLIGHT_FADING_FIX: "Retting for soluttoning"
+STR_REMAP_FRONT_BUTTONS: "Tilordne frontknapper på nytt"
+STR_BOOKMARKS: "Bokmerker"
+STR_BOOKMARK_ADDED: "Bokmerke lagt til."
+STR_BOOKMARK_REMOVED: "Bokmerke fjernet."
+STR_OPDS_BROWSER: "OPDS-leser"
+STR_SEARCH: "Søk"
+STR_COVER_CUSTOM: "Omslag + Egendefinert"
+STR_QUICK_RESUME: "Hurtig gjenopptak"
+STR_MENU_RECENT_BOOKS: "Nylige bøker"
+STR_REMOVE_FROM_RECENTS: "Fjern fra Nylige bøker?"
+STR_NO_RECENT_BOOKS: "Ingen nylige bøker"
+STR_CALIBRE_DESC: "Bruk trådløs enhetsoverføring med Calibre"
+STR_FORGET_AND_REMOVE: "Glem nettverk og fjern lagret passord?"
+STR_FORGET_BUTTON: "Glem"
+STR_CALIBRE_STARTING: "Starter Calibre..."
+STR_CALIBRE_SETUP: "Oppsett"
+STR_CALIBRE_STATUS: "Status"
+STR_CLEAR_BUTTON: "Tøm"
+STR_DEFAULT_VALUE: "Standard"
+STR_REMAP_PROMPT: "Trykk en frontknapp for hver rolle"
+STR_UNASSIGNED: "Ikke tilordnet"
+STR_ALREADY_ASSIGNED: "Allerede tilordnet"
+STR_REMAP_RESET_HINT: "Sideknapp opp: Nullstill til standardoppsett"
+STR_REMAP_CANCEL_HINT: "Sideknapp ned: Avbryt omtilordning"
+STR_HW_BACK_LABEL: "Tilbake (1. knapp)"
+STR_HW_CONFIRM_LABEL: "Bekreft (2. knapp)"
+STR_HW_LEFT_LABEL: "Venstre (3. knapp)"
+STR_HW_RIGHT_LABEL: "Høyre (4. knapp)"
+STR_GO_TO_PERCENT: "Gå til %"
+STR_GO_HOME_BUTTON: "Hjem"
+STR_SYNC_PROGRESS: "Synkroniser fremdrift"
+STR_DELETE_CACHE: "Slett bokbuffer"
+STR_DELETE: "Slett"
+STR_CONFIRM_DELETE_BOOKMARK: "Slette dette bokmerket?"
+STR_DISPLAY_QR: "Vis side som QR"
+STR_CHAPTER_PREFIX: "Kapittel: "
+STR_PAGES_SEPARATOR: " sider  |  "
+STR_BOOK_PREFIX: "Bok: "
+STR_CALIBRE_URL_HINT: "For Calibre, legg til /opds i URL-en din"
+STR_PERCENT_STEP_HINT: "Venstre/Høyre: 1%  Opp/Ned: 10%"
+STR_SYNCING_TIME: "Synkroniserer tid..."
+STR_CALC_HASH: "Beregner dokument-hash..."
+STR_HASH_FAILED: "Kunne ikke beregne dokument-hash"
+STR_FETCH_PROGRESS: "Henter ekstern fremdrift..."
+STR_UPLOAD_PROGRESS: "Laster opp fremdrift..."
+STR_NO_CREDENTIALS_MSG: "Ingen påloggingsinfo angitt"
+STR_KOREADER_SETUP_HINT: "Sett opp KOReader-konto i Innstillinger"
+STR_PROGRESS_FOUND: "Fremdrift funnet!"
+STR_REMOTE_LABEL: "Ekstern:"
+STR_LOCAL_LABEL: "Lokal:"
+STR_PAGE_OVERALL_FORMAT: "Side %d, %.2f%% totalt"
+STR_PAGE_TOTAL_OVERALL_FORMAT: "Side %d/%d, %.2f%% totalt"
+STR_DEVICE_FROM_FORMAT: "  Fra: %s"
+STR_APPLY_REMOTE: "Bruk ekstern fremdrift"
+STR_UPLOAD_LOCAL: "Last opp lokal fremdrift"
+STR_NO_REMOTE_MSG: "Ingen ekstern fremdrift funnet"
+STR_UPLOAD_PROMPT: "Last opp nåværende posisjon?"
+STR_UPLOAD_SUCCESS: "Fremdrift lastet opp!"
+STR_SYNC_FAILED_MSG: "Synkronisering mislyktes"
+STR_SAVE_PROGRESS_FAILED: "Kunne ikke lagre fremdrift"
+STR_SECTION_PREFIX: "Del "
+STR_UPLOAD: "Last opp"
+STR_BOOK_S_STYLE: "Bokens stil"
+STR_EMBEDDED_STYLE: "Innebygd stil"
+STR_FOCUS_READING: "Fokuslesing"
+STR_OPDS_SERVER_URL: "OPDS-server-URL"
+STR_PWR_BTN_FOOTNOTE_BACK: "Hurtig retur fra fotnoter"
+STR_SET_SLEEP_COVER: "Velg omslag"
+STR_FOOTNOTES: "Fotnoter"
+STR_NO_FOOTNOTES: "Ingen fotnoter på denne siden"
+STR_LINK: "[lenke]"
+STR_SCREENSHOT_BUTTON: "Ta skjermbilde"
+STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
+STR_SLEEP_NEVER: "Aldri"
+STR_SLEEP_TIMER_STEP_HINT: "Venstre/Høyre: 1 min  Opp/Ned: 5 min"
+STR_ADD_SERVER: "Legg til server"
+STR_SERVER_NAME: "Servernavn"
+STR_NO_SERVERS: "Ingen OPDS-servere konfigurert"
+STR_DELETE_SERVER: "Slett server"
+STR_OPDS_SERVERS: "OPDS-servere"
+STR_AUTO_TURN_ENABLED: "Automatisk bla aktivert: "
+STR_AUTO_TURN_PAGES_PER_MIN: "Automatisk bla (sider per minutt)"
+STR_MANAGE_FONTS: "Administrer skrifttyper"
+STR_FONT_BROWSER: "Bla i skrifttyper"
+STR_LOADING_FONT_LIST: "Laster skrifttypeliste..."
+STR_NO_FONTS_AVAILABLE: "Ingen skrifttyper tilgjengelig"
+STR_FONT_INSTALLED: "Skrifttype installert!"
+STR_FONT_INSTALL_FAILED: "Installasjon av skrifttype mislyktes"
+STR_INSTALLED: "Installert"
+STR_DOWNLOAD_ALL: "Last ned alle"
+STR_UPDATE_ALL: "Oppdater alle"
+STR_UPDATE_AVAILABLE: "Oppdater"
+STR_CRASH_TITLE: "Systemkrasj"
+STR_CRASH_DESCRIPTION: "En detaljert rapport ble lagret i crash_report.txt. Legg ved denne filen i feilrapporten din."
+STR_CRASH_REASON: "Krasjårsak:"
+STR_CRASH_NO_REASON: "(Ingen årsak ble registrert)"
+STR_TILT_PAGE_TURN: "Vipp for å bla"
+STR_KB_HINT_MOVE_CURSOR: "Trykk VENSTRE eller HØYRE for å flytte markøren"
+STR_KB_HINT_RETURN_CURSOR: "Trykk VENSTRE for å gå tilbake til markørposisjonen"
+STR_KB_HINT_HIDE_PASSWORD: "Hold HØYRE og trykk [***] for å skjule passord"
+STR_KB_HINT_SHOW_PASSWORD: "Hold HØYRE og trykk [abc] for å vise passord"
+STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "Trykk [***] for å skjule passord"
+STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "Trykk [abc] for å vise passord"
+STR_KB_HINT_EDIT_ENTRY: "Hold OPP for å redigere oppføring"
+STR_KB_TIPS: "Tips:"
+STR_KB_HINT_RETURN_KEYBOARD: "Trykk NED for å gå tilbake til tastaturet"
+STR_KB_HINT_EXIT_URL_MODE: "Trykk ABC for å avslutte URL-modus"
+STR_KB_HINT_CLEAR_TEXT: "Hold DEL for å slette all tekst"
+STR_KB_HINT_SECONDARY_CHAR: "Hold VELG for sekundærtegn"
+STR_KB_HINT_UPPER_SECONDARY: "Hold VELG for STORE BOKSTAVER eller sekundærtegn"
+STR_KB_HINT_LOWER_SECONDARY: "Hold VELG for små bokstaver eller sekundærtegn"
+STR_KB_HINT_URL_SNIPPETS: "Trykk URL for tekstbiter"
+STR_SD_FIRMWARE_UPDATE: "Fastvareoppdatering fra SD-kort"
+STR_SELECT_FIRMWARE_FILE: "Velg fastvarefil (.bin)"
+STR_NO_BIN_FILES: "Ingen .bin-filer funnet"
+STR_VALIDATING_FIRMWARE: "Validerer fastvare..."
+STR_INVALID_FIRMWARE: "Ugyldig fastvarefil"
+STR_FIRMWARE_TOO_LARGE: "Fastvaren er for stor for partisjonen"
+STR_FIRMWARE_TOO_SMALL: "Fastvarefilen er for liten"
+STR_FIRMWARE_UPDATE_PROMPT: "Oppdatere fastvare?"
+STR_FIRMWARE_FILE_OPEN_FAILED: "Kan ikke åpne filen"
+STR_FIRMWARE_WRITE_FAILED: "Skriving av fastvare mislyktes"
+STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Ikke slå av!"
+STR_RECOVERY_MODE: "Gjenopprettingsmodus"
+STR_RECOVERY_MODE_HINT: "Legg firmware.bin i roten av SD-kortet og velg den"

lib/I18n/translations/polish.yaml

@@ -72,6 +72,7 @@ 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 czytnika"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuj przednie przyciski"
 STR_LONG_PRESS_BEHAVIOR: "Funkcja długiego przyciśnięcia"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Wył."
@@ -316,6 +317,11 @@ STR_SERVER_NAME: "Nazwa serwera"
 STR_NO_SERVERS: "Brak skonfigurowanych serwerów OPDS"
 STR_DELETE_SERVER: "Usuń serwer"
 STR_OPDS_SERVERS: "Serwery OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Folder pobierania"
+STR_OPDS_FILENAME_FORMAT: "Format nazwy pliku"
+STR_FMT_AUTHOR_TITLE: "Autor - Tytuł"
+STR_FMT_TITLE_AUTHOR: "Tytuł - Autor"
+STR_FMT_TITLE: "Tytuł"
 STR_AUTO_TURN_ENABLED: "Auto-kartkowanie: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Auto-kartkowanie (str./min)"
 STR_DOWNLOAD_FONTS: "Pobierz czcionki"

lib/I18n/translations/portuguese-BR.yaml

@@ -73,6 +73,7 @@ STR_IMAGES_SUPPRESS: "Ocultar"
 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: "Controles táteis do leitor"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botões frontais"
 STR_LONG_PRESS_BEHAVIOR: "Comportamento de Pressionar e segurar"
 STR_LONG_PRESS_BEHAVIOR_OFF: "DESL."
@@ -339,6 +340,11 @@ STR_SERVER_NAME: "Nome do Servidor"
 STR_NO_SERVERS: "Nenhum servidor OPDS configurado"
 STR_DELETE_SERVER: "Excluir Servidor"
 STR_OPDS_SERVERS: "Servidores OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Pasta de downloads"
+STR_OPDS_FILENAME_FORMAT: "Formato do nome do arquivo"
+STR_FMT_AUTHOR_TITLE: "Autor - Título"
+STR_FMT_TITLE_AUTHOR: "Título - Autor"
+STR_FMT_TITLE: "Título"
 STR_AUTO_TURN_ENABLED: "Virada automática ativada: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Virada automática (páginas por minuto)"
 STR_MANAGE_FONTS: "Gerenciar fontes"

lib/I18n/translations/portuguese-PT.yaml

@@ -18,7 +18,6 @@ STR_NO_CHAPTERS: "Sem capítulos"
 STR_END_OF_BOOK: "Fim do livro"
 STR_EMPTY_CHAPTER: "Capítulo vazio"
 STR_INDEXING: "A indexar"
-STR_INDEX_FAILED: "Falha ao indexar - livro inválido"
 STR_MEMORY_ERROR: "Erro de memória"
 STR_PAGE_LOAD_ERROR: "Erro ao carregar a página"
 STR_EMPTY_FILE: "Ficheiro vazio"
@@ -29,10 +28,7 @@ STR_WIFI_NETWORKS: "Redes Wi-Fi"
 STR_NO_NETWORKS: "Nenhuma rede encontrada"
 STR_NETWORKS_FOUND: "%zu redes encontradas"
 STR_SCANNING: "A procurar..."
-STR_FINDING_SAVED_WIFI: "A procurar Wi-Fi guardado..."
 STR_CONNECTING: "A ligar..."
-STR_CONNECTING_SAVED_WIFI: "A ligar ao Wi-Fi guardado..."
-STR_SHOW_NETWORKS: "Mostrar"
 STR_CONNECTED: "Ligado!"
 STR_CONNECTION_FAILED: "Falha na ligação"
 STR_FORGET_NETWORK: "Esquecer rede?"
@@ -53,8 +49,6 @@ STR_NETWORK_LEGEND: "* = Encriptada | + = Guardada"
 STR_MAC_ADDRESS: "Endereço MAC:"
 STR_CHECKING_WIFI: "A verificar o Wi-Fi..."
 STR_ENTER_WIFI_PASSWORD: "Introduza a palavra-passe do Wi-Fi"
-STR_ADD_HIDDEN_NETWORK: "Adicionar rede oculta..."
-STR_ENTER_WIFI_SSID: "Introduza o nome da rede (SSID)"
 STR_TO_PREFIX: "para "
 STR_CALIBRE_RECEIVING: "A receber: "
 STR_CALIBRE_RECEIVED: "Recebido: "
@@ -76,8 +70,6 @@ STR_IMAGES: "Imagens"
 STR_IMAGES_DISPLAY: "Exibição"
 STR_IMAGES_PLACEHOLDER: "Espaço reservado"
 STR_IMAGES_SUPPRESS: "Suprimir"
-STR_EOB_HOME: "Início"
-STR_EOB_CONTINUE_WITH: "Continuar com"
 STR_SHORT_PWR_BTN: "Clique curto no botão de energia"
 STR_ORIENTATION: "Orientação de leitura"
 STR_SIDE_BTN_LAYOUT: "Disposição dos botões laterais (leitor)"
@@ -347,6 +339,11 @@ STR_SERVER_NAME: "Nome do servidor"
 STR_NO_SERVERS: "Nenhum servidor OPDS configurado"
 STR_DELETE_SERVER: "Eliminar servidor"
 STR_OPDS_SERVERS: "Servidores OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Pasta de downloads"
+STR_OPDS_FILENAME_FORMAT: "Formato do nome do ficheiro"
+STR_FMT_AUTHOR_TITLE: "Autor - Título"
+STR_FMT_TITLE: "Título"
+STR_FMT_TITLE_AUTHOR: "Título - Autor"
 STR_AUTO_TURN_ENABLED: "Virar página automático ativado: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Virar página automático (Páginas por minuto)"
 STR_MANAGE_FONTS: "Gerir tipos de letra"
@@ -392,3 +389,5 @@ STR_FIRMWARE_WRITE_FAILED: "Falha na gravação do firmware"
 STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Não desligue o dispositivo!"
 STR_RECOVERY_MODE: "Modo de Recuperação"
 STR_RECOVERY_MODE_HINT: "Coloque o ficheiro firmware.bin na raiz do cartão SD e selecione-o"
+STR_ADD_HIDDEN_NETWORK: "Adicionar rede oculta..."
+STR_ENTER_WIFI_SSID: "Introduza o nome da rede (SSID)"

lib/I18n/translations/romanian.yaml

@@ -72,6 +72,7 @@ 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: "Comenzi tactile cititor"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientare butoane frontale"
 STR_LONG_PRESS_BEHAVIOR: "Comportament buton apăsat lung"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Dezactivat"
@@ -300,6 +301,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Niciodată"
 STR_STEP_HINT_FRONT: "Butoane frontale:"
 STR_STEP_HINT_SIDE: "Butoane laterale:"
+STR_OPDS_DOWNLOAD_FOLDER: "Dosar descărcări"
+STR_OPDS_FILENAME_FORMAT: "Format nume fișier"
+STR_FMT_AUTHOR_TITLE: "Autor - Titlu"
+STR_FMT_TITLE_AUTHOR: "Titlu - Autor"
+STR_FMT_TITLE: "Titlu"
 STR_SCREENSHOT_BUTTON: "Captură ecran"
 STR_AUTO_TURN_ENABLED: "Răsfoire automată: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Pagini pe minut"

lib/I18n/translations/russian.yaml

@@ -73,6 +73,7 @@ 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: "Ничего"
@@ -339,6 +340,11 @@ STR_SERVER_NAME: "Имя сервера"
 STR_NO_SERVERS: "Нет настроенных серверов OPDS"
 STR_DELETE_SERVER: "Удалить сервер"
 STR_OPDS_SERVERS: "Серверы OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Папка загрузок"
+STR_OPDS_FILENAME_FORMAT: "Формат имени файла"
+STR_FMT_AUTHOR_TITLE: "Автор - Название"
+STR_FMT_TITLE_AUTHOR: "Название - Автор"
+STR_FMT_TITLE: "Название"
 STR_AUTO_TURN_ENABLED: "Автоперелистывание: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Автоперелистывание (стр./мин)"
 STR_MANAGE_FONTS: "Управление шрифтами"

lib/I18n/translations/slovak.yaml

@@ -72,7 +72,8 @@ 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_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"
@@ -335,6 +336,11 @@ 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_OPDS_DOWNLOAD_FOLDER: "Priečinok sťahovania"
+STR_OPDS_FILENAME_FORMAT: "Formát názvu súboru"
+STR_FMT_AUTHOR_TITLE: "Autor - Názov"
+STR_FMT_TITLE_AUTHOR: "Názov - Autor"
+STR_FMT_TITLE: "Názov"
 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"

lib/I18n/translations/slovenian.yaml

@@ -72,6 +72,7 @@ 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: "Upravljanje bralnika na dotik"
 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"
@@ -297,6 +298,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
 STR_SLEEP_NEVER: "Nikoli"
 STR_STEP_HINT_FRONT: "Sprednji gumbi:"
 STR_STEP_HINT_SIDE: "Stranski gumbi:"
+STR_OPDS_DOWNLOAD_FOLDER: "Mapa za prenose"
+STR_OPDS_FILENAME_FORMAT: "Oblika imena datoteke"
+STR_FMT_AUTHOR_TITLE: "Avtor - Naslov"
+STR_FMT_TITLE_AUTHOR: "Naslov - Avtor"
+STR_FMT_TITLE: "Naslov"
 STR_SCREENSHOT_BUTTON: "Naredi posnetek zaslona"
 STR_AUTO_TURN_ENABLED: "Samodejno obračanje: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Samodejno obračanje (strani na minuto)"

lib/I18n/translations/spanish.yaml

@@ -78,6 +78,7 @@ STR_EOB_CONTINUE_WITH: "Continuar con"
 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 del 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"
@@ -345,6 +346,11 @@ STR_SERVER_NAME: "Nombre de servidor"
 STR_NO_SERVERS: "No se configuraron servidores OPDS"
 STR_DELETE_SERVER: "Borrar servidor"
 STR_OPDS_SERVERS: "Servidores OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Carpeta de descargas"
+STR_OPDS_FILENAME_FORMAT: "Formato del nombre de archivo"
+STR_FMT_AUTHOR_TITLE: "Autor - Título"
+STR_FMT_TITLE_AUTHOR: "Título - Autor"
+STR_FMT_TITLE: "Título"
 STR_AUTO_TURN_ENABLED: "Avance activado: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Avance auto. (pág./min)"
 STR_MANAGE_FONTS: "Gestionar tipografías"

lib/I18n/translations/swedish.yaml

@@ -10,6 +10,7 @@ STR_BROWSE_FILES: "Bläddra filer…"
 STR_FILE_TRANSFER: "Filöverföring"
 STR_SETTINGS_TITLE: "Inställningar"
 STR_CONTINUE_READING: "Fortsätt läsa"
+STR_RESUME: "Återuppta"
 STR_NO_OPEN_BOOK: "Ingen öppen bok"
 STR_START_READING: "Börja läsa nedan"
 STR_NO_FILES_FOUND: "Inga filer hittades"
@@ -25,11 +26,20 @@ STR_EMPTY_FILE: "Tom fil"
 STR_OUT_OF_BOUNDS: "Utanför gränserna"
 STR_LOADING: "Laddar…"
 STR_LOADING_POPUP: "Laddar"
+STR_LOOKUP: "Slå upp"
+STR_DICT_LOOKING_UP: "Slår upp..."
+STR_DICT_INDEXING: "Indexerar ordbok..."
+STR_DICT_NOT_FOUND: "Hittades inte"
+STR_DICT_NO_DICT_SET: "Ingen ordbok angiven"
+STR_DICT_ERROR: "Ordboksfel"
 STR_WIFI_NETWORKS: "Trådlösa nätverk"
 STR_NO_NETWORKS: "Inga nätverk funna"
 STR_NETWORKS_FOUND: "%zu nätverk funna"
 STR_SCANNING: "Scannar…"
+STR_FINDING_SAVED_WIFI: "Hittar sparade Wi-Fi..."
 STR_CONNECTING: "Ansluter…"
+STR_CONNECTING_SAVED_WIFI: "Ansluter till sparat Wi-Fi..."
+STR_SHOW_NETWORKS: "Visa"
 STR_CONNECTED: "Ansluten!"
 STR_CONNECTION_FAILED: "Anslutning misslyckades"
 STR_FORGET_NETWORK: "Glöm nätverk?"
@@ -50,6 +60,8 @@ STR_NETWORK_LEGEND: "* = Krypterad | + = Sparad"
 STR_MAC_ADDRESS: "MAC-adress:"
 STR_CHECKING_WIFI: "Kontrollerar trådlöst nätverk…"
 STR_ENTER_WIFI_PASSWORD: "Skriv in Wi-Fi-lösenord"
+STR_ADD_HIDDEN_NETWORK: "Lägg till dolt nätverk..."
+STR_ENTER_WIFI_SSID: "Ange nätverksnamn (SSID)"
 STR_TO_PREFIX: "till "
 STR_CALIBRE_RECEIVING: "Tar emot:"
 STR_CALIBRE_RECEIVED: "Mottaget:"
@@ -76,6 +88,7 @@ STR_EOB_CONTINUE_WITH: "Fortsätt med"
 STR_SHORT_PWR_BTN: "Kort strömknappsklick"
 STR_ORIENTATION: "Läsrikting"
 STR_SIDE_BTN_LAYOUT: "Sidoknappslayout (Läsare)"
+STR_TOUCH_READER_CONTROLS: "Pekkontroller i läsaren"
 STR_FRONT_BTN_FOLLOW_ORIENTATION: "Rikta främre knappar"
 STR_LONG_PRESS_BEHAVIOR: "Beteende vid lång knapptryckning"
 STR_LONG_PRESS_BEHAVIOR_OFF: "AV"
@@ -103,7 +116,15 @@ STR_PASSWORD: "Lösenord"
 STR_SYNC_SERVER_URL: "Synkronisera serveradress"
 STR_DOCUMENT_MATCHING: "Dokumentmatchning"
 STR_SEND_METADATA: "Skicka dokumentmetadata"
+STR_SYNC_BEHAVIOR: "Synkroniseringsbeteende"
+STR_ASK_EVERY_TIME: "Fråga varje gång"
+STR_SMART_SYNC: "Smart synkronisering"
 STR_AUTHENTICATE: "Autentisera "
+STR_SIGN_UP: "Registrera dig"
+STR_CREATING_ACCOUNT: "Skapar konto..."
+STR_ACCOUNT_CREATED: "Konto skapat"
+STR_SIGNUP_FAILED: "Registreringen misslyckades"
+STR_USERNAME_TAKEN: "Användarnamnet är redan registrerat"
 STR_KOREADER_USERNAME: "KOReader användarnamn"
 STR_KOREADER_PASSWORD: "KOReader lösenord"
 STR_FILENAME: "Filnamn"
@@ -149,6 +170,7 @@ STR_PREV_NEXT: "Förra/Nästa"
 STR_NEXT_PREV: "Nästa/Förra"
 STR_KOSYNC: "KOSync"
 STR_BOOKMARK_OPTION: "Bokmärke"
+STR_DICTIONARY: "Ordbok"
 STR_DISABLED: "Inaktiverad"
 STR_NOTO_SERIF: "Noto Serif"
 STR_NOTO_SANS: "Noto Sans"
@@ -319,6 +341,7 @@ STR_UPLOAD_LOCAL: "Ladda upp lokala framsteg"
 STR_NO_REMOTE_MSG: "Inga fjärrframsteg funna"
 STR_UPLOAD_PROMPT: "Ladda upp nuvarande position?"
 STR_UPLOAD_SUCCESS: "Framsteg uppladdade!"
+STR_ALREADY_SYNCED: "Redan synkroniserad"
 STR_SYNC_FAILED_MSG: "Synkronisering misslyckades"
 STR_SAVE_PROGRESS_FAILED: "Kunde inte spara framsteg"
 STR_SECTION_PREFIX: "Sektion"
@@ -328,6 +351,7 @@ STR_EMBEDDED_STYLE: "Inbäddad stil"
 STR_FOCUS_READING: "Fokusläsning"
 STR_OPDS_SERVER_URL: "OPDS-serveradress"
 STR_PWR_BTN_FOOTNOTE_BACK: "Snabbåtergång från fotnoter"
+STR_BACK_SHORT_TO_FILE_BROWSER: "Snabb tillbaka till filläsaren"
 STR_SET_SLEEP_COVER: "Ställ in omslag"
 STR_FOOTNOTES: "Fotnoter"
 STR_NO_FOOTNOTES: "Inga fotnoter på den här sidan"
@@ -342,6 +366,12 @@ STR_SERVER_NAME: "Servernamn"
 STR_NO_SERVERS: "Inga OPDS-servrar konfigurerade"
 STR_DELETE_SERVER: "Ta bort server"
 STR_OPDS_SERVERS: "OPDS-servrar"
+STR_OPDS_DOWNLOAD_FOLDER: "Hämtningsmapp"
+STR_OPDS_FILENAME_FORMAT: "Filnamnsformat"
+STR_FMT_AUTHOR_TITLE: "Författare - Titel"
+STR_FMT_TITLE_AUTHOR: "Titel - Författare"
+STR_FMT_TITLE: "Titel"
+STR_OPDS_SD_ROOT: "SD-rot"
 STR_AUTO_TURN_ENABLED: "Automatisk vändning aktiverad: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Automatisk vändning (sidor per minut)"
 STR_MANAGE_FONTS: "Hantera teckensnitt"
@@ -387,5 +417,3 @@ STR_FIRMWARE_WRITE_FAILED: "Skrivning till firmware misslyckades"
 STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Stäng inte av!"
 STR_RECOVERY_MODE: "Återställningsläge"
 STR_RECOVERY_MODE_HINT: "Placera firmware.bin i SD-kortroten och välj den"
-STR_ADD_HIDDEN_NETWORK: "Lägg till dolt nätverk..."
-STR_ENTER_WIFI_SSID: "Ange nätverksnamn (SSID)"

lib/I18n/translations/turkish.yaml

@@ -67,11 +67,12 @@ 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_LONG_PRESS_BEHAVIOR: "Uzun basma tuş davranışı"
+STR_LONG_PRESS_BEHAVIOR_OFF: "KAPALI"
+STR_LONG_PRESS_BEHAVIOR_SKIP: "Bölüm atlama"
+STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Yön değiştirme"
 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"
@@ -291,6 +292,11 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u dak"
 STR_SLEEP_NEVER: "Asla"
 STR_STEP_HINT_FRONT: "Ön tuşlar:"
 STR_STEP_HINT_SIDE: "Yan tuşlar:"
+STR_OPDS_DOWNLOAD_FOLDER: "İndirme klasörü"
+STR_OPDS_FILENAME_FORMAT: "Dosya adı biçimi"
+STR_FMT_AUTHOR_TITLE: "Yazar - Başlık"
+STR_FMT_TITLE_AUTHOR: "Başlık - Yazar"
+STR_FMT_TITLE: "Başlık"
 STR_NO_FILES_FOUND: "Dosya bulunamadı"
 STR_NO_FOOTNOTES: "Bu sayfada dipnot yok"
 STR_PREVIEW: "Önizleme"
@@ -306,3 +312,89 @@ STR_TITLE: "Başlık"
 STR_TILT_PAGE_TURN: "Eğerek sayfa çevirme"
 STR_ADD_HIDDEN_NETWORK: "Gizli ağ ekle..."
 STR_ENTER_WIFI_SSID: "Ağ adını girin (SSID)"
+STR_ADD_SERVER: "Sunucu Ekle"
+STR_BOOKMARKS: "Yer İmleri"
+STR_BOOKMARK_ADDED: "Yer imi eklendi."
+STR_BOOKMARK_OPTION: "Yer İmi"
+STR_BOTTOM: "Alt"
+STR_CLOCK: "Saat"
+STR_CLOCK_FORMAT: "Saat Biçimi"
+STR_CLOCK_FORMAT_12H: "12 saat"
+STR_CLOCK_FORMAT_24H: "24 saat"
+STR_CLOCK_SYNC: "Saati Eşitle"
+STR_CLOCK_SYNCED: "Saat Eşitlendi"
+STR_CLOCK_SYNCING: "NTP'den eşitleniyor..."
+STR_CLOCK_SYNC_FAIL: "Eşitleme başarısız"
+STR_CLOCK_SYNC_NOW: "Saati şimdi eşitle"
+STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi bağlı değil"
+STR_CLOCK_SYNC_NO_WIFI_HINT: "Önce Wi-Fi'ye bağlanın, sonra tekrar deneyin."
+STR_CLOCK_SYNC_OK: "Saat eşitlendi"
+STR_CLOCK_UTC_OFFSET: "Saat UTC Farkı"
+STR_CONFIRM_DELETE_BOOKMARK: "Bu yer imi silinsin mi?"
+STR_CONNECTING_SAVED_WIFI: "Kayıtlı Wi-Fi'ye bağlanılıyor..."
+STR_CRASH_DESCRIPTION: "Ayrıntılı rapor crash_report.txt dosyasına kaydedildi. Lütfen hata bildiriminize bu dosyayı ekleyin."
+STR_CRASH_NO_REASON: "(Neden kaydedilmedi)"
+STR_CRASH_REASON: "Çökme nedeni:"
+STR_CRASH_TITLE: "Sistem Çökmesi"
+STR_CURRENT_TIME: "Şu anki saat:"
+STR_DELETE_SERVER: "Sunucuyu Sil"
+STR_DISABLED: "Devre dışı"
+STR_DOWNLOAD_ALL: "Tümünü İndir"
+STR_EOB_CONTINUE_WITH: "Şununla devam et"
+STR_EOB_HOME: "Ana Ekran"
+STR_FINDING_SAVED_WIFI: "Kayıtlı Wi-Fi aranıyor..."
+STR_FIRMWARE_FILE_OPEN_FAILED: "Dosya açılamıyor"
+STR_FIRMWARE_TOO_LARGE: "Firmware, bölümlemeye sığmıyor"
+STR_FIRMWARE_TOO_SMALL: "Firmware dosyası çok küçük"
+STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Cihazı kapatmayın!"
+STR_FIRMWARE_UPDATE_PROMPT: "Firmware güncellensin mi?"
+STR_FIRMWARE_WRITE_FAILED: "Firmware yazılamadı"
+STR_FONT_BROWSER: "Yazı Tipi Tarayıcısı"
+STR_FONT_INSTALLED: "Yazı tipi yüklendi!"
+STR_FONT_INSTALL_FAILED: "Yazı tipi yüklenemedi"
+STR_FORCE_REFRESH: "Ekranı Yenile"
+STR_INDEX_FAILED: "Endeksleme başarısız - geçersiz kitap"
+STR_INSTALLED: "Yüklü"
+STR_INVALID_FIRMWARE: "Geçersiz firmware dosyası"
+STR_KB_HINT_CLEAR_TEXT: "Tüm metni silmek için DEL tuşunu basılı tutun"
+STR_KB_HINT_EDIT_ENTRY: "Girdiyi düzenlemek için UP tuşunu basılı tutun"
+STR_KB_HINT_EXIT_URL_MODE: "URL modundan çıkmak için ABC'ye basın"
+STR_KB_HINT_HIDE_PASSWORD: "Şifreyi gizlemek için RIGHT'ı basılı tutup [***] tuşuna basın"
+STR_KB_HINT_LOWER_SECONDARY: "Küçük harf veya ikincil karakter için SELECT'i basılı tutun"
+STR_KB_HINT_MOVE_CURSOR: "İmleci taşımak için LEFT veya RIGHT'a basın"
+STR_KB_HINT_RETURN_CURSOR: "İmleç konumuna dönmek için LEFT'e basın"
+STR_KB_HINT_RETURN_KEYBOARD: "Klavyeye dönmek için DOWN'a basın"
+STR_KB_HINT_SECONDARY_CHAR: "İkincil karakter için SELECT'i basılı tutun"
+STR_KB_HINT_SHOW_PASSWORD: "Şifreyi göstermek için RIGHT'ı basılı tutup [abc] tuşuna basın"
+STR_KB_HINT_TOGGLE_HIDE_PASSWORD: "Şifreyi gizlemek için [***] tuşuna basın"
+STR_KB_HINT_TOGGLE_SHOW_PASSWORD: "Şifreyi göstermek için [abc] tuşuna basın"
+STR_KB_HINT_UPPER_SECONDARY: "BÜYÜK harf veya ikincil karakter için SELECT'i basılı tutun"
+STR_KB_HINT_URL_SNIPPETS: "Hazır kalıplar için URL'ye basın"
+STR_KB_TIPS: "İpuçları:"
+STR_KOSYNC: "KOSync"
+STR_LOADING_FONT_LIST: "Yazı tipi listesi yükleniyor..."
+STR_LONG_PRESS_MENU: "Uzun Basma Menüsü"
+STR_MANAGE_FONTS: "Yazı Tiplerini Yönet"
+STR_NEXT_FIELD: "Sonraki"
+STR_NEXT_PAGE: "Sonraki Sayfa »"
+STR_NO_BIN_FILES: ".bin dosyası bulunamadı"
+STR_NO_FONTS_AVAILABLE: "Kullanılabilir yazı tipi yok"
+STR_NO_SERVERS: "Yapılandırılmış OPDS sunucusu yok"
+STR_OPDS_SERVERS: "OPDS Sunucuları"
+STR_PREV_PAGE: "« Önceki Sayfa"
+STR_PWR_BTN_FOOTNOTE_BACK: "Dipnottan hızlı dönüş"
+STR_RECOVERY_MODE: "Kurtarma Modu"
+STR_RECOVERY_MODE_HINT: "firmware.bin dosyasını SD kartın köküne koyup seçin"
+STR_RESTARTING_HINT: "Yeniden başlatılıyor... Cihaz yeniden başlamazsa güç düğmesini birkaç saniye basılı tutun."
+STR_SD_FIRMWARE_UPDATE: "SD Karttan Firmware Güncelleme"
+STR_SEARCH: "Ara"
+STR_SELECT_FIRMWARE_FILE: "Firmware dosyası seçin (.bin)"
+STR_SERVER_NAME: "Sunucu Adı"
+STR_SET_SLEEP_COVER: "Kapak Ayarla"
+STR_SHOW_NETWORKS: "Göster"
+STR_THEME_ROUNDEDRAFF: "RoundedRaff"
+STR_TOP: "Üst"
+STR_UPDATE_ALL: "Tümünü Güncelle"
+STR_UPDATE_AVAILABLE: "Güncelle"
+STR_VALIDATING_FIRMWARE: "Firmware doğrulanıyor..."
+STR_XTC_STATUS_BAR: "XTC Durum Çubuğu"

lib/I18n/translations/ukrainian.yaml

@@ -73,6 +73,7 @@ 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: "Немає"
@@ -336,6 +337,11 @@ STR_SERVER_NAME: "Назва сервера"
 STR_NO_SERVERS: "Не налаштовано жодного сервера OPDS"
 STR_DELETE_SERVER: "Видалити сервер"
 STR_OPDS_SERVERS: "Сервери OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Папка завантажень"
+STR_OPDS_FILENAME_FORMAT: "Формат імені файлу"
+STR_FMT_AUTHOR_TITLE: "Автор - Назва"
+STR_FMT_TITLE_AUTHOR: "Назва - Автор"
+STR_FMT_TITLE: "Назва"
 STR_AUTO_TURN_ENABLED: "Автоперегортання увімк: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Автоперегортання (ст/хв)"
 STR_MANAGE_FONTS: "Керування шрифтами"

lib/I18n/translations/valencian.yaml

@@ -79,6 +79,7 @@ STR_EOB_CONTINUE_WITH: "Continua amb"
 STR_SHORT_PWR_BTN: "Pulsació curta 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: "Acció en mantindre premut un botó"
 STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
@@ -348,6 +349,11 @@ STR_SERVER_NAME: "Nom del servidor"
 STR_NO_SERVERS: "No hi ha servidors OPDS configurats"
 STR_DELETE_SERVER: "Elimina el servidor"
 STR_OPDS_SERVERS: "Servidors OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Carpeta de baixades"
+STR_OPDS_FILENAME_FORMAT: "Format del nom de fitxer"
+STR_FMT_AUTHOR_TITLE: "Autor - Títol"
+STR_FMT_TITLE_AUTHOR: "Títol - Autor"
+STR_FMT_TITLE: "Títol"
 STR_MANAGE_FONTS: "Gestiona les fonts"
 STR_FONT_BROWSER: "Navegador de fonts"
 STR_LOADING_FONT_LIST: "S'està carregant la llista de fonts..."

lib/I18n/translations/vietnamese.yaml

@@ -73,6 +73,7 @@ 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 bằng cảm ứng"
 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"
@@ -335,6 +336,11 @@ STR_SERVER_NAME: "Tên máy chủ"
 STR_NO_SERVERS: "Chưa cấu hình máy chủ OPDS"
 STR_DELETE_SERVER: "Xóa máy chủ"
 STR_OPDS_SERVERS: "Máy chủ OPDS"
+STR_OPDS_DOWNLOAD_FOLDER: "Thư mục tải xuống"
+STR_OPDS_FILENAME_FORMAT: "Định dạng tên tệp"
+STR_FMT_AUTHOR_TITLE: "Tác giả - Tựa đề"
+STR_FMT_TITLE_AUTHOR: "Tựa đề - Tác giả"
+STR_FMT_TITLE: "Tựa đề"
 STR_AUTO_TURN_ENABLED: "Tự lật trang: "
 STR_AUTO_TURN_PAGES_PER_MIN: "Tự lật (số trang mỗi phút)"
 STR_MANAGE_FONTS: "Quản lý phông chữ"

lib/JpegToBmpConverter/JpegToBmpConverter.cpp

@@ -5,6 +5,8 @@
 #include <JPEGDEC.h>
 #include <Logging.h>
 #include <Memory.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
 #include <cstdio>
 #include <cstring>
@@ -169,11 +171,22 @@ constexpr uint32_t FP_ONE = 1UL << 16;
 // Static file pointer for JPEGDEC open callback.
 // Safe in single-threaded embedded context; never accessed concurrently.
 static HalFile* s_jpegFile = nullptr;
+static uint8_t s_jpegIoSinceYield = 0;
+
+static void yieldToIdle() { vTaskDelay(1); }
+
+static void yieldDuringJpegIo() {
+  if (++s_jpegIoSinceYield < 4) return;
+  s_jpegIoSinceYield = 0;
+  yieldToIdle();
+}
 
 void* bmpJpegOpen(const char* /*filename*/, int32_t* size) {
   if (!s_jpegFile || !*s_jpegFile) return nullptr;
+  s_jpegIoSinceYield = 0;
   s_jpegFile->seek(0);
   *size = static_cast<int32_t>(s_jpegFile->size());
+  yieldDuringJpegIo();
   return s_jpegFile;
 }
 
@@ -187,6 +200,7 @@ int32_t bmpJpegRead(JPEGFILE* pFile, uint8_t* pBuf, int32_t len) {
   int32_t n = f->read(pBuf, len);
   if (n < 0) n = 0;
   pFile->iPos += n;
+  yieldDuringJpegIo();
   return n;
 }
 
@@ -194,6 +208,7 @@ int32_t bmpJpegSeek(JPEGFILE* pFile, int32_t pos) {
   auto* f = reinterpret_cast<HalFile*>(pFile->fHandle);
   if (!f || !f->seek(pos)) return -1;
   pFile->iPos = pos;
+  yieldDuringJpegIo();
   return pos;
 }
 
@@ -236,9 +251,23 @@ struct BmpConvertCtx {
   std::unique_ptr<FloydSteinbergDitherer> fsDitherer;
   std::unique_ptr<Atkinson1BitDitherer> atkinson1BitDitherer;
 
+  uint8_t rowsSinceYield;
+  uint8_t blocksSinceYield;
   bool error;
 };
 
+static void yieldDuringDecode(BmpConvertCtx* ctx) {
+  if (++ctx->rowsSinceYield < 8) return;
+  ctx->rowsSinceYield = 0;
+  yieldToIdle();
+}
+
+static void yieldDuringDecodeBlock(BmpConvertCtx* ctx) {
+  if (++ctx->blocksSinceYield < 16) return;
+  ctx->blocksSinceYield = 0;
+  yieldToIdle();
+}
+
 // Write a fully-assembled output row (grayscale bytes, length outWidth) to BMP
 static void writeOutputRow(BmpConvertCtx* ctx, const uint8_t* srcRow, int outY) {
   memset(ctx->bmpRow.get(), 0, ctx->bytesPerRow);
@@ -274,6 +303,7 @@ static void writeOutputRow(BmpConvertCtx* ctx, const uint8_t* srcRow, int outY)
   }
 
   ctx->bmpOut->write(ctx->bmpRow.get(), ctx->bytesPerRow);
+  yieldDuringDecode(ctx);
 }
 
 // Matches the progressive-JPEG smoothing used by JpegToFramebufferConverter, but stays
@@ -396,6 +426,7 @@ static void flushScaledRow(BmpConvertCtx* ctx) {
 
   ctx->bmpOut->write(ctx->bmpRow.get(), ctx->bytesPerRow);
   ctx->currentOutY++;
+  yieldDuringDecode(ctx);
 }
 
 // JPEGDEC draw callback — receives one MCU-width × MCU-height block at a time,
@@ -405,6 +436,7 @@ static void flushScaledRow(BmpConvertCtx* ctx) {
 int bmpDrawCallback(JPEGDRAW* pDraw) {
   auto* ctx = reinterpret_cast<BmpConvertCtx*>(pDraw->pUser);
   if (!ctx || ctx->error) return 0;
+  yieldDuringDecodeBlock(ctx);
 
   const uint8_t* pixels = reinterpret_cast<uint8_t*>(pDraw->pPixels);
   const int stride = pDraw->iWidth;
@@ -599,6 +631,8 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
   ctx.smoothScaleY_fp = interpolationStep(ctx.srcHeight, outHeight);
   ctx.smoothNextOutY = 0;
   ctx.smoothPrevY = -1;
+  ctx.rowsSinceYield = 0;
+  ctx.blocksSinceYield = 0;
   ctx.error = false;
 
   // MCU row buffer: MAX_MCU_HEIGHT rows × decoded srcWidth columns of grayscale

lib/KOReaderSync/KOReaderCredentialStore.cpp

@@ -5,16 +5,27 @@
 #include <ObfuscationUtils.h>
 
 namespace {
-// Default sync server URL
-constexpr char DEFAULT_SERVER_URL[] = "https://sync.koreader.rocks:443";
+// Default sync server URL. crosspoint-sync speaks the full KOSync protocol, so
+// pointing at any other kosync server (e.g. https://sync.koreader.rocks:443)
+// still works via the custom server URL setting.
+constexpr char DEFAULT_SERVER_URL[] = "https://sync.crosspointreader.com";
+
+// Default before config version 2. Configs saved without a version stamp and an
+// empty serverUrl were implicitly syncing here — they get pinned on upgrade.
+constexpr char LEGACY_DEFAULT_SERVER_URL[] = "https://sync.koreader.rocks:443";
+
+// Bumped when a change to defaults would alter behavior for existing configs.
+constexpr uint8_t CONFIG_VERSION = 2;
 }  // namespace
 
 void KOReaderCredentialStore::toJson(JsonDocument& doc) const {
+  doc["cfgVersion"] = CONFIG_VERSION;
   doc["username"] = getUsername();
   doc["password_obf"] = obfuscation::obfuscateToBase64(getPassword());
   doc["serverUrl"] = getServerUrl();
   doc["matchMethod"] = static_cast<uint8_t>(getMatchMethod());
   doc["sendMetadata"] = getSendMetadata();
+  doc["syncBehavior"] = static_cast<uint8_t>(getSyncBehavior());
 }
 
 bool KOReaderCredentialStore::fromJson(JsonVariantConst doc) {
@@ -26,6 +37,19 @@ bool KOReaderCredentialStore::fromJson(JsonVariantConst doc) {
   setCredentials(user, pass);
   setServerUrl(doc["serverUrl"] | "");
 
+  // The default server changed in config v2 (sync.koreader.rocks -> crosspoint-sync).
+  // A pre-v2 config with credentials and no explicit URL was actively syncing
+  // against the old default — pin that URL so the upgrade doesn't switch servers
+  // out from under the user. Fresh setups get the new default.
+  const uint8_t cfgVersion = doc["cfgVersion"] | (uint8_t)1;
+  if (cfgVersion < CONFIG_VERSION) {
+    if (getServerUrl().empty() && hasCredentials()) {
+      LOG_DBG("KRS", "Pre-v2 config used the old default server; pinning %s", LEGACY_DEFAULT_SERVER_URL);
+      setServerUrl(LEGACY_DEFAULT_SERVER_URL);
+    }
+    needsResave = true;  // stamp cfgVersion so this migration runs once
+  }
+
   uint8_t method = doc["matchMethod"] | (uint8_t)0;
   if (method <= static_cast<uint8_t>(DocumentMatchMethod::BINARY)) {
     setMatchMethod(static_cast<DocumentMatchMethod>(method));
@@ -35,6 +59,18 @@ bool KOReaderCredentialStore::fromJson(JsonVariantConst doc) {
   }
   setSendMetadata(doc["sendMetadata"] | false);
 
+  const JsonVariantConst behaviorValue = doc["syncBehavior"];
+  const bool missingBehavior = behaviorValue.isNull();
+  uint8_t behavior = behaviorValue | static_cast<uint8_t>(KOReaderSyncBehavior::ASK_EVERY_TIME);
+  if (behavior <= static_cast<uint8_t>(KOReaderSyncBehavior::SMART)) {
+    setSyncBehavior(static_cast<KOReaderSyncBehavior>(behavior));
+    needsResave = needsResave || missingBehavior;
+  } else {
+    LOG_DBG("KRS", "Invalid syncBehavior %u in JSON, resetting to ASK_EVERY_TIME", behavior);
+    setSyncBehavior(KOReaderSyncBehavior::ASK_EVERY_TIME);
+    needsResave = true;
+  }
+
   if (needsResave) {
     LOG_DBG("KRS", "Resaved KOReader credentials to update format");
     saveToFile();
@@ -105,3 +141,11 @@ void KOReaderCredentialStore::setSendMetadata(bool enabled) {
   sendMetadata = enabled;
   LOG_DBG("KRS", "Set send metadata: %s", enabled ? "true" : "false");
 }
+
+void KOReaderCredentialStore::setSyncBehavior(KOReaderSyncBehavior behavior) {
+  if (static_cast<uint8_t>(behavior) > static_cast<uint8_t>(KOReaderSyncBehavior::SMART)) {
+    behavior = KOReaderSyncBehavior::ASK_EVERY_TIME;
+  }
+  syncBehavior = behavior;
+  LOG_DBG("KRS", "Set sync behavior: %s", behavior == KOReaderSyncBehavior::SMART ? "Smart" : "Ask");
+}

lib/KOReaderSync/KOReaderCredentialStore.h

@@ -11,6 +11,12 @@ enum class DocumentMatchMethod : uint8_t {
   BINARY = 1,    // Match by partial MD5 of file content (more accurate, but files must be identical)
 };
 
+// How manual "Sync Progress" resolves differences after fetching remote progress.
+enum class KOReaderSyncBehavior : uint8_t {
+  ASK_EVERY_TIME = 0,  // Preserve legacy behavior: always show Apply/Upload choices.
+  SMART = 1,           // Auto-resolve simple cases using furthest progress.
+};
+
 /**
  * Singleton class for storing KOReader sync credentials on the SD card.
  * Passwords are XOR-obfuscated with the device's unique hardware MAC address
@@ -25,6 +31,7 @@ class KOReaderCredentialStore : public PersistableStore<KOReaderCredentialStore>
   std::string serverUrl;                                            // Custom sync server URL (empty = default)
   DocumentMatchMethod matchMethod = DocumentMatchMethod::FILENAME;  // Default to filename for compatibility
   bool sendMetadata = false;                                        // Send document metadata with progress sync
+  KOReaderSyncBehavior syncBehavior = KOReaderSyncBehavior::SMART;
 
   // Private constructor for singleton
   KOReaderCredentialStore() = default;
@@ -65,6 +72,10 @@ class KOReaderCredentialStore : public PersistableStore<KOReaderCredentialStore>
   // Send metadata setting
   void setSendMetadata(bool enabled);
   bool getSendMetadata() const { return sendMetadata; }
+
+  // Sync behavior
+  void setSyncBehavior(KOReaderSyncBehavior behavior);
+  KOReaderSyncBehavior getSyncBehavior() const { return syncBehavior; }
 };
 
 // Helper macro to access credential store

lib/KOReaderSync/KOReaderSyncClient.cpp

@@ -22,21 +22,7 @@ constexpr char DEVICE_ID[] = "crosspoint-reader";
 // footprint is smaller than mbedTLS's old ~48KB peak, but keep a conservative
 // floor. Check both total free heap and largest contiguous block so fragmented
 // heap does not fall through into a failed TLS allocation path.
-// MEMFIX-PORT: TLS heap gate; portable
-// Field data (July 2026): launching sync from a reader session lands at
-// 51.9-58.2 KB free / 42-53 KB maxAlloc after WiFi comes up. wolfSSL handles
-// allocation failure by returning MEMORY_E (no abort under -fno-exceptions),
-// so an optimistic attempt degrades to the same clean "sync failed" as the
-// gate — the gate only needs to keep out states where a doomed handshake
-// would waste tens of seconds, not guarantee success.
-//
-// Free and largest-block have separate requirements: with SP ECC
-// (WOLFSSL_HAVE_SP_ECC) the handshake's crypto uses fixed 256-bit arrays, so
-// the largest single TLS allocation is the ~17 KB wolfSSL record buffer, not
-// a run of fast-math bignums. A handshake was measured succeeding inside a
-// 43 KB largest block; requiring 50 KB contiguous refused syncs that fit.
-constexpr uint32_t MIN_FREE_FOR_TLS = 50000;
-constexpr uint32_t MIN_BLOCK_FOR_TLS = 20000;
+constexpr uint32_t MIN_HEAP_FOR_TLS = 55000;
 
 // Apply the shared KOSync auth headers after begin(). x-auth-* is the native
 // KOSync scheme; Basic auth is added for Calibre-Web-Automated compatibility.
@@ -53,9 +39,9 @@ void applyAuthHeaders(freeink::SecureHttpClient& http) {
 bool insufficientHeap() {
   const uint32_t freeHeap = ESP.getFreeHeap();
   const uint32_t maxAllocHeap = ESP.getMaxAllocHeap();
-  if (freeHeap < MIN_FREE_FOR_TLS || maxAllocHeap < MIN_BLOCK_FOR_TLS) {
-    LOG_ERR("KOSync", "Insufficient heap for TLS handshake: %u bytes free (need %u), %u max alloc (need %u)", freeHeap,
-            MIN_FREE_FOR_TLS, maxAllocHeap, MIN_BLOCK_FOR_TLS);
+  if (freeHeap < MIN_HEAP_FOR_TLS || maxAllocHeap < MIN_HEAP_FOR_TLS) {
+    LOG_ERR("KOSync", "Insufficient heap for TLS handshake: %u bytes free, %u max alloc (need %u)", freeHeap,
+            maxAllocHeap, MIN_HEAP_FOR_TLS);
     return true;
   }
   return false;
@@ -92,6 +78,43 @@ KOReaderSyncClient::Error KOReaderSyncClient::authenticate() {
   return SERVER_ERROR;
 }
 
+KOReaderSyncClient::Error KOReaderSyncClient::createUser() {
+  lastHttpCode = 0;
+  if (!KOREADER_STORE.hasCredentials()) {
+    LOG_DBG("KOSync", "No credentials configured");
+    return NO_CREDENTIALS;
+  }
+
+  const std::string url = KOREADER_STORE.getBaseUrl() + "/users/create";
+  LOG_DBG("KOSync", "Creating account: %s (heap: %u)", url.c_str(), (unsigned)ESP.getFreeHeap());
+  if (insufficientHeap()) return LOW_MEMORY;
+
+  JsonDocument doc;
+  doc["username"] = KOREADER_STORE.getUsername();
+  doc["password"] = KOREADER_STORE.getMd5Password();
+  std::string body;
+  serializeJson(doc, body);
+
+  freeink::SecureHttpClient http;
+  http.setInsecure();
+  if (!http.begin(url)) {
+    LOG_ERR("KOSync", "Bad URL: %s", url.c_str());
+    return NETWORK_ERROR;
+  }
+  http.addHeader("Accept", "application/vnd.koreader.v1+json");
+  http.addHeader("Content-Type", "application/json");
+  const int httpCode = http.sendRequest("POST", body);
+  http.end();
+  lastHttpCode = httpCode;
+
+  LOG_DBG("KOSync", "Create user response: %d", httpCode);
+
+  if (httpCode <= 0) return NETWORK_ERROR;
+  if (httpCode == 200 || httpCode == 201) return OK;
+  if (httpCode == 402) return USER_EXISTS;
+  return SERVER_ERROR;
+}
+
 KOReaderSyncClient::Error KOReaderSyncClient::getProgress(const std::string& documentHash,
                                                           KOReaderProgress& outProgress) {
   lastHttpCode = 0;
@@ -138,6 +161,24 @@ KOReaderSyncClient::Error KOReaderSyncClient::getProgress(const std::string& doc
     outProgress.deviceId = doc["device_id"].as<std::string>();
     outProgress.timestamp = doc["timestamp"].as<int64_t>();
 
+    // Extended crosspoint-sync field; absent on plain kosync servers.
+    outProgress.position.reset();
+    const JsonObjectConst pos = doc["position"].as<JsonObjectConst>();
+    if (!pos.isNull()) {
+      KOReaderRichPosition rich;
+      rich.pctQ = pos["pctQ"].as<uint32_t>();
+      rich.spineIndex = pos["spine"].as<uint16_t>();
+      rich.pageNumber = pos["page"].as<uint16_t>();
+      const uint16_t pages = pos["pages"].as<uint16_t>();
+      rich.totalPages = pages > 0 ? pages : 1;
+      const uint16_t para = pos["para"].as<uint16_t>();
+      if (para > 0) rich.paragraphIndex = para;
+      rich.xpath = pos["xpath"].as<const char*>() ? pos["xpath"].as<const char*>() : "";
+      LOG_DBG("KOSync", "Got rich position: spine=%u page=%u/%u para=%u", rich.spineIndex, rich.pageNumber,
+              rich.totalPages, para);
+      outProgress.position = std::move(rich);
+    }
+
     LOG_DBG("KOSync", "Got progress: %.2f%% at %s", outProgress.percentage * 100, outProgress.progress.c_str());
     return OK;
   }
@@ -172,6 +213,18 @@ KOReaderSyncClient::Error KOReaderSyncClient::updateProgress(const KOReaderProgr
   doc["percentage"] = progress.percentage;
   doc["device"] = DEVICE_NAME;
   doc["device_id"] = DEVICE_ID;
+  if (progress.position.has_value()) {
+    // Extended crosspoint-sync field; kosync servers ignore unknown keys.
+    const auto& p = *progress.position;
+    auto pos = doc["position"].to<JsonObject>();
+    pos["pctQ"] = p.pctQ;
+    pos["spine"] = p.spineIndex;
+    pos["page"] = p.pageNumber;
+    pos["pages"] = p.totalPages;
+    if (p.paragraphIndex.has_value()) pos["para"] = *p.paragraphIndex;
+    // Server rejects the whole position object if xpath exceeds 120 bytes.
+    if (!p.xpath.empty() && p.xpath.size() <= 120) pos["xpath"] = p.xpath;
+  }
 
   std::string body;
   serializeJson(doc, body);

lib/KOReaderSync/KOReaderSyncClient.h

@@ -14,17 +14,33 @@ struct KOReaderMetadata {
   std::string authors;   // Author(s) from EPUB metadata
 };
 
+/**
+ * Rich CrossPoint position sent alongside progress uploads. Maps 1:1 onto the
+ * crosspoint-sync extended `position` object (see crosspoint-sync docs/API.md).
+ * The official KOSync server ignores unknown fields; crosspoint-sync stores it
+ * so CrossPoint<->CrossPoint sync is lossless instead of xpath-approximated.
+ */
+struct KOReaderRichPosition {
+  uint32_t pctQ = 0;                       // Percentage quantized 0..1,000,000 (authoritative)
+  uint16_t spineIndex = 0;                 // Spine (chapter) index
+  uint16_t pageNumber = 0;                 // Page within spine (layout-dependent hint)
+  uint16_t totalPages = 1;                 // Spine page count (layout-dependent hint)
+  std::optional<uint16_t> paragraphIndex;  // Synthetic 1-based paragraph index
+  std::string xpath;                       // KOReader-style xpath (server cap: 120 bytes)
+};
+
 /**
  * Progress data from KOReader sync server.
  */
 struct KOReaderProgress {
-  std::string document;                      // Document hash
-  std::string progress;                      // XPath-like progress string
-  float percentage;                          // Progress percentage (0.0 to 1.0)
-  std::string device;                        // Device name
-  std::string deviceId;                      // Device ID
-  int64_t timestamp;                         // Unix timestamp of last update
-  std::optional<KOReaderMetadata> metadata;  // Optional document metadata
+  std::string document;                          // Document hash
+  std::string progress;                          // XPath-like progress string
+  float percentage;                              // Progress percentage (0.0 to 1.0)
+  std::string device;                            // Device name
+  std::string deviceId;                          // Device ID
+  int64_t timestamp;                             // Unix timestamp of last update
+  std::optional<KOReaderMetadata> metadata;      // Optional document metadata
+  std::optional<KOReaderRichPosition> position;  // Optional rich position (crosspoint-sync servers only)
 };
 
 /**
@@ -43,7 +59,17 @@ struct KOReaderProgress {
  */
 class KOReaderSyncClient {
  public:
-  enum Error { OK = 0, NO_CREDENTIALS, NETWORK_ERROR, AUTH_FAILED, SERVER_ERROR, JSON_ERROR, NOT_FOUND, LOW_MEMORY };
+  enum Error {
+    OK = 0,
+    NO_CREDENTIALS,
+    NETWORK_ERROR,
+    AUTH_FAILED,
+    SERVER_ERROR,
+    JSON_ERROR,
+    NOT_FOUND,
+    LOW_MEMORY,
+    USER_EXISTS
+  };
 
   /**
    * Authenticate with the sync server (validate credentials).
@@ -51,6 +77,14 @@ class KOReaderSyncClient {
    */
   static Error authenticate();
 
+  /**
+   * Register a new account on the sync server using the stored credentials
+   * (POST /users/create with the MD5 auth key — the server never sees the
+   * plain password).
+   * @return OK on success, USER_EXISTS if the username is taken
+   */
+  static Error createUser();
+
   /**
    * Get reading progress for a document.
    * @param documentHash The document hash (from KOReaderDocumentId)

lib/KOReaderSync/ProgressMapper.cpp

@@ -724,6 +724,59 @@ SavedProgressPosition ProgressMapper::toSavedProgress(const std::shared_ptr<Epub
   return result;
 }
 
+std::optional<CrossPointPosition> ProgressMapper::fromRichPosition(const std::shared_ptr<Epub>& epub,
+                                                                   const KOReaderRichPosition& rich,
+                                                                   GfxRenderer& renderer) {
+  const int spineCount = epub->getSpineItemsCount();
+  if (static_cast<int>(rich.spineIndex) >= spineCount) {
+    LOG_DBG("PM", "Rich position spine %u out of range (%d spine items)", rich.spineIndex, spineCount);
+    return std::nullopt;
+  }
+
+  CrossPointPosition result{};
+  result.spineIndex = rich.spineIndex;
+
+  Section tempSection(epub, result.spineIndex, renderer);
+  const auto cachedCount = tempSection.getCachedPageCount();
+  if (!cachedCount || *cachedCount <= 0) {
+    // No local layout for the target spine yet; the percentage/xpath mapping
+    // handles density estimation better than a blind copy of remote pages.
+    LOG_DBG("PM", "Rich position spine %u has no cached page count", rich.spineIndex);
+    return std::nullopt;
+  }
+  result.totalPages = *cachedCount;
+
+  const int remotePages = rich.totalPages > 0 ? rich.totalPages : 1;
+  if (result.totalPages == remotePages) {
+    // Identical layout (same render settings) — the page transfers losslessly.
+    result.pageNumber = std::min<int>(rich.pageNumber, result.totalPages - 1);
+    LOG_DBG("PM", "Rich position exact: spine=%d page=%d/%d", result.spineIndex, result.pageNumber, result.totalPages);
+    return result;
+  }
+
+  // Layout differs; the paragraph LUT is the most accurate anchor we have.
+  if (rich.paragraphIndex.has_value()) {
+    const auto lutPage = tempSection.getPageForParagraphIndex(*rich.paragraphIndex);
+    if (lutPage.has_value()) {
+      result.paragraphIndex = *rich.paragraphIndex;
+      result.hasParagraphIndex = true;
+      result.pageNumber = std::min<int>(*lutPage, result.totalPages - 1);
+      LOG_DBG("PM", "Rich position para %u -> spine=%d page=%d/%d", *rich.paragraphIndex, result.spineIndex,
+              result.pageNumber, result.totalPages);
+      return result;
+    }
+  }
+
+  // Fall back to the intra-spine page fraction.
+  const float intra =
+      (remotePages > 1) ? static_cast<float>(rich.pageNumber) / static_cast<float>(remotePages - 1) : 0.0f;
+  result.pageNumber = std::max(
+      0, std::min(static_cast<int>(intra * static_cast<float>(result.totalPages - 1) + 0.5f), result.totalPages - 1));
+  LOG_DBG("PM", "Rich position scaled: spine=%d remote %u/%d -> page=%d/%d", result.spineIndex, rich.pageNumber,
+          remotePages, result.pageNumber, result.totalPages);
+  return result;
+}
+
 CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr<Epub>& epub, const SavedProgressPosition& koPos,
                                                 GfxRenderer& renderer, int currentSpineIndex,
                                                 int totalPagesInCurrentSpine, int fallbackTotalPages) {

lib/KOReaderSync/ProgressMapper.h

@@ -3,8 +3,11 @@
 #include <GfxRenderer.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
+#include "KOReaderSyncClient.h"
+
 /**
  * CrossPoint position representation.
  */
@@ -65,6 +68,20 @@ class ProgressMapper {
                                          GfxRenderer& renderer, int currentSpineIndex = -1,
                                          int totalPagesInCurrentSpine = 0, int fallbackTotalPages = 0);
 
+  /**
+   * Convert a rich CrossPoint position (downloaded from a crosspoint-sync
+   * server) directly to a CrossPoint position, without XPath approximation.
+   * When the local layout matches the uploader's (same spine page count) the
+   * page transfers losslessly; otherwise the paragraph LUT or the intra-spine
+   * page fraction is used.
+   *
+   * @return The position, or std::nullopt when the rich position cannot be
+   *         applied (spine out of range, no section cache) and the caller
+   *         should fall back to toCrossPoint().
+   */
+  static std::optional<CrossPointPosition> fromRichPosition(const std::shared_ptr<Epub>& epub,
+                                                            const KOReaderRichPosition& rich, GfxRenderer& renderer);
+
  private:
   /**
    * Generate a fallback XPath by streaming the spine item's XHTML and resolving

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,16 @@ void logPrintf(const char* level, const char* origin, const char* format, ...) {
     }
   }
   va_end(args);
+#if FREEINK_LOG_TRANSPORT == FREEINK_LOG_TRANSPORT_ROM_PRINTF
+  // IDF/ROM console path for boards monitored over USB-Serial-JTAG, where the
+  // HWCDC `operator bool` reads false under `pio device monitor` and logs would
+  // otherwise be silently dropped (e.g. Sticky).
+  esp_rom_printf("%s", buf);
+#else
   if (logSerial) {
     logSerial.print(buf);
   }
+#endif
   addToLogRingBuffer(buf);
 }
 

lib/Logging/Logging.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#include <Arduino.h>
 #include <HardwareSerial.h>
+#if defined(ARDUINO_USB_CDC_ON_BOOT) && ARDUINO_USB_CDC_ON_BOOT
+#include <HWCDC.h>
+#endif
 
 #include <string>
 
@@ -27,7 +31,13 @@ won't trigger deprecation warnings.
 #define LOG_LEVEL 0
 #endif
 
+#if defined(ARDUINO_USB_CDC_ON_BOOT) && ARDUINO_USB_CDC_ON_BOOT
 static HWCDC& logSerial = Serial;
+#define LOG_SERIAL_HAS_TX_TIMEOUT 1
+#else
+static HardwareSerial& logSerial = Serial;
+#define LOG_SERIAL_HAS_TX_TIMEOUT 0
+#endif
 
 void logPrintf(const char* level, const char* origin, const char* format, ...);
 

lib/PngToBmpConverter/PngToBmpConverter.cpp

@@ -4,6 +4,8 @@
 #include <HalStorage.h>
 #include <InflateStream.h>
 #include <Logging.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
 #include <cstdio>
 #include <cstring>
@@ -72,6 +74,12 @@ enum PngFilter : uint8_t {
   PNG_FILTER_PAETH = 4,
 };
 
+void yieldDuringDecode(uint8_t& rowsSinceYield) {
+  if (++rowsSinceYield < 8) return;
+  rowsSinceYield = 0;
+  vTaskDelay(1);
+}
+
 // Read a big-endian 32-bit value from file
 bool readBE32(HalFile& file, uint32_t& value) {
   uint8_t buf[4];
@@ -659,6 +667,7 @@ bool PngToBmpConverter::pngFileToBmpStreamInternal(HalFile& pngFile, Print& bmpO
   }
 
   bool success = true;
+  uint8_t rowsSinceYield = 0;
 
   // Process each scanline
   for (uint32_t y = 0; y < height; y++) {
@@ -710,6 +719,7 @@ bool PngToBmpConverter::pngFileToBmpStreamInternal(HalFile& pngFile, Print& bmpO
           fsDitherer->nextRow();
       }
       bmpOut.write(rowBuffer, bytesPerRow);
+      yieldDuringDecode(rowsSinceYield);
     } else {
       // Area-averaging scaling (same as JpegToBmpConverter)
       for (int outX = 0; outX < outWidth; outX++) {
@@ -778,6 +788,7 @@ bool PngToBmpConverter::pngFileToBmpStreamInternal(HalFile& pngFile, Print& bmpO
 
         bmpOut.write(rowBuffer, bytesPerRow);
         currentOutY++;
+        yieldDuringDecode(rowsSinceYield);
 
         nextOutY_srcStart = static_cast<uint32_t>(currentOutY + 1) * scaleY_fp;
 

lib/Xtc/Xtc.cpp

@@ -10,6 +10,16 @@
 #include <Bitmap.h>
 #include <HalStorage.h>
 #include <Logging.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+namespace {
+void yieldDuringThumbnail(uint8_t& rowsSinceYield) {
+  if (++rowsSinceYield < 8) return;
+  rowsSinceYield = 0;
+  vTaskDelay(1);
+}
+}  // namespace
 
 bool Xtc::load() {
   LOG_DBG("XTC", "Loading XTC: %s", filepath.c_str());
@@ -380,6 +390,7 @@ bool Xtc::generateThumbBmp(int height) const {
   const uint8_t* plane2 = (bitDepth == 2) ? pageBuffer + planeSize : nullptr;
   const size_t colBytes = (bitDepth == 2) ? ((pageInfo.height + 7) / 8) : 0;
   const size_t srcRowBytes = (bitDepth == 1) ? ((pageInfo.width + 7) / 8) : 0;
+  uint8_t rowsSinceYield = 0;
 
   for (uint16_t dstY = 0; dstY < thumbHeight; dstY++) {
     memset(rowBuffer, 0xFF, rowSize);  // Start with all white (bit 1)
@@ -471,6 +482,7 @@ bool Xtc::generateThumbBmp(int height) const {
 
     // Write row (already padded to 4-byte boundary by rowSize)
     thumbBmp.write(rowBuffer, rowSize);
+    yieldDuringThumbnail(rowsSinceYield);
   }
 
   free(rowBuffer);

lib/hal/HalClock.cpp

@@ -5,46 +5,11 @@
 #include <esp_sntp.h>
 #include <time.h>
 
-#include <cassert>
-
 HalClock halClock;  // Singleton instance
 
-// DS3231 register layout (BCD encoded):
-//   0x00: Seconds  (bits 6-4 = tens, bits 3-0 = ones)
-//   0x01: Minutes  (bits 6-4 = tens, bits 3-0 = ones)
-//   0x02: Hours    (bit 6 = 12/24 mode, bits 5-4 = tens, bits 3-0 = ones)
-
-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() {
-  if (!gpio.deviceIsX3()) {
-    _available = false;
-    return;
-  }
-
-  // I2C is already initialised by HalPowerManager::begin() for X3.
-  // Probe the DS3231 by reading the seconds register.
-  Wire.beginTransmission(I2C_ADDR_DS3231);
-  Wire.write(DS3231_SEC_REG);
-  if (Wire.endTransmission(false) != 0) {
-    LOG_INF("CLK", "DS3231 RTC not found");
-    _available = false;
-    return;
-  }
-  Wire.requestFrom(I2C_ADDR_DS3231, (uint8_t)1);
-  if (Wire.available() < 1) {
-    _available = false;
-    return;
-  }
-  Wire.read();  // discard — just testing connectivity
-
-  _available = true;
-  LOG_INF("CLK", "DS3231 RTC found");
-
-  // Prime the cache with an initial read
-  uint8_t h, m;
-  getTime(h, m);
+  _available = _sdkRtc.begin();
+  LOG_INF("CLK", _available ? "SDK RTC found" : "RTC not found");
 }
 
 bool HalClock::getTime(uint8_t& hour, uint8_t& minute) const {
@@ -57,44 +22,18 @@ bool HalClock::getTime(uint8_t& hour, uint8_t& minute) const {
     return true;
   }
 
-  // Read 3 bytes starting at register 0x00: seconds, minutes, hours
-  Wire.beginTransmission(I2C_ADDR_DS3231);
-  Wire.write(DS3231_SEC_REG);
-  if (Wire.endTransmission(false) != 0) {
+  Rtc::DateTime dt;
+  if (!_sdkRtc.now(dt)) {
     if (!_hasCachedTime) return false;
     _lastPollMs = now;
     hour = _cachedHour;
     minute = _cachedMinute;
     return true;
   }
-  Wire.requestFrom(I2C_ADDR_DS3231, (uint8_t)3);
-  if (Wire.available() < 3) {
-    if (!_hasCachedTime) return false;
-    _lastPollMs = now;
-    hour = _cachedHour;
-    minute = _cachedMinute;
-    return true;
-  }
-
-  Wire.read();  // seconds — not needed
-  const uint8_t rawMin = Wire.read();
-  const uint8_t rawHour = Wire.read();
-
-  _cachedMinute = bcdToDec(rawMin & 0x7F);
-  // Handle 12/24h mode: bit 6 high = 12h mode
-  if (rawHour & 0x40) {
-    // 12h mode: bit 5 = PM, bits 4-0 = hours (1-12)
-    uint8_t h12 = bcdToDec(rawHour & 0x1F);
-    bool pm = rawHour & 0x20;
-    if (h12 == 12) h12 = 0;
-    _cachedHour = pm ? (h12 + 12) : h12;
-  } else {
-    // 24h mode: bits 5-0 = hours (0-23)
-    _cachedHour = bcdToDec(rawHour & 0x3F);
-  }
+  _cachedHour = dt.hour;
+  _cachedMinute = dt.minute;
   _lastPollMs = now;
   _hasCachedTime = true;
-
   hour = _cachedHour;
   minute = _cachedMinute;
   return true;
@@ -127,28 +66,6 @@ bool HalClock::formatTime(char* buf, size_t bufSize, uint8_t utcOffsetQuarterHou
   return true;
 }
 
-bool HalClock::writeTimeToRTC(uint8_t hour, uint8_t minute, uint8_t second) {
-  assert(hour < 24);
-  assert(minute < 60);
-  assert(second < 60);
-  Wire.beginTransmission(I2C_ADDR_DS3231);
-  Wire.write(DS3231_SEC_REG);    // Start at register 0x00
-  Wire.write(decToBcd(second));  // 0x00: Seconds
-  Wire.write(decToBcd(minute));  // 0x01: Minutes
-  Wire.write(decToBcd(hour));    // 0x02: Hours (24h mode, bit 6 = 0)
-  if (Wire.endTransmission() != 0) {
-    LOG_ERR("CLK", "Failed to write time to DS3231");
-    return false;
-  }
-
-  // Invalidate cache so next read fetches fresh data
-  _lastPollMs = 0;
-  _cachedHour = hour;
-  _cachedMinute = minute;
-  _hasCachedTime = true;
-  return true;
-}
-
 bool HalClock::syncFromNTP() {
   if (!_available) return false;
 
@@ -168,8 +85,21 @@ bool HalClock::syncFromNTP() {
       struct tm timeinfo;
       gmtime_r(&now, &timeinfo);
 
-      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);
+      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;

lib/hal/HalClock.h

@@ -1,15 +1,14 @@
 #pragma once
 
 #include <Arduino.h>
-#include <Wire.h>
-
-#include "HalGPIO.h"
+#include <Rtc.h>
 
 class HalClock;
 extern HalClock halClock;  // Singleton
 
 class HalClock {
   bool _available = false;
+  mutable Rtc _sdkRtc;
   mutable uint8_t _cachedHour = 0;
   mutable uint8_t _cachedMinute = 0;
   mutable bool _hasCachedTime = false;
@@ -18,10 +17,10 @@ class HalClock {
   static constexpr unsigned long CLOCK_POLL_MS = 10000;  // 10 seconds
 
  public:
-  // Call after gpio.begin() and powerManager.begin() (I2C already initialised for X3)
+  // Call after BoardConfig has selected the active device.
   void begin();
 
-  // True if the DS3231 RTC is present on this device
+  // True if an RTC is present on this device
   bool isAvailable() const { return _available; }
 
   // Get current hour (0-23) and minute (0-59).
@@ -35,14 +34,11 @@ class HalClock {
   // Returns false if RTC is not available.
   bool formatTime(char* buf, size_t bufSize, uint8_t utcOffsetQuarterHoursBiased = 48, bool use12Hour = false) const;
 
-  // Sync the DS3231 RTC from an NTP server. Requires WiFi to be connected.
+  // Sync the RTC from an NTP server. Requires WiFi to be connected.
   // Blocks for up to ~5s while waiting for SNTP response.
   // Returns true if the RTC was successfully updated.
   //
   // Debouncing (skip if already synced once) is enforced by the caller, not here,
   // so the HAL stays free of any app-layer settings dependency.
   bool syncFromNTP();
-
- private:
-  bool writeTimeToRTC(uint8_t hour, uint8_t minute, uint8_t second);
 };

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>
@@ -191,15 +192,20 @@ HalGPIO::DeviceType detectDeviceTypeWithFingerprint() {
 }  // namespace
 
 void HalGPIO::begin() {
-  inputMgr.begin();
+#if FREEINK_MCU_C3
   SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS);
 
   _deviceType = detectDeviceTypeWithFingerprint();
+  BoardConfig::selectDevice(deviceIsX3() ? BoardConfig::Board::XteinkX3 : BoardConfig::Board::XteinkX4);
 
   if (deviceIsX4()) {
     pinMode(BAT_GPIO0, INPUT);
     pinMode(UART0_RXD, INPUT);
   }
+#else
+  _deviceType = DeviceType::X4;
+#endif
+  inputMgr.begin();
 }
 
 void HalGPIO::update() {
@@ -225,29 +231,54 @@ unsigned long HalGPIO::getHeldTime() const { return inputMgr.getHeldTime(); }
 
 unsigned long HalGPIO::getPowerButtonHeldTime() const { return inputMgr.getPowerButtonHeldTime(); }
 
-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();
+bool HalGPIO::hasTouch() const { return inputMgr.hasTouch(); }
+
+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);
 }
 
-void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed) {
+bool HalGPIO::isTouchHeldAt(float& nx, float& ny) const { return inputMgr.isTouchHeldAt(nx, ny); }
+
+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::wasTouchActivity() const { return inputMgr.wasTouchActivity(); }
+
+void HalGPIO::setSharedConfirmPowerShortPressEmitsPower(const bool enabled) {
+  InputManager::setSharedConfirmPowerShortPressEmitsPower(enabled);
+}
+
+bool HalGPIO::isXteinkDevice() const {
+  return BoardConfig::ACTIVE.board == BoardConfig::Board::XteinkX3 ||
+         BoardConfig::ACTIVE.board == BoardConfig::Board::XteinkX4;
+}
+
+bool HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed) {
+  // Boards without a power button (or M5Paper's latch circuit) cannot verify a
+  // hold; treat the wake as valid.
+  if (BoardConfig::ACTIVE.input.power < 0) {
+    return true;
+  }
+#if defined(FREEINK_DEVICE_M5PAPER) && FREEINK_DEVICE_M5PAPER
+  return true;
+#endif
   if (shortPressAllowed) {
     // Fast path - no duration check needed
-    return;
+    return true;
   }
   // 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;
+  // Calibrate: subtract boot time already elapsed, assuming button held since boot.
+  const unsigned long calibration = millis();
+  const unsigned long calibratedDuration = (calibration < requiredDurationMs) ? (requiredDurationMs - calibration) : 1;
 
   const auto start = millis();
   inputMgr.update();
@@ -262,11 +293,12 @@ void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPre
       inputMgr.update();
     } while (inputMgr.isPressed(BTN_POWER) && inputMgr.getPowerButtonHeldTime() < calibratedDuration);
     if (inputMgr.getPowerButtonHeldTime() < calibratedDuration) {
-      startDeepSleep();
+      return false;
     }
   } else {
-    startDeepSleep();
+    return false;
   }
+  return true;
 }
 
 bool HalGPIO::isUsbConnected() const {
@@ -282,8 +314,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 +326,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

@@ -58,6 +58,7 @@ class HalGPIO {
   // Inline device type helpers for cleaner downstream checks
   inline bool deviceIsX3() const { return _deviceType == DeviceType::X3; }
   inline bool deviceIsX4() const { return _deviceType == DeviceType::X4; }
+  bool isXteinkDevice() const;
 
   // Start button GPIO and setup SPI for screen and SD card
   void begin();
@@ -71,14 +72,20 @@ class HalGPIO {
   bool wasAnyReleased() const;
   unsigned long getHeldTime() const;
   unsigned long getPowerButtonHeldTime() const;
-
-  // Setup wake up GPIO and enter deep sleep
-  void startDeepSleep();
+  bool hasTouch() const;
+  bool wasTouchTap(float& nx, float& ny) const;
+  bool wasTouchDown(float& nx, float& ny) const;
+  bool isTouchTapCandidate(float& nx, float& ny, unsigned long& heldMs) const;
+  bool isTouchHeldAt(float& nx, float& ny) const;
+  unsigned long lastTouchHeldMs() const;
+  bool wasSwipe(float& nxStart, float& nyStart, float& nxEnd, float& nyEnd) const;
+  bool wasTouchActivity() const;
+  void setSharedConfirmPowerShortPressEmitsPower(bool enabled);
 
   // Verify power button was held long enough after wakeup.
-  // If verification fails, enters deep sleep and does not return.
+  // Returns true if verification succeeded, false if device should return to sleep.
   // Should only be called when wakeup reason is PowerButton.
-  void verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed);
+  bool verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed);
 
   // Check if USB is connected
   bool isUsbConnected() const;

lib/hal/HalPowerManager.cpp

@@ -1,8 +1,11 @@
 #include "HalPowerManager.h"
 
+#include <BoardConfig.h>
 #include <Logging.h>
+#include <PowerManager.h>
 #include <WiFi.h>
 #include <esp_sleep.h>
+#include <soc/soc_caps.h>
 
 #include <cassert>
 
@@ -11,14 +14,8 @@
 HalPowerManager powerManager;  // Singleton instance
 
 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);
-    _batteryUseI2C = true;
-  } else {
-    pinMode(BAT_GPIO0, INPUT);
+  if (BoardConfig::ACTIVE.batteryAdc >= 0) {
+    pinMode(BoardConfig::ACTIVE.batteryAdc, INPUT);
   }
   normalFreq = getCpuFrequencyMhz();
   modeMutex = xSemaphoreCreateMutex();
@@ -61,12 +58,6 @@ void HalPowerManager::setPowerSaving(bool enabled) {
 }
 
 void HalPowerManager::startDeepSleep(HalGPIO& gpio) const {
-  // Ensure that the power button has been released to avoid immediately turning back on if you're holding it
-  while (gpio.isPressed(HalGPIO::BTN_POWER)) {
-    delay(50);
-    gpio.update();
-  }
-
 #ifdef ENABLE_SERIAL_LOG
   // Tear down HWCDC so the host sees a clean disconnect and the peripheral
   // doesn't hold power domains that interfere with USB-powered GPIO wake.
@@ -75,53 +66,47 @@ void HalPowerManager::startDeepSleep(HalGPIO& gpio) const {
   logSerial.end();
 #endif
 
-  // Pre-sleep routines from the original firmware
-  // 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
-  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();
+#if !SOC_PM_SUPPORT_EXT1_WAKEUP
+  if (gpio.isXteinkDevice() && !gpio.deviceIsX3()) {
+    // X4 GPIO13 is connected to the battery latch MOSFET. Keeping it low powers
+    // the MCU off on battery, while the SDK wake source still handles USB power.
+    constexpr gpio_num_t GPIO_SPIWP = GPIO_NUM_13;
+    gpio_set_direction(GPIO_SPIWP, GPIO_MODE_OUTPUT);
+    gpio_set_level(GPIO_SPIWP, 0);
+    gpio_hold_en(GPIO_SPIWP);
+  }
+#endif
+
+  // Cut the gated peripheral rails (touch/SD/EPD on boards like the Sticky) and
+  // hold the enables off through deep sleep — otherwise the GT911 and SD card
+  // stay powered all through "off" and drain the battery. No-op on boards with
+  // no switched rails (X4/X3). Trade-off: no touch-to-wake; wake is the power
+  // button. Must run after display.deepSleep() so the panel controller gets its
+  // deep-sleep command while its rail is still up (enterDeepSleep() in main.cpp
+  // guarantees that ordering).
+  freeink::PowerManager::powerDownRailsForSleep();
+
+  // Waits for the power button to be physically released (so holding it doesn't
+  // immediately wake the device again), then arms the wake source and sleeps.
+  freeink::PowerManager::deepSleepUntilPowerButton();
 }
 
 uint16_t HalPowerManager::getBatteryPercentage() const {
-  if (_batteryUseI2C) {
+  static const BatteryMonitor battery;
+  if (BoardConfig::ACTIVE.batteryGauge.gaugeAddr != 0) {
     const unsigned long now = millis();
     if (_batteryLastPollMs != 0 && (now - _batteryLastPollMs) < BATTERY_POLL_MS) {
       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) {
-      _batteryLastPollMs = now;
-      return _batteryCachedPercent;
-    }
-    Wire.requestFrom(I2C_ADDR_BQ27220, (uint8_t)2);
-    if (Wire.available() < 2) {
-      _batteryLastPollMs = now;
-      return _batteryCachedPercent;
-    }
-    const uint8_t lo = Wire.read();
-    const uint8_t hi = Wire.read();
-    const uint16_t soc = (hi << 8) | lo;
-    _batteryCachedPercent = soc > 100 ? 100 : soc;
     _batteryLastPollMs = now;
+    uint16_t percent = 0;
+    if (!battery.readPercentageChecked(percent)) {
+      return _batteryCachedPercent;
+    }
+    _batteryCachedPercent = percent;
     return _batteryCachedPercent;
   }
-  static const BatteryMonitor battery = BatteryMonitor(BAT_GPIO0);
 
   // smooth the battery %.
   if (_batteryCachedPercent == 0) {

lib/hal/HalPowerManager.h

@@ -4,7 +4,6 @@
 #include <BatteryMonitor.h>
 #include <InputManager.h>
 #include <Logging.h>
-#include <Wire.h>
 #include <freertos/semphr.h>
 
 #include <cassert>
@@ -18,8 +17,6 @@ class HalPowerManager {
   int normalFreq = 0;  // MHz
   bool isLowPower = false;
 
-  // I2C fuel gauge configuration for X3 battery monitoring
-  bool _batteryUseI2C = false;                   // True if using I2C fuel gauge (X3), false for ADC (X4)
   mutable int _batteryCachedPercent = 0;         // Last read battery percentage (0-100)
   mutable unsigned long _batteryLastPollMs = 0;  // Timestamp of last battery read in milliseconds
 
@@ -28,7 +25,11 @@ class HalPowerManager {
   SemaphoreHandle_t modeMutex = nullptr;  // Protect access to currentLockMode
 
  public:
-  static constexpr int LOW_POWER_FREQ = 10;                    // MHz
+#if BOARD_HAS_PSRAM
+  static constexpr int LOW_POWER_FREQ = 80;  // MHz
+#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,11 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
     __real_panic_print_backtrace(frame, core);
     return;
   }
+
+#if !__riscv
+  __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 +70,7 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
   }
 
   __real_panic_print_backtrace(frame, core);
+#endif
 }
 }
 

lib/hal/HalTiltSensor.cpp

@@ -4,84 +4,29 @@
 
 HalTiltSensor halTiltSensor;  // Singleton instance
 
-bool HalTiltSensor::writeReg(uint8_t reg, uint8_t val) const {
-  Wire.beginTransmission(_i2cAddr);
-  Wire.write(reg);
-  Wire.write(val);
-  return Wire.endTransmission() == 0;
-}
-
-bool HalTiltSensor::readReg(uint8_t reg, uint8_t* val) const {
-  Wire.beginTransmission(_i2cAddr);
-  Wire.write(reg);
-  if (Wire.endTransmission(false) != 0) {
-    return false;
-  }
-  Wire.requestFrom(_i2cAddr, (uint8_t)1);
-  if (Wire.available() < 1) {
-    return false;
-  }
-  *val = Wire.read();
-  return true;
-}
-
 bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const {
-  Wire.beginTransmission(_i2cAddr);
-  Wire.write(REG_GX_L);  // Start reading at Gyro X Low
-  if (Wire.endTransmission(false) != 0) {
-    return false;
-  }
-
-  Wire.requestFrom(_i2cAddr, (uint8_t)6);
-  if (Wire.available() < 6) {
-    return false;
-  }
-
-  auto readInt16 = [&]() -> int16_t {
-    const uint8_t lo = Wire.read();
-    const uint8_t hi = Wire.read();
-    return static_cast<int16_t>((hi << 8) | lo);
-  };
-
-  // If Full Scale is ±512 dps, the scale factor is 32768 / 512 = 64 LSB/dps
-  constexpr float SCALE = 1.0f / 64.0f;
-  gx = readInt16() * SCALE;
-  gy = readInt16() * SCALE;
-  gz = readInt16() * SCALE;
+  Imu::Sample sample;
+  if (!_sdkImu.read(sample)) return false;
+  gx = sample.gx;
+  gy = sample.gy;
+  gz = sample.gz;
   return true;
 }
 
 void HalTiltSensor::begin() {
-  if (!gpio.deviceIsX3()) {
-    _available = false;
-    return;
-  }
-
-  // Try primary address, then alternate
-  uint8_t whoami = 0;
-  _i2cAddr = I2C_ADDR_QMI8658;
-  if (!readReg(QMI8658_WHO_AM_I_REG, &whoami) || whoami != QMI8658_WHO_AM_I_VALUE) {
-    _i2cAddr = I2C_ADDR_QMI8658_ALT;
-    if (!readReg(QMI8658_WHO_AM_I_REG, &whoami) || whoami != QMI8658_WHO_AM_I_VALUE) {
-      LOG_ERR("GYR", "QMI8658 IMU not found");
-      _available = false;
-      return;
+  _available = _sdkImu.begin();
+  if (_available) {
+    _initMs = millis();
+    _lastPollMs = millis();
+    // begin() leaves the sensors sampling; stand them by until tilt page turn
+    // actually wakes them, so a disabled IMU doesn't drain the battery.
+    if (!_sdkImu.sleep()) {
+      LOG_ERR("GYR", "IMU standby failed");
     }
-  }
-
-  LOG_INF("GYR", "QMI8658 IMU found at 0x%02X", _i2cAddr);
-
-  if (!writeReg(REG_CTRL7, CTRL7_DISABLE_ALL) || !writeReg(REG_CTRL3, CTRL3_FS_512DPS | CTRL3_ODR_28HZ) ||
-      !writeReg(REG_CTRL1, CTRL1_BASE | CTRL1_SENSOR_DISABLE)) {
-    LOG_ERR("GYR", "QMI8658 register configuration failed");
-    _available = false;
+    LOG_INF("GYR", "SDK IMU initialized");
     return;
   }
-
-  _available = true;
-  _initMs = millis();
-  _lastPollMs = millis();
-  LOG_INF("GYR", "QMI8658 gyro initialized and put to sleep");
+  LOG_ERR("GYR", "SDK IMU not found");
 }
 
 bool HalTiltSensor::wake() {
@@ -89,21 +34,16 @@ bool HalTiltSensor::wake() {
     return false;
   }
 
-  // Wait for init to complete before waking
-  if ((millis() - _initMs) < SLEEP_STABILIZE_MS) {
+  if (!_sdkImu.wake()) {
+    LOG_ERR("GYR", "IMU wake failed");
     return false;
   }
 
-  if (writeReg(REG_CTRL1, CTRL1_BASE) && writeReg(REG_CTRL7, CTRL7_GYRO_ENABLE)) {
-    _lastPollMs = millis();
-    _lastTiltMs = millis();
-    _wakeMs = millis();
-    LOG_INF("GYR", "QMI8658 woke up");
-    return true;
-  } else {
-    LOG_ERR("GYR", "Failed to wake QMI8658");
-    return false;
-  }
+  _lastPollMs = millis();
+  _lastTiltMs = millis();
+  _wakeMs = millis();
+  _isAwake = true;
+  return true;
 }
 
 bool HalTiltSensor::deepSleep() {
@@ -111,20 +51,15 @@ bool HalTiltSensor::deepSleep() {
     return false;
   }
 
-  if ((millis() - _wakeMs) < SLEEP_STABILIZE_MS) {
+  if (!_sdkImu.sleep()) {
+    LOG_ERR("GYR", "IMU sleep failed");
     return false;
   }
 
-  if (writeReg(REG_CTRL7, CTRL7_DISABLE_ALL) && writeReg(REG_CTRL1, CTRL1_BASE | CTRL1_SENSOR_DISABLE)) {
-    // Clear any residual state so it doesn't immediately trigger upon waking
-    clearPendingEvents();
-    _inTilt = false;
-    LOG_INF("GYR", "QMI8658 entered sleep mode");
-    return true;
-  } else {
-    LOG_ERR("GYR", "Failed to put QMI8658 to sleep");
-    return false;
-  }
+  clearPendingEvents();
+  _inTilt = false;
+  _isAwake = false;
+  return true;
 }
 
 void HalTiltSensor::update(const uint8_t mode, const uint8_t orientation, const bool inReader) {

lib/hal/HalTiltSensor.h

@@ -1,9 +1,7 @@
 #pragma once
 
 #include <Arduino.h>
-#include <Wire.h>
-
-#include "HalGPIO.h"
+#include <Imu.h>
 
 // TODO: Move enums into new header and share with CrossPointSettings.h
 namespace CrossPointOrientation {
@@ -19,7 +17,7 @@ extern HalTiltSensor halTiltSensor;  // Singleton
 
 class HalTiltSensor {
   bool _available = false;
-  uint8_t _i2cAddr = 0;
+  mutable Imu _sdkImu;
 
   // Tilt gesture state machine
   bool _tiltForwardEvent = false;  // Consumed by wasTiltedForward()
@@ -37,47 +35,22 @@ class HalTiltSensor {
   static constexpr unsigned long COOLDOWN_MS = 600;        // Minimum ms between triggers
   static constexpr unsigned long POLL_INTERVAL_MS = 50;    // 20 Hz polling
   static constexpr unsigned long WAKE_STABILIZE_MS = 300;  // Ignore readings after wake
-  static constexpr unsigned long SLEEP_STABILIZE_MS = 15;  // Sleep turn on/off delay
 
   mutable unsigned long _lastPollMs = 0;
 
-  // --- QMI8658 registers ---
-  static constexpr uint8_t REG_CTRL1 = 0x02;
-  static constexpr uint8_t REG_CTRL3 = 0x04;
-  static constexpr uint8_t REG_CTRL7 = 0x08;
-  static constexpr uint8_t REG_GX_L = 0x3B;
-
-  // --- Register Bit Flags ---
-
-  // REG_CTRL1 (0x02)
-  static constexpr uint8_t CTRL1_BIG_ENDIAN = (1 << 5);                     // 0x20: Default state (1 = Big Endian)
-  static constexpr uint8_t CTRL1_AUTO_INC = (1 << 6);                       // 0x40: Enable address auto-increment
-  static constexpr uint8_t CTRL1_SENSOR_DISABLE = (1 << 0);                 // 0x01: Power down sensor engine
-  static constexpr uint8_t CTRL1_BASE = CTRL1_AUTO_INC | CTRL1_BIG_ENDIAN;  // 0x60
-
-  // REG_CTRL3 (0x04) - Gyro Config
-  static constexpr uint8_t CTRL3_FS_512DPS = (0b101 << 4);  // Bits 6:4 = 101
-  static constexpr uint8_t CTRL3_ODR_28HZ = 0b1000;         // Bits 3:0 = 1000 (28.025 Hz)
-
-  // REG_CTRL7 (0x08) - Enable
-  static constexpr uint8_t CTRL7_DISABLE_ALL = 0x00;
-  static constexpr uint8_t CTRL7_GYRO_ENABLE = (1 << 1);  // Bit 1 = 1
-
-  bool writeReg(uint8_t reg, uint8_t val) const;
-  bool readReg(uint8_t reg, uint8_t* val) const;
   bool readGyro(float& gx, float& gy, float& gz) const;
 
  public:
-  // Call after gpio.begin() and powerManager.begin() (I2C already initialised for X3)
+  // Call after BoardConfig has selected the active device.
   void begin();
 
-  // Enables the QMI8658 internal sensor engine
+  // Enables tilt polling state
   bool wake();
 
-  // Puts the QMI8658 into a low-power standby state
+  // Puts tilt polling state to sleep
   bool deepSleep();
 
-  // True if the QMI8658 IMU is present on this device
+  // True if an IMU is present on this device
   bool isAvailable() const { return _available; }
 
   // Poll the accelerometer and update tilt gesture state.

nix/default.nix

@@ -0,0 +1 @@
+shell.nix

nix/flake.lock

@@ -0,0 +1,43 @@
+{
+  "nodes": {
+    "flake-compat": {
+      "locked": {
+        "lastModified": 1767039857,
+        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
+        "owner": "NixOS",
+        "repo": "flake-compat",
+        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1784356753,
+        "narHash": "sha256-12KrbMiWLcf8m7pCvAtZh1ZrgF85ZXDXvfR/fWTKy84=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "61b7c44c4073f0b827768aff0049561b5110ea5a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

nix/flake.nix

@@ -0,0 +1,79 @@
+{
+  description = "CrossPoint Reader development environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-compat.url = "github:NixOS/flake-compat";
+  };
+
+  outputs =
+    { nixpkgs, ... }:
+    let
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+      ];
+      forAllSystems = nixpkgs.lib.genAttrs systems;
+    in
+    {
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+          # Detect the project root from wherever the user entered the shell,
+          # so commands work from the repository root or any subdirectory.
+          # Using `git rev-parse` to do so (assuming git is installed
+          # system-wide); user can overwrite this by setting PROJECT_ROOT env.
+          setEnvs = ''
+            PROJECT_ROOT="''${PROJECT_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+            export PROJECT_ROOT
+            export PLATFORMIO_CORE_DIR="$PROJECT_ROOT/.cache/platformio"
+          '';
+          fhsEnv = pkgs.buildFHSEnv {
+            name = "crosspoint-reader-shell";
+
+            targetPkgs =
+              pkgs: with pkgs; [
+                python3
+                uv
+
+                # Runtime libraries used by PlatformIO's downloaded ESP32 toolchain binaries.
+                stdenv.cc.cc.lib
+                zlib
+                ncurses
+              ];
+
+            profile = ''
+              ${setEnvs}
+              export PATH="$PROJECT_ROOT/.venv/bin:$PATH"
+
+              if [ ! -x "$PROJECT_ROOT/.venv/bin/pio" ]; then
+                echo "Creating .venv and installing pioarduino PlatformIO Core..."
+                # Forcing python3 from fhsEnv, otherwise we get the following
+                # exception while running `pip check`
+                # ModuleNotFoundError: No module named 'littlefs'
+                uv venv --python /usr/bin/python3 "$PROJECT_ROOT/.venv" &&
+                uv pip install --python "$PROJECT_ROOT/.venv/bin/python" \
+                  -U https://github.com/pioarduino/platformio-core/archive/refs/tags/v6.1.19.zip \
+                  -r "$PROJECT_ROOT/requirements.txt" ||
+                echo "Failed to install pioarduino PlatformIO Core" >&2
+              fi
+            '';
+          };
+          pio = pkgs.writeShellScriptBin "pio" ''
+            exec ${fhsEnv}/bin/crosspoint-reader-shell -c 'exec pio "$@"' pio "$@"
+          '';
+        in
+        {
+          default = pkgs.mkShell {
+            packages = [
+              pio
+              fhsEnv
+            ];
+
+            shellHook = setEnvs;
+          };
+        }
+      );
+    };
+}

nix/shell.nix

@@ -0,0 +1,12 @@
+(import (
+  let
+    lock = builtins.fromJSON (builtins.readFile ./flake.lock);
+    nodeName = lock.nodes.root.inputs.flake-compat;
+  in
+  fetchTarball {
+    url =
+      lock.nodes.${nodeName}.locked.url
+        or "https://github.com/NixOS/flake-compat/archive/${lock.nodes.${nodeName}.locked.rev}.tar.gz";
+    sha256 = lock.nodes.${nodeName}.locked.narHash;
+  }
+) { src = ./.; }).shellNix

platformio.ini

@@ -13,10 +13,7 @@ framework = arduino
 monitor_speed = 115200
 upload_speed = 921600
 check_tool = cppcheck
-; missingInclude (project headers) is suppressed alongside missingIncludeSystem: on a
-; fresh CI checkout cppcheck has no resolved include paths, so it reports every
-; project header as missing (~470 information-level lines) and fails the job.
-check_flags = --enable=all --suppress=missingIncludeSystem --suppress=missingInclude --suppress=unusedFunction --suppress=unmatchedSuppression --suppress=*:*/.pio/* --inline-suppr
+check_flags = --enable=all --suppress=missingIncludeSystem --suppress=unusedFunction --suppress=unmatchedSuppression --suppress=*:*/.pio/* --inline-suppr
 check_skip_packages = yes
 
 board_upload.flash_size = 16MB
@@ -38,21 +35,12 @@ build_flags =
 # Increase PNG scanline buffer to support up to 2048px wide images
 # Default is (320*4+1)*2=2562, we need more for larger images
   -DPNG_MAX_BUFFERED_PIXELS=16416
-  -DFREEINK_DEVICE_X4=1
-  -DFREEINK_DEVICE_X3=1
   -DFREEINK_NET_WOLFSSL=1
   -DWOLFSSL_USER_SETTINGS
   -DWOLFSSL_OPTIONS_H
   -DWOLFSSL_CLIENT_EXAMPLE
   -DWOLFSSL_TLS13
-# MEMFIX-PORT: single-precision ECC (sp_c32.c). Without it every P-256 operation
-# (TLS 1.3 key_share keygen, ECDHE, ECDSA cert verify) runs on fast-math bignums
-# that WOLFSSL_SMALL_STACK heap-allocates at FP_MAX_BITS size -- tens of KB of
-# temporaries, which OOMs (MP_MEM) at the ~50KB free heap a reading session
-# leaves. SP uses fixed 256-bit arrays: a few KB, and several times faster.
-# SP_SMALL trades the large precomputed point tables for smaller flash.
-  -DWOLFSSL_HAVE_SP_ECC
-  -DWOLFSSL_SP_SMALL
+  -DWOLFSSL_SP_RISCV32
   -DHAVE_TLS_EXTENSIONS
   -DHAVE_SUPPORTED_CURVES
   -DHAVE_HKDF
@@ -63,16 +51,6 @@ build_flags =
   -Wno-bidi-chars
   -Wl,--wrap=panic_print_backtrace,--wrap=panic_abort,--wrap=bootloader_common_check_efuse_blk_validity
   -fno-exceptions
-# FreeInk panel profiles: compile both X3 (792x528/UC8253) and X4 (800x480/SSD1677);
-# the firmware picks the active one at runtime via HalDisplay setDisplayX3().
-  -DFREEINK_DEVICE_X3=1
-  -DFREEINK_DEVICE_X4=1
-# BLE HID page-turner host (BleKeyboardHost). NimBLE role/bond config is baked into
-# the prebuilt arduino-esp32 framework's sdkconfig.h, so we don't redefine it here
-# (doing so only warns and has no effect). The host only compiles when
-# FREEINK_CAP_BLE_HID_HOST is set on the env (below); with the capability off,
-# BleKeyboardHost links stubs and pulls in zero NimBLE code.
-  -DFREEINK_BLE_HID_SHOW_UNNAMED_DEVICES=0
 
 build_unflags =
   -std=gnu++11
@@ -83,63 +61,6 @@ board_build.flash_mode = dio
 board_build.flash_size = 16MB
 board_build.partitions = partitions.csv
 
-; Shrink the NimBLE footprint for a 1-connection HID host moving 3-6 byte reports.
-; Field-measured: begin() costs ~52 KB with these trims vs ~68 KB with the prebuilt
-; framework defaults — and that 15 KB is the difference between the stack landing
-; above the reader's render shed floor (stable coexistence) and below it (a
-; guaranteed shed/restart flap). Rebuilds the Arduino core libs on first build
-; (slower once, cached after; needs the CMake pin in platformio.local.ini on macOS).
-custom_sdkconfig =
-  CONFIG_BT_NIMBLE_ROLE_PERIPHERAL=n
-  CONFIG_BT_NIMBLE_ROLE_BROADCASTER=n
-  CONFIG_BT_NIMBLE_MAX_CONNECTIONS=1
-  CONFIG_BT_NIMBLE_MAX_CCCDS=2
-  CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU=23
-  CONFIG_BT_NIMBLE_MSYS_1_BLOCK_COUNT=6
-  CONFIG_BT_NIMBLE_MSYS_2_BLOCK_COUNT=6      ; was 24 x 320 B
-  CONFIG_BT_NIMBLE_ACL_BUF_COUNT=6           ; was 24 x 255 B
-  CONFIG_BT_NIMBLE_HCI_EVT_HI_BUF_COUNT=12   ; was 30 x 70 B; only scan bursts need many
-  ; IDF 5.5 sizes the HCI transport pools under TRANSPORT_* names; pin both spellings.
-  CONFIG_BT_NIMBLE_TRANSPORT_ACL_FROM_LL_COUNT=6
-  CONFIG_BT_NIMBLE_TRANSPORT_EVT_COUNT=12
-  CONFIG_BT_NIMBLE_ATT_MAX_PREP_ENTRIES=4    ; was 64; a HID host never does prepared writes
-  CONFIG_BT_CTRL_BLE_MAX_ACT=3               ; was 6; need conn + scan + initiate only
-  CONFIG_BT_CTRL_BLE_ADV_REPORT_FLOW_CTRL_NUM=50   ; was 100; pairing-time scan only
-  CONFIG_BT_CTRL_ADV_DUP_FILT_MAX=10               ; was 30
-  ; MEMFIX-PORT: task stack right-sizing (~7 KB); NOTE develop has no
-  ; custom_sdkconfig block — port via sdkconfig.defaults or equivalent.
-  ; Task stack right-sizing from measured high-water marks (heap block map +
-  ; per-task stack audit, July 2026): esp_timer used ~0.8 KB of 8 KB across
-  ; every capture incl. BLE sessions; the FreeRTOS timer service used ~0.5 KB
-  ; of 4 KB. Neither runs TLS or app code. ~7 KB back to the heap.
-  CONFIG_ESP_TIMER_TASK_STACK_SIZE=4096
-  CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=2560
-  ; Move the WiFi stack's non-critical hot paths out of IRAM into flash.
-  ; On the C3, IRAM and DRAM share one SRAM pool, so the ~25-30 KB this
-  ; frees lands directly in the heap — paid for with lower WiFi throughput
-  ; during transfers (occasional sync/OTA use, not streaming: acceptable).
-  ; IRAM cost is static, so the heap gain applies even with WiFi off.
-  CONFIG_ESP_WIFI_IRAM_OPT=n
-  CONFIG_ESP_WIFI_RX_IRAM_OPT=n
-  ; Keep the Arduino wrappers for the removed cloud components (below) out of
-  ; the core source list; all other bundled libraries default to enabled.
-  CONFIG_ARDUINO_SELECTIVE_COMPILATION=y
-  CONFIG_ARDUINO_SELECTIVE_RainMaker=n
-  CONFIG_ARDUINO_SELECTIVE_Insights=n
-
-; Drop unused cloud components from the core rebuild. esp_insights/rainmaker
-; require embedded server certs the lib builder can't generate
-; ("https_server.crt.S not found"); this firmware uses none of them.
-custom_component_remove =
-  espressif/esp_insights
-  espressif/esp_rainmaker
-  espressif/esp_diagnostics
-  espressif/esp_diag_data_store
-  espressif/esp_schedule
-  espressif/esp_rcp_update
-  espressif/esp_secure_cert_mgr
-  espressif/cbor
-
 extra_scripts =
   pre:scripts/patch_wolfssl.py
   pre:scripts/build_html.py
@@ -154,7 +75,6 @@ lib_deps =
   InputManager=symlink://freeink-sdk/libs/hardware/InputManager
   EInkDisplay=symlink://freeink-sdk/libs/display/FreeInkDisplay
   SDCardManager=symlink://freeink-sdk/libs/hardware/SDCardManager
-  ; FreeInk HAL support libs the above depend on (BoardConfig pin maps, etc.).
   BoardConfig=symlink://freeink-sdk/libs/hardware/BoardConfig
   PowerManager=symlink://freeink-sdk/libs/hardware/PowerManager
   Rtc=symlink://freeink-sdk/libs/hardware/Rtc
@@ -162,8 +82,6 @@ lib_deps =
   SecureNet=symlink://freeink-sdk/libs/network/SecureNet
   FreeInkUI=symlink://freeink-sdk/libs/ui/FreeInkUI
   Icons=symlink://freeink-sdk/libs/assets/Icons
-  BleKeyboardHost=symlink://freeink-sdk/libs/network/BleKeyboardHost
-  h2zero/NimBLE-Arduino @ ^2.3.8
   bblanchon/ArduinoJson @ 7.4.2
   ricmoo/QRCode @ 0.0.1
   bitbank2/PNGdec @ 1.1.6
@@ -179,35 +97,55 @@ extends = base
 build_flags =
   ${base.build_flags}
   ; CROSSPOINT_VERSION is set by scripts/git_branch.py (includes branch + short SHA)
+  -DFREEINK_DEVICE_X4=1
+  -DFREEINK_DEVICE_X3=1
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=2 ; Set log level to debug for development builds
-  -DFREEINK_CAP_BLE_HID_HOST=1 ; BLE HID page-turner host (NimBLE)
-  -DFREEINK_BLE_HID_SCAN_DEBUG=1 ; verbose BLE scan lifecycle/advertisement logs for bring-up
-  -DFREEINK_BLE_HID_REPORT_DEBUG=1 ; raw HID report hex dumps + report-map hints (bring-up)
 
 
 [env:gh_release]
 extends = base
 build_flags =
   ${base.build_flags}
+  -DFREEINK_DEVICE_X4=1
+  -DFREEINK_DEVICE_X3=1
   -DCROSSPOINT_VERSION=\"${crosspoint.version}\"
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=1 ; Set log level to info for release builds
-  -DFREEINK_CAP_BLE_HID_HOST=1 ; BLE HID page-turner host (NimBLE)
 
 [env:gh_release_rc]
 extends = base
 build_flags =
   ${base.build_flags}
+  -DFREEINK_DEVICE_X4=1
+  -DFREEINK_DEVICE_X3=1
   -DCROSSPOINT_VERSION=\"${crosspoint.version}-rc+${sysenv.CROSSPOINT_RC_HASH}\"
   -DENABLE_SERIAL_LOG
   -DLOG_LEVEL=1 ; Set log level to info for release candidate builds
-  -DFREEINK_CAP_BLE_HID_HOST=1 ; BLE HID page-turner host (NimBLE)
 
 [env:slim]
 extends = base
 build_flags =
   ${base.build_flags}
+  -DFREEINK_DEVICE_X4=1
+  -DFREEINK_DEVICE_X3=1
   -DCROSSPOINT_VERSION=\"${crosspoint.version}-slim\"
   ; serial output is disabled in slim builds to save space
   -UENABLE_SERIAL_LOG
+
+; --- Seeed Sticky — ESP32-S3R8, 3.97" 800x480 SSD1677 + GT911 touch -----------
+; Different MCU family than the C3 envs (one binary per family). The SDK
+; auto-enables CAP_TOUCH (GT911) and the BQ27220 gauge for this device; PSRAM is
+; intentionally left off (48KB framebuffer fits in DRAM, same as X4).
+;   pio run -e sticky -t upload
+[env:sticky]
+extends = base
+board = esp32-s3-devkitc1-n16r8
+board_build.mcu = esp32s3
+build_flags =
+  ${base.build_flags}
+  -DFREEINK_DEVICE_STICKY=1
+  ; git_branch.py only injects CROSSPOINT_VERSION for the default env; set it here.
+  -DCROSSPOINT_VERSION=\"${crosspoint.version}-sticky\"
+  -DENABLE_SERIAL_LOG
+  -DLOG_LEVEL=2

scripts/patch_wolfssl.py

@@ -12,12 +12,8 @@ OVERRIDES = f"""
 #ifndef HAVE_FFDHE_2048
 #define HAVE_FFDHE_2048
 #endif
-/* MEMFIX-PORT: 8192 handles up to RSA-4096 keys (the public-CA maximum,
-   ISRG Root X1 included) with half the per-bignum heap of 16384: with
-   WOLFSSL_SMALL_STACK each fast-math temp is FP_MAX_BITS/8 * 2 bytes on the
-   heap, and TLS cert verification allocates dozens at once. */
 #undef FP_MAX_BITS
-#define FP_MAX_BITS 8192
+#define FP_MAX_BITS 16384
 """
 
 

src/BleInput.cpp

@@ -1,121 +0,0 @@
-#include "BleInput.h"
-
-#include <GfxRenderer.h>
-#include <HalPowerManager.h>
-#include <I18n.h>
-
-#include <cstdio>
-#include <cstring>
-
-#include "MappedInputManager.h"
-#include "components/UITheme.h"
-
-namespace bleinput {
-
-namespace {
-volatile bool g_startInProgress = false;
-}
-
-// NimBLE controller init/deinit hang (interrupt WDT) if run at the 10 MHz low-power
-// frequency, so force normal CPU speed around both. Centralized here so every caller
-// (boot restore, settings toggle, reader toggle, sleep) is covered automatically.
-bool ensureStarted() {
-  g_startInProgress = true;
-  HalPowerManager::Lock powerLock;
-  const bool ok = BleHid.begin(kHostName);
-  g_startInProgress = false;
-  return ok;
-}
-
-bool startInProgress() { return g_startInProgress; }
-
-// Full teardown (NimBLE deinit), not just a link drop, so the BLE stack's RAM is
-// returned to the heap — otherwise memory-hungry work like EPUB inflate can't
-// allocate even after the user turns Bluetooth off.
-void stop() {
-  HalPowerManager::Lock powerLock;
-  BleHid.end();
-}
-
-bool encodeKey(const freeink::KeyEvent& ev, uint8_t& kind, uint8_t& value) {
-  if (ev.special != freeink::SpecialKey::None) {
-    kind = 0;
-    value = static_cast<uint8_t>(ev.special);
-    return true;
-  }
-  if (ev.keycode != 0) {
-    kind = 1;
-    value = ev.keycode;
-    return true;
-  }
-  return false;
-}
-
-namespace {
-const char* specialName(uint8_t value) {
-  switch (static_cast<freeink::SpecialKey>(value)) {
-    case freeink::SpecialKey::Enter:
-      return "Enter";
-    case freeink::SpecialKey::Backspace:
-      return "Backspace";
-    case freeink::SpecialKey::Tab:
-      return "Tab";
-    case freeink::SpecialKey::Escape:
-      return "Escape";
-    case freeink::SpecialKey::Delete:
-      return "Delete";
-    case freeink::SpecialKey::Left:
-      return "Left";
-    case freeink::SpecialKey::Right:
-      return "Right";
-    case freeink::SpecialKey::Up:
-      return "Up";
-    case freeink::SpecialKey::Down:
-      return "Down";
-    case freeink::SpecialKey::Home:
-      return "Home";
-    case freeink::SpecialKey::End:
-      return "End";
-    case freeink::SpecialKey::PageUp:
-      return "Page Up";
-    case freeink::SpecialKey::PageDown:
-      return "Page Down";
-    default:
-      return nullptr;
-  }
-}
-}  // namespace
-
-void showConnectingUntilLinked(const GfxRenderer& renderer, const MappedInputManager& input) {
-  if (!BleHid.isRunning() || BleHid.isConnected()) return;
-  // drawPopup refreshes the panel itself, so draw once and let e-ink hold it while we
-  // pump the host. Holds until the remote links, the user presses a button to bail, or
-  // a generous timeout (a remote that slept after a disconnect needs a button to wake).
-  GUI.drawPopup(renderer, tr(STR_BT_CONNECTING_POPUP));
-  const unsigned long deadline = millis() + 10000;
-  while (!BleHid.isConnected() && millis() < deadline) {
-    BleHid.poll();
-    input.update();
-    if (input.wasAnyPressed()) break;
-    delay(50);
-  }
-  // Note: the caller must redraw to clear the popup. For grayscale reader pages the
-  // caller should also request a ghost-cleanup (HALF) refresh first — a plain fast/
-  // partial refresh ghosts badly over the BW popup (see Activity::requestGhostCleanup).
-}
-
-void describeKey(uint8_t kind, uint8_t value, char* out, size_t outLen) {
-  if (!out || outLen == 0) return;
-  if (kind == 0) {
-    const char* name = specialName(value);
-    if (name) {
-      strncpy(out, name, outLen - 1);
-      out[outLen - 1] = '\0';
-      return;
-    }
-  }
-  // Printable ASCII usage handled as a generic key code; show the raw value.
-  snprintf(out, outLen, "Key 0x%02X", static_cast<unsigned>(value));
-}
-
-}  // namespace bleinput

src/BleInput.h

@@ -1,62 +0,0 @@
-#pragma once
-
-// CrossPoint <-> FreeInk BLE HID host glue.
-//
-// Thin, capability-safe helpers around freeink::BleKeyboardHost (the `BleHid`
-// singleton). When FREEINK_CAP_BLE_HID_HOST is compiled out the SDK links stubs,
-// so every call here is still valid and simply no-ops / returns false — callers
-// need no #ifdefs.
-//
-// The (kind, value) pair produced by encodeKey() is the stable identity stored in
-// CrossPointSettings::bleKeyMap. Page-turner remotes emit "special" keys
-// (PageUp/PageDown/arrows); plain keyboards emit usage codes. We deliberately
-// ignore modifiers and the printable char for matching (page turners don't use
-// modifiers), keeping the persisted entry a trivial two-byte comparison.
-
-#include <BleKeyboardHost.h>
-
-#include <cstdint>
-
-class GfxRenderer;
-class MappedInputManager;
-
-namespace bleinput {
-
-// Advertised central name shown to peripherals during pairing.
-inline constexpr const char* kHostName = "CrossPoint";
-
-// Heap floor for starting the NimBLE stack (measured begin() cost: ~52-57 KB).
-// The reader now lends the framebuffer to section builds, so BLE startup no
-// longer needs to reserve the old full build headroom. Keep a modest margin and
-// let the render/build shed paths handle genuinely tight moments.
-inline constexpr size_t kStartMinFreeHeap = 56 * 1024;
-
-// Lower floor for the Bluetooth settings screen, where the user has explicitly asked
-// for BLE right now (scanning/pairing is dead without the stack). No page renders or
-// section builds run there, so the reader-sized reserve above doesn't apply — only
-// NimBLE's own ~57 KB plus working margin.
-inline constexpr size_t kStartMinFreeHeapExplicit = 70 * 1024;
-
-// Start the BLE HID host (idempotent). Returns false if BLE is compiled out or
-// NimBLE init failed. Safe to call repeatedly.
-bool ensureStarted();
-bool startInProgress();
-
-// Drop the active link (e.g. before deep sleep or when the user disables BT).
-void stop();
-
-// Encode a decoded key event into the stable (kind, value) identity used by the
-// settings map. kind: 0 = SpecialKey, 1 = HID usage. Returns false when the event
-// carries no usable identity (no special key and no usage code).
-bool encodeKey(const freeink::KeyEvent& ev, uint8_t& kind, uint8_t& value);
-
-// Human-readable name for a stored (kind, value) identity, for the mapping UI.
-// Writes a null-terminated string into out (e.g. "Page Down", "Key 0x4B").
-void describeKey(uint8_t kind, uint8_t value, char* out, size_t outLen);
-
-// Draw a "BT Connecting..." popup and pump the BLE host until the bonded remote
-// links, the user presses a button to dismiss, or a timeout. No-op if BLE isn't
-// running or is already connected. The caller must redraw afterward to clear it.
-void showConnectingUntilLinked(const GfxRenderer& renderer, const MappedInputManager& input);
-
-}  // namespace bleinput

src/CrossPointSettings.h

@@ -29,8 +29,8 @@ class CrossPointSettings {
     LIGHT = 1,
     CUSTOM = 2,
     COVER = 3,
-    BLANK = 4,
-    COVER_CUSTOM = 5,
+    COVER_CUSTOM = 4,
+    BLANK = 5,
     QUICK_RESUME = 6,
     SLEEP_SCREEN_MODE_COUNT
   };
@@ -153,6 +153,7 @@ class CrossPointSettings {
     LP_MENU_KOSYNC = 0,
     LP_MENU_DISABLED = 1,
     LP_MENU_BOOKMARK = 2,
+    LP_MENU_DICTIONARY = 3,
     LONG_PRESS_MENU_FUNCTION_COUNT
   };
 
@@ -175,6 +176,8 @@ class CrossPointSettings {
 
   enum TILT_PAGE_TURN { TILT_OFF = 0, TILT_NORMAL = 1, TILT_NVERTED = 2, TILT_PAGE_TURN_COUNT };
 
+  enum TOUCH_READER_CONTROLS { TOUCH_READER_OFF = 0, TOUCH_READER_ON = 1, TOUCH_READER_CONTROLS_COUNT };
+
   enum QUICK_RESUME_SLEEP_SCREEN {
     QUICK_RESUME_NEVER = 0,
     QUICK_RESUME_AFTER_TIMEOUT = 1,
@@ -225,22 +228,6 @@ class CrossPointSettings {
   uint8_t frontButtonConfirm = FRONT_HW_CONFIRM;
   uint8_t frontButtonLeft = FRONT_HW_LEFT;
   uint8_t frontButtonRight = FRONT_HW_RIGHT;
-  // --- Bluetooth (BLE HID page-turner) ---
-  // Master on/off for the BLE HID host. Persisted; auto-restored on boot/wake.
-  // Managed by BluetoothSettingsActivity and the in-reader "Toggle Bluetooth" menu item.
-  uint8_t bluetoothEnabled = 0;
-  // Remote-button mapping table: each slot binds a decoded BLE key identity to a
-  // logical MappedInputManager::Button. Fixed-capacity POD (no heap), persisted
-  // manually in JsonSettingsIO (like the front-button remap). 0xFF = empty/unassigned.
-  // Headroom for several buttons plus optional presets and rolling-code remotes
-  // (some buttons emit more than one code). Each entry is 3 bytes.
-  static constexpr uint8_t BLE_MAP_CAPACITY = 10;
-  struct BleKeyMapEntry {
-    uint8_t keyKind = 0xFF;  // 0 = SpecialKey, 1 = HID usage code; 0xFF = empty slot
-    uint8_t keyValue = 0;    // (uint8_t)freeink::SpecialKey, or the raw HID usage id
-    uint8_t button = 0xFF;   // (uint8_t)MappedInputManager::Button; 0xFF = unassigned
-  };
-  BleKeyMapEntry bleKeyMap[BLE_MAP_CAPACITY] = {};
   // Reader font settings
   uint8_t fontFamily = NOTOSERIF;
   uint8_t fontSize = MEDIUM;
@@ -254,6 +241,14 @@ class CrossPointSettings {
 
   // Reader screen margin settings
   uint8_t screenMargin = 5;
+  // OPDS download destination folder ("" = SD root). Global; edited from the
+  // OPDS server list. Persisted via a category-less SettingInfo::String in
+  // SettingsList.h, so it stays out of the on-device Settings screen.
+  char opdsDownloadFolder[64] = "";
+  // On-disk filename format for OPDS downloads (0=Author-Title default, 1=Title-Author,
+  // 2=Title). See OpdsFilenameFormat. Persisted via a category-less SettingInfo::Enum,
+  // edited from the OPDS server list; hidden from the on-device Settings screen.
+  uint8_t opdsFilenameFormat = 0;
   // Hide battery percentage
   uint8_t hideBatteryPercentage = HIDE_NEVER;
   // Long-press page turn button behavior
@@ -273,16 +268,22 @@ class CrossPointSettings {
   uint8_t focusReadingEnabled = 0;
   // SD card font family name (empty = use built-in fontFamily)
   char sdFontFamilyName[32] = "";
+  // Dictionary folder name under /dictionaries (empty = no dictionary)
+  char dictionaryName[32] = "";
   // Show hidden files/directories (starting with '.') in the file browser (0 = hidden, 1 = show)
   uint8_t showHiddenFiles = 0;
   // Remove a book from the Recent Books list when its End-of-Book screen is reached (0 = off, 1 = on)
   uint8_t removeReadBooksFromRecents = 0;
   // Move epub to /Read/ folder on SD card when finished (0 = disabled, 1 = enabled)
   uint8_t moveFinishedToReadFolder = 0;
+  // Short press Back goes to file browser instead of home (0 = disabled, 1 = enabled)
+  uint8_t backShortToFileBrowser = 0;
   // Image rendering mode in EPUB reader
   uint8_t imageRendering = IMAGES_DISPLAY;
   // Tilt-based page turning (X3 only — requires QMI8658 IMU)
   uint8_t tiltPageTurn = TILT_OFF;
+  // Touch screen reader zones/gestures on boards with a touch controller.
+  uint8_t touchReaderControls = TOUCH_READER_ON;
   // Language setting (Language enum index, default 0 = EN)
   uint8_t language = 0;
   // Quick Resume: keep current content visible with moon icon instead of showing a static sleep screen.

src/HeapMap.cpp

@@ -1,85 +0,0 @@
-#include "HeapMap.h"
-
-#include <Arduino.h>
-#include <Logging.h>
-#include <Memory.h>
-#include <esp_heap_caps.h>
-
-#include <cstdio>
-
-#include "rom/ets_sys.h"
-
-// heap_caps_dump walks each heap inside a critical section (interrupts
-// masked), so its output can neither go through the UART-0 ROM path we can't
-// see nor be flow-controlled toward the CDC (the CDC ring drains in an
-// interrupt handler — waiting deadlocks into the interrupt WDT,
-// field-verified). Instead the ROM putc parses each line into a compact
-// record; the captured table is logged after the dump with interrupts live.
-namespace heapmap {
-namespace {
-struct BlockRec {
-  uint32_t addr;
-  uint32_t size;
-  bool free;
-};
-constexpr uint16_t kMaxRecs = 1400;
-BlockRec* g_recs = nullptr;  // borrowed buffer, valid only during capture
-uint16_t g_recCount = 0;
-bool g_overflowed = false;
-char g_line[96];
-uint8_t g_lineLen = 0;
-
-void captInterpolatePutc(char c) {
-  if (c != '\n') {
-    if (g_lineLen < sizeof(g_line) - 1) g_line[g_lineLen++] = c;
-    return;
-  }
-  g_line[g_lineLen] = '\0';
-  g_lineLen = 0;
-  // e.g. "Block 0x3fcc69bc data, size: 89424 bytes, Free: Yes"
-  unsigned addr = 0, size = 0;
-  char freeWord[4] = {0};
-  if (sscanf(g_line, "Block 0x%x data, size: %u bytes, Free: %3s", &addr, &size, freeWord) == 3) {
-    if (g_recs && g_recCount < kMaxRecs) {
-      g_recs[g_recCount++] = {addr, size, freeWord[0] == 'Y'};
-    } else {
-      g_overflowed = true;
-    }
-  }
-}
-}  // namespace
-
-void dump() {
-  auto recBuf = makeUniqueNoThrow<BlockRec[]>(kMaxRecs);
-  if (!recBuf) {
-    LOG_ERR("MEM", "heap map skipped: no room for capture buffer");
-    return;
-  }
-  g_recs = recBuf.get();
-  g_recCount = 0;
-  g_overflowed = false;
-  g_lineLen = 0;
-  // Capture (interrupts masked inside the dump): parse into records, never
-  // wait. Log the table afterward with the system live. NOTE: the capture
-  // buffer itself appears in the map as a used block of ~17.4 KB — it frees
-  // on return (observer effect, do not chase it as a leak/splitter).
-  ets_install_putc1(&captInterpolatePutc);
-  heap_caps_dump(MALLOC_CAP_8BIT);
-  ets_install_uart_printf();
-  g_recs = nullptr;
-
-  LOG_DBG("MEM", "---- heap block map: %u blocks%s ----", g_recCount, g_overflowed ? " (TRUNCATED)" : "");
-  uint32_t dustCount = 0, dustBytes = 0;
-  for (uint16_t i = 0; i < g_recCount; ++i) {
-    const auto& r = recBuf[i];
-    if (r.free || r.size >= 256) {
-      LOG_DBG("MEM", "%s 0x%08x %u", r.free ? "FREE" : "used", r.addr, r.size);
-    } else {
-      dustCount++;
-      dustBytes += r.size;
-    }
-  }
-  LOG_DBG("MEM", "dust: %u used blocks < 256B totaling %u bytes", dustCount, dustBytes);
-  LOG_DBG("MEM", "---- end heap block map ----");
-}
-}  // namespace heapmap

src/HeapMap.h

@@ -1,10 +0,0 @@
-#pragma once
-
-// MEMFIX-PORT: heap block map (on-demand via CMD:MEMMAP + reader one-shot); portable, no BLE dependency
-namespace heapmap {
-// Capture-and-log the DRAM heap block map (address/size/free per block,
-// sub-256B used blocks rolled up as "dust"). Safe to call from the main loop;
-// ~60-100 LOG_DBG lines. See HeapMap.cpp for why capture-then-log is the only
-// shape that works (heap_caps_dump runs with interrupts masked).
-void dump();
-}  // namespace heapmap

src/JsonSettingsIO.cpp

@@ -7,13 +7,11 @@
 
 #include <algorithm>
 #include <cstring>
-#include <iterator>
 #include <string>
 
 #include "BookmarkEntry.h"
 #include "CrossPointSettings.h"
 #include "CrossPointState.h"
-#include "MappedInputManager.h"
 #include "OpdsServerStore.h"
 #include "RecentBooksStore.h"
 #include "SettingsList.h"
@@ -145,22 +143,16 @@ bool JsonSettingsIO::saveSettings(const CrossPointSettings& s, const char* path)
   doc["frontButtonConfirm"] = s.frontButtonConfirm;
   doc["frontButtonLeft"] = s.frontButtonLeft;
   doc["frontButtonRight"] = s.frontButtonRight;
-  // Bluetooth — managed by BluetoothSettingsActivity, not in SettingsList.
-  doc["bluetoothEnabled"] = s.bluetoothEnabled;
-  JsonArray bleMap = doc["bleKeyMap"].to<JsonArray>();
-  for (const auto& e : s.bleKeyMap) {
-    if (e.keyKind == 0xFF || e.button == 0xFF) continue;  // skip empty/unassigned slots
-    JsonObject o = bleMap.add<JsonObject>();
-    o["k"] = e.keyKind;
-    o["v"] = e.keyValue;
-    o["b"] = e.button;
-  }
   // Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it.
   doc["fontFamily"] = s.fontFamily;
   // SD card font family name — not in SettingsList, save manually
   if (s.sdFontFamilyName[0] != '\0') {
     doc["sdFontFamilyName"] = s.sdFontFamilyName;
   }
+  // Dictionary folder name — uses dynamic getter/setter in SettingsList, save manually
+  if (s.dictionaryName[0] != '\0') {
+    doc["dictionaryName"] = s.dictionaryName;
+  }
 
   // Language -- managed by LanguageSelectActivity, not in SettingsList.
   // Stored as ISO code string ("EN", "DE", ...) for stability across enum reorders.
@@ -252,23 +244,6 @@ bool JsonSettingsIO::loadSettings(CrossPointSettings& s, const char* json, bool*
       clamp(doc["frontButtonRight"] | (uint8_t)S::FRONT_HW_RIGHT, S::FRONT_BUTTON_HARDWARE_COUNT, S::FRONT_HW_RIGHT);
   CrossPointSettings::validateFrontButtonMapping(s);
 
-  // Bluetooth — managed by BluetoothSettingsActivity, not in SettingsList.
-  s.bluetoothEnabled = clamp(doc["bluetoothEnabled"] | (uint8_t)0, 2, 0);
-  std::fill(std::begin(s.bleKeyMap), std::end(s.bleKeyMap), CrossPointSettings::BleKeyMapEntry{});  // reset to empty
-  JsonArrayConst bleMap = doc["bleKeyMap"];
-  if (!bleMap.isNull()) {
-    uint8_t slot = 0;
-    for (JsonObjectConst o : bleMap) {
-      if (slot >= CrossPointSettings::BLE_MAP_CAPACITY) break;
-      const uint8_t button = o["b"] | (uint8_t)0xFF;
-      if (button >= MappedInputManager::kButtonCount) continue;  // drop invalid mappings
-      s.bleKeyMap[slot].keyKind = o["k"] | (uint8_t)0xFF;
-      s.bleKeyMap[slot].keyValue = o["v"] | (uint8_t)0;
-      s.bleKeyMap[slot].button = button;
-      slot++;
-    }
-  }
-
   // Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it.
   const uint8_t storedFontFamily = doc["fontFamily"] | (uint8_t)0;
   s.fontFamily = clamp(storedFontFamily, CrossPointSettings::BUILTIN_FONT_COUNT, 0);
@@ -285,6 +260,11 @@ bool JsonSettingsIO::loadSettings(CrossPointSettings& s, const char* json, bool*
     if (needsResave) *needsResave = true;
   }
 
+  // Dictionary folder name — uses dynamic getter/setter in SettingsList, load manually
+  const char* dictName = doc["dictionaryName"] | "";
+  strncpy(s.dictionaryName, dictName, sizeof(s.dictionaryName) - 1);
+  s.dictionaryName[sizeof(s.dictionaryName) - 1] = '\0';
+
   // Language -- stored as code string for stability across enum reorders.
   if (doc["language"].is<const char*>()) {
     s.language = static_cast<uint8_t>(I18n::languageFromCode(doc["language"].as<const char*>()));

src/MappedInputManager.cpp

@@ -2,8 +2,11 @@
 
 #include <GfxRenderer.h>
 
-#include "BleInput.h"
+#include <algorithm>
+#include <cstdlib>
+
 #include "CrossPointSettings.h"
+#include "components/UITheme.h"
 
 bool MappedInputManager::isNavDirectionSwapped() const {
   // Key the swap on the orientation the screen is *actually* rendered at, not the persisted reader
@@ -75,103 +78,222 @@ bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint
   return false;
 }
 
-bool MappedInputManager::bleEdge(const bool* arr, const Button button) const {
-  // Mirror mapButton()'s composite navigation handling so a BLE key bound to a
-  // physical direction also satisfies the derived NavNext / NavPrevious logical
-  // buttons (used by list navigation), respecting the orientation axis flip.
-  switch (button) {
-    case Button::NavNext:
-      return isNavDirectionSwapped() ? (arr[(int)Button::Up] || arr[(int)Button::Left])
-                                     : (arr[(int)Button::Down] || arr[(int)Button::Right]);
-    case Button::NavPrevious:
-      return isNavDirectionSwapped() ? (arr[(int)Button::Down] || arr[(int)Button::Right])
-                                     : (arr[(int)Button::Up] || arr[(int)Button::Left]);
-    default:
-      return arr[(int)button];
-  }
+namespace {
+constexpr float LEFT_EDGE_BACK_GESTURE_FRAC_X = 0.25f;
+constexpr float BOTTOM_EDGE_BACK_GESTURE_FRAC_Y = 0.14f;
+constexpr float TOP_EDGE_MENU_GESTURE_FRAC_Y = 0.14f;
+constexpr unsigned long TOUCH_DOWN_SELECT_DELAY_MS = 90;
+constexpr unsigned long TOUCH_HELD_OVERRIDE_WINDOW_MS = 250;
+}  // namespace
+
+bool MappedInputManager::hasTouch() const { return gpio.hasTouch(); }
+
+void MappedInputManager::rememberTouchHeldTime() const {
+  touchHeldOverrideValid = true;
+  touchHeldOverrideMs = gpio.lastTouchHeldMs();
+  touchHeldOverrideAt = millis();
 }
 
-bool MappedInputManager::wasPressed(const Button button) const {
-  return mapButton(button, &HalGPIO::wasPressed) || bleEdge(blePressEdge, button);
-}
-
-bool MappedInputManager::wasReleased(const Button button) const {
-  return mapButton(button, &HalGPIO::wasReleased) || bleEdge(bleReleaseEdge, button);
-}
-
-bool MappedInputManager::isPressed(const Button button) const {
-  // A BLE tap is momentary: report "pressed" only on the press-edge frame.
-  return mapButton(button, &HalGPIO::isPressed) || bleEdge(blePressEdge, button);
-}
-
-void MappedInputManager::setBleCaptureMode(const bool on) {
-  bleCaptureMode = on;
-  bleHasCaptured = false;
-  if (on) {
-    // Clear any stale overlay so a held remote key doesn't leak into the UI.
-    for (uint8_t i = 0; i < kButtonCount; i++) {
-      blePressEdge[i] = false;
-      bleReleaseEdge[i] = false;
-    }
-  }
-}
-
-bool MappedInputManager::takeCapturedBleKey(uint8_t& kind, uint8_t& value) {
-  if (!bleHasCaptured) return false;
-  kind = bleCapturedKind;
-  value = bleCapturedValue;
-  bleHasCaptured = false;
+bool MappedInputManager::wasScreenTapped(int& x, int& y) const {
+  float nx = 0.0f;
+  float ny = 0.0f;
+  if (!gpio.wasTouchTap(nx, ny)) return false;
+  renderer.tapToLogical(nx, ny, x, y);
+  rememberTouchHeldTime();
   return true;
 }
 
-void MappedInputManager::pollBle() {
-  bleActivityThisFrame = false;
-  // Age last frame's press edges into this frame's release edges (the FreeInk host
-  // surfaces presses + synthetic repeats but never releases), then clear presses. A
-  // pending release also counts as BLE activity this frame so getHeldTime() reports
-  // zero on the release frame too (page-turn handlers often fire on release).
-  for (uint8_t i = 0; i < kButtonCount; i++) {
-    bleReleaseEdge[i] = blePressEdge[i];
-    blePressEdge[i] = false;
-    if (bleReleaseEdge[i]) bleActivityThisFrame = true;
-  }
-
-  freeink::KeyEvent ev;
-  while (BleHid.popKey(ev)) {
-    uint8_t kind = 0xFF;
-    uint8_t value = 0;
-    if (!bleinput::encodeKey(ev, kind, value)) continue;
-
-    if (bleCaptureMode) {
-      bleCapturedKind = kind;
-      bleCapturedValue = value;
-      bleHasCaptured = true;
-      continue;
-    }
-
-    // Resolve the key identity against the persisted mapping table.
-    for (const auto& e : SETTINGS.bleKeyMap) {
-      if (e.button == 0xFF || e.keyKind != kind || e.keyValue != value) continue;
-      if (e.button < kButtonCount) {
-        blePressEdge[e.button] = true;
-        bleActivityThisFrame = true;
-      }
-      break;
-    }
-  }
+bool MappedInputManager::wasScreenTouchDown(int& x, int& y) const {
+  float nx = 0.0f;
+  float ny = 0.0f;
+  unsigned long heldMs = 0;
+  if (!gpio.isTouchTapCandidate(nx, ny, heldMs)) return false;
+  if (heldMs < TOUCH_DOWN_SELECT_DELAY_MS) return false;
+  renderer.tapToLogical(nx, ny, x, y);
+  return true;
 }
 
+bool MappedInputManager::isScreenTouchHeld(int& x, int& y) const {
+  // Live contact position while the finger is down (no tap-slop gate) — drag tracking.
+  float nx = 0.0f;
+  float ny = 0.0f;
+  if (!gpio.isTouchHeldAt(nx, ny)) return false;
+  renderer.tapToLogical(nx, ny, x, y);
+  return true;
+}
+
+bool MappedInputManager::wasTapInRect(const int x, const int y, const int width, const int height) const {
+  int tx = 0;
+  int ty = 0;
+  return wasScreenTapped(tx, ty) && tx >= x && tx < x + width && ty >= y && ty < y + height;
+}
+
+bool MappedInputManager::listItemFromPoint(const int x, const int y, int& index, const int itemCount,
+                                           const int selectedIndex, const int listTop, const int listHeight,
+                                           const bool hasSubtitle) const {
+  (void)x;
+  if (itemCount <= 0) return false;
+  if (y < listTop || y >= listTop + listHeight) return false;
+
+  const auto& theme = UITheme::getInstance().getTheme();
+  const int rowStep = theme.getListRowStep(hasSubtitle);
+  if (rowStep <= 0) return false;
+
+  const int pageItems = theme.getListPageItems(listHeight, hasSubtitle);
+  if (pageItems <= 0) return false;
+  const int pageStart = std::max(0, selectedIndex / pageItems) * pageItems;
+  const int row = (y - listTop) / rowStep;
+  const int tapped = pageStart + row;
+  if (row < 0 || row >= pageItems || tapped >= itemCount) return false;
+  index = tapped;
+  return true;
+}
+
+bool MappedInputManager::wasListItemTapped(int& index, const int itemCount, const int selectedIndex, const int listTop,
+                                           const int listHeight, const bool hasSubtitle) const {
+  int tx = 0;
+  int ty = 0;
+  return wasScreenTapped(tx, ty) &&
+         listItemFromPoint(tx, ty, index, itemCount, selectedIndex, listTop, listHeight, hasSubtitle);
+}
+
+bool MappedInputManager::wasListItemTouchedDown(int& index, const int itemCount, const int selectedIndex,
+                                                const int listTop, const int listHeight, const bool hasSubtitle) const {
+  int tx = 0;
+  int ty = 0;
+  return wasScreenTouchDown(tx, ty) &&
+         listItemFromPoint(tx, ty, index, itemCount, selectedIndex, listTop, listHeight, hasSubtitle);
+}
+
+MappedInputManager::RowTouch MappedInputManager::rowTouch(int& row, const int top, const int rowStep,
+                                                          const int rowCount, const int xStart, const int xEnd,
+                                                          const int rowHeight) const {
+  if (rowStep <= 0 || rowCount <= 0) return RowTouch::None;
+  const auto hit = [&](const int x, const int y) {
+    if (x < xStart || x >= xEnd || y < top) return false;
+    const int r = (y - top) / rowStep;
+    if (r >= rowCount) return false;
+    if (rowHeight > 0 && (y - top) % rowStep >= rowHeight) return false;
+    row = r;
+    return true;
+  };
+  int x = 0;
+  int y = 0;
+  if (wasScreenTouchDown(x, y) && hit(x, y)) return RowTouch::Down;
+  if (wasScreenTapped(x, y) && hit(x, y)) return RowTouch::Tap;
+  return RowTouch::None;
+}
+
+MappedInputManager::RowTouch MappedInputManager::colTouch(int& col, const int left, const int colStep,
+                                                          const int colCount, const int yStart, const int yEnd,
+                                                          const int colWidth) const {
+  if (colStep <= 0 || colCount <= 0) return RowTouch::None;
+  const auto hit = [&](const int x, const int y) {
+    if (y < yStart || y >= yEnd || x < left) return false;
+    const int c = (x - left) / colStep;
+    if (c >= colCount) return false;
+    if (colWidth > 0 && (x - left) % colStep >= colWidth) return false;
+    col = c;
+    return true;
+  };
+  int x = 0;
+  int y = 0;
+  if (wasScreenTouchDown(x, y) && hit(x, y)) return RowTouch::Down;
+  if (wasScreenTapped(x, y) && hit(x, y)) return RowTouch::Tap;
+  return RowTouch::None;
+}
+
+bool MappedInputManager::decodeSwipe(int& sx, int& sy, int& ex, int& ey) const {
+  float nxs = 0.0f;
+  float nys = 0.0f;
+  float nxe = 0.0f;
+  float nye = 0.0f;
+  if (!gpio.wasSwipe(nxs, nys, nxe, nye)) return false;
+  renderer.tapToLogical(nxs, nys, sx, sy);
+  renderer.tapToLogical(nxe, nye, ex, ey);
+  return true;
+}
+
+MappedInputManager::SwipeDir MappedInputManager::wasSwipe() const {
+  int sx = 0;
+  int sy = 0;
+  int ex = 0;
+  int ey = 0;
+  if (!decodeSwipe(sx, sy, ex, ey)) return SwipeDir::None;
+  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::wasBackGesture() const {
+  // Back = left-to-right swipe starting near the left edge. Edge-anchored so that
+  // mid-screen horizontal swipes stay available to activities that consume
+  // SwipeDir::Left/Right (e.g. percent selection, image viewer).
+  int sx = 0;
+  int sy = 0;
+  int ex = 0;
+  int ey = 0;
+  if (!decodeSwipe(sx, sy, ex, ey)) return false;
+  const bool hit = sx <= renderer.getScreenWidth() * LEFT_EDGE_BACK_GESTURE_FRAC_X && ex > sx &&
+                   std::abs(ex - sx) > std::abs(ey - sy);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasMenuGesture() const {
+  // Downward swipe starting at the top edge (mirror of the bottom-edge home gesture).
+  int sx = 0;
+  int sy = 0;
+  int ex = 0;
+  int ey = 0;
+  if (!decodeSwipe(sx, sy, ex, ey)) return false;
+  const int topEdgeBottom = static_cast<int>(renderer.getScreenHeight() * TOP_EDGE_MENU_GESTURE_FRAC_Y);
+  const bool hit = sy <= topEdgeBottom && ey > sy && std::abs(ey - sy) > std::abs(ex - sx);
+  if (hit) rememberTouchHeldTime();
+  return hit;
+}
+
+bool MappedInputManager::wasHomeGesture() const {
+  int sx = 0;
+  int sy = 0;
+  int ex = 0;
+  int ey = 0;
+  if (decodeSwipe(sx, sy, ex, ey)) {
+    const int bottomEdgeTop =
+        renderer.getScreenHeight() - static_cast<int>(renderer.getScreenHeight() * BOTTOM_EDGE_BACK_GESTURE_FRAC_Y);
+    if (sy >= bottomEdgeTop && ey < sy && std::abs(ey - sy) > std::abs(ex - sx)) {
+      rememberTouchHeldTime();
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MappedInputManager::wasPressed(const Button button) const {
+  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); }
+
 bool MappedInputManager::wasAnyPressed() const { return gpio.wasAnyPressed(); }
 
 bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); }
 
 unsigned long MappedInputManager::getHeldTime() const {
-  // A BLE-mapped key is a momentary tap with no physical hold (we don't model BLE
-  // press-and-hold). gpio.getHeldTime() returns the *last physical* button's hold
-  // duration, which is stale — if a BLE edge drove input this frame, reporting that
-  // stale value makes a tap look like a long-press (e.g. page tap -> chapter skip).
-  // Report zero in that case so BLE taps are always treated as short presses.
-  if (bleActivityThisFrame) return 0;
+  if (!gpio.wasAnyPressed() && !gpio.wasAnyReleased() && touchHeldOverrideValid &&
+      millis() - touchHeldOverrideAt <= TOUCH_HELD_OVERRIDE_WINDOW_MS) {
+    return touchHeldOverrideMs;
+  }
+  touchHeldOverrideValid = false;
   return gpio.getHeldTime();
 }
 

src/MappedInputManager.h

@@ -7,9 +7,7 @@ class GfxRenderer;
 class MappedInputManager {
  public:
   enum class Button { Back, Confirm, Left, Right, Up, Down, Power, PageBack, PageForward, NavNext, NavPrevious };
-  // Number of values in Button (Back..NavPrevious). Used to size the BLE overlay and
-  // to clamp persisted BLE mappings. Keep in sync with the enum above.
-  static constexpr uint8_t kButtonCount = 11;
+  enum class SwipeDir { None, Left, Right, Up, Down };
 
   struct Labels {
     const char* btn1;
@@ -24,30 +22,39 @@ class MappedInputManager {
   bool wasPressed(Button button) const;
   bool wasReleased(Button button) const;
   bool isPressed(Button button) const;
+  bool hasTouch() const;
+  bool wasScreenTapped(int& x, int& y) const;
+  bool wasScreenTouchDown(int& x, int& y) const;
+  bool isScreenTouchHeld(int& x, int& y) const;
+  bool wasTapInRect(int x, int y, int width, int height) const;
+  bool wasListItemTapped(int& index, int itemCount, int selectedIndex, int listTop, int listHeight,
+                         bool hasSubtitle) const;
+  bool wasListItemTouchedDown(int& index, int itemCount, int selectedIndex, int listTop, int listHeight,
+                              bool hasSubtitle) const;
+
+  // Combined touch interaction for a band of equal rows with caller-supplied
+  // geometry — the shared hit-test for lists the theme helpers above do not
+  // cover (custom row heights, option prompts, menus). Down = a held
+  // tap-candidate is on a row (update the selection highlight); Tap = a tap
+  // released on one (activate). rowHeight limits the hit to the top rowHeight
+  // px of each step (0 = the full step, no gap band).
+  enum class RowTouch : uint8_t { None, Down, Tap };
+  RowTouch rowTouch(int& row, int top, int rowStep, int rowCount, int xStart = 0, int xEnd = INT32_MAX,
+                    int rowHeight = 0) const;
+  // Horizontal variant for side-by-side button pairs (confirmation prompts).
+  RowTouch colTouch(int& col, int left, int colStep, int colCount, int yStart, int yEnd, int colWidth = 0) const;
+
+  SwipeDir wasSwipe() const;
+  bool wasHomeGesture() const;
+  bool wasMenuGesture() const;
   bool wasAnyPressed() const;
   bool wasAnyReleased() const;
   unsigned long getHeldTime() const;
+  const GfxRenderer& getRenderer() const { return renderer; }
   Labels mapLabels(const char* back, const char* confirm, const char* previous, const char* next) const;
   // Returns the raw front button index that was pressed this frame (or -1 if none).
   int getPressedFrontButton() const;
 
-  // --- BLE page-turner overlay -------------------------------------------------
-  // Drain decoded key events from the FreeInk BLE HID host and translate the ones
-  // bound in SETTINGS.bleKeyMap into per-frame logical-button edges that OR into
-  // wasPressed()/isPressed()/wasReleased(). Call once per main-loop iteration,
-  // right after gpio.update() and BleHid.poll(). No-ops when BLE is compiled out.
-  void pollBle();
-  // True when a mapped BLE key produced an edge this frame — keeps the inactivity
-  // / auto-sleep timer alive while a remote is the only input device in use.
-  bool bleHadActivityThisFrame() const { return bleActivityThisFrame; }
-  // Capture mode: while on, pollBle() stops mapping events and instead stashes the
-  // raw decoded key identity so the button-mapping UI can read it without racing the
-  // live mapping over the single popKey() queue.
-  void setBleCaptureMode(bool on);
-  // Pop a captured (kind, value) key identity grabbed while in capture mode.
-  // Returns false when nothing has been captured since the last call.
-  bool takeCapturedBleKey(uint8_t& kind, uint8_t& value);
-
   // 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,
@@ -64,17 +71,14 @@ class MappedInputManager {
   const GfxRenderer& renderer;
 
   bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const;
-  // OR-in the BLE overlay for a logical button, mirroring mapButton()'s composite
-  // handling of NavNext/NavPrevious so a remote key bound to Up/Down/Left/Right also
-  // drives list navigation.
-  bool bleEdge(const bool* arr, Button button) const;
+  bool wasBackGesture() const;
+  // Fetch the pending swipe (if any) and map both endpoints to logical screen coords
+  bool decodeSwipe(int& sx, int& sy, int& ex, int& ey) const;
+  bool listItemFromPoint(int x, int y, int& index, int itemCount, int selectedIndex, int listTop, int listHeight,
+                         bool hasSubtitle) const;
+  void rememberTouchHeldTime() const;
 
-  // Per-frame BLE overlay, indexed by (uint8_t)Button.
-  bool blePressEdge[kButtonCount] = {};    // press edge this frame   -> wasPressed / isPressed
-  bool bleReleaseEdge[kButtonCount] = {};  // release edge this frame  -> wasReleased
-  bool bleActivityThisFrame = false;
-  bool bleCaptureMode = false;
-  bool bleHasCaptured = false;
-  uint8_t bleCapturedKind = 0xFF;
-  uint8_t bleCapturedValue = 0;
+  mutable bool touchHeldOverrideValid = false;
+  mutable unsigned long touchHeldOverrideMs = 0;
+  mutable unsigned long touchHeldOverrideAt = 0;
 };

src/SdCardFontSystem.h

@@ -32,10 +32,6 @@ class SdCardFontSystem {
   /// Non-const access to the registry (for FontInstaller).
   SdCardFontRegistry& registry() { return registry_; }
 
-  // MEMFIX-PORT: font system audit passthrough; portable
-  /// Resident heap held by loaded SD fonts (audit; see SdCardFont::reportMemory).
-  size_t reportFontMemory() const { return manager_.reportMemory(); }
-
   /// Mark the registry as needing re-discovery.
   /// Thread-safe: can be called from the web server task.
   void markRegistryDirty() { registryDirty_.store(true, std::memory_order_release); }

src/SettingsList.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <BoardConfig.h>
 #include <HalClock.h>
 #include <HalTiltSensor.h>
 #include <I18n.h>
@@ -13,6 +14,7 @@
 #include "CrossPointSettings.h"
 #include "KOReaderCredentialStore.h"
 #include "activities/settings/SettingsActivity.h"
+#include "util/DictionaryRegistry.h"
 
 // Build the font family setting dynamically. When registry is non-null, SD card fonts
 // are appended after the built-in fonts. Otherwise only built-in fonts are listed.
@@ -90,6 +92,47 @@ inline SettingInfo buildFontFamilySetting(const SdCardFontRegistry* registry) {
   return s;
 }
 
+// Build the dictionary selection setting dynamically from the folders discovered
+// under /dictionaries. "None" plus one option per dictionary; the selected folder
+// name persists in SETTINGS.dictionaryName (saved/loaded manually in
+// JsonSettingsIO — the generic loop skips dynamic entries).
+inline SettingInfo buildDictionarySetting(const std::vector<DictionaryEntry>& dictionaries) {
+  std::vector<std::string> folderNames;
+  folderNames.reserve(dictionaries.size());
+  std::transform(dictionaries.begin(), dictionaries.end(), std::back_inserter(folderNames),
+                 [](const DictionaryEntry& d) { return d.name; });
+
+  SettingInfo s;
+  s.nameId = StrId::STR_DICTIONARY;
+  s.type = SettingType::ENUM;
+  s.enumStringValues.reserve(folderNames.size() + 1);
+  s.enumStringValues.push_back(I18N.get(StrId::STR_NONE_OPT));
+  s.enumStringValues.insert(s.enumStringValues.end(), folderNames.begin(), folderNames.end());
+  s.category = StrId::STR_CAT_READER;
+
+  s.valueGetter = [folderNames]() -> uint8_t {
+    for (size_t i = 0; i < folderNames.size(); i++) {
+      // Compare within the settings field capacity: an over-long folder name is
+      // stored truncated, and must still match its list entry.
+      if (strncmp(folderNames[i].c_str(), SETTINGS.dictionaryName, sizeof(SETTINGS.dictionaryName) - 1) == 0) {
+        return static_cast<uint8_t>(i + 1);
+      }
+    }
+    return 0;  // "None", also when the stored folder no longer exists
+  };
+
+  s.valueSetter = [folderNames](uint8_t v) {
+    if (v == 0 || v > folderNames.size()) {
+      SETTINGS.dictionaryName[0] = '\0';
+      return;
+    }
+    strncpy(SETTINGS.dictionaryName, folderNames[v - 1].c_str(), sizeof(SETTINGS.dictionaryName) - 1);
+    SETTINGS.dictionaryName[sizeof(SETTINGS.dictionaryName) - 1] = '\0';
+  };
+
+  return s;
+}
+
 // Shared settings list used by both the device settings UI and the web settings API.
 // Each entry has a key (for JSON API) and category (for grouping).
 // ACTION-type entries and entries without a key are device-only.
@@ -99,7 +142,8 @@ inline SettingInfo buildFontFamilySetting(const SdCardFontRegistry* registry) {
 // SdCardFontRegistry is supplied AND has SD card fonts installed, the
 // font-family entry is replaced in a per-call copy with a registry-aware
 // version. Callers without SD fonts pay only a vector copy.
-inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* registry = nullptr) {
+inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* registry = nullptr,
+                                                const std::vector<DictionaryEntry>* dictionaries = nullptr) {
   static const std::vector<SettingInfo> baseList = [] {
     std::vector<SettingInfo> v = {
         // --- Display ---
@@ -166,6 +210,8 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
         SettingInfo::Enum(StrId::STR_SIDE_BTN_LAYOUT, &CrossPointSettings::sideButtonLayout,
                           {StrId::STR_PREV_NEXT, StrId::STR_NEXT_PREV, StrId::STR_DISABLED}, "sideButtonLayout",
                           StrId::STR_CAT_CONTROLS),
+        SettingInfo::Enum(StrId::STR_TOUCH_READER_CONTROLS, &CrossPointSettings::touchReaderControls,
+                          {StrId::STR_STATE_OFF, StrId::STR_STATE_ON}, "touchReaderControls", StrId::STR_CAT_CONTROLS),
         SettingInfo::Toggle(StrId::STR_FRONT_BTN_FOLLOW_ORIENTATION, &CrossPointSettings::frontButtonFollowOrientation,
                             "frontButtonFollowOrientation", StrId::STR_CAT_CONTROLS),
         SettingInfo::Enum(StrId::STR_LONG_PRESS_BEHAVIOR, &CrossPointSettings::longPressButtonBehavior,
@@ -173,14 +219,16 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
                            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),
+                          {StrId::STR_KOSYNC, StrId::STR_DISABLED, StrId::STR_BOOKMARK_OPTION, StrId::STR_DICTIONARY},
+                          "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),
+        SettingInfo::Toggle(StrId::STR_BACK_SHORT_TO_FILE_BROWSER, &CrossPointSettings::backShortToFileBrowser,
+                            "backShortToFileBrowser", StrId::STR_CAT_CONTROLS),
 
         // --- System ---
         SettingInfo::Value(
@@ -194,6 +242,16 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
         SettingInfo::Toggle(StrId::STR_MOVE_FINISHED_TO_READ, &CrossPointSettings::moveFinishedToReadFolder,
                             "moveFinishedToReadFolder", StrId::STR_CAT_SYSTEM),
 
+        // OPDS download folder: persisted + web-exposed, but category-less so it
+        // is hidden from the on-device Settings screen (edited via OPDS UI).
+        SettingInfo::String(StrId::STR_OPDS_DOWNLOAD_FOLDER, &SETTINGS.opdsDownloadFolder[0],
+                            sizeof(SETTINGS.opdsDownloadFolder), "opdsDownloadFolder"),
+        // OPDS download filename format: persisted + web-exposed, category-less so it
+        // is hidden from the on-device Settings screen (cycled from the OPDS UI).
+        SettingInfo::Enum(StrId::STR_OPDS_FILENAME_FORMAT, &CrossPointSettings::opdsFilenameFormat,
+                          {StrId::STR_FMT_AUTHOR_TITLE, StrId::STR_FMT_TITLE_AUTHOR, StrId::STR_FMT_TITLE},
+                          "opdsFilenameFormat"),
+
         // --- KOReader Sync (web-only, uses KOReaderCredentialStore) ---
         SettingInfo::DynamicString(
             StrId::STR_KOREADER_USERNAME, [] { return KOREADER_STORE.getUsername(); },
@@ -232,6 +290,14 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
               KOREADER_STORE.saveToFile();
             },
             "koSendMetadata", StrId::STR_KOREADER_SYNC),
+        SettingInfo::DynamicEnum(
+            StrId::STR_SYNC_BEHAVIOR, {StrId::STR_ASK_EVERY_TIME, StrId::STR_SMART_SYNC},
+            [] { return static_cast<uint8_t>(KOREADER_STORE.getSyncBehavior()); },
+            [](uint8_t v) {
+              KOREADER_STORE.setSyncBehavior(static_cast<KOReaderSyncBehavior>(v));
+              KOREADER_STORE.saveToFile();
+            },
+            "koSyncBehavior", StrId::STR_KOREADER_SYNC),
         // --- Status Bar Settings (web-only, uses StatusBarSettingsActivity) ---
         SettingInfo::Toggle(StrId::STR_CHAPTER_PAGE_COUNT, &CrossPointSettings::statusBarChapterPageCount,
                             "statusBarChapterPageCount", StrId::STR_CUSTOMISE_STATUS_BAR),
@@ -282,11 +348,30 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
   }();
 
   std::vector<SettingInfo> v = baseList;
+  if (!BoardConfig::hasTouch()) {
+    v.erase(std::remove_if(v.begin(), v.end(),
+                           [](const SettingInfo& s) {
+                             return s.nameId == StrId::STR_TOUCH_READER_CONTROLS ||
+                                    s.nameId == StrId::STR_SUNLIGHT_FADING_FIX;
+                           }),
+            v.end());
+  }
+  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());
+  }
   if (registry && registry->getFamilyCount() > 0) {
     auto it = std::find_if(v.begin(), v.end(), [](const SettingInfo& s) { return s.nameId == StrId::STR_FONT_FAMILY; });
     if (it != v.end()) {
       *it = buildFontFamilySetting(registry);
     }
   }
+  if (dictionaries && !dictionaries->empty()) {
+    // Insert at the end of the Reader category (just before the first Controls entry).
+    auto it =
+        std::find_if(v.begin(), v.end(), [](const SettingInfo& s) { return s.category == StrId::STR_CAT_CONTROLS; });
+    v.insert(it, buildDictionarySetting(*dictionaries));
+  }
   return v;
 }

src/SilentRestart.h

@@ -6,7 +6,3 @@
 
 void silentRestart();          // home screen
 void silentRestartToReader();  // currently-open EPUB (APP_STATE.openEpubPath)
-// True when this boot itself came from a silent restart. Callers that restart
-// as a last-resort defrag must check this so a failure that survives the
-// restart degrades to an error instead of a reboot loop.
-bool bootWasSilentRestart();

src/activities/Activity.cpp

@@ -22,3 +22,20 @@ void Activity::startActivityForResult(std::unique_ptr<Activity>&& activity, Acti
 void Activity::setResult(ActivityResult&& result) { this->result = std::move(result); }
 
 void Activity::finish() { activityManager.popActivity(); }
+
+Activity::ListTouchResult Activity::handleListTouch(int& selectedIndex, const int itemCount, const int listTop,
+                                                    const int listHeight, const bool hasSubtitle) {
+  int touched = -1;
+  if (mappedInput.wasListItemTouchedDown(touched, itemCount, selectedIndex, listTop, listHeight, hasSubtitle)) {
+    if (selectedIndex != touched) {
+      selectedIndex = touched;
+      requestUpdate();
+    }
+    return ListTouchResult::Consumed;
+  }
+  if (mappedInput.wasListItemTapped(touched, itemCount, selectedIndex, listTop, listHeight, hasSubtitle)) {
+    selectedIndex = touched;
+    return ListTouchResult::Activated;
+  }
+  return ListTouchResult::None;
+}

src/activities/Activity.h

@@ -44,17 +44,8 @@ class Activity {
   virtual bool skipLoopDelay() { return false; }
   virtual bool preventAutoSleep() { return false; }
   virtual bool isReaderActivity() const { return false; }
-  // True if this activity needs the BLE stack resident (beyond the readers, which are
-  // covered by isReaderActivity()). The Bluetooth settings screen overrides this so
-  // pairing/scanning works there. Everywhere else BLE is torn down to free heap.
-  virtual bool keepsBluetoothAlive() const { return false; }
-  // True while the current activity is doing heap-heavy work that must finish
-  // before the BLE stack (~52 KB) may start.
-  virtual bool deferBluetoothStart() const { return false; }
-  // Ask the activity to make its next render a full ghost-cleanup (HALF) refresh rather
-  // than a fast/partial one. Used after drawing a transient popup over grayscale content
-  // (e.g. the "BT Connecting..." popup over a reader page) so it clears without ghosting.
-  virtual void requestGhostCleanup() {}
+  virtual bool isHomeActivity() const { return false; }
+  virtual bool handleHomeGesture() { return false; }
   virtual ScreenshotInfo getScreenshotInfo() const { return {}; }
 
   // Start a new activity without destroying the current one
@@ -71,4 +62,16 @@ class Activity {
   // TODO: remove this in near future
   void onGoHome(HomeMenuItem item = HomeMenuItem::NONE);
   void onSelectBook(const std::string& path);
+
+ protected:
+  enum class ListTouchResult : uint8_t {
+    None,      // touch did not hit the list
+    Consumed,  // touchdown moved the highlight (repaint already requested)
+    Activated  // tap landed on a row: selectedIndex is updated, caller activates it
+  };
+
+  // Shared touch handling for selectable list screens: touchdown highlights the
+  // touched row, a tap selects and reports Activated. The caller supplies the
+  // list band and runs its own activate action on Activated.
+  ListTouchResult handleListTouch(int& selectedIndex, int itemCount, int listTop, int listHeight, bool hasSubtitle);
 };

src/activities/ActivityManager.cpp

@@ -22,12 +22,17 @@
 static portMUX_TYPE activityManagerSpinlock = portMUX_INITIALIZER_UNLOCKED;
 
 void ActivityManager::begin() {
+#if defined(configNUM_CORES) && configNUM_CORES > 1
+  constexpr BaseType_t renderTaskCore = 1;
+#else
+  constexpr BaseType_t renderTaskCore = 0;
+#endif
   xTaskCreatePinnedToCore(&renderTaskTrampoline, "ActivityManagerRender",
                           8192,               // Stack size
                           this,               // Parameters
                           1,                  // Priority
                           &renderTaskHandle,  // Task handle
-                          0                   // Pin to core 0 (PRO_CPU)
+                          renderTaskCore  // Keep long renders/cover decodes off CPU 0's idle watchdog when available
   );
   assert(renderTaskHandle != nullptr && "Failed to create render task");
 }
@@ -61,6 +66,14 @@ void ActivityManager::renderTaskLoop() {
 
 void ActivityManager::loop() {
   if (currentActivity) {
+    if (!currentActivity->isHomeActivity() && mappedInput.wasHomeGesture()) {
+      if (currentActivity->handleHomeGesture()) {
+        return;
+      }
+      goHome();
+      return;
+    }
+
     // Note: do not hold a lock here, the loop() method must be responsible for acquire one if needed
     currentActivity->loop();
   }
@@ -256,25 +269,6 @@ bool ActivityManager::isReaderActivity() const {
          (currentActivity && currentActivity->isReaderActivity());
 }
 
-bool ActivityManager::currentKeepsBluetoothAlive() const {
-  return currentActivity && currentActivity->keepsBluetoothAlive();
-}
-
-void ActivityManager::requestGhostCleanup() {
-  if (currentActivity) currentActivity->requestGhostCleanup();
-}
-
-bool ActivityManager::bluetoothShouldBeActive() const {
-  const auto wants = [](const auto& activity) {
-    return activity && (activity->isReaderActivity() || activity->keepsBluetoothAlive());
-  };
-  return std::any_of(stackActivities.begin(), stackActivities.end(), wants) || wants(currentActivity);
-}
-
-bool ActivityManager::bluetoothStartDeferred() const {
-  return currentActivity && currentActivity->deferBluetoothStart();
-}
-
 bool ActivityManager::skipLoopDelay() const { return currentActivity && currentActivity->skipLoopDelay(); }
 
 ScreenshotInfo ActivityManager::getScreenshotInfo() const {